private async Task StopOrStart(QuartzOptionDTO quartzOption, QuartzModel model)
{
model.LastRunTime = DateTime.Now;
quartzService.Update(model);
QuartzResult result = null;
if (model.TaskStatus == 1)
{
result = await schedulerFactory.Pause(mapper.Map <QuartzOption>(quartzOption));
MessageService.Show($"停止：{JsonConvert.SerializeObject(result)} ");
}
else
{
result = await schedulerFactory.Start(mapper.Map <QuartzOption>(quartzOption));
if (!result.status)
{
result = await schedulerFactory.AddJob(mapper.Map <QuartzOption>(quartzOption));
}
MessageService.Show($"开始：{JsonConvert.SerializeObject(result)} ");
}
if (result != null && result.status)
{
await ResetCache();
await ReLoadData();
}
}
/// <summary>
/// 停止指定的计划
/// </summary>
/// <param name="jobId">jobId</param>
/// <param name="isDelete">停止并删除任务</param>
/// <returns></returns>
public async Task <QuartzResult> StopScheduleJob(Guid jobId, bool isDelete = false)
{
if (!this.Scheduler.Result.IsStarted)
{
await this.Scheduler.Result.Start();
}
QuartzResult result;
try
{
Scheduler schedule = ScheduleList.Where(p => p.Id.Equals(jobId)).FirstOrDefault(); //获取任务实例
await this.Scheduler.Result.PauseJob(new JobKey(schedule.JobName, schedule.JobGroup));
if (isDelete)
{
ScheduleList.Remove(schedule); //从列表移除
}
result = new QuartzResult
{
Code = 1000,
Msg = "停止任务计划成功！"
};
}
catch (Exception ex)
{
result = new QuartzResult
{
Code = -1,
Msg = ex.Message
};
}
return(result);
}
private static QuartzResult Exists(this QuartzOption QuartzOptions)
{
if (_taskList.Any(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName))
{
return(QuartzResult.Error($"作业:{QuartzOptions.TaskName},分组：{QuartzOptions.GroupName}已经存在"));
}
return(QuartzResult.Ok("不存在"));
}
/// <summary>
/// 添加任务调度（指定IJob实现类）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public static async Task <QuartzResult> AddJob <T>(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions) where T : IJob
{
if (QuartzOptions is null)
{
throw new ArgumentNullException(nameof(QuartzOptions));
}
if (scheduler == null)
{
scheduler = schedulerFactory?.GetScheduler().Result;
}
try
{
//检查任务是否已存在
if (await scheduler.CheckExists(new JobKey(QuartzOptions.TaskName, QuartzOptions.GroupName)))
{
return(QuartzResult.Error($"任务 {QuartzOptions.TaskName},任务组 {QuartzOptions.GroupName} 已存在"));
}
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail jobDetail = CreateJobDetail <T>(QuartzOptions);//JobBuilder.CreateForAsync<T>().WithIdentity(Option.TaskName, Option.GroupName).Build();
// 创建触发器
ITrigger trigger;
if (QuartzOptions.IntervalType == IntervalType.Cron)
{
if (!CronExpression.IsValidExpression(QuartzOptions.Interval))
{
return(QuartzResult.Error($"请确认表达式{QuartzOptions.Interval}是否正确!"));
}
trigger = QuartzOptions.CreateCronTrigger();
}
else
{
trigger = CreateSimpleTrigger(QuartzOptions);
}
// 设置监听器
//JobListener listener = new JobListener();
//// IMatcher<JobKey> matcher = KeyMatcher<JobKey>.KeyEquals(job.Key);
//scheduler.ListenerManager.AddJobListener(listener, GroupMatcher<JobKey>.AnyGroup());
await scheduler.ScheduleJob(jobDetail, trigger);
if (QuartzOptions.TaskStatus == TriggerState.Normal)
{
await scheduler.Start();
}
else
{
await schedulerFactory.Pause(QuartzOptions);
}
logger.LogDebug($"作业:{QuartzOptions.TaskName},目标:{QuartzOptions.TaskTarget},分组:{QuartzOptions.GroupName},状态为:{QuartzOptions.TaskStatus}");
return(QuartzResult.Ok("添加成功"));
}
catch (Exception ex)
{
logger.LogError($"添加任务出错--{ex.StackTrace}");
return(QuartzResult.Error($"添加任务出错--{ex.StackTrace}"));
}
}
/// <summary>
/// 添加作业
/// </summary>
/// <param name="QuartzOptions"></param>
/// <param name="schedulerFactory"></param>
///是否初始化,否=需要重新生成配置文件，是=不重新生成配置文件
//trigger.JobDataMap, job.JobDataMap任选一个传参
//trigger.JobDataMap.Add(typeof(HttpRequestJob).Name, Options.TaskData);
/// <returns></returns>
public static async Task <QuartzResult> AddJob(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions)
{
if (QuartzOptions is null)
{
throw new ArgumentNullException(nameof(QuartzOptions));
}
if (scheduler == null)
{
scheduler = schedulerFactory?.GetScheduler().Result;
}
try
{
if (await scheduler.CheckExists(new JobKey(QuartzOptions.TaskName, QuartzOptions.GroupName)))
{
return(QuartzResult.Error($"任务 {QuartzOptions.TaskName},任务组 {QuartzOptions.GroupName} 已存在"));
}
IJobDetail jobDetail = QuartzOptions.CreateJobDetail();
if (jobDetail == null)
{
return(QuartzResult.Error($"创建jobDetail 失败"));
}
ITrigger trigger = null;
if (QuartzOptions.IntervalType == IntervalType.Cron)
{
if (!CronExpression.IsValidExpression(QuartzOptions.Interval))
{
return(QuartzResult.Error($"请确认表达式{QuartzOptions.Interval}是否正确!"));
}
trigger = QuartzOptions.CreateCronTrigger();
}
else
{
trigger = QuartzOptions.CreateSimpleTrigger();
}
_taskList.Add(QuartzOptions);
await scheduler.ScheduleJob(jobDetail, trigger);
if (QuartzOptions.TaskStatus == TriggerState.Normal)
{
await scheduler.Start();
}
else
{
await schedulerFactory.Pause(QuartzOptions);
}
logger.LogDebug($"作业:{QuartzOptions.TaskName},目标:{QuartzOptions.TaskTarget},分组:{QuartzOptions.GroupName},状态为:{QuartzOptions.TaskStatus}");
}
catch (Exception ex)
{
return(QuartzResult.Error(ex.Message));
}
return(QuartzResult.Ok($"作业:{QuartzOptions.TaskName},分组:{QuartzOptions.GroupName} 添加成功"));
}
public async static Task <QuartzResult> ModifyTaskEntity(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions, JobAction action)
{
QuartzOption options = null;
switch (action)
{
case JobAction.Delete:
for (int i = 0; i < _taskList.Count; i++)
{
options = _taskList[i];
if (options.TaskName == QuartzOptions.TaskName && options.GroupName == QuartzOptions.GroupName)
{
_taskList.RemoveAt(i);
}
}
break;
case JobAction.Modify:
options = _taskList.Where(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName).FirstOrDefault();
//移除以前的配置
if (options != null)
{
_taskList.Remove(options);
}
//生成任务并添加新配置
await schedulerFactory.AddJob(QuartzOptions); //.GetAwaiter().GetResult();
break;
case JobAction.Pause:
case JobAction.Start:
case JobAction.Stop:
case JobAction.StartNow:
options = _taskList.Where(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName).FirstOrDefault();
if (action == JobAction.Pause)
{
options.TaskStatus = TriggerState.Paused;
}
else if (action == JobAction.Stop)
{
options.TaskStatus = (TriggerState)action;
}
else
{
options.TaskStatus = TriggerState.Normal;
}
break;
}
//生成配置文件
//FileQuartz.WriteJobConfig(_taskList);
//FileQuartz.WriteJobAction(action, QuartzOptions.TaskName, QuartzOptions.GroupName, "操作对象：" + JsonConvert.SerializeObject(QuartzOptions));
return(QuartzResult.Ok("成功"));
}
/// <summary>
/// 运行指定的计划
/// </summary>
/// <param name="schedule">jobId</param>
/// <returns></returns>
public async Task <QuartzResult> RunScheduleJob(Scheduler schedule)
{
QuartzResult result;
if (!this.Scheduler.Result.IsStarted)
{
await this.Scheduler.Result.Start();
}
var runResult = await Task.Factory.StartNew(async() =>
{
var tempResult = new QuartzResult();
try
{
string _AssemblyName = AppDomain.CurrentDomain.BaseDirectory + schedule.AssemblyName;
var jobType = AssemblyHandler.GetClassType(_AssemblyName, schedule.ClassName); //反射获取任务执行类
IJobDetail job = new JobDetailImpl(schedule.JobName, schedule.JobGroup, jobType); // 定义这个工作，并将其绑定到IJob实现类
ITrigger trigger = CreateCronTrigger(schedule); // 创建触发器
await this.Scheduler.Result.ScheduleJob(job, trigger); // 告诉Quartz使用我们的触发器来安排作业
tempResult.Code = 1000;
ScheduleList.Add(schedule);
}
catch (Exception ex)
{
tempResult.Code = 1001;
tempResult.Msg = ex.Message;
}
return(tempResult);
});
if (runResult.Result.Code == 1000)
{
await this.Scheduler.Result.ResumeJob(new JobKey(schedule.JobName, schedule.JobGroup)); //用给定的密钥恢复（取消暂停）IJobDetail
result = new QuartzResult
{
Code = 1000,
Msg = "启动成功"
};
}
else
{
result = new QuartzResult
{
Code = -1
};
}
return(result);
}
protected async Task Submit()
{
formAlign = LabelAlign.Right;
if (!demoForm.IsValid())
{
return;
}
bool result = false;
var taskCount = await Quartzservice.CountAsync();
if (taskCount > 15)
{
return;
}
var quartzOption = demoForm.GetValue <QuartzOptionDTO>();
var quartzModel = mapper.Map <QuartzModel>(quartzOption);
quartzModel.LastRunTime = DateTime.Now;
quartzModel.Describe ??= quartzOption.TaskName;
if (Operation == Operation.Update)
{
if (quartzModel.Id == 1000 || quartzModel.Id == 1001)
{
this.MessageService.Show($"默认任务不可修改 ", MessageType.Error);
return;
}
var oldjob = mapper.Map <QuartzOptionDTO>(Quartzservice.QueryById(quartzModel.Id));
QuartzResult operationResult = null;
if (oldjob != null)
{
if (oldjob.TaskStatus != quartzOption.TaskStatus)
{
switch (quartzOption.TaskStatus)
{
case TriggerState.Normal:
operationResult = await schedulerFactory.Start(mapper.Map <QuartzOption>(oldjob));
break;
case TriggerState.Paused:
operationResult = await schedulerFactory.Pause(mapper.Map <QuartzOption> (oldjob));
break;
case TriggerState.Complete:
case TriggerState.Error:
case TriggerState.Blocked:
case TriggerState.None:
operationResult = await schedulerFactory.Remove(mapper.Map <QuartzOption>(oldjob));
break;
default:
throw new NotImplementedException(" unkown TriggerState");
}
}
result = await Quartzservice.UpdateAsync(quartzModel);
if (operationResult != null && operationResult.status)
{
this.MessageService.Show($"操作结果：{JsonConvert.SerializeObject(operationResult)} ");
}
}
}
else
{
var AddJobResult = await schedulerFactory.AddJob(mapper.Map <QuartzOption>(quartzOption));
if (!AddJobResult.status)
{
this.MessageService.Show($"添加调度任务失败：{JsonConvert.SerializeObject(AddJobResult)} ");
return;
}
result = await Quartzservice.InsertAsync(quartzModel);
if (!result)
{
await schedulerFactory.Remove(mapper.Map <QuartzOption>(quartzOption));
}
}
if (result)
{
await ResetCache();
}
this.MessageService.Show($"操作结果：{result} ");
await DialogService.CloseDialogAsync(this, result);
}
/// <summary>
/// 触发新增、删除、修改、暂停、启用、立即执行事件
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="action"></param>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public static async Task <QuartzResult> TriggerAction(this ISchedulerFactory schedulerFactory, JobAction action, QuartzOption QuartzOptions)
{
try
{
List <JobKey> jobKeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(QuartzOptions.GroupName)).Result.ToList();
if (jobKeys == null || jobKeys.Count() == 0)
{
return(QuartzResult.Error($"未找到分组[{QuartzOptions.GroupName}]"));
}
JobKey jobKey = jobKeys?.Where(x => x.Name == QuartzOptions.TaskName && x.Group == QuartzOptions.GroupName)?.FirstOrDefault();
if (jobKey == null)
{
return(QuartzResult.Error($"未找到触发器[{QuartzOptions.TaskName}]"));
}
var triggers = await scheduler.GetTriggersOfJob(jobKey);
ITrigger trigger = triggers?.Where(x => x.JobKey.Name == QuartzOptions.TaskName && x.JobKey.Group == QuartzOptions.GroupName).FirstOrDefault();
if (trigger == null)
{
return(QuartzResult.Error($"未找到触发器[{QuartzOptions.TaskName}]"));
}
object result = null;
switch (action)
{
case JobAction.Delete:
case JobAction.Modify:
await scheduler.PauseTrigger(trigger.Key);
await scheduler.UnscheduleJob(trigger.Key); // 移除触发器
await scheduler.DeleteJob(trigger.JobKey);
result = schedulerFactory.ModifyTaskEntity(QuartzOptions, action);
break;
case JobAction.Pause:
case JobAction.Stop:
case JobAction.Start:
result = schedulerFactory.ModifyTaskEntity(QuartzOptions, action);
if (action == JobAction.Pause)
{
await scheduler.PauseTrigger(trigger.Key);
}
else if (action == JobAction.Start)
{
await scheduler.ResumeTrigger(trigger.Key);
// await scheduler.RescheduleJob(trigger.Key, trigger);
}
else
{
await scheduler.Shutdown();
}
break;
case JobAction.StartNow:
await scheduler.TriggerJob(jobKey);
break;
}
return(QuartzResult.Ok("成功"));
}
catch (Exception ex)
{
return(QuartzResult.Error($"失败 {ex.StackTrace}"));
}
finally
{
}
}
