YD_SmartSports.Api/VOL.WebApi/HostedService/QuartzStartup.cs

using Microsoft.Extensions.Hosting;
using Quartz.Impl;
using Quartz;
using System.Threading;
using VOL.Core.Quartz;
using System.Threading.Tasks;
using System;
using VOL.Business.IServices;
using VOL.Business.Services.Norm;
using VOL.Core.Extensions;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using Newtonsoft.Json;
using VOL.Core.Enums;
using VOL.Core.Services;
using VOL.Core.EFDbContext;
using VOL.Entity.DomainModels;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using VOL.Entity.Enum;

namespace VOL.WebApi.HostedService
{
    public class QuartzStartup : IHostedService
    {
        private readonly IScheduler _scheduler;

        public QuartzStartup(
            ISchedulerFactory schedulerFactory)
        {
            _scheduler = schedulerFactory.GetScheduler().Result;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            // 注入的 job 添加到调度器
            //var job = JobBuilder.Create<StatResultJob>()
            //    .WithIdentity("MyStatResultJob", "MyStatResultGroup")
            //    .Build();

            //var trigger = TriggerBuilder.Create()
            //    .WithIdentity("MyStatResultTrigger", "MyStatResultGroup")
            //    //.StartNow()
            //    .WithSimpleSchedule(x => x
            //        .WithIntervalInMinutes(1) // 每分钟执行一次
            //        .RepeatForever())
            //    .Build();

            //await _scheduler.ScheduleJob(job, trigger);
            await _scheduler.Start();
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            await _scheduler.Shutdown();
        }

        /// <summary>
        /// 动态添加活动任务
        /// </summary>
        public async Task ScheduleActivityJobs(string activityId, DateTime startTime, DateTime endTime)
        {
            // 创建开始任务
            var startJob = JobBuilder.Create<ActivityStartJob>()
                .WithIdentity($"StartJob-{activityId}", "ActivityJobs")
                .UsingJobData("ActivityId", activityId) // 传递活动ID
                .Build();

            var startTrigger = TriggerBuilder.Create()
                .WithIdentity($"StartTrigger-{activityId}", "ActivityJobs")
                .StartAt(startTime) // 在活动开始时间执行
                .Build();

            // 创建结束任务
            var endJob = JobBuilder.Create<ActivityEndJob>()
                .WithIdentity($"EndJob-{activityId}", "ActivityJobs")
                .UsingJobData("ActivityId", activityId) // 传递活动ID
                .Build();

            var endTrigger = TriggerBuilder.Create()
                .WithIdentity($"EndTrigger-{activityId}", "ActivityJobs")
                .StartAt(endTime) // 在活动结束时间执行
                .Build();

            // 将任务和触发器添加到调度器
            await _scheduler.ScheduleJob(startJob, startTrigger);
            await _scheduler.ScheduleJob(endJob, endTrigger);
        }
        public async Task UpdateActivityJobs(string activityId, DateTime newStartTime, DateTime newEndTime)
        {
            // 定义 Job 和 Trigger 的标识
            var startJobKey = new JobKey($"StartJob-{activityId}", "ActivityJobs");
            var endJobKey = new JobKey($"EndJob-{activityId}", "ActivityJobs");
            var startTriggerKey = new TriggerKey($"StartTrigger-{activityId}", "ActivityJobs");
            var endTriggerKey = new TriggerKey($"EndTrigger-{activityId}", "ActivityJobs");

            // 检查并删除旧的任务和触发器
            if (await _scheduler.CheckExists(startJobKey))
            {
                await _scheduler.DeleteJob(startJobKey);
            }

            if (await _scheduler.CheckExists(endJobKey))
            {
                await _scheduler.DeleteJob(endJobKey);
            }
        }
    }

    // 活动开始任务
    public class ActivityStartJob : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            string activityId = context.JobDetail.JobDataMap.GetString("ActivityId");
            using (var dbContext = new VOLContext())
            {
                var activity = await dbContext.Set<G_Activities>().FirstOrDefaultAsync(x => x.Id == Convert.ToInt32(activityId));
                if (activity == null)
                {
                    Logger.Info(LoggerType.Info, activityId, $"未找到活动 {activityId}");
                    return;
                }

                activity.ActivitiesStatus = ActivitiesStatus.Afoot;
                activity.ModifyDate = DateTime.Now;

                dbContext.Set<G_Activities>().Update(activity);
                await dbContext.SaveChangesAsync();
            }
            Logger.AddAsync(LoggerType.Info, activityId, $"活动 {activityId} 开始时间触发: {DateTime.Now},修改状态为:进行中", "", LoggerStatus.Info);
        }
    }

    // 活动结束任务
    public class ActivityEndJob : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            string activityId = context.JobDetail.JobDataMap.GetString("ActivityId");
            using (var dbContext = new VOLContext())
            {
                var activity = await dbContext.Set<G_Activities>().FirstOrDefaultAsync(x => x.Id == Convert.ToInt32(activityId));
                if (activity == null)
                {
                    Logger.Info(LoggerType.Info, activityId, $"未找到活动 {activityId}");
                    return;
                }

                activity.ActivitiesStatus = ActivitiesStatus.Completed;
                activity.ModifyDate = DateTime.Now;

                dbContext.Set<G_Activities>().Update(activity);
                await dbContext.SaveChangesAsync();
            }
            Logger.AddAsync(LoggerType.Info, activityId, $"活动 {activityId} 结束时间触发: {DateTime.Now},修改状态为:已完成", "", LoggerStatus.Info);
        }
    }
}