Dot.QuartzPanel 1.2.0

<div align="center">

⚡ Dot.QuartzPanel

A powerful, plug-and-play Blazor admin panel for Quartz.NET

Real-time monitoring • Job management • Execution history • Modern UI

</div>

🌟 Features

✨ Real-time Dashboard

• Live metrics with job execution statistics
• Interactive charts showing 24-hour execution history (configurable time ranges: 1h, 3h, 6h, 12h, 24h)
• Scheduler controls for Start/Standby/Shutdown operations
• SignalR integration for instant updates without page refresh
• Visual indicators for real-time data changes

🎯 Job Management

• Comprehensive job browser with instant search
• Detailed job inspection with metadata and configuration
• Job operations: Pause, resume, trigger, and delete
• Bulk operations for managing multiple jobs
• Data map viewer to inspect job parameters

⏰ Trigger Management

• View all triggers across your jobs in one place
• All trigger types: Cron, Simple, DailyTimeInterval, CalendarInterval
• Trigger operations: Pause/resume/delete with detail view
• Next fire time predictions for scheduled jobs
• Create new triggers via intuitive tabbed dialog

📆 Calendar Management

• Holiday calendars to exclude dates from trigger firing
• Create and manage calendars through the UI
• Associate calendars with triggers

📊 Execution History

• Complete audit trail of all job executions
• Advanced filtering by job name, status, and time range
• Error tracking with full stack traces for debugging
• Performance metrics including execution duration
• Instant search for quick lookups

🎨 Modern UI

• Glassmorphic design with a contemporary aesthetic
• Dark/Light mode toggle with preference persistence
• Fully responsive layout for desktop and mobile
• Smooth animations and micro-interactions
• Loading skeletons for seamless perceived performance
• Built with MudBlazor components

♿ Accessibility

• ARIA labels on all interactive elements
• Tooltips explaining button actions
• Keyboard navigation support throughout
• Screen reader compatible

⚡ Performance

• Event throttling (100ms batching) for high-frequency updates
• Debounced search (300ms) on all list pages
• Exponential backoff for SignalR reconnection
• Server-side filtering for efficient data handling

🚀 Quick Start

Installation

Install via NuGet Package Manager:

dotnet add package Dot.QuartzPanel

Or via Package Manager Console:

Install-Package Dot.QuartzPanel

Basic Setup

Add to your Program.cs:

using Dot.QuartzPanel;

var builder = WebApplication.CreateBuilder(args);

// 1️⃣ Configure Quartz.NET (your existing Quartz setup)
builder.Services.AddQuartz(q =>
{
    q.AddJob<SampleJob>(opts => opts
        .WithIdentity("SampleJob", "MyGroup")
        .StoreDurably());
    
    q.AddTrigger(opts => opts
        .ForJob("SampleJob", "MyGroup")
        .WithIdentity("SampleTrigger", "MyGroup")
        .WithCronSchedule("0 */5 * * * ?"));
});
builder.Services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);

// 2️⃣ Add Quartz Panel - That's it! ✨
builder.AddQuartzPanel();

var app = builder.Build();

// 3️⃣ Use Quartz Panel - One line! ✨
app.UseQuartzPanel();

app.Run();

That's only 2 lines of code to add a complete admin panel! 🎉

What's Included Automatically

When you call AddQuartzPanel() and UseQuartzPanel(), you get:

• ✅ SignalR real-time updates
• ✅ MudBlazor UI components
• ✅ Job execution history tracking
• ✅ Health check endpoint at /quartz/health
• ✅ Stats API at /quartz/api/stats
• ✅ Auto-registered job listener (no manual setup needed!)
• ✅ Static files for panel assets

Access the Panel

Navigate to https://localhost:5000/quartz to access your Quartz admin panel! 🎉

Health Check Endpoint

The panel exposes a health check endpoint for monitoring:

curl https://localhost:5000/quartz/health

Returns:

