private void EvaluateNextRecursiveItem(sysBpmsElement element, List <sysBpmsTask> list)
{
switch ((sysBpmsElement.e_TypeLU)element.TypeLU)
{
case sysBpmsElement.e_TypeLU.Event:
this.GetRecursiveBeginElements(element.ID, element.ProcessID, list);
break;
case sysBpmsElement.e_TypeLU.Gateway:
this.GetRecursiveBeginElements(element.ID, element.ProcessID, list);
break;
case sysBpmsElement.e_TypeLU.Task:
sysBpmsTask task = this.Context.sysBpmsTasks.AsNoTracking().FirstOrDefault(c => c.ProcessID == element.ProcessID && c.ElementID == element.ID);
switch ((sysBpmsTask.e_TypeLU)task.TypeLU)
{
case sysBpmsTask.e_TypeLU.ServiceTask:
this.GetRecursiveBeginElements(task.ElementID, element.ProcessID, list);
break;
case sysBpmsTask.e_TypeLU.UserTask:
list.Add(task);
break;
}
break;
}
}
public ServiceTaskDTO(sysBpmsTask task)
{
this.ID = task.ID;
this.ProcessID = task.ProcessID;
this.ElementID = task.ElementID;
this.TypeLU = task.TypeLU;
this.Code = task.Code;
}
public TaskDTO(sysBpmsTask task)
{
this.ID = task.ID;
this.ElementID = task.ElementID;
this.ProcessID = task.ProcessID;
this.RoleName = task.RoleName;
this.OwnerTypeLU = task.OwnerTypeLU;
this.UserID = task.UserID;
this.Rule = task.Rule;
this.MarkerTypeLU = task.MarkerTypeLU;
if (task.OwnerTypeLU == (int)sysBpmsTask.e_OwnerTypeLU.Role)
{
this.SpecificDepartmentID = this.UserTaskRuleModel.SpecificDepartmentId;
}
else
{
this.SpecificDepartmentID = null;
}
}
public ResultOperation Delete(Guid taskId)
{
ResultOperation resultOperation = null;
try
{
resultOperation = new ResultOperation();
if (resultOperation.IsSuccess)
{
sysBpmsTask sysBpmsTask = this.GetInfo(taskId);
this.BeginTransaction();
if (new ThreadTaskService(base.UnitOfWork).HasAny(sysBpmsTask.ProcessID, sysBpmsTask.ID))
{
resultOperation.AddError(LangUtility.Get("CannotDelete.Text", nameof(sysBpmsTask)));
return(resultOperation);
}
foreach (sysBpmsStep item in new StepService(base.UnitOfWork).GetList(taskId, null))
{
resultOperation = new StepService(base.UnitOfWork).Delete(item.ID);
if (!resultOperation.IsSuccess)
{
break;
}
}
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <ITaskRepository>().Delete(taskId);
this.UnitOfWork.Save();
resultOperation = new ElementService(base.UnitOfWork).Delete(sysBpmsTask.ElementID, sysBpmsTask.ProcessID);
}
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
public object PostAddEditServiceTask(PostAddEditServiceTaskDTO model)
{
using (ProcessService processService = new ProcessService())
{
if (!processService.GetInfo(base.ProcessId.Value).AllowEdit())
{
return(new PostMethodMessage(LangUtility.Get("NotAllowEdit.Text", nameof(sysBpmsProcess)), DisplayMessageType.error));
}
}
using (TaskService taskService = new TaskService())
{
sysBpmsTask task = taskService.GetInfo(model.ElementId, base.ProcessId.Value);
task.UpdateCode(model.DesignCode);
ResultOperation resultOperation = taskService.Update(task);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success));
}
/// <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 object PostAddEditUserTask(PostAddEditUserTaskDTO userTaskDTO)
{
using (ProcessService processService = new ProcessService())
{
if (!processService.GetInfo(userTaskDTO.ProcessID).AllowEdit())
{
return(new PostMethodMessage(LangUtility.Get("NotAllowEdit.Text", nameof(sysBpmsProcess)), DisplayMessageType.error));
}
}
ResultOperation resultOperation = new ResultOperation();
using (TaskService taskService = new TaskService())
{
//save access
sysBpmsTask task = taskService.GetInfo(userTaskDTO.ID);
UserTaskRuleModel userTaskRuleModel = new UserTaskRuleModel();
if (userTaskDTO.OwnerTypeLU.HasValue)
{
switch ((sysBpmsTask.e_OwnerTypeLU)userTaskDTO.OwnerTypeLU)
{
case sysBpmsTask.e_OwnerTypeLU.User:
userTaskRuleModel.AccessType = userTaskDTO.UserAccessType.ToIntObj();
switch ((UserTaskRuleModel.e_UserAccessType)userTaskDTO.UserAccessType)
{
case UserTaskRuleModel.e_UserAccessType.Static:
//userTaskDTO.UserID is filled automativally
break;
case UserTaskRuleModel.e_UserAccessType.Variable:
userTaskRuleModel.Variable = userTaskDTO.ddlUserVariable;
break;
}
break;
case sysBpmsTask.e_OwnerTypeLU.Role:
userTaskRuleModel.AccessType = userTaskDTO.RoleAccessType.ToIntObj();
switch ((UserTaskRuleModel.e_RoleAccessType)userTaskDTO.RoleAccessType)
{
case UserTaskRuleModel.e_RoleAccessType.Static:
//userTaskRuleModel.RoleCode = Request.Form["RoleName"];
userTaskRuleModel.SpecificDepartmentId = userTaskDTO.SpecificDepartmentID;
break;
case UserTaskRuleModel.e_RoleAccessType.Variable:
userTaskRuleModel.Variable = userTaskDTO.ddlRoleVariable;
userTaskRuleModel.SpecificDepartmentId = userTaskDTO.SpecificDepartmentID;
break;
case UserTaskRuleModel.e_RoleAccessType.CorrespondentRole:
userTaskRuleModel.RoleCode = userTaskDTO.ddlRoleRuleRoleName;
userTaskRuleModel.UserType = userTaskDTO.ddlRoleRuleUserType;
userTaskRuleModel.GoUpDepartment = userTaskDTO.GoUpDepartment;
break;
}
break;
}
userTaskDTO.Rule = userTaskRuleModel.BuildXml();
resultOperation = task.Update(userTaskDTO.RoleName, userTaskDTO.SpecificDepartmentID, userTaskDTO.OwnerTypeLU, userTaskDTO.UserID, userTaskDTO.Rule);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
resultOperation = taskService.Update(task);
//save step
int index = 0;
userTaskDTO.ListSteps = userTaskDTO.ListSteps ?? new List <StepDTO>();
userTaskDTO.ListSteps.ForEach(c => { c.Position = ++index; });
using (StepService stepService = new StepService())
{
List <sysBpmsStep> CurrentSteps = stepService.GetList(userTaskDTO.ID, null);
foreach (sysBpmsStep item in CurrentSteps.Where(c => !userTaskDTO.ListSteps.Any(d => d.ID == c.ID)))
{
resultOperation = stepService.Delete(item.ID);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
foreach (StepDTO item in userTaskDTO.ListSteps)
{
resultOperation = null;
if (item.ID != Guid.Empty)
{
resultOperation = stepService.Update(new sysBpmsStep(item.ID, item.TaskID, item.Position, item.DynamicFormID, item.Name));
}
else
{
resultOperation = stepService.Add(new sysBpmsStep(item.ID, item.TaskID, item.Position, item.DynamicFormID, item.Name));
}
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
if (resultOperation.IsSuccess)
{
return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success));
}
else
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
}
}
