private TaskDataBaseItem CreateNewDataBaseItemFromTaskAccordingToType(TaskBase task)
{
TaskDataBaseItem newItem = null;
switch (task.TaskType)
{
case TaskType.RecurringTask:
RecurringTask recurringTask = task as RecurringTask;
newItem = new TaskDataBaseItem()
{
Name = recurringTask.Name,
Description = recurringTask.Description,
TaskType = recurringTask.TaskType,
TimeDue = recurringTask.TimeDue,
Interval = recurringTask.Interval,
TaskOccurences = recurringTask.TaskOccurrences.ToArray()
};
break;
default:
throw new NotSupportedException();
}
return(newItem);
}
public Response Update(RecurringTask recurringTask)
{
_recurringTaskService.Update(recurringTask);
return(new Response {
Body = "success"
});
}
public RecurringTaskEntity ToEntity(RecurringTask domain)
{
RecurringTaskEntity entity = new RecurringTaskEntity {
};
_taskMapper.ToEntity(domain, entity);
return(entity);
}
public RecurringTask ToDomain(RecurringTaskEntity entity)
{
RecurringTask domain = new RecurringTask {
};
_taskMapper.ToDomain(entity, domain);
return(domain);
}
private Task ScheduleSteamUpdates(List <Service> services)
{
var user = TCAdmin.SDK.Session.GetCurrentUser();
var rTask = new RecurringTask
{
UserId = user.UserId,
Name = "Batch Steam Update",
Enabled = true,
Source = this.GetType().Name,
SourceId = "-1",
Notes = "Created by Steam Batch Update",
};
var trigger = new Trigger
{
TriggerType = TriggerType.OneTime,
OneTime = new TriggerOneTime
{
StartTimeUtc = DateTime.UtcNow
}
};
rTask.Triggers = new[] { trigger };
foreach (var service in services)
{
var arguments = new XmlField
{
["ScheduledScript.ServiceId"] = service.ServiceId,
["ScheduledScript.ScriptId"] = "steam",
["ScheduledScript.ForceExecution"] = true,
["ScheduledScript.WaitEmpty"] = false,
["ScheduledScript.SkipExecution"] = false,
["ScheduledScript.CheckSteamApiUpdate"] = false
};
var step = new RecurringStep
{
ModuleId = "d3b2aa93-7e2b-4e0d-8080-67d14b2fa8a9",
ProcessId = 18,
ServerId = service.ServerId,
Arguments = arguments.ToString(),
};
var steps = rTask.Steps.ToList();
steps.Add(step);
rTask.Steps = steps.ToArray();
}
rTask.GenerateKey();
rTask.Save();
rTask.ScheduleNextTask();
return(new Task(rTask.TaskId));
}
public async Task AddRecurringTask(RecurringTaskModel model, int userId)
{
using (var db = _dbContextFactory.Create())
{
var recurringTask = new RecurringTask();
recurringTask = _lifeTaskMappingService.PopulateRecurringTaskFromModel(model, recurringTask, userId);
db.RecurringTasks.Add(recurringTask);
await db.SaveChangesAsync();
}
}
private void ProcessRecurringTask(RecurringTask RecurringTask)
{
try
{
if (RecurringTask.WorkFlowStatus == Ignyt.BusinessInterface.WorkFlow.Enum.WorkFlowStatus.Enabled)
{
MyWorkbench.BusinessObjects.Helpers.RecurringHelper.ExecuteRecurring(RecurringTask);
}
}
catch (Exception ex)
{
this.TaskExceptionList.TaskExceptions.Add(ex);
}
}
private void InitializeTaskList()
{
RecurringTask vacuum = new RecurringTask("Run vacuum.")
{
Interval = new TimeSpan(7, 23, 0, 0)
};
RecurringTask dishes = new RecurringTask("Wash dishes.")
{
Interval = new TimeSpan(1, 23, 0, 0)
};
dishes.AddOccurrence(new DateTime(2018, 10, 19), new TimeSpan(0, 20, 0));
this.taskCollection.AddTask(dishes);
this.taskCollection.AddTask(vacuum);
this.taskList.ItemsSource = this.taskCollection;
}
public static void ExecuteRecurring(RecurringTask RecurringTask)
{
using (UnitOfWork unitOfWork = new UnitOfWork(RecurringTask.Session.DataLayer))
{
var myCloner = new DevExpress.Persistent.Base.Cloner();
RecurringTask recurringTask = unitOfWork.FindObject <RecurringTask>(CriteriaOperator.Parse("Oid == ?", RecurringTask.Oid));
Task task = null;
if (recurringTask.WorkFlowStatus == WorkFlowStatus.Enabled && (recurringTask.NextDate == null || recurringTask.NextDate <= MyWorkbench.BaseObjects.Constants.Constants.DateTimeTimeZone(unitOfWork)))
{
task = new Task(unitOfWork);
recurringTask.CopyProperties(task);
task.BookedTime = recurringTask.NextDate != null ? recurringTask.NextDate : recurringTask.Starting;
task.BookedTimeEnd = ((DateTime)task.BookedTime).AddHours(Constants.AppointmentLength(task.Session));
task.Party = recurringTask.Party;
if (recurringTask.WorkflowResources.Count >= 1)
{
var j = recurringTask.WorkflowResources.Count;
for (int i = 0; i < j; i++)
{
task.WorkflowResources.Add(myCloner.CloneTo(recurringTask.WorkflowResources[i], typeof(WorkflowResource)) as WorkflowResource);
}
}
recurringTask.AdvanceNextDate();
// New Object Tracking
(task as WorkflowBase).ChildItems.Add(recurringTask);
(task as WorkflowBase).Tracking.Add(CreateTracking(unitOfWork, task, string.Format("Created from {0}", recurringTask.No)));
//Current Object Tracking
recurringTask.ChildItems.Add(task as WorkflowBase);
recurringTask.Tracking.Add(CreateTracking(unitOfWork, task, string.Format("Converted to {0}", (task as WorkflowBase).GetType().Name)));
}
unitOfWork.CommitChanges();
}
}
internal static IRecurringStartCalculator Create(RecurringTask task)
{
switch (task.TaskType)
{
case RecurringTaskTypes.Daily:
return(new DailyStartCalculator(task.Interval, task.StartDate, task.EndDate, task.StartTime));
case RecurringTaskTypes.Weekly:
return(new WeeklyStartCalculator(task.Interval, task.RecurrenceFactor, task.StartDate, task.EndDate, task.StartTime));
case RecurringTaskTypes.Monthly:
return(new MonthlyStartCalculator(task.Interval, task.RecurrenceFactor, task.StartDate, task.EndDate, task.StartTime));
case RecurringTaskTypes.MonthlyRelative:
return(new MonthlyRelativeStartCalculator(task.Interval, task.RelativeInterval, task.RecurrenceFactor, task.StartDate, task.EndDate, task.StartTime));
default:
throw new ArgumentException("Неопределенный тип расписания циклической задачи: " + task.TaskType);
}
}
public async Task ItAllowsForRecurringTasksToBeCanceled()
{
var taskName = Guid.NewGuid().ToString();
RecurringTask recurringTask = null;
Func <string, TaskScheduler, Task> configureSchedulerAction = async(semaphoreFile, taskScheduler) =>
{
recurringTask = await taskScheduler.AddRecurringTask(() => TaskQueueTestFixture.WriteSemaphore(semaphoreFile),
$"*/{IntervalSeconds} * * * * *", taskName);
};
Func <TaskScheduler, Task> cancelTaskAction = async(taskScheduler) =>
{
(await taskScheduler.CancelRecurringTask(recurringTask)).Should().BeTrue();
};
await TaskSchedulerTestHelpers.AssertTaskSchedulerDoesNotWriteSemaphore(
IntervalSeconds,
configureSchedulerAction,
cancelTaskAction);
}
public void UpdateItemInformation(TaskDataBaseItem dataBaseItem)
{
TaskBase task = this.dataBaseItemToTask[dataBaseItem];
dataBaseItem.Name = task.Name;
dataBaseItem.Description = task.Description;
dataBaseItem.TaskType = task.TaskType;
dataBaseItem.TimeDue = task.TimeDue;
switch (task.TaskType)
{
case TaskType.RecurringTask:
RecurringTask recurringTask = task as RecurringTask;
dataBaseItem.Interval = recurringTask.Interval;
dataBaseItem.TaskOccurences = recurringTask.TaskOccurrences.ToArray();
break;
default:
throw new NotSupportedException();
}
}
private TaskBase CreateNewTaskAccordingToTaskBaseItem(TaskDataBaseItem dataBaseItem)
{
TaskBase newTask = null;
switch (dataBaseItem.TaskType)
{
case TaskType.RecurringTask:
RecurringTask newRecurringTask = new RecurringTask(dataBaseItem.Name);
newRecurringTask.Description = dataBaseItem.Description;
newRecurringTask.Interval = dataBaseItem.Interval;
foreach (TaskOccurrence occurrence in dataBaseItem.TaskOccurences)
{
newRecurringTask.AddOccurrence(occurrence.OccurrenceMoment, occurrence.OccurrenceDuration);
}
newTask = newRecurringTask;
break;
default:
throw new NotSupportedException();
}
return(newTask);
}
public RecurringTask PopulateRecurringTaskFromModel(RecurringTaskModel model, RecurringTask dbRecurringTask, int?userId = null)
{
if (dbRecurringTask.UserId == 0)
{
if (userId.HasValue)
{
dbRecurringTask.UserId = userId.Value;
}
else
{
throw new InvalidOperationException("This task has not been created in the context of a user");
}
}
dbRecurringTask.Name = model.Name;
dbRecurringTask.Description = model.Description;
dbRecurringTask.RecurrenceInterval = model.RecurrenceInterval;
dbRecurringTask.TaskRecurrenceType = model.TaskRecurrenceType;
foreach (var taskModel in model.Tasks)
{
var dbTask = new LifeTask();
dbTask = PopulateLifeTaskFromModel(taskModel, dbTask, userId);
dbRecurringTask.Tasks.Add(dbTask);
}
return(dbRecurringTask);
}
public void Update(RecurringTask domain)
{
_modelServiceTools.UpdateProcessing <RecurringTaskEntity>(domain);
_lifeManagerRepository.SaveEntity(_recurringTaskMapper.ToEntity(domain));
}
public void Create(RecurringTask domain)
{
_modelServiceTools.InitialiseNewItem(domain);
_lifeManagerRepository.SaveEntity(_recurringTaskMapper.ToEntity(domain));
}