{
  "status": "healthy",
  "scheduler": {
    "name": "QuartzScheduler",
    "instanceId": "NON_CLUSTERED",
    "isStarted": true,
    "isShutdown": false,
    "inStandbyMode": false,
    "state": "Running"
  },
  "timestamp": "2024-01-15T10:30:00Z"
}

⚙️ Configuration

Panel Options

Configure the panel when registering services:

builder.Services.AddQuartzPanel(options =>
{
    // Maximum number of execution history items to keep in memory
    options.MaxHistoryItems = 1000;
    
    // Enable or disable real-time updates via SignalR
    options.EnableRealTimeUpdates = true;
    
    // Auto-refresh interval in seconds (0 = disabled)
    // Note: Real-time updates via SignalR are preferred over polling
    options.AutoRefreshIntervalSeconds = 5;
    
    // Base path for panel routes (default: "/quartz")
    options.BasePath = "/quartz";
    
    // Enable dark mode by default
    options.DefaultDarkMode = false;
    
    // Custom panel title
    options.Title = "My Job Scheduler";
});

Custom Route

Customize the panel's URL path:

// Access panel at /jobs instead of /quartz
app.MapQuartzPanel("/jobs");

📦 Architecture

Components

• Blazor Server: Server-side Blazor for rich, interactive UI
• MudBlazor: Material Design component library for modern aesthetics
• SignalR: Real-time bidirectional communication for live updates
• Quartz.NET: Robust job scheduling framework

Data Flow

graph LR
    A[Quartz Scheduler] --> B[Job Listener]
    B --> C[History Store]
    C --> D[SignalR Hub]
    D --> E[Blazor Components]
    E --> F[User Interface]
    F --> G[Job Operations]
    G --> A

Storage

By default, execution history is stored in-memory with a configurable maximum size. For enterprise applications requiring persistent storage, implement a custom store:

public class DatabaseJobHistoryStore : IJobHistoryStore
{
    private readonly ApplicationDbContext _db;
    
    public DatabaseJobHistoryStore(ApplicationDbContext db)
    {
        _db = db;
    }
    
    public async Task AddExecutionAsync(JobExecutionRecord record)
    {
        _db.JobExecutions.Add(record);
        await _db.SaveChangesAsync();
    }
    
    public async Task<IEnumerable<JobExecutionRecord>> GetExecutionsAsync(int maxItems)
    {
        return await _db.JobExecutions
            .OrderByDescending(x => x.FiredTime)
            .Take(maxItems)
            .ToListAsync();
    }
    
    // Implement other interface methods...
}

// Register your custom implementation
builder.Services.AddSingleton<IJobHistoryStore, DatabaseJobHistoryStore>();

💡 Advanced Usage

Custom Jobs Integration

Create jobs that work seamlessly with the panel:

public class ReportGenerationJob : IJob
{
    private readonly ILogger<ReportGenerationJob> _logger;
    private readonly IReportService _reportService;
    
    public ReportGenerationJob(
        ILogger<ReportGenerationJob> logger, 
        IReportService reportService)
    {
        _logger = logger;
        _reportService = reportService;
    }
    
    public async Task Execute(IJobExecutionContext context)
    {
        _logger.LogInformation("Starting report generation...");
        
        var dataMap = context.JobDetail.JobDataMap;
        var reportType = dataMap.GetString("ReportType");
        
        await _reportService.GenerateAsync(reportType);
        
        _logger.LogInformation("Report generation completed!");
    }
}

Register with data map:

q.AddJob<ReportGenerationJob>(opts => opts
    .WithIdentity("MonthlyReport", "Reports")
    .UsingJobData("ReportType", "Monthly")
    .StoreDurably());

Cron Expression Examples

// Every minute
.WithCronSchedule("0 * * * * ?")

// Every 5 minutes
.WithCronSchedule("0 */5 * * * ?")

// Every day at 3:00 AM
.WithCronSchedule("0 0 3 * * ?")

