public static void ScheduleJob <TJob>(this IApplicationBuilder app, TriggerBuilder triggerBuilder) where TJob : class, IJob
{
var scheduler = app.ApplicationServices.GetRequiredService <IScheduler>();
var jobName = typeof(TJob).FullName;
var job = JobBuilder.Create <TJob>()
.WithIdentity(jobName)
.Build();
triggerBuilder = triggerBuilder
.ForJob(job)
.WithIdentity($"{jobName}.trigger");
var trigger = triggerBuilder.Build();
// TODO: Fix this issue - currently probably only in tests
if (scheduler.CheckExists(job.Key).Result)
{
Log.Logger.Warning("Job should not exist but it does. {@JobKey}", job.Key);
scheduler.DeleteJob(job.Key).Wait();
}
scheduler.ScheduleJob(job, trigger).Wait();
}
public async Task <DateTimeOffset?> ScheduleRemoveOldEventsJob(int intervalSecs, DateTime?startAt)
{
ValidateRemoveOldEventsJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(RemoveOldEventsTriggerKey);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
builder = builder.WithSimpleSchedule(x => x
.WithInterval(TimeSpan.FromSeconds(intervalSecs))
.RepeatForever());
var trigger = builder.ForJob(RemoveOldEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(RemoveOldEventsTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(RemoveOldEventsTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(trigger));
}
public static async void AddTaskTriggerForJob(Models.Task task, User user)
{
try
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(task.Id.ToString())
.WithCronSchedule(task.Period);
if (DateTime.Now >= DateTime.Parse(task.StartTime))
{
triggerBuilder.StartNow();
}
else
{
triggerBuilder.StartAt(DateTimeOffset.Parse(task.StartTime));
}
ITrigger trigger = null;
if (task.ApiId == (int)APIID.COVID) // создание триггеров на задачи по получанию данных covid
{
trigger = triggerBuilder.ForJob(covidJobName).Build();
}
else if (task.ApiId == (int)APIID.FOREX) // создание триггеров на задачи по получанию данных forex
{
trigger = triggerBuilder.ForJob(forexJobName).Build();
}
else if (task.ApiId == (int)APIID.QUOTE) // создание триггеров на задачи по получанию данных quote
{
trigger = triggerBuilder.ForJob(quoteJobName).Build();
}
trigger.JobDataMap["apiParam"] = task.ApiParam;
trigger.JobDataMap["idTask"] = task.Id;
trigger.JobDataMap["userMail"] = user.Email;
await scheduler.ScheduleJob(trigger);
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
/// <summary>
/// 创建只触发一次的触发器
/// </summary>
/// <param name="secondBase">时间</param>
/// <param name="forJob">此触发器将关联到哪一个作业</param>
/// <returns></returns>
public static ISimpleTrigger CreateOnceTrigger(int secondBase, IJobDetail forJob = null)
{
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, secondBase);
TriggerBuilder builder =
TriggerBuilder.Create()
.WithIdentity(System.Guid.NewGuid().ToString())
.WithDescription("此触发器只执行一次.")
.StartAt(startTime);
if (forJob != null)
{
builder = builder.ForJob(forJob);
}
return((ISimpleTrigger)builder.Build());
}
/// <summary>
/// Schedule a recurring Task
/// </summary>
/// <param name="Task"></param>
/// <param name="CallBackDelay"></param>
/// <param name="Parameters"></param>
/// <returns></returns>
public static TaskScheduleResult ScheduleRecurringTask(JobBuilder Task, string CronSchedule, Dictionary <string, object> Parameters = null)
{
TaskScheduleResult Result = new TaskScheduleResult();
Guid Id = Guid.NewGuid();
IJobDetail job = Task.WithIdentity(Id.ToString(), Task.Build().JobType.Name).Build();
bool Success = false;
try
{
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
scheduler.Start();
string Group = job.JobType.Name;
JobKey Key = new JobKey(Id.ToString(), Group);
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(Id.ToString(), Group).WithCronSchedule(
CronSchedule,
x => x.InTimeZone(TimeZoneInfo.Utc)
);
if (Parameters != null)
{
foreach (var Param in Parameters)
{
triggerBuilder = triggerBuilder.UsingJobData(Param.Key, Param.Value.ToString());
}
}
ITrigger trigger = triggerBuilder.ForJob(job).Build();
var DatetimeOffset = scheduler.ScheduleJob(job, trigger);
Success = DatetimeOffset != null ? true : false;
Result.GroupName = Group;
Result.Id = Id.ToString();
}
catch (Exception e)
{
Success = false;
Commons.Logger.GenerateError(e, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "job = " + job.JobType.Name);
}
Result.Result = Success;
return(Result);
}
public async Task <DateTimeOffset?> TriggerSendUnsentEventsJob(DateTime?startAt)
{
ValidateSendUnsentJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(nameof(SendUnsentEventsJob) + Guid.NewGuid().ToString(), Constants.Group.General);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
var trigger = builder.ForJob(SendUnsentEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(SendUnsentEventsJobTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(SendUnsentEventsJobTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(trigger));
}
/// <summary>
/// 根据数据采集计划来创建作业触发器
/// </summary>
/// <param name="jobDetail">采集计划</param>
/// <param name="clMethod">数据采集方法</param>
/// <param name="forJob">将此触发器添加到哪个作业</param>
/// <returns></returns>
public static ITrigger CreateTrigger(ScheduleJob_Details_Triggers trigger, IJobDetail forJob = null)
{
if (trigger == null)
{
throw new ArgumentNullException("『CreateTrigger』的trigger参数为空！");
}
TriggerBuilder builder = TriggerBuilder.Create();
builder =
builder
.WithIdentity(GetTriggerKey(trigger))
.WithDescription(trigger.description);
builder =
trigger.trigger_type.ToUpper() == "cron".ToUpper() ? (
string.IsNullOrEmpty(trigger.cronexpression) ?
builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)))
: builder.WithCronSchedule(trigger.cronexpression)
) : builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)));
if (forJob != null)
{
builder.ForJob(forJob);
}
return(builder.Build());
}
public async Task <Result <JobDto> > TriggerJob <TJob>(JobDto jobDto) where TJob : IJob
{
Result <JobDto> result;
try
{
_scheduler = await StdSchedulerFactory.GetDefaultScheduler();
await _scheduler.Start();
_jobName = $"{typeof(TJob).FullName}-{jobDto.Guid}";
_job = JobBuilder.Create <TJob>()
.WithIdentity($"{_jobName}.{jobDto.Guid}")
.StoreDurably(true)
.Build();
_cronTrigger = GenerateCronTrigger(jobDto, false, _jobName);
_triggerBuilder = TriggerBuilder.Create();
_trigger = _triggerBuilder
.ForJob(_job.Key)
.WithCronSchedule(jobDto.JobDataDtoList.FirstOrDefault().TimerRegex)
.WithIdentity($"{_jobName}.{jobDto.Guid}")
.Build();
_dateTimeOffset = await _scheduler.ScheduleJob(_job, _cronTrigger);
jobDto.LastRunTime = _dateTimeOffset.UtcDateTime;
result = new Result <JobDto>(jobDto);
}
catch (Exception ex)
{
result = new Result <JobDto>(false, $"An error occured while triggering job. Ex : {ex.ToString()}");
}
return(result);
}
public static TriggerBuilder ForJob(this TriggerBuilder builder, string jobKey)
{
var parts = jobKey.Split('.');
return(builder.ForJob(new JobKey(parts[1], parts[0])));
}
private static void ScheduleJobs()
{
int priority = Jobs.Count;
foreach (var tsk in Jobs.Where(x => x.TaskType == "S" && x.Status == "Queued")) // O - On Demand ; S- Scheduled.
{
var schedule = Schedules.FirstOrDefault(x => x.taskID == tsk.taskID);
var client = Machines.FirstOrDefault(x => x.ID == tsk.ClientID);
IJobDetail job = JobBuilder.Create <Job>().WithIdentity(tsk.TaskName, tsk.ClientID.ToString()).Build();
job.JobDataMap["command"] = tsk.Command;
job.JobDataMap["taskname"] = tsk.TaskName;
job.JobDataMap["TaskId"] = tsk.taskID;
if (client != null)
{
job.JobDataMap["remotepc"] = "\\\\" + client.HostName;
job.JobDataMap["username"] = client.Username;
job.JobDataMap["password"] = client.Password;
}
if (schedule != null)
{
TriggerBuilder tb = TriggerBuilder.Create();
tb.WithIdentity(tsk.TaskName);
if (schedule.repeatforever <= 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours));
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec));
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin));
}
else
{
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin).RepeatForever());
}
}
if (schedule.startAt != null)
{
tb.StartAt(new DateTimeOffset((DateTime)schedule.startAt));
}
if (schedule.endAt != null)
{
tb.EndAt(new DateTimeOffset((DateTime)schedule.endAt));
}
tb.ForJob(job);
ITrigger trigger = tb.Build();
Scheduler.ScheduleJob(job, trigger);
}
}
}
private void scheduleTask(ScheduledTask task)
{
if (!string.IsNullOrEmpty(task.ServerName) && task.ServerName.ToLower(CultureInfo.GetCultureInfo("en-US")) != System.Environment.MachineName.ToLower(CultureInfo.GetCultureInfo("en-US")))
{
return;
}
JobKey jobKey = new JobKey(task.Name);
if (!task.Enabled)
{
if (_scheduler.CheckExists(jobKey))
{
_scheduler.DeleteJob(jobKey);
}
return;
}
TriggerKey triggerkey = new TriggerKey(string.Format("{0}_trigger", task.Name));
TriggerBuilder triggerBuilder = null;
if (!_scheduler.CheckExists(triggerkey))
{
triggerBuilder = TriggerBuilder.Create().WithIdentity(triggerkey);
}
else
{
ICronTrigger oldTrigger = (ICronTrigger)_scheduler.GetTrigger(triggerkey);
if (oldTrigger.CronExpressionString == task.CronExpression)
{
return;
}
triggerBuilder = oldTrigger.GetTriggerBuilder();
}
TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(PxConfigurationManager.PxConfig.Schedule.TimeZoneId);
switch (task.MissedScheduleAction)
{
case MissedScheduleActionType.RunLatest:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionFireAndProceed());
break;
case MissedScheduleActionType.RunAll:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionIgnoreMisfires());
break;
case MissedScheduleActionType.NoAction:
default:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionDoNothing());
break;
}
if (task.StartDate != null && (DateTime)task.StartDate != DateTime.MinValue)
{
triggerBuilder = triggerBuilder.StartAt(new DateTimeOffset(task.StartDate.Value));
}
else
{
triggerBuilder = triggerBuilder.StartAt(new DateTimeOffset(DateTime.Now));
}
if (task.EndDate != null && (DateTime)task.EndDate != DateTime.MinValue)
{
triggerBuilder = triggerBuilder.EndAt(new DateTimeOffset((DateTime)task.EndDate));
}
IJobDetail job = JobBuilder.Create <PxScheduledTask>().WithIdentity(jobKey).RequestRecovery().Build();
job.JobDataMap.Put("ScheduledTask", task);
ICronTrigger trigger = (ICronTrigger)triggerBuilder.ForJob(job).Build();
if (!_scheduler.CheckExists(triggerkey))
{
_scheduler.ScheduleJob(job, trigger);
}
else
{
_scheduler.RescheduleJob(triggerkey, trigger);
}
}
