public virtual async Task <IActionResult> TaskUpdate(ScheduleTaskModel model)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
//try to get a schedule task with the specified id
var scheduleTask = await _scheduleTaskService.GetTaskByIdAsync(model.Id)
?? throw new ArgumentException("Schedule task cannot be loaded");
//To prevent inject the XSS payload in Schedule tasks ('Name' field), we must disable editing this field,
//but since it is required, we need to get its value before updating the entity.
if (!string.IsNullOrEmpty(scheduleTask.Name))
{
model.Name = scheduleTask.Name;
ModelState.Remove(nameof(model.Name));
}
if (!ModelState.IsValid)
{
return(ErrorJson(ModelState.SerializeErrors()));
}
scheduleTask = model.ToEntity(scheduleTask);
await _scheduleTaskService.UpdateTaskAsync(scheduleTask);
//activity log
await _customerActivityService.InsertActivityAsync("EditTask",
string.Format(await _localizationService.GetResourceAsync("ActivityLog.EditTask"), scheduleTask.Id), scheduleTask);
return(new NullJsonResult());
}
protected ScheduleTaskModel PrepareScheduleTaskModel(ScheduleTask task)
{
var model = new ScheduleTaskModel()
{
Id = task.Id,
Name = task.Name,
Seconds = task.Seconds,
Enabled = task.Enabled,
StopOnError = task.StopOnError,
LastStartUtc = task.LastStartUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastStartUtc.Value, DateTimeKind.Utc).ToString("G") : "",
LastEndUtc = task.LastEndUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastEndUtc.Value, DateTimeKind.Utc).ToString("G") : "",
LastSuccessUtc = task.LastSuccessUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastSuccessUtc.Value, DateTimeKind.Utc).ToString("G") : "",
LastError = task.LastError.EmptyNull(),
IsRunning = task.IsRunning, //task.LastStartUtc.GetValueOrDefault() > task.LastEndUtc.GetValueOrDefault(),
Duration = ""
};
var span = TimeSpan.Zero;
if (task.LastStartUtc.HasValue)
{
span = model.IsRunning ? DateTime.UtcNow - task.LastStartUtc.Value : task.LastEndUtc.Value - task.LastStartUtc.Value;
model.Duration = span.ToString("g");
}
return(model);
}
public async Task <IActionResult> EditScheduler(ScheduleTaskModel model, bool continueEditing)
{
var scheduleTask = await _scheduleTaskService.GetTaskById(model.Id);
if (ModelState.IsValid)
{
scheduleTask.Enabled = model.Enabled;
scheduleTask.LeasedByMachineName = model.LeasedByMachineName;
scheduleTask.StopOnError = model.StopOnError;
scheduleTask.TimeInterval = model.TimeInterval;
await _scheduleTaskService.UpdateTask(scheduleTask);
SuccessNotification(_localizationService.GetResource("Admin.System.ScheduleTasks.Updated"));
if (continueEditing)
{
//return RedirectToAction("Edit", new { id = model.Id });
return(await EditScheduler(model.Id));
}
return(RedirectToAction("List"));
}
model.ScheduleTaskName = scheduleTask.ScheduleTaskName;
model.Type = scheduleTask.Type;
ErrorNotification(ModelState);
return(View(model));
}
public ActionResult TaskUpdate(ScheduleTaskModel model, GridCommand command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
//display the first model error
var modelStateErrors = this.ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (scheduleTask == null)
{
return(Content("Schedule task cannot be loaded"));
}
scheduleTask.Name = model.Name;
scheduleTask.Seconds = model.Seconds;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
int max = Int32.MaxValue / 1000;
scheduleTask.Seconds = (model.Seconds > max ? max : model.Seconds);
_scheduleTaskService.UpdateTask(scheduleTask);
return(List(command));
}
public IScheduledProcessorService Build(ScheduleTaskModel schedule, MainContext context)
{
return(new ScheduledProcessorService(_serviceProvider.GetService(typeof(ILogger <ScheduledProcessorService>)) as ILogger <ScheduledProcessorService>,
context,
_serviceProvider.GetService(typeof(IConfiguration)) as IConfiguration,
schedule));
}
protected virtual ScheduleTaskModel PrepareScheduleTaskModel(ScheduleTask task)
{
var model = new ScheduleTaskModel
{
Id = task.Id,
Name = task.Name,
Seconds = task.Seconds,
Enabled = task.Enabled,
StopOnError = task.StopOnError,
LastStartUtc =
task.LastStartUtc.HasValue
? _dateTimeHelper.ConvertToUserTime(task.LastStartUtc.Value, DateTimeKind.Utc).ToString("G")
: "",
LastEndUtc =
task.LastEndUtc.HasValue
? _dateTimeHelper.ConvertToUserTime(task.LastEndUtc.Value, DateTimeKind.Utc).ToString("G")
: "",
LastSuccessUtc =
task.LastSuccessUtc.HasValue
? _dateTimeHelper.ConvertToUserTime(task.LastSuccessUtc.Value, DateTimeKind.Utc).ToString("G")
: ""
};
return(model);
}
public virtual IActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(ErrorJson(ModelState.SerializeErrors()));
}
//try to get a schedule task with the specified id
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id)
?? throw new ArgumentException("Schedule task cannot be loaded");
scheduleTask = model.ToEntity(scheduleTask);
_scheduleTaskService.UpdateTask(scheduleTask);
//activity log
_customerActivityService.InsertActivity("EditTask",
string.Format(_localizationService.GetResource("ActivityLog.EditTask"), scheduleTask.Id), scheduleTask);
return(new NullJsonResult());
}
public virtual IActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
//try to get a schedule task with the specified id
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id)
?? throw new ArgumentException("Schedule task cannot be loaded");
scheduleTask.Name = model.Name;
scheduleTask.Seconds = model.Seconds;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
_scheduleTaskService.UpdateTask(scheduleTask);
//activity log
_customerActivityService.InsertActivity("EditTask",
string.Format("EditTask{0}", scheduleTask.Id), scheduleTask);
return(new NullJsonResult());
}
public virtual IActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
//try to get a schedule task with the specified id
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id)
?? throw new ArgumentException("Schedule task cannot be loaded");
scheduleTask.Name = model.Name;
scheduleTask.Seconds = model.Seconds;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
_scheduleTaskService.UpdateTask(scheduleTask);
//activity log
//_userActivityService.InsertActivity("EditTask",
// string.Format("ActivityLog.EditTask {0}", scheduleTask.Id), scheduleTask);
return(new NullJsonResult());
}
public ActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult()
{
Errors = ModelState.SerializeErrors()
}));
}
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (scheduleTask == null)
{
return(Content("Schedule task cannot be loaded"));
}
scheduleTask.Name = model.Name;
scheduleTask.Seconds = model.Seconds;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
_scheduleTaskService.UpdateTask(scheduleTask);
return(new NullJsonResult());
}
public IActionResult EditScheduler(string id)
{
var task = _scheduleTaskService.GetTaskById(id);
var model = new ScheduleTaskModel();
{
model.Id = task.Id;
model.ScheduleTaskName = task.ScheduleTaskName;
model.LeasedByMachineName = task.LeasedByMachineName;
model.Type = task.Type;
model.Enabled = task.Enabled;
model.StopOnError = task.StopOnError;
model.LastStartUtc = task.LastStartUtc;
model.LastEndUtc = task.LastNonSuccessEndUtc;
model.LastSuccessUtc = task.LastSuccessUtc;
model.TimeIntervalChoice = (int)task.TimeIntervalChoice;
model.TimeInterval = task.TimeInterval;
model.MinuteOfHour = task.MinuteOfHour;
model.HourOfDay = task.HourOfDay;
model.DayOfWeek = (int)task.DayOfWeek;
model.MonthOptionChoice = (int)task.MonthOptionChoice;
model.DayOfMonth = task.DayOfMonth;
}
return(View(model));
}
public virtual ActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (scheduleTask == null)
{
return(Content("Schedule task cannot be loaded"));
}
scheduleTask.Name = model.Name;
scheduleTask.Seconds = model.Seconds;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
_scheduleTaskService.UpdateTask(scheduleTask);
//activity log
_customerActivityService.InsertActivity("EditTask", _localizationService.GetResource("ActivityLog.EditTask"), scheduleTask.Id);
return(new NullJsonResult());
}
public override ActionResult TaskUpdate(ScheduleTaskModel model)
{
//check token renewal limit for the renew access token task
CheckRenewAccessTokenTask(model);
return(base.TaskUpdate(model));
}
private void CheckRenewAccessTokenTask(ScheduleTaskModel model)
{
//whether the updated task is a renew access token task
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (!scheduleTask?.Type.Equals(SquarePaymentDefaults.RenewAccessTokenTask) ?? true)
{
return;
}
//check whether the plugin is installed
if (!(_paymentService.LoadPaymentMethodBySystemName(SquarePaymentDefaults.SystemName)?.PluginDescriptor?.Installed ?? false))
{
return;
}
//check token renewal limit
var accessTokenRenewalPeriod = model.Seconds / 60 / 60 / 24;
if (accessTokenRenewalPeriod > SquarePaymentDefaults.AccessTokenRenewalPeriodMax)
{
var error = string.Format(_localizationService.GetResource("Plugins.Payments.Square.AccessTokenRenewalPeriod.Error"),
SquarePaymentDefaults.AccessTokenRenewalPeriodMax, SquarePaymentDefaults.AccessTokenRenewalPeriodRecommended);
this.ModelState.AddModelError(string.Empty, error);
}
}
public ScheduledProcessorService(ILogger <ScheduledProcessorService> logger, MainContext context, IConfiguration configuration, ScheduleTaskModel schedule)
{
_logger = logger;
_context = context;
_schedule = schedule;
_configuration = configuration;
_trunkName = _configuration.GetValue <string>("Asterisk:TrunkName");
}
public async Task <IActionResult> TaskSubmission(Guid id)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
_logger.LogInformation(user.FirstName + " " + user.LastName + " has accessed TaskSubmission");
ScheduleTaskModel model = _db.ScheduleTask.Where(b => b.Id == id).FirstOrDefault();
return(View(model));
}
/// <summary>
/// Creates and prepares a schedule task view model.
/// </summary>
/// <param name="task">Schedule task.</param>
/// <param name="lastEntry">Last task history entry.</param>
/// <returns>Schedule task model.</returns>
public ScheduleTaskModel CreateScheduleTaskModel(ScheduleTask task, ScheduleTaskHistory lastEntry)
{
if (task == null)
{
return(null);
}
var now = DateTime.UtcNow;
var nextRunPretty = string.Empty;
var isOverdue = false;
TimeSpan?dueIn = task.NextRunUtc.HasValue
? task.NextRunUtc.Value - now
: (TimeSpan?)null;
if (dueIn.HasValue)
{
if (dueIn.Value.TotalSeconds > 0)
{
nextRunPretty = dueIn.Value.Prettify();
}
else
{
nextRunPretty = T("Common.Waiting") + "...";
isOverdue = true;
}
}
var model = new ScheduleTaskModel
{
Id = task.Id,
Name = task.Name,
CronExpression = task.CronExpression,
CronDescription = CronExpression.GetFriendlyDescription(task.CronExpression),
Enabled = task.Enabled,
Priority = task.Priority,
RunPerMachine = task.RunPerMachine,
StopOnError = task.StopOnError,
NextRunPretty = nextRunPretty,
CancelUrl = _urlHelper.Action("CancelJob", "ScheduleTask", new { id = task.Id }),
ExecuteUrl = _urlHelper.Action("RunJob", "ScheduleTask", new { id = task.Id }),
EditUrl = _urlHelper.Action("Edit", "ScheduleTask", new { id = task.Id }),
IsOverdue = isOverdue
};
if (task.NextRunUtc.HasValue)
{
model.NextRun = _dateTimeHelper.ConvertToUserTime(task.NextRunUtc.Value, DateTimeKind.Utc);
}
model.LastHistoryEntry = CreateScheduleTaskHistoryModel(lastEntry);
return(model);
}
/// <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 Edit(ScheduleTaskModel model, bool continueEditing, string returnUrl = null)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(AccessDeniedView());
}
ViewBag.ReturnUrl = returnUrl;
if (!ModelState.IsValid)
{
return(View(model));
}
var reloadResult = RedirectToAction("Edit", new { id = model.Id, returnUrl = returnUrl });
var returnResult = RedirectToReferrer(returnUrl, () => RedirectToAction("List"));
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (scheduleTask == null)
{
NotifyError("Schedule task cannot be loaded");
return(reloadResult);
}
scheduleTask.Name = model.Name;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
scheduleTask.CronExpression = model.CronExpression;
if (model.Enabled)
{
scheduleTask.NextRunUtc = _scheduleTaskService.GetNextSchedule(scheduleTask);
}
else
{
scheduleTask.NextRunUtc = null;
}
_scheduleTaskService.UpdateTask(scheduleTask);
NotifySuccess(T("Admin.System.ScheduleTasks.UpdateSuccess"));
if (continueEditing)
{
return(reloadResult);
}
return(returnResult);
}
protected virtual async Task <ScheduleTaskModel> PrepareStores(ScheduleTaskModel model)
{
model.AvailableStores.Add(new SelectListItem {
Text = _translationService.GetResource("Admin.Common.Select"), Value = ""
});
foreach (var s in await _storeService.GetAllStores())
{
model.AvailableStores.Add(new SelectListItem {
Text = s.Shortcut, Value = s.Id.ToString()
});
}
return(model);
}
public virtual IActionResult TaskUpdate(ScheduleTaskModel model)
{
if (!ModelState.IsValid)
{
return(ErrorJson(ModelState.SerializeErrors()));
}
//try to get a schedule task with the specified id
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id)
?? throw new ArgumentException("Schedule task cannot be loaded");
scheduleTask = model.ToEntity(scheduleTask);
_scheduleTaskService.UpdateTask(scheduleTask);
return(new NullJsonResult());
}
protected virtual ScheduleTaskModel PrepareScheduleTaskModel(ScheduleTask task)
{
var model = new ScheduleTaskModel {
Id = task.Id,
ScheduleTaskName = task.ScheduleTaskName,
LeasedByMachineName = task.LeasedByMachineName,
Type = task.Type,
Enabled = task.Enabled,
StopOnError = task.StopOnError,
LastStartUtc = task.LastStartUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastStartUtc.Value, DateTimeKind.Utc) : default(DateTime?),
LastEndUtc = task.LastNonSuccessEndUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastNonSuccessEndUtc.Value, DateTimeKind.Utc) : default(DateTime?),
LastSuccessUtc = task.LastSuccessUtc.HasValue ? _dateTimeHelper.ConvertToUserTime(task.LastSuccessUtc.Value, DateTimeKind.Utc) : default(DateTime?),
TimeInterval = task.TimeInterval,
};
return(model);
}
protected virtual ScheduleTaskModel PrepareScheduleTaskModel(ScheduleTask task)
{
var model = new ScheduleTaskModel {
Id = task.Id,
ScheduleTaskName = task.ScheduleTaskName,
LeasedByMachineName = task.LeasedByMachineName,
Type = task.Type,
Enabled = task.Enabled,
StopOnError = task.StopOnError,
LastStartUtc = task.LastStartUtc,
LastEndUtc = task.LastNonSuccessEndUtc,
LastSuccessUtc = task.LastSuccessUtc,
TimeInterval = task.TimeInterval,
};
return(model);
}
public ActionResult EditScheduler(ScheduleTaskModel model)
{
if (ModelState.IsValid)
{
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
scheduleTask.TimeIntervalChoice = (TimeIntervalChoice)model.TimeIntervalChoice;
scheduleTask.TimeInterval = model.TimeInterval;
scheduleTask.MinuteOfHour = model.MinuteOfHour;
scheduleTask.HourOfDay = model.HourOfDay;
scheduleTask.DayOfWeek = (DayOfWeek)model.DayOfWeek;
scheduleTask.MonthOptionChoice = (MonthOptionChoice)model.MonthOptionChoice;
scheduleTask.DayOfMonth = model.DayOfMonth;
_scheduleTaskService.UpdateTask(scheduleTask);
return(EditScheduler(model.Id));
}
return(View(model));
}
public async Task <IActionResult> EditScheduler(ScheduleTaskModel model)
{
var scheduleTask = await _scheduleTaskService.GetTaskById(model.Id);
if (ModelState.IsValid)
{
scheduleTask.Enabled = model.Enabled;
scheduleTask.LeasedByMachineName = model.LeasedByMachineName;
scheduleTask.StopOnError = model.StopOnError;
scheduleTask.TimeInterval = model.TimeInterval;
await _scheduleTaskService.UpdateTask(scheduleTask);
return(await EditScheduler(model.Id));
}
model.ScheduleTaskName = scheduleTask.ScheduleTaskName;
model.Type = scheduleTask.Type;
return(View(model));
}
public async Task <IActionResult> EditScheduler(string id)
{
var task = await _scheduleTaskService.GetTaskById(id);
var model = new ScheduleTaskModel();
{
model.Id = task.Id;
model.ScheduleTaskName = task.ScheduleTaskName;
model.LeasedByMachineName = task.LeasedByMachineName;
model.Type = task.Type;
model.Enabled = task.Enabled;
model.StopOnError = task.StopOnError;
model.LastStartUtc = task.LastStartUtc;
model.LastEndUtc = task.LastNonSuccessEndUtc;
model.LastSuccessUtc = task.LastSuccessUtc;
model.TimeInterval = task.TimeInterval;
}
return(View(model));
}
/// <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);
}
public ActionResult Edit(ScheduleTaskModel model, bool continueEditing, string returnUrl = null)
{
ViewBag.ReturnUrl = returnUrl;
if (!ModelState.IsValid)
{
return(View(model));
}
var scheduleTask = _scheduleTaskService.GetTaskById(model.Id);
if (scheduleTask == null)
{
NotifyError("Schedule task cannot be loaded");
return(RedirectToAction("Edit", new { id = model.Id, returnUrl }));
}
scheduleTask.Name = model.Name;
scheduleTask.Enabled = model.Enabled;
scheduleTask.StopOnError = model.StopOnError;
scheduleTask.CronExpression = model.CronExpression;
scheduleTask.Priority = model.Priority;
scheduleTask.NextRunUtc = model.Enabled
? _scheduleTaskService.GetNextSchedule(scheduleTask)
: null;
_scheduleTaskService.UpdateTask(scheduleTask);
NotifySuccess(T("Admin.System.ScheduleTasks.UpdateSuccess"));
if (continueEditing)
{
return(RedirectToAction("Edit", new { id = model.Id, returnUrl }));
}
else if (returnUrl.HasValue())
{
return(RedirectToReferrer(returnUrl, () => RedirectToAction("List")));
}
return(RedirectToAction("List"));
}
public ActionResult TaskUpdate(ScheduleTaskModel task)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ""
}));
}
var scheduleTask = _scheduleTaskService.GetTaskById(task.Id);
if (scheduleTask == null)
{
return(Content("Schedule task cannot be loaded"));
}
scheduleTask.Name = task.Name;
scheduleTask.Seconds = task.Seconds;
scheduleTask.StopOnError = task.StopOnError;
scheduleTask.Enable = task.Enabled;
_scheduleTaskService.UpdateTask(scheduleTask);
return(new JsonResult());
}
public ActionResult Update(ScheduleTaskModel model)
{
if (!CheckPermission(TasksPermissions.ManageScheduleTasks))
{
return(new HttpUnauthorizedResult());
}
if (!ModelState.IsValid)
{
throw new InvalidModelStateException(ModelState);
}
ScheduleTask scheduleTask;
if (model.Id == Guid.Empty)
{
scheduleTask = new ScheduleTask
{
Name = model.Name,
Type = model.Type,
CronExpression = model.CronExpression,
Enabled = model.Enabled
};
scheduleTaskService.InsertTask(scheduleTask);
}
else
{
scheduleTask = scheduleTaskService.GetTaskById(model.Id);
scheduleTask.Name = model.Name;
scheduleTask.Type = model.Type;
scheduleTask.CronExpression = model.CronExpression;
scheduleTask.Enabled = model.Enabled;
scheduleTaskService.UpdateTask(scheduleTask);
}
scheduleTaskManager.ScheduleJob(scheduleTask);
return(new AjaxResult().NotifyMessage("UPDATE_ENTITY_COMPLETE").CloseModalDialog());
}