// Every weekday at 9:00 AM
.WithCronSchedule("0 0 9 ? * MON-FRI")

// First day of every month at midnight
.WithCronSchedule("0 0 0 1 * ?")

🎯 Demo Project

Test drive the panel with the included demo:

git clone https://github.com/nathanmac/Dot.QuartzPanel.git
cd Dot.QuartzPanel/Dot.QuartzPanel.DemoApi
dotnet run

Then navigate to https://localhost:5001/quartz to explore the panel with sample jobs.

The demo includes:

• ✅ Multiple sample jobs with different schedules
• ✅ Real-time SignalR updates
• ✅ Error simulation for testing error tracking
• ✅ Various trigger types (Cron, Simple)

🔧 Troubleshooting

Jobs not appearing in the panel

Solution: Ensure jobs are marked as StoreDurably():

q.AddJob<MyJob>(opts => opts
    .WithIdentity("MyJob", "MyGroup")
    .StoreDurably());  // ← Important!

Execution history not showing

Solutions:

1. The job listener is auto-registered by AddQuartzPanel() - make sure you're using the latest version
2. Verify Quartz is configured with AddQuartzHostedService()
3. Check that the scheduler is running (not in standby mode)

Real-time updates not working

Solutions:

1. Ensure you're calling both AddQuartzPanel() and UseQuartzPanel()
2. Check browser console for SignalR connection errors
3. Verify WebSocket connections are not blocked by a proxy

Panel not accessible

Solutions:

1. Check the URL path - default is /quartz
2. Verify UseQuartzPanel() is called after UseRouting()
3. Check the health endpoint: GET /quartz/health

Custom base path

// Configure custom path in options
builder.AddQuartzPanel(options => options.BasePath = "/admin/scheduler");

// Or override when mapping
app.UseQuartzPanel("/admin/scheduler");

📋 Requirements

• .NET 10.0 or later
• Quartz.NET 3.x (3.15.1+ recommended)
• ASP.NET Core with Blazor Server support
• Modern browser with WebSocket support for SignalR

🗺️ Roadmap

We're continuously improving Dot.QuartzPanel! Here's what's coming:

✅ Completed

• 🆕 Interactive job creation dialog (with type discovery and data map)
• 📅 Visual cron expression builder
• 📁 Export history to CSV/JSON
• ✏️ Job data map editor with validation
• 📆 Calendar management (Holiday calendars)
• ⏰ All trigger types (Cron, Simple, DailyTimeInterval, CalendarInterval)
• 📋 Trigger detail page
• 🌙 Dark mode persistence
• 💀 Loading skeletons for all pages
• 🔍 Debounced search with improved empty states
• ⚠️ Confirmation dialogs for destructive actions
• ♿ ARIA labels and accessibility improvements
• ⚡ SignalR event throttling and exponential backoff
• 🎯 Configurable panel title

🔜 Planned

• 🔐 Built-in authentication & authorization
• 🌐 Clustering and multi-scheduler support
• 🔔 Alert notifications for job failures
• 📊 Advanced analytics and reporting
• 🎨 Theme customization options
• 🌍 Internationalization (i18n)

Have a feature request? Open an issue!

🤝 Contributing

Contributions are welcome and appreciated! Whether it's:

• 🐛 Bug reports
• 💡 Feature suggestions
• 📝 Documentation improvements
• 🔧 Code contributions

Please feel free to:

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request

📄 License

This project is licensed under the MIT License - feel free to use it in your personal and commercial projects!

See the LICENSE file for details.

🙏 Credits

Built with ❤️ using these amazing technologies:

• Quartz.NET - Enterprise job scheduling
• MudBlazor - Material Design components
• ASP.NET Core - Web framework
• SignalR - Real-time communication

📞 Support

• 📖 Documentation
• 🐛 Issue Tracker
• 💬 Discussions

<div align="center">

⭐ If you find this project useful, please consider giving it a star! ⭐

Made by Nathan Wilcké

</div>