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 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;
_scheduleTaskService.UpdateTask(scheduleTask);
return(List(command));
}
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 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 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 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 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 async Task <IActionResult> EditScheduler(string id)
{
var task = await _scheduleTaskService.GetTaskById(id);
var model = task.ToModel(_dateTimeService);
model = await PrepareStores(model);
return(View(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 virtual void DeleteExportProfile(ExportProfile profile, bool force = false)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (!force && profile.IsSystemProfile)
{
throw new SmartException(_localizationService.GetResource("Admin.DataExchange.Export.CannotDeleteSystemProfile"));
}
int scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetExportFolder();
_exportProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
_eventPublisher.EntityDeleted(profile);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
public virtual void DeleteExportProfile(ExportProfile profile, bool force = false)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (!force && profile.IsSystemProfile)
{
throw new SmartException(_localizationService.GetResource("Admin.DataExchange.Export.CannotDeleteSystemProfile"));
}
int scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetExportFolder();
var deployments = profile.Deployments.Where(x => !x.IsTransientRecord()).ToList();
if (deployments.Any())
{
_exportDeploymentRepository.DeleteRange(deployments);
_exportDeploymentRepository.Context.SaveChanges();
}
_exportProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
/// <summary>
/// Handle model received event
/// </summary>
/// <param name="eventMessage">Event message</param>
public void HandleEvent(ModelReceivedEvent <BaseNopModel> eventMessage)
{
//whether received model is ScheduleTaskModel
if (!(eventMessage?.Model is ScheduleTaskModel scheduleTaskModel))
{
return;
}
//whether renew access token task is changed
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskModel.Id);
if (!scheduleTask?.Type.Equals(SquarePaymentDefaults.RenewAccessTokenTask) ?? true)
{
return;
}
//check token renewal limit
var accessTokenRenewalPeriod = scheduleTaskModel.Seconds / 60 / 60 / 24;
if (accessTokenRenewalPeriod > SquarePaymentDefaults.AccessTokenRenewalPeriodMax)
{
var error = string.Format(_localizationService.GetResource("Plugins.Payments.Square.AccessTokenRenewalPeriod.Error"),
SquarePaymentDefaults.AccessTokenRenewalPeriodMax, SquarePaymentDefaults.AccessTokenRenewalPeriodRecommended);
eventMessage.ModelState.AddModelError(string.Empty, error);
}
}
public ActionResult RunNow(int id)
{
//var a = new Eden.Web.Console.Infrastructure.RealtimeAqiMakeTask();
//var t = Type.GetType("Eden.Web.Console.Infrastructure.RealtimeAqiMakeTask");
try
{
var scheduleTask = _taskService.GetTaskById(id);
if (scheduleTask == null)
{
return(BadArguments());
}
var task = new Task(scheduleTask);
//ensure that the task is enabled
task.Enabled = true;
//do not dispose. otherwise, we can get exception that DbContext is disposed
task.Execute(true, false);
}
catch (Exception ex)
{
return(new BadResponse(ex.Message));
}
return(Ok());
}
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());
}
public Task <ActionResult> ExecuteTask()
{
var stask = _scheduleTaskService.GetTaskById(3).Result;
var task = new Service.Tasks.Task(stask);
task.Enabled = true;
task.Execute(true);
return(null);
}
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));
}
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 Edit(Guid id)
{
if (!CheckPermission(TasksPermissions.ManageScheduleTasks))
{
return(new HttpUnauthorizedResult());
}
var model = scheduleTaskService.GetTaskById(id);
WorkContext.Breadcrumbs.Add(T("Scheduled Tasks"), Url.Action("Index"));
WorkContext.Breadcrumbs.Add(model.Name);
WorkContext.Breadcrumbs.Add(T("Edit"));
return(new ControlFormResult <ScheduleTaskModel>(model)
{
Title = T("Edit Task").Text,
UpdateActionName = "Update",
ShowBoxHeader = false,
FormWrapperStartHtml = Constants.Form.FormWrapperStartHtml,
FormWrapperEndHtml = Constants.Form.FormWrapperEndHtml
});
}
//available even when navigation is not allowed
// [CheckAccessPublicStore(true)]
public virtual IActionResult PasswordRecovery(PasswordRecoveryModel model)
{
if (ModelState.IsValid)
{
var user = _userService.GetUserByEmail(model.Email);
if (user != null && user.IsActive && !user.Deleted)
{
//save token and current date
var passwordRecoveryToken = Guid.NewGuid();
_genericAttributeService.SaveAttribute(user, ResearchUserDefaults.PasswordRecoveryTokenAttribute,
passwordRecoveryToken.ToString());
DateTime?generatedDateTime = DateTime.UtcNow;
_genericAttributeService.SaveAttribute(user,
ResearchUserDefaults.PasswordRecoveryTokenDateGeneratedAttribute, generatedDateTime);
//send email
_workflowMessageService.SendUserPasswordRecoveryMessage(user, 0);
var scheduleTask = _scheduleTaskService.GetTaskById(1);
var task = new Task(scheduleTask)
{
Enabled = true
};
task.Execute(true, false);
model.Result = "ระบบได้ส่งอีเมลเพื่อดำเนินการรีเซตรหัสผ่านเรียบร้อยแล้ว";
}
else
{
model.Result = "ไม่พบอีเมลของท่านในระบบ";
}
return(View(model));
}
//If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Execute(int id /* taskId */)
{
if (!_taskScheduler.VerifyAuthToken(Request.Headers["X-AUTH-TOKEN"]))
{
return(new HttpUnauthorizedResult());
}
var task = _scheduledTaskService.GetTaskById(id);
if (task == null)
{
return(HttpNotFound());
}
_taskExecutor.Execute(task);
return(Content("Task '{0}' executed".FormatCurrent(task.Name)));
}
public ActionResult Edit(ScheduleTaskModel model, bool continueEditing, string returnUrl = null)
{
if (!Services.Permissions.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 = returnUrl.HasValue() ? (ActionResult)Redirect(returnUrl) : (ActionResult)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;
scheduleTask.NextRunUtc = model.Enabled
? _scheduleTaskService.GetNextSchedule(scheduleTask)
: null;
_scheduleTaskService.UpdateTask(scheduleTask);
NotifySuccess(T("Admin.System.ScheduleTasks.UpdateSuccess"));
if (continueEditing)
{
return(reloadResult);
}
return(returnResult);
}
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 virtual void DeleteImportProfile(ImportProfile profile)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
var scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetImportFolder();
_importProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
public async Task <ActionResult> Execute(int id /* taskId */)
{
if (!_taskScheduler.VerifyAuthToken(Request.Headers["X-AUTH-TOKEN"]))
{
return(new HttpUnauthorizedResult());
}
var task = _scheduleTaskService.GetTaskById(id);
if (task == null)
{
return(HttpNotFound());
}
var taskParameters = QueryString.Current.ToDictionary();
Virtualize(taskParameters);
await _taskExecutor.ExecuteAsync(task, taskParameters);
return(Content("Task '{0}' executed".FormatCurrent(task.Name)));
}
public ActionResult GetTaskRunInfo(int id /* taskId */)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(new HttpUnauthorizedResult());
}
var task = _scheduleTaskService.GetTaskById(id);
if (task == null)
{
return(HttpNotFound());
}
var model = PrepareScheduleTaskModel(task);
return(Json(new
{
lastRunHtml = this.RenderPartialViewToString("_LastRun", model),
nextRunHtml = this.RenderPartialViewToString("_NextRun", model)
}));
}
public ActionResult GetTaskRunInfo(int id /* taskId */)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
{
return(new HttpUnauthorizedResult());
}
var task = _scheduleTaskService.GetTaskById(id);
if (task == null)
{
return(HttpNotFound());
}
var model = task.ToScheduleTaskModel(_localizationService, _dateTimeHelper, Url);
return(Json(new
{
lastRunHtml = this.RenderPartialViewToString("~/Administration/Views/ScheduleTask/_LastRun.cshtml", model),
nextRunHtml = this.RenderPartialViewToString("~/Administration/Views/ScheduleTask/_NextRun.cshtml", model)
}));
}
/// <summary>
/// Gets a task
/// </summary>
/// <param name="taskId">Task identifier</param>
/// <returns>Task</returns>
public ScheduleTask GetTaskById(int taskId)
{
return(_scheduleTaskService.GetTaskById(taskId));
}
