public ResultOperation TerminateIfPossible(sysBpmsUser currentUser)
{
ResultOperation resultOperation = new ResultOperation();
ThreadTaskService threadTaskService = new ThreadTaskService(base.UnitOfWork);
ThreadEventService threadEventService = new ThreadEventService(base.UnitOfWork);
List <sysBpmsThreadTask> listActiveTask = threadTaskService.GetList(this.EngineSharedModel.CurrentThreadID.Value, null, null, null).Where(c => c.StatusLU != (int)sysBpmsThreadTask.e_StatusLU.Done).ToList();
//if terminated
if (this.EngineSharedModel.CurrentThread.StatusLU == (int)sysBpmsThread.Enum_StatusLU.Done)
{
foreach (var itm in listActiveTask)
{
itm.Update(DateTime.Now, (int)sysBpmsThreadTask.e_StatusLU.Done,
itm.OwnerUserID ?? currentUser?.ID);
resultOperation = threadTaskService.Update(itm);
}
List <sysBpmsThreadEvent> listEvents = threadEventService.GetActive(base.EngineSharedModel.CurrentThreadID.Value);
foreach (var item in listEvents)
{
item.Done();
resultOperation = threadEventService.Update(item);
}
}
else
{
if (!listActiveTask.Any() && !threadEventService.GetActive(base.EngineSharedModel.CurrentThreadID.Value).Any())
{
resultOperation = new ThreadService(this.UnitOfWork).DoneThread(base.EngineSharedModel.CurrentThreadID.Value);
}
}
return(resultOperation);
}
public ResultOperation DoneThreadTask(sysBpmsThreadTask currentThreadTask, sysBpmsUser currentUser)
{
ThreadTaskService threadTaskService = new ThreadTaskService(base.UnitOfWork);
currentThreadTask.Update(DateTime.Now, (int)sysBpmsThreadTask.e_StatusLU.Done,
currentThreadTask.OwnerUserID ?? currentUser?.ID);
return(threadTaskService.Update(currentThreadTask));
}
/// <summary>
/// It is called by Process engine for adding theadtask related to task element.
/// </summary>
/// <param name="item"></param>
public (ResultOperation result, List <sysBpmsThreadTask> listTask) AddThreadTask(sysBpmsTask item, bool isFirstTask)
{
ThreadTaskService threadTaskService = new ThreadTaskService(base.UnitOfWork);
ResultOperation result = new ResultOperation();
List <sysBpmsThreadTask> listTask = new List <sysBpmsThreadTask>();
switch ((sysBpmsTask.e_TypeLU)item.TypeLU)
{
case sysBpmsTask.e_TypeLU.UserTask:
if (item.MarkerTypeLU.HasValue)
{
foreach (sysBpmsThreadTask threadTaskItem in threadTaskService.GetMultiInstanceTask(item, base.EngineSharedModel))
{
//if user has access to this method, set thread task access Info to userID
if (isFirstTask && this.CheckAccessByThreadTask(item, threadTaskItem, base.EngineSharedModel.CurrentThread.UserID, null))
{
threadTaskItem.UpdateAccessInfo(base.EngineSharedModel.CurrentThread.UserID, null);
}
threadTaskService.Add(threadTaskItem);
listTask.Add(threadTaskItem);
}
}
else
{
sysBpmsThreadTask threadTask = new sysBpmsThreadTask();
threadTask.Update(base.EngineSharedModel.CurrentThreadID.Value, item.ID, DateTime.Now, null, string.Empty, 0, (int)sysBpmsThreadTask.e_StatusLU.New);
threadTaskService.SetAccessInfoTo(threadTask, item, base.EngineSharedModel);
//if user has access to this method, set thread task access Info to thread userID
if (isFirstTask && this.CheckAccessByThreadTask(item, threadTask, base.EngineSharedModel.CurrentThread.UserID, null))
{
threadTask.UpdateAccessInfo(base.EngineSharedModel.CurrentThread.UserID, null);
}
threadTaskService.Add(threadTask);
listTask.Add(threadTask);
}
break;
}
return(result, listTask);
}
public (List <sysBpmsSequenceFlow> flowsList, bool result) CheckGateway(sysBpmsGateway gateway, sysBpmsSequenceFlow joinFromSequenceFlow, Guid?threadTaskID)
{
SequenceFlowService sequenceFlowService = new SequenceFlowService(this.UnitOfWork);
List <sysBpmsSequenceFlow> acceptedForkSequenceFlows = new List <sysBpmsSequenceFlow>();
ConditionService conditionService = new ConditionService(this.UnitOfWork);
switch ((sysBpmsGateway.e_TypeLU)gateway.TypeLU)
{
case sysBpmsGateway.e_TypeLU.ExclusiveGateWay:
{
List <sysBpmsCondition> listCondition = conditionService.GetList(gateway.ID, null, null);
foreach (sysBpmsCondition condition in listCondition)
{
if (new DynamicCodeEngine(base.EngineSharedModel, this.UnitOfWork).ExecuteBooleanCode(DesignCodeUtility.GetDesignCodeFromXml(condition.Code)))
{
acceptedForkSequenceFlows.Add(sequenceFlowService.GetInfo(condition.SequenceFlowID.Value));
break;
}
}
}
break;
case sysBpmsGateway.e_TypeLU.InclusiveGateWay:
{
List <sysBpmsThreadTask> listRunningThreadTask = new ThreadTaskService(base.UnitOfWork).GetListRunning(base.EngineSharedModel.CurrentThreadID.ToGuidObj());
if (!listRunningThreadTask.Any(c => c.ID != threadTaskID && gateway.TraceToStart.ToStringObj().Split(',').Contains(c.Task.ElementID)))
{
List <sysBpmsCondition> listCondition = conditionService.GetList(gateway.ID, null, null);
foreach (sysBpmsCondition condition in listCondition)
{
if (new DynamicCodeEngine(base.EngineSharedModel, this.UnitOfWork).ExecuteBooleanCode(DesignCodeUtility.GetDesignCodeFromXml(condition.Code)))
{
acceptedForkSequenceFlows.Add(sequenceFlowService.GetInfo(condition.SequenceFlowID.Value));
}
}
}
else
{
return(new List <sysBpmsSequenceFlow>(), true);
}
}
break;
case sysBpmsGateway.e_TypeLU.ParallelGateWay:
{
List <sysBpmsSequenceFlow> listJoinSequenceFlow = sequenceFlowService.GetList(base.EngineSharedModel.CurrentProcessID.Value, gateway.ElementID, "", "");
//if all sequence flow were executed, run condition code and clear gateway Status Xml List
if (listJoinSequenceFlow.Where(c => c.ID != joinFromSequenceFlow.ID).All(c => base.EngineSharedModel.CurrentThread.GatewayStatus.Any(d => d.GatewayID == gateway.ID && d.List.Any(f => f.SequenceFlowID == c.ID && f.Done))) || base.EngineSharedModel.CurrentThread == null)
{
acceptedForkSequenceFlows = sequenceFlowService.GetList(base.EngineSharedModel.CurrentProcessID.Value, "", gateway.ElementID, "");
new ThreadService(base.UnitOfWork).ClearGatewayStatusXml(base.EngineSharedModel.CurrentThread, gateway.ID);
}
else
{
//add this sequence flow path to executed path in Thread.GatewayStatusXml
new ThreadService(base.UnitOfWork).AddGatewayStatusXml(base.EngineSharedModel.CurrentThread, gateway.ID, joinFromSequenceFlow.ID);
return(new List <sysBpmsSequenceFlow>(), true);
}
}
break;
}
if (!acceptedForkSequenceFlows.Any() && gateway.DefaultSequenceFlowID.HasValue)
{
acceptedForkSequenceFlows.Add(sequenceFlowService.GetInfo(gateway.DefaultSequenceFlowID.Value));
}
return(acceptedForkSequenceFlows, acceptedForkSequenceFlows.Any());
}
public ResultOperation Delete(Guid threadId)
{
ResultOperation resultOperation = new ResultOperation();
try
{
this.BeginTransaction();
//Delete sysBpmsDocument
DocumentService documentService = new DocumentService(base.UnitOfWork);
foreach (sysBpmsDocument document in documentService.GetList(null, null, null, "", null, null, threadId))
{
if (resultOperation.IsSuccess)
{
resultOperation = documentService.Delete(document.GUID);
}
}
//Delete sysBpmsThreadVariable
ThreadVariableService threadVariableService = new ThreadVariableService(base.UnitOfWork);
foreach (sysBpmsThreadVariable sysThreadVariable in threadVariableService.GetList(threadId, null, ""))
{
if (resultOperation.IsSuccess)
{
resultOperation = threadVariableService.Delete(sysThreadVariable.ID);
}
}
//Delete sysBpmsThreadEvent
ThreadEventService threadEventService = new ThreadEventService(base.UnitOfWork);
foreach (sysBpmsThreadEvent sysBpmsThreadEvent in threadEventService.GetList(threadId))
{
if (resultOperation.IsSuccess)
{
resultOperation = threadEventService.Delete(sysBpmsThreadEvent.ID);
}
}
//Delete sysBpmsThreadTask
ThreadTaskService threadTaskService = new ThreadTaskService(base.UnitOfWork);
foreach (sysBpmsThreadTask sysBpmsThreadTask in threadTaskService.GetList(threadId, null, null, null))
{
if (resultOperation.IsSuccess)
{
resultOperation = threadTaskService.Delete(sysBpmsThreadTask.ID);
}
}
//Delete Thread
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <IThreadRepository>().Delete(threadId);
this.UnitOfWork.Save();
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
