/// <summary>
/// this method add threadEvent for each type of event but it depend on event type.
/// </summary>
/// <param name="_event">if event is start one ,it will add it after calling ProcessEngine.ContinueProcess method, because start event should add after condition time ad continue immediately but other events just add before condition time to execute after schedule executing .</param>
public ResultOperation NextTimerExecuteDate(sysBpmsEvent _event, Guid?threadTaskId)
{
ResultOperation resultOperation = new ResultOperation();
if (_event.SubTypeTimerEventModel != null && base.EngineSharedModel.CurrentProcessID.HasValue)
{
sysBpmsThreadEvent newThreadEvent = new sysBpmsThreadEvent()
{
StartDate = DateTime.Now,
EventID = _event.ID,
StatusLU = (int)sysBpmsThreadEvent.e_StatusLU.InProgress,
ThreadID = base.EngineSharedModel.CurrentThreadID.Value,
ThreadTaskID = threadTaskId
};
ThreadEventService threadEventService = new ThreadEventService(base.UnitOfWork);
sysBpmsThreadEvent lastExecutedThreadEvent;
switch ((SubTypeTimerEventModel.e_Type)_event.SubTypeTimerEventModel.Type)
{
case SubTypeTimerEventModel.e_Type.Interval:
lastExecutedThreadEvent = this.GetLastExecutedThreadEventForInterval(_event);
this.SetThreadEventOnInterval(_event, newThreadEvent, lastExecutedThreadEvent);
break;
case SubTypeTimerEventModel.e_Type.WaitFor:
lastExecutedThreadEvent = this.GetLastExecutedThreadEvent(_event);
this.SetThreadEventOnWaitFor(_event, newThreadEvent);
break;
case SubTypeTimerEventModel.e_Type.WaitUntil:
lastExecutedThreadEvent = this.GetLastExecutedThreadEvent(_event);
this.SetThreadEventOnWaitUntil(_event, newThreadEvent);
break;
default:
return(resultOperation);
}
if (_event.TypeLU == (int)sysBpmsEvent.e_TypeLU.StartEvent)
{
//if threadEvent prevoiusly was created , it would not create new one.
if (newThreadEvent.ExecuteDate > DateTime.Now ||
(lastExecutedThreadEvent != null && newThreadEvent.ExecuteDate == lastExecutedThreadEvent.ExecuteDate))
{
return(resultOperation);
}
else
{
resultOperation = new ProcessEngine(base.EngineSharedModel, base.UnitOfWork).ContinueProcess(newThreadEvent, false).Item1;
if (!resultOperation.IsSuccess)
{
return(resultOperation);
}
newThreadEvent.ThreadID = base.EngineSharedModel.CurrentThreadID.Value;
newThreadEvent.StatusLU = (int)sysBpmsThreadEvent.e_StatusLU.Done;
}
}
threadEventService.Add(newThreadEvent);
}
return(resultOperation);
}
public void Delete(Guid threadEventId)
{
sysBpmsThreadEvent threadEvent = this.Context.sysBpmsThreadEvents.FirstOrDefault(d => d.ID == threadEventId);
if (threadEvent != null)
{
this.Context.sysBpmsThreadEvents.Remove(threadEvent);
}
}
public ResultOperation Update(sysBpmsThreadEvent threadEvent)
{
ResultOperation resultOperation = new ResultOperation();
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <IThreadEventRepository>().Update(threadEvent);
this.UnitOfWork.Save();
}
return(resultOperation);
}
public void Update(sysBpmsThreadEvent threadEvent)
{
//To fix 'Attaching an entity failed' error.
var local = this.Context.Set <sysBpmsThreadEvent>().Local.FirstOrDefault(f => f.ID == threadEvent.ID);
if (local != null)
{
this.Context.Entry(local).State = EntityState.Detached;
local = null;
}
this.Context.Entry(threadEvent.Clone()).State = EntityState.Modified;
}
private void SetThreadEventOnWaitUntil(sysBpmsEvent _event, sysBpmsThreadEvent newThreadEvent)
{
string variableData = _event.SubTypeTimerEventModel.VariableData;
switch ((SubTypeTimerEventModel.e_SetType)_event.SubTypeTimerEventModel.SetType)
{
case SubTypeTimerEventModel.e_SetType.Static:
newThreadEvent.ExecuteDate = _event.SubTypeTimerEventModel.DateTime.Value;
break;
case SubTypeTimerEventModel.e_SetType.Variable:
newThreadEvent.ExecuteDate = Convert.ToDateTime(new DataManageEngine(base.EngineSharedModel, base.UnitOfWork).GetValueByBinding(variableData));
break;
}
}
public ResultOperation AddThreadEventMessage(sysBpmsEvent senderEvent, Guid?threadTaskId)
{
ResultOperation resultOperation = new ResultOperation();
ThreadEventService threadEventService = new ThreadEventService(base.UnitOfWork);
sysBpmsThreadEvent threadEvent = new sysBpmsThreadEvent()
{
StartDate = DateTime.Now,
EventID = senderEvent.ID,
StatusLU = (int)sysBpmsThreadEvent.e_StatusLU.InProgress,
ThreadID = base.EngineSharedModel.CurrentThreadID.Value,
ThreadTaskID = threadTaskId,
ExecuteDate = DateTime.Now,//it eill be updated in SendMessage method.
};
threadEventService.Add(threadEvent);
return(resultOperation);
}
private void SetThreadEventOnWaitFor(sysBpmsEvent _event, sysBpmsThreadEvent newThreadEvent)
{
string variableData = _event.SubTypeTimerEventModel.VariableData;
switch ((SubTypeTimerEventModel.e_SetType)_event.SubTypeTimerEventModel.SetType)
{
case SubTypeTimerEventModel.e_SetType.Static:
if (_event.TypeLU == (int)sysBpmsEvent.e_TypeLU.StartEvent)
{
newThreadEvent.ExecuteDate = new ProcessService(base.UnitOfWork).GetInfo(_event.Element.ProcessID).PublishDate.Value.AddMinutes(_event.SubTypeTimerEventModel.Minute.Value);
}
else
{
newThreadEvent.ExecuteDate = DateTime.Now.AddMinutes(_event.SubTypeTimerEventModel.Minute.Value);
}
break;
case SubTypeTimerEventModel.e_SetType.Variable:
newThreadEvent.ExecuteDate = DateTime.Now.AddMinutes(new DataManageEngine(base.EngineSharedModel, base.UnitOfWork).GetValueByBinding(variableData).ToIntObj());
break;
}
}
private void SetThreadEventOnInterval(sysBpmsEvent _event, sysBpmsThreadEvent newThreadEvent, sysBpmsThreadEvent lastExecutedThreadEvent)
{
IDataManageEngine dataManageEngine = new DataManageEngine(base.EngineSharedModel, base.UnitOfWork);
string variableData = _event.SubTypeTimerEventModel.VariableData;
ThreadEventService threadEventService = new ThreadEventService(base.UnitOfWork);
int executedCount = 0;
if (_event.TypeLU == (int)sysBpmsEvent.e_TypeLU.StartEvent)
{
executedCount = threadEventService.GetCount(null, _event.ID, base.EngineSharedModel.CurrentProcessID, (int)sysBpmsThreadEvent.e_StatusLU.Done);
}
else
{
executedCount = threadEventService.GetCount(base.EngineSharedModel.CurrentThreadID, _event.ID, null, (int)sysBpmsThreadEvent.e_StatusLU.Done);
}
PersianCalendar pc = new PersianCalendar();
if (_event.SubTypeTimerEventModel.RepeatTimes.ToIntObj() == 0 || _event.SubTypeTimerEventModel.RepeatTimes > executedCount)
{
switch ((SubTypeTimerEventModel.e_IntervalType)_event.SubTypeTimerEventModel.IntervalType)
{
case SubTypeTimerEventModel.e_IntervalType.SpecificMinute:
switch ((SubTypeTimerEventModel.e_SetType)_event.SubTypeTimerEventModel.SetType)
{
case SubTypeTimerEventModel.e_SetType.Static:
newThreadEvent.ExecuteDate = DateTime.Now.AddMinutes(_event.SubTypeTimerEventModel.Minute.ToIntObj());
break;
case SubTypeTimerEventModel.e_SetType.Variable:
newThreadEvent.ExecuteDate = DateTime.Now.AddMinutes(dataManageEngine.GetValueByBinding(variableData).ToIntObj());
break;
}
break;
case SubTypeTimerEventModel.e_IntervalType.EveryMonth:
int lastDayExecuted = DateTime.Now.Day - 1;
if (lastExecutedThreadEvent != null && lastExecutedThreadEvent.ExecuteDate.AreInTheSameMonth(DateTime.Now))
{
lastDayExecuted = lastExecutedThreadEvent.ExecuteDate.Day;
}
List <int> MonthDays = null;
switch ((SubTypeTimerEventModel.e_SetType)_event.SubTypeTimerEventModel.SetType)
{
case SubTypeTimerEventModel.e_SetType.Static:
MonthDays = _event.SubTypeTimerEventModel.GetListMonthDays;
break;
case SubTypeTimerEventModel.e_SetType.Variable:
MonthDays = dataManageEngine.GetValueByBinding(variableData).ToStringObj().Split(',').Where(c => !string.IsNullOrWhiteSpace(c)).Select(c => c.ToIntObj()).ToList();
break;
}
int?persianMonthDay = MonthDays.FirstOrDefault(c => c > lastDayExecuted);
//if persianMonthDay is null ,monthDate must be filled by next month ,otherwise it is filled by current month.
DateTime monthDate = persianMonthDay.HasValue ? DateTime.Now : DateTime.Now.AddMonths(1);
if (!persianMonthDay.HasValue)
{
//if lastDayExecuted is not in the same month with persianMonthDay
persianMonthDay = MonthDays.FirstOrDefault();
}
newThreadEvent.ExecuteDate = pc.ToDateTime(monthDate.Year, monthDate.Month, persianMonthDay.Value, _event.SubTypeTimerEventModel.TimeHour.ToIntObj(), _event.SubTypeTimerEventModel.TimeMinute.ToIntObj(), 0, 0);
break;
case SubTypeTimerEventModel.e_IntervalType.EveryWeek:
lastDayExecuted = DateTime.Now.GetDayOfWeekBy7() - 1;
if (lastExecutedThreadEvent != null && lastExecutedThreadEvent.ExecuteDate.AreInTheSameWeek(DateTime.Now))
{
lastDayExecuted = lastExecutedThreadEvent.ExecuteDate.GetDayOfWeekBy7();
}
List <int> weekDays = null;
switch ((SubTypeTimerEventModel.e_SetType)_event.SubTypeTimerEventModel.SetType)
{
case SubTypeTimerEventModel.e_SetType.Static:
weekDays = _event.SubTypeTimerEventModel.GetListWeekDays;
break;
case SubTypeTimerEventModel.e_SetType.Variable:
weekDays = dataManageEngine.GetValueByBinding(variableData).ToStringObj().Split(',').Where(c => !string.IsNullOrWhiteSpace(c)).Select(c => c.ToIntObj()).ToList();
break;
}
//if weekDays has a day bigger than last day executed
int?weekDay7 = weekDays.FirstOrDefault(c => c > lastDayExecuted);
//if need to go next week because ther is no greater day of week in weekDays and start from the first day of week selected by user after monday.
if (!weekDay7.HasValue)
{
weekDay7 = weekDays.FirstOrDefault();
//lastDayExecuted is not in the same week with persianWeekDay
newThreadEvent.ExecuteDate = DateTime.Now.AddDays(weekDay7.Value + (7 - DateTime.Now.GetDayOfWeekBy7()));
}
else
{
//lastDayExecuted is in the same week with persianWeekDay
newThreadEvent.ExecuteDate = DateTime.Now.AddDays(weekDay7.Value - lastDayExecuted);
}
break;
}
}
}
public void Add(sysBpmsThreadEvent threadEvent)
{
threadEvent.ID = Guid.NewGuid();
this.Context.sysBpmsThreadEvents.Add(threadEvent);
}
