public void Start(HttpContextBase httpContext)
{
var tasks = _taskService.GetAllTasks(true);
_taskService.CalculateFutureSchedules(tasks, true /* isAppStart */);
var baseUrl = CommonHelper.GetAppSetting <string>("sm:TaskSchedulerBaseUrl");
if (baseUrl.IsWebUrl())
{
_taskScheduler.BaseUrl = baseUrl;
}
else
{
// autoresolve base url
_taskScheduler.SetBaseUrl(_storeService, httpContext);
}
_taskScheduler.SweepIntervalMinutes = CommonHelper.GetAppSetting <int>("sm:TaskSchedulerSweepInterval", 1);
_taskScheduler.Start();
Logger.Info("Initialized TaskScheduler with base url '{0}'".FormatInvariant(_taskScheduler.BaseUrl));
_eventPublisher.Publish(new AppInitScheduledTasksEvent {
ScheduledTasks = tasks
});
}
public void Execute()
{
//获取所有京东Task
var jdTasks = _typeFinder.FindClassesOfType <IJDTask>();
//系统已注册的Task
var allTask = _scheduleTaskService.GetAllTasks(true);
//未注册计划任务的Task
var notRegJDTask = jdTasks.Where(t => allTask.Select(p => p.Type).Contains(t.AssemblyQualifiedName) == false);
//注册
notRegJDTask.Select(p =>
{
var task = (IJDTask)Activator.CreateInstance(p);
return(new ScheduleTask()
{
Name = task.TaskName,
Seconds = task.Minutes * 60,
Type = p.AssemblyQualifiedName,
Enabled = true,
StopOnError = task.StopOnError
});
}).ToList().ForEach(task =>
{
_scheduleTaskService.InsertTask(task);
});
}
public ActionResult List()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
var models = _scheduleTaskService.GetAllTasks(true)
.Select(PrepareScheduleTaskModel)
.ToList();
var model = new GridModel <ScheduleTaskModel>
{
Data = models,
Total = models.Count
};
return(View(model));
}
public async Task <IActionResult> List(DataSourceRequest command)
{
var models = (await _scheduleTaskService.GetAllTasks())
.Select(PrepareScheduleTaskModel)
.ToList();
var gridModel = new DataSourceResult {
Data = models,
Total = models.Count
};
return(Json(gridModel));
}
public ActionResult List(DataSourceRequest command)
{
var models = _scheduleTaskService.GetAllTasks(true).Select(PrepareScheduleTaskModel).ToList();
//var models = _scheduleTaskService.GetAllTasks(true).ToList();
var gridModel = new DataSourceResult
{
Data = models,
Total = models.Count
};
return(Json(gridModel));
}
public async Task <IActionResult> List(DataSourceRequest command)
{
//get all tasks and then change their type inside PrepareSCheduleTaskModel and return as List<ScheduleTaskModel>
var models = (await _scheduleTaskService.GetAllTasks())
.Select(PrepareScheduleTaskModel)
.ToList();
var gridModel = new DataSourceResult {
Data = models,
Total = models.Count
};
return(Json(gridModel));
}
/// <summary>
/// Prepare paged schedule task list model
/// </summary>
/// <param name="searchModel">Schedule task search model</param>
/// <returns>Schedule task list model</returns>
public virtual ScheduleTaskListModel PrepareScheduleTaskListModel(ScheduleTaskSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
//get schedule tasks
var scheduleTasks = _scheduleTaskService.GetAllTasks(true);
//prepare list model
var model = new ScheduleTaskListModel
{
Data = scheduleTasks.PaginationByRequestModel(searchModel).Select(scheduleTask =>
{
//fill in model values from the entity
var scheduleTaskModel = new ScheduleTaskModel
{
Id = scheduleTask.Id,
Name = scheduleTask.Name,
Seconds = scheduleTask.Seconds,
Enabled = scheduleTask.Enabled,
StopOnError = scheduleTask.StopOnError
};
//convert dates to the user time
if (scheduleTask.LastStartUtc.HasValue)
{
scheduleTaskModel.LastStartUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastStartUtc.Value, DateTimeKind.Utc).ToString("G");
}
if (scheduleTask.LastEndUtc.HasValue)
{
scheduleTaskModel.LastEndUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastEndUtc.Value, DateTimeKind.Utc).ToString("G");
}
if (scheduleTask.LastSuccessUtc.HasValue)
{
scheduleTaskModel.LastSuccessUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastSuccessUtc.Value, DateTimeKind.Utc).ToString("G");
}
return(scheduleTaskModel);
}),
Total = scheduleTasks.Count
};
return(model);
}
public ActionResult List()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
var model = _scheduleTaskService.GetAllTasks(true)
.Where(IsTaskVisible)
.Select(PrepareScheduleTaskModel)
.ToList();
return(View(model));
}
public ActionResult List()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
var model = _scheduleTaskService.GetAllTasks(true)
.Where(IsTaskVisible)
.Select(x => x.ToScheduleTaskModel(_localizationService, _dateTimeHelper, Url))
.ToList();
return(View(model));
}
/// <summary>
/// Initializes the task manager
/// </summary>
public void Initialize()
{
_taskThreads.Clear();
IScheduleTaskService taskService = ServiceProviderFactory.ServiceProvider.GetService <IScheduleTaskService>();
List <ScheduleTask> scheduleTasks = taskService
.GetAllTasks()
.OrderBy(x => x.Seconds)
.ToList();
foreach (ScheduleTask scheduleTask in scheduleTasks)
{
TaskThread taskThread = new TaskThread
{
Seconds = scheduleTask.Seconds
};
//sometimes a task period could be set to several hours (or even days)
//in this case a probability that it'll be run is quite small (an application could be restarted)
//calculate time before start an interrupted task
if (scheduleTask.LastStartUtc.HasValue)
{
//seconds left since the last start
double secondsLeft = (DateTime.UtcNow - scheduleTask.LastStartUtc).Value.TotalSeconds;
if (secondsLeft >= scheduleTask.Seconds)
{
//run now (immediately)
taskThread.InitSeconds = 0;
}
else
{
//calculate start time
//and round it (so "ensureRunOncePerPeriod" parameter was fine)
taskThread.InitSeconds = (int)(scheduleTask.Seconds - secondsLeft) + 1;
}
}
else
{
//first start of a task
taskThread.InitSeconds = scheduleTask.Seconds;
}
taskThread.AddTask(scheduleTask);
_taskThreads.Add(taskThread);
}
}
public virtual ActionResult List(DataSourceRequest command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedKendoGridJson());
}
var models = _scheduleTaskService.GetAllTasks(true).OrderByDescending(p => p.Enabled).ThenByDescending(p => p.Id)
.Select(PrepareScheduleTaskModel)
.ToList();
var gridModel = new DataSourceResult
{
Data = models,
Total = models.Count
};
return(Json(gridModel));
}
public ActionResult List()
{
var models = new List <ScheduleTaskModel>();
var tasks = _scheduleTaskService.GetAllTasks(true);
var lastHistoryEntries = _scheduleTaskService.GetHistoryEntries(0, int.MaxValue, 0, true, true).ToDictionarySafe(x => x.ScheduleTaskId);
foreach (var task in tasks.Where(x => x.IsVisible()))
{
lastHistoryEntries.TryGetValue(task.Id, out var lastEntry);
var model = _adminModelHelper.CreateScheduleTaskModel(task, lastEntry);
if (model != null)
{
models.Add(model);
}
}
return(View(models));
}
/// <summary>
/// Prepare paged schedule task list model
/// </summary>
/// <param name="searchModel">Schedule task search model</param>
/// <returns>Schedule task list model</returns>
public virtual ScheduleTaskListModel PrepareScheduleTaskListModel(ScheduleTaskSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
//get schedule tasks
var scheduleTasks = _scheduleTaskService.GetAllTasks(true).ToPagedList(searchModel);
//prepare list model
var model = new ScheduleTaskListModel().PrepareToGrid(searchModel, scheduleTasks, () =>
{
return(scheduleTasks.Select(scheduleTask =>
{
//fill in model values from the entity
var scheduleTaskModel = scheduleTask.ToModel <ScheduleTaskModel>();
//convert dates to the user time
if (scheduleTask.LastStartUtc.HasValue)
{
scheduleTaskModel.LastStartUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastStartUtc.Value, DateTimeKind.Utc).ToString("G");
}
if (scheduleTask.LastEndUtc.HasValue)
{
scheduleTaskModel.LastEndUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastEndUtc.Value, DateTimeKind.Utc).ToString("G");
}
if (scheduleTask.LastSuccessUtc.HasValue)
{
scheduleTaskModel.LastSuccessUtc = _dateTimeHelper
.ConvertToUserTime(scheduleTask.LastSuccessUtc.Value, DateTimeKind.Utc).ToString("G");
}
return scheduleTaskModel;
}));
});
return(model);
}
public IActionResult List(DataSourceRequest command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
//get all tasks and then change their type inside PrepareSCheduleTaskModel and return as List<ScheduleTaskModel>
var models = _scheduleTaskService.GetAllTasks()
.Select(PrepareScheduleTaskModel)
.ToList();
var gridModel = new DataSourceResult
{
Data = models,
Total = models.Count
};
return(Json(gridModel));
}
/// <summary>
/// Prepare paged schedule task list model
/// </summary>
/// <param name="searchModel">Schedule task search model</param>
/// <returns>Schedule task list model</returns>
public virtual ScheduleTaskListModel PrepareScheduleTaskListModel(ScheduleTaskSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
//get schedule tasks
var scheduleTasks = _scheduleTaskService.GetAllTasks(true);
//prepare list model
ScheduleTaskListModel model = new ScheduleTaskListModel
{
Data = scheduleTasks.PaginationByRequestModel(searchModel).Select(scheduleTask =>
{
//fill in model values from the entity
ScheduleTaskModel scheduleTaskModel = scheduleTask.ToModel <ScheduleTaskModel>();
//convert dates to the user time
if (scheduleTask.LastStartUtc.HasValue)
{
scheduleTaskModel.LastStartUtc = scheduleTask.LastStartUtc.Value.ToString("G");
}
if (scheduleTask.LastEndUtc.HasValue)
{
scheduleTaskModel.LastEndUtc = scheduleTask.LastEndUtc.Value.ToString("G");
}
if (scheduleTask.LastSuccessUtc.HasValue)
{
scheduleTaskModel.LastSuccessUtc = scheduleTask.LastSuccessUtc.Value.ToString("G");
}
return(scheduleTaskModel);
}),
Total = scheduleTasks.Count
};
return(model);
}
private ScheduleTask FindScheduledTask()
{
return(_scheduleTaskService.GetAllTasks().Where(x => x.Type.Equals("Nop.Plugin.Misc.ScheduledXmlEporter.ScheduledXmlEporterSynchronizationTask, Nop.Plugin.Misc.ScheduledXmlEporter", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault());
}
private ScheduleTask FindScheduledTask()
{
return(_scheduleTaskService.GetAllTasks().Where(x => x.Type.Equals("Nop.Plugin.Misc.XmlUpdateFromRotap.XmlUpdateFromRotapTask, Nop.Plugin.Misc.XmlUpdateFromRotap", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault());
}
private ControlGridAjaxData <ScheduleTask> GetScheduleTasks(ControlGridFormRequest arg)
{
var tasks = scheduleTaskService.GetAllTasks();
return(new ControlGridAjaxData <ScheduleTask>(tasks));
}
/// <summary>
/// Gets all tasks
/// </summary>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>Tasks</returns>
public IList <ScheduleTask> GetAllTasks(bool showHidden = false)
{
return(_scheduleTaskService.GetAllTasks(showHidden));
}
