Dot.QuartzPanel 1.0.0

Dot.QuartzPanel

A powerful, plug-and-play Blazor admin panel for Quartz.NET with real-time monitoring, job management, and execution history tracking.

Features

✨ Real-time Dashboard

• Live job execution stats
• 24-hour execution history charts
• Scheduler control panel (Start/Standby/Shutdown)
• Auto-refresh with configurable intervals

🎯 Job Management

• Browse and search all jobs
• View detailed job metadata and configuration
• Pause, resume, trigger, and delete jobs
• Bulk operations support
• Job data map viewing

⏰ Trigger Management

• View all triggers across jobs
• Cron and Simple trigger support
• Pause/resume/delete triggers
• Next fire time predictions

📊 Execution History

• Complete execution history with filtering
• Error tracking with full stack traces
• Duration and status monitoring
• Search and filter capabilities

🎨 Modern UI

• Built with MudBlazor
• Dark mode support
• Responsive design
• Intuitive navigation

Installation

1. Install NuGet Package

dotnet add package Dot.QuartzPanel

2. Configure Services

In your Program.cs:

using Dot.QuartzPanel;

var builder = WebApplication.CreateBuilder(args);

// Add Quartz.NET
builder.Services.AddQuartz(q =>
{
    // Configure your jobs and triggers
    q.AddJob<MyJob>(opts => opts.WithIdentity("MyJob", "MyGroup"));
    q.AddTrigger(opts => opts
        .ForJob("MyJob", "MyGroup")
        .WithCronSchedule("0 0 * * * ?"));
});

builder.Services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);

// Add Quartz Panel
builder.Services.AddQuartzPanel(options =>
{
    options.MaxHistoryItems = 1000;
    options.EnableRealTimeUpdates = true;
    options.AutoRefreshIntervalSeconds = 5;
});

// Add SignalR for real-time updates
builder.Services.AddSignalR();

// Add Blazor Server
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

3. Register Job Listener

Important: Manually register the listener with Quartz scheduler:

using Dot.QuartzPanel.Listeners;

// After adding Quartz Panel services
builder.Services.AddSingleton(sp =>
{
    var schedulerFactory = sp.GetRequiredService<ISchedulerFactory>();
    var listener = sp.GetRequiredService<QuartzPanelJobListener>();
    
    _ = Task.Run(async () =>
    {
        var scheduler = await schedulerFactory.GetScheduler();
        scheduler.ListenerManager.AddJobListener(listener);
    });
    
    return listener;
});

4. Map Endpoints

In your middleware pipeline:

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

// Map Quartz Panel (includes SignalR hub)
app.MapQuartzPanel("/quartz");  // Default path is "/quartz"

app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

app.Run();

5. Access the Panel

Navigate to https://localhost:5000/quartz (or your configured path) to access the admin panel.

Configuration Options

builder.Services.AddQuartzPanel(options =>
{
    // Maximum execution history items to retain in memory
    options.MaxHistoryItems = 1000;
    
    // Enable real-time updates via SignalR
    options.EnableRealTimeUpdates = true;
    
    // Auto-refresh interval in seconds (0 = disabled)
    options.AutoRefreshIntervalSeconds = 5;
    
    // Base path for the panel routes
    options.BasePath = "/quartz";
    
    // Enable dark mode by default
    options.DefaultDarkMode = false;
    
    // Panel title
    options.Title = "Quartz Panel";
});

Screenshots

Dashboard

Real-time monitoring with execution charts and scheduler controls.

Jobs Management

Browse, search, and manage all your Quartz jobs.

Execution History

Track job executions with filtering and error details.

Architecture

• Blazor Server: Server-side Blazor for rich interactivity
• MudBlazor: Material Design component library
• SignalR: Real-time updates for job executions
• In-Memory History: Bounded execution history store (customizable)

Custom History Storage

The default implementation uses in-memory storage. To implement persistent storage:

public class DatabaseJobHistoryStore : IJobHistoryStore
{
    // Implement interface methods
    // Store execution history in your database
}

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

Requirements

• .NET 10.0 or later
• Quartz.NET 3.x
• Blazor Server capabilities

Demo Project

Run the included demo API:

cd Dot.QuartzPanel.DemoApi
dotnet run

Navigate to https://localhost:5001/quartz to see the panel in action with sample jobs.

Roadmap

• Job creation dialog
• Cron expression builder
• Calendar view of scheduled jobs
• Export history to CSV/JSON
• Authorization/authentication support
• Job data map editor
• Clustering support

License

MIT License - feel free to use in your projects!

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

Credits

Built with:

• Quartz.NET
• MudBlazor
• ASP.NET Core