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()); }