Confusion about ASP.NET Core and how to implement my own factory

[ghost]

Hey,
I managed to get a simple example working in my ASP.NET Core project, but once I tried to make the creation of my triggers and jobs a bit more complicated I can't get my jobs to run.

In my Program.cs I do following:

builder.Services.AddTransient<IStoreRepository, StoreRepository>();

builder.Services.AddQuartzServer(options => options.WaitForJobsToComplete = true);
builder.Services.AddQuartz(q => q.UseMicrosoftDependencyInjectionJobFactory());
builder.Services.AddStoreCrawlers(true);

This is how I add my triggers and jobs:

public static void AddStoreCrawlers(this IServiceCollection services, bool bDevExecute)
{
    List<JobKey> jobKeys = new()
    {
        services.RegisterJob<CrawlerExample>(_sStoreGroup),
    };

    services.AddQuartz(q =>
    {
        q.AddTrigger(options =>
        {
            options.WithIdentity($"{_sStoreGroup}_Trigger", _sStoreGroup);

            if (bDevExecute)
            {
                // Start once immediately for development environment
                options
                    .WithSimpleSchedule(x => x
                        .WithIntervalInSeconds(5)
                        .WithMisfireHandlingInstructionFireNow()
                        .WithRepeatCount(0));
            }
            else
            {
                // Run every month
                options
                    .WithCronSchedule("0 0 0 1 * ? *");
            }

            foreach (var jobKey in jobKeys)
                options.ForJob(jobKey);
        });
    });
}

private static JobKey RegisterJob<T>(this IServiceCollection services, string groupName)
    where T : CrawlerBase
{
    JobKey jobKey = new JobKey($"{typeof(T).Name}_Job", groupName);
    services.AddQuartz(q =>
    {
        q.AddJob<T>(options =>
        {
            options.WithIdentity(jobKey);
        });
    });

    return jobKey;
}

And lastly my example of job:

public class CrawlerBase : IJob
{
    public async Task Execute(IJobExecutionContext context)
    {
        try
        {
            await Crawl();
            // SOME OTHER STUFF - for example logging to my UI interface or something else
            await Task.FromResult(true);
        }
        catch
        {
            await Task.FromResult(false);
        }
    }

    protected virtual Task Crawl()
    {
        return Task.CompletedTask;
    }
}

public class CrawlerExample : CrawlerBase
{
        private readonly IStoreRepository _storeRepository;

        public CrawlerExample (IStoreRepository storeRepository)
        {
            _storeRepository = storeRepository;
        }

        protected override async Task Crawl()
        {
            // DO STUFF
        }
}

My plan is to have a lot of small jobs that need to run every month and all of them do very similar stuff - that's why the abstraction.
I am basically creating web crawlers that need to get information into my database every month.

Additionally, I would like to be able to toggle if I want my crawlers to run once immediately when I am in debug mode - or for example force trigger of one job somehow so I can work in this project - this part sadly fails. I do believe that I managed to trigger jobs like this before adding dependency injection and with interval set for every 30s.

Am I approaching this in wrong way?
(I've been also considering if it's smart to have it as part of my API code as most of documentation isn't for ASP.NET Core - maybe have these jobs as separate project?)