public void PushTaskForInitialConsideration(TaskScheduleModel model)
{
var executionDate = model.IdentifyNextEntry(DateTime.Now);
if (model.IsContinuous)
{
executionDate = DateTime.Now;
}
logger.DebugFormat("Task \"{0}\" next execution is: \"{1}\".", model.TaskId, executionDate);
schedules[model.TaskId] = executionDate;
if (!model.IsContainer)
{
return;
}
var ordering = model.ScheduleItems
.OrderBy(x => x.Order)
.Select(x => x.TaskId)
.ToArray();
logger.DebugFormat("Task \"{0}\" is a container task. Execution plan: \"{1}\".",
model.TaskId, string.Join(", ", ordering));
lock (executionPlans)
{
var execution = new List <string>(ordering);
executionPlans[model.TaskId] = execution;
}
}
public async Task <Result> DelTaskAsync(TaskScheduleModel model)
{
Result result = new Result();
if (model == null)
{
return(result.SetError("Model 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobName))
{
return(result.SetError("JobName 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobGroup))
{
return(result.SetError("JobGroup 不能为空！"));
}
//search
var taskInfo = base.Single <TaskSchedule>(t => t.Id.Equals(model.Id));
var info = await jobCenter.StopScheduleJobAsync(model.JobGroup, model.JobName);
if (!info.Status.Equals(200))
{
return(result.SetError(info.Message));
}
//del
base.Delete(taskInfo, true);
return(result);
}
public async Task <ResponsResult> AddTaskAsync([FromBody] TaskScheduleModel model)
{
if (model != null && !string.IsNullOrEmpty(model.Id) && !model.Id.Equals("-1"))
{
return(await _taskService.ModifyTaskAsync(model));
}
return(await _taskService.AddTaskAsync(model));
}
public void PublishScheduleAdded(TaskScheduleModel task, DateTime date)
{
var payload = new
{
task.TaskId,
Date = date,
Execution = task.ScheduleItems
.Select(y => new { taskId = y.TaskId, order = y.Order, })
.ToArray(),
};
Publish("schedule", "add", payload);
}
/// <summary>
/// 暂停指定任务计划
/// </summary>
/// <returns></returns>
public void StopScheduleJobAsync(TaskScheduleModel sm)
{
if (!IsStart)
{
throw new Exception("任务计划未初始化");
}
var jk = new JobKey(sm.JobName, sm.JobGroup);
if (scheduler.CheckExists(jk).Result)
{
//使任务暂停
scheduler.PauseJob(jk).Wait();
Logger.LogInformation($"暂停任务{sm.JobGroup}.{sm.JobName}");
}
}
/// <summary>
/// 恢复指定的任务计划**恢复的是暂停后的任务计划，如果是程序奔溃后 或者是进程杀死后的恢复，此方法无效
/// </summary>
/// <returns></returns>
public async Task <ResponsResult> RunScheduleJobAsync(TaskScheduleModel sm)
{
ResponsResult result = new ResponsResult();
try
{
#region 开任务
//scheduler = await GetSchedulerAsync();
//DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(sm.StarRunTime, 1);
//DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(sm.EndRunTime, 1);
//IJobDetail job = JobBuilder.Create<HttpJob>()
// .WithIdentity(sm.JobName, sm.JobGroup)
// .Build();
//ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
// .StartAt(starRunTime)
// .EndAt(endRunTime)
// .WithIdentity(sm.JobName, sm.JobGroup)
// .WithCronSchedule(sm.CronExpress)
// .Build();
//await scheduler.ScheduleJob(job, trigger);
//await scheduler.Start();
#endregion
scheduler = await GetSchedulerAsync();
//resumejob 恢复
await scheduler.ResumeJob(new JobKey(sm.JobName, sm.JobGroup));
var status = new StatusViewModel()
{
Status = 0,
Msg = "恢复任务计划成功",
};
result.Data = status.GetJson();
return(result);
}
catch (Exception ex)
{
Log4Net.Error($"[JobCenter_RunScheduleJobAsync]_{ex}");
var status = new StatusViewModel()
{
Status = -1,
Msg = "恢复任务计划失败",
};
result.Data = status.GetJson();
return(result);
}
}
/// <summary>
/// 添加一个工作调度（映射程序集指定IJob实现类）
/// </summary>
/// <returns></returns>
private void AddScheduleJobAsync(TaskScheduleModel m)
{
if (!IsStart)
{
throw new Exception("任务计划未初始化");
}
//检查任务是否已存在
var jk = new JobKey(m.JobName, m.JobGroup);
if (scheduler.CheckExists(jk).Result)
{
//删除已经存在任务
scheduler.PauseJob(jk).Wait(); //先暂停
scheduler.DeleteJob(jk).Wait(); //在删除
Logger.LogInformation($"移除了老任务{m.JobGroup}.{m.JobName}");
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
//反射获取IJob实现
string dllFilePath = Path.Combine(WebHostEnvironment.WebRootPath, "JobPlugins") + "/" + m.FileName;
Assembly assembly = Assembly.LoadFile(dllFilePath);
Type[] types = assembly.GetExportedTypes();
Type typeIJob = typeof(IJob);
Type jobType = null;
for (int i = 0; i < types.Length; i++)
{
if (typeIJob.IsAssignableFrom(types[i]) && !types[i].IsAbstract)
{
jobType = types[i];
break;
}
}
IJobDetail job = JobBuilder.Create(jobType)
.WithIdentity(m.JobName, m.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(m.JobName, m.JobGroup)
.WithCronSchedule(m.CronExpress)
.Build();
scheduler.ScheduleJob(job, trigger).Wait();
Logger.LogInformation($"创建新任务{m.JobGroup}.{m.JobName}");
}
public void AddOrUpdateTaskSchedule(TaskScheduleModel model)
{
var existing = collection
.FirstOrDefault(x => x.TaskId.Equals(model.TaskId));
if (existing != null)
{
collection.Remove(existing);
}
collection.Add(model);
if (!schedules.ContainsKey(model.TaskId))
{
PushTaskForConsideration(model);
}
}
public async Task <BaseResult> ModifyJob(TaskScheduleModel model)
{
await this.scheduler.PauseJob(model.JobKey);
await this.scheduler.DeleteJob(model.JobKey);
await this.AddScheduleJobAsync(model);
if (!model.IsPaused)
{
await this.scheduler.PauseJob(model.JobKey);
}
return(new BaseResult()
{
Msg = "修改计划任务成功！"
});
}
public async Task <Result> AddTaskAsync(TaskScheduleModel model)
{
Result result = new Result();
if (model == null)
{
return(result.SetError("Model 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobName))
{
return(result.SetError("JobName 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobGroup))
{
return(result.SetError("JobGroup 不能为空！"));
}
if (model.StarRunTime == null)
{
model.StarRunTime = DateTime.Now;
}
if (model.EndRunTime == null)
{
model.EndRunTime = DateTime.MaxValue.AddDays(-1);
}
var info = await jobCenter.AddScheduleJobAsync(model);
if (info.Status != 200)
{
return(result.SetError(info.Message));
}
base.Add(new TaskSchedule
{
Id = Guid.NewGuid().ToString("N"),
CreateAuthr = identity.Name,
CronExpress = model.CronExpress,
EndRunTime = model.EndRunTime,
StarRunTime = model.StarRunTime,
JobGroup = model.JobGroup,
JobName = model.JobName,
RunStatus = model.RunStatus
}, true);
return(result);
}
private async Task <BaseResult> AddScheduleJobAsync(TaskScheduleModel entity)
{
var result = new BaseResult();
try
{
if (await this.scheduler.CheckExists(entity.JobKey))
{
result.Code = 500;
result.Msg = "任务已存在";
return(result);
}
var map = new Dictionary <string, string>()
{
{ nameof(Constant.RequestUrl), entity.Url },
{ nameof(Constant.RequestParameters), entity.Parameters },
{ nameof(Constant.RequestType), entity.HttpMethod.ToString() },
{ Constant.Headers, "" },
{ Constant.MailMessage, entity.Id.ToString() },
};
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(map))
.WithDescription(entity.Description)
.WithIdentity(entity.Name, entity.Group)
.Build();
ITrigger trigger = this.CreateTrigger(entity);
await this.scheduler.ScheduleJob(job, trigger);
result.Code = 200;
}
catch (Exception ex)
{
result.Code = 505;
result.Msg = ex.Message;
}
return(result);
}
/// <summary>
/// 恢复指定的任务计划**恢复的是暂停后的任务计划，如果没有指定任务就创建新的任务
/// </summary>
/// <returns></returns>
public void ResumeScheduleJobAsync(TaskScheduleModel sm)
{
if (!IsStart)
{
throw new Exception("任务计划未初始化");
}
var jk = new JobKey(sm.JobName, sm.JobGroup);
if (scheduler.CheckExists(jk).Result)
{
//有任务就恢复
scheduler.ResumeJob(jk).Wait();
Logger.LogInformation($"恢复任务{sm.JobGroup}.{sm.JobName}");
}
else
{
//没有任务就创建
this.AddScheduleJobAsync(sm);
}
}
private ITrigger CreateTrigger(TaskScheduleModel entity)
{
var builder = TriggerBuilder.Create()
.WithIdentity(entity.TriggerKey)
.StartAt((DateTimeOffset)entity.StartTime)
.EndAt(entity.EndTime);
switch (entity.TriggerType)
{
case TriggerTypeEnum.Cron:
if (!CronExpression.IsValidExpression(entity.CronExpression))
{
throw new Exception();
}
builder = builder.WithCronSchedule(entity.CronExpression);
break;
case TriggerTypeEnum.Simple:
Action <SimpleScheduleBuilder> action;
if (entity.RunTimes.HasValue && entity.RunTimes > 0)
{
action = x => x.WithIntervalInSeconds(entity.IntervalTime.Value)
.WithRepeatCount(entity.RunTimes.Value);
}
else
{
action = x => x.WithIntervalInSeconds(entity.IntervalTime.Value)
.RepeatForever();
}
builder = builder.WithSimpleSchedule(action);
break;
default:
throw new ArgumentException();
}
return(builder.ForJob(entity.JobKey).Build());
}
/// <summary>
/// 添加任务计划//或者进程终止后的开启
/// </summary>
/// <returns></returns>
public async Task <ResponsResult> AddScheduleJobAsync(TaskScheduleModel m)
{
ResponsResult result = new ResponsResult();
try
{
if (m != null)
{
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
scheduler = await GetSchedulerAsync();
IJobDetail job = JobBuilder.Create <HttpJob>()
.WithIdentity(m.JobName, m.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(m.JobName, m.JobGroup)
.WithCronSchedule(m.CronExpress)
.Build();
await scheduler.ScheduleJob(job, trigger);
await scheduler.Start();
result.Data = m;
return(result);
}
return(result.SetError("传入实体为空"));
}
catch (Exception ex)
{
Log4Net.Error($"[JobCenter_AddScheduleJobAsync]_{ex}");
return(result.SetError(ex.Message));
}
}
public string SaveSchedule(TaskScheduleModel schedule)
{
_taskService.SaveSchedule(schedule.TaskId, schedule.Enabled, schedule.CronExpression);
return("Сохранено");
}
public async Task <Result> ModifyTaskAsync(TaskScheduleModel model)
{
Result result = new Result();
if (model == null)
{
return(result.SetError("Model 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobName))
{
return(result.SetError("JobName 不能为空！"));
}
if (string.IsNullOrEmpty(model.JobGroup))
{
return(result.SetError("JobGroup 不能为空！"));
}
if (model.StarRunTime == null)
{
model.StarRunTime = DateTime.Now;
}
if (model.EndRunTime == null)
{
model.EndRunTime = DateTime.MaxValue.AddDays(-1);
}
//modify
var taskInfo = base.Single <TaskSchedule>(t => t.Id.Equals(model.Id));
if (taskInfo == null)
{
return(result.SetError("无此任务！"));
}
//cron
if (!taskInfo.CronExpress.Equals(model.CronExpress))
{
taskInfo.CronExpress = model.CronExpress;
var stopInfo = await jobCenter.StopScheduleJobAsync(model.JobGroup, model.JobName);
if (!stopInfo.Status.Equals(200))
{
return(result.SetError(stopInfo.Message));
}
var info = await jobCenter.AddScheduleJobAsync(model);
if (!stopInfo.Status.Equals(200))
{
return(result.SetError(info.Message));
}
}
//状态
if (!taskInfo.RunStatus.Equals(model.RunStatus))
{
taskInfo.RunStatus = model.RunStatus;
if (model.RunStatus != (int)TaskJobStatus.PauseJob)
{
var stopInfo = await jobCenter.StopScheduleJobAsync(model.JobGroup, model.JobName);
if (!stopInfo.Status.Equals(200))
{
return(result.SetError(stopInfo.Message));
}
var info = await jobCenter.AddScheduleJobAsync(model);
if (!stopInfo.Status.Equals(200))
{
return(result.SetError(info.Message));
}
}
else
{
var stopInfo = await jobCenter.StopScheduleJobAsync(model.JobGroup, model.JobName);
if (!stopInfo.Status.Equals(200))
{
return(result.SetError(stopInfo.Message));
}
}
}
//
taskInfo.CreateAuthr = identity.Name;
taskInfo.UpdateTime = DateTime.Now;
taskInfo.EndRunTime = model.EndRunTime;
taskInfo.StarRunTime = model.StarRunTime;
taskInfo.JobGroup = model.JobGroup;
taskInfo.JobName = model.JobName;
base.Update(taskInfo, true);
return(result);
}
public async Task <BaseResult> AddJob(TaskScheduleModel entity)
{
return(await this.AddScheduleJobAsync(entity));
}
private bool RunTask(TaskScheduleModel task)
{
//if (task.TaskType == TaskScheduleType.UpdateIntradiaryBOLSAR)
//{
// try
// {
// if (String.IsNullOrEmpty(task.Data))
// UpdateMarketRealTimeQuotes("BCBA");
// else
// {
// LOG.Log($"!!!BOLSAR(BCBA): Data => {task.Data}{Environment.NewLine}");
// UpdateMarketRealTimeQuotes("BOLSAR", "BCBA", task.Data);
// }
// }
// catch (Exception ex)
// {
// LOG.Log($"???ERROR(BCBA): Message=>{ex.Message}{Environment.NewLine}");
// return false;
// }
//}
//if(task.TaskType == TaskScheduleType.UpdateIntradiaryBOLSARINDEX)
//{
// try
// {
// if (!String.IsNullOrEmpty(task.Data))
// {
// LOG.Log($"!!!BOLSARINDEX(BCBA): Data => {task.Data}{Environment.NewLine}");
// UpdateMarketRealTimeQuotes("BOLSARINDEX", "BCBA", task.Data);
// }
// }
// catch (Exception ex)
// {
// LOG.Log($"???ERROR(BCBAINDEX): Message=>{ex.Message}{Environment.NewLine}");
// return false;
// }
//}
//if(task.TaskType == TaskScheduleType.UpdateIntradiaryEOD)
//{
// try
// {
// if (String.IsNullOrEmpty(task.Data))
// {
// try { UpdateMarketRealTimeQuotes("NYSE"); } catch (Exception ex) { LOG.Log($"???ERROR(NYSE): Message=>{ex.Message}{Environment.NewLine}"); return false; }
// try { UpdateMarketRealTimeQuotes("NASDAQ"); } catch (Exception ex) { LOG.Log($"???ERROR(NASDAQ): Message=>{ex.Message}{Environment.NewLine}"); return false; }
// }
// else
// UpdateMarketRealTimeQuotes("EOD","NYSE", task.Data);
// }
// catch (Exception ex)
// {
// LOG.Log($"???ERROR(EOD): Message=>{ex.Message}{Environment.NewLine}");
// return false;
// }
//}
if (task.TaskType == TaskScheduleType.DailyStockTechnicalReport)
{
try { UpdateReportData(); } catch (Exception ex) { LOG.Log($"???ERROR(REPORT): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
}
if (task.TaskType == TaskScheduleType.TenantTypeExpirationValidation)
{
try { VerifyUserTypeExpiration(); } catch (Exception ex) { LOG.Log($"???ERROR(VERIFY USER TYPE EXPIRATION): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
try { UpdateUserTypeExpirationFromMercadoPago(); } catch (Exception ex) { LOG.Log($"???ERROR(MERCADO PAGO: UPDATE USER TYPE EXPIRATION): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
}
if (task.TaskType == TaskScheduleType.DeleteIntradiaryBOLSAR)
{
try { DeleteIntradiaryData("BCBA"); } catch (Exception ex) { LOG.Log($"???ERROR(DeleteIntradiaryData=BOLSAR): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
}
if (task.TaskType == TaskScheduleType.DeleteIntradiaryEOD)
{
try { DeleteIntradiaryData("NASDAQ"); } catch (Exception ex) { LOG.Log($"???ERROR(DeleteIntradiaryData=NASDAQ): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
try { DeleteIntradiaryData("NYSE"); } catch (Exception ex) { LOG.Log($"???ERROR(DeleteIntradiaryData=NYSE): Message=>{ex.Message}{Environment.NewLine}"); return(false); }
}
return(true);
}
public async Task <ResponsResult> DelTaskAsync([FromBody] TaskScheduleModel model)
{
return(await _taskService.DelTaskAsync(model));
}
public static string BuildCronExpression(TaskScheduleModel taskScheduleModel)
{
// 一次性的
if (taskScheduleModel.Cycle == Cycle.Disposable.Key)
{
return(string.Empty);
}
var cronExpression = new StringBuilder();
// 秒
cronExpression.Append(GetSMHValue(taskScheduleModel.Second));
//分
cronExpression.Append(GetSMHValue(taskScheduleModel.Minute));
//小时
cronExpression.Append(GetSMHValue(taskScheduleModel.Hour));
// 每天
if (taskScheduleModel.Cycle == Cycle.Daily.Key)
{
// 日
cronExpression.Append("* ");
// 月
cronExpression.Append("* ");
// 周
cronExpression.Append("?");
}
// 每周
else if (taskScheduleModel.Cycle == Cycle.Weekly.Key)
{
// 一个月中第几天
cronExpression.Append("? ");
// 月份
cronExpression.Append("* ");
// 周
if (string.IsNullOrWhiteSpace(taskScheduleModel.DayOfWeeks))
{
throw new Exception("请设置周");
}
// 一周的哪几天
cronExpression.Append(taskScheduleModel.DayOfWeeks);
}
// 每月
else if (taskScheduleModel.Cycle == Cycle.Monthly.Key)
{
if (string.IsNullOrWhiteSpace(taskScheduleModel.DayOfMonths))
{
throw new Exception("请设置日");
}
// 一个月的哪几天
cronExpression.Append(taskScheduleModel.DayOfMonths);
// 月份
cronExpression.Append(" * ");
// 周
cronExpression.Append("?");
}
var cron = cronExpression.ToString();
return(cron);
}