public object GetBeginTask(Guid ProcessID)
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
(ResultOperation result, List <MessageModel> msgModel) = new ProcessEngine(new EngineSharedModel(currentThread: null, currentProcessID: ProcessID, baseQueryModel: base.MyRequest.GetList(false, base.ApiSessionId).ToList(), currentUserName: base.ClientUserName, apiSessionId: base.ApiSessionId)).StartProcess(base.MyUser.ID);
if (result.IsSuccess)
{
sysBpmsThreadTask threadTask = threadTaskService.GetList(((sysBpmsThread)result.CurrentObject).ID, (int)sysBpmsTask.e_TypeLU.UserTask, null, (int)sysBpmsThreadTask.e_StatusLU.New).LastOrDefault();
return(new
{
MessageList = msgModel,
ThreadTaskID = threadTask.ID,
Result = true,
});
}
else
{
return(new
{
MessageList = new List <MessageModel>()
{
new MessageModel(DisplayMessageType.error, result.GetErrors())
},
Result = false,
});
}
}
}
public object GetPopUp(Guid threadTaskID, Guid formID)
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
using (DynamicFormService dynamicFormService = new DynamicFormService())
{
sysBpmsThreadTask threadTask = threadTaskService.GetInfo(threadTaskID, new string[] { nameof(sysBpmsThreadTask.Thread) });
using (ProcessEngine ProcessEngine = new ProcessEngine(new EngineSharedModel(threadTask.ThreadID, threadTask.Thread.ProcessID, this.MyRequest.GetList(dynamicFormService.GetInfo(formID).ConfigXmlModel.IsEncrypted, base.ApiSessionId).ToList(), base.ClientUserName, base.ApiSessionId)))
{
GetTaskFormResponseModel responseVM = ProcessEngine.GetForm(threadTaskID, formID);
if (responseVM.EngineFormModel != null)
{
string popUpUrl = UrlUtility.GetCartableApiUrl(base.MyRequest, base.PortalSettings.DefaultPortalAlias, nameof(CartableThreadController.GetPopUp), nameof(CartableThreadController), "", "threadTaskID=" + threadTaskID);
string postUrl = UrlUtility.GetCartableApiUrl(base.MyRequest, base.PortalSettings.DefaultPortalAlias, nameof(CartableThreadController.PostPopUp), nameof(CartableThreadController), "", UrlUtility.GetParamsAsArray(new HttpRequestWrapper(base.MyRequest), new string[] { $"formID={formID}", $"threadTaskID={threadTaskID}", $"stepID={responseVM.EngineFormModel.FormModel.StepID}" }).ToArray());
responseVM.EngineFormModel.SetUrls(popUpUrl, postUrl, new HttpRequestWrapper(base.MyRequest), base.PortalSettings.DefaultPortalAlias, FormTokenUtility.GetFormToken(base.ApiSessionId, responseVM.EngineFormModel?.FormModel?.ContentHtml?.DynamicFormID ?? Guid.Empty, responseVM?.EngineFormModel?.FormModel?.IsEncrypted ?? false));
}
return(new
{
Model = responseVM?.EngineFormModel,
MessageList = responseVM?.ListMessageModel.Select(c => new PostMethodMessage(c.Message, c.DisplayMessageType)),
RedirectUrl = base.GetRedirectUrl(responseVM?.RedirectUrlModel),
Result = true,
});
}
}
}
}
private BeginTaskResponseModel BeginTask(Guid processID)
{
List <QueryModel> baseQueryModel = base.MyRequest.GetList(false, string.Empty).ToList();
using (ProcessEngine processEngine = new ProcessEngine(new EngineSharedModel(currentThread: null, currentProcessID: processID, baseQueryModel: baseQueryModel, currentUserName: base.ClientUserName, apiSessionId: base.ApiSessionId)))
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
using (UserService userService = new UserService())
{
var result = processEngine.StartProcess(userService.GetInfo(base.ClientUserName)?.ID);
if (result.Item1.IsSuccess)
{
sysBpmsThreadTask threadTask = threadTaskService.GetList(((sysBpmsThread)result.Item1.CurrentObject).ID, (int)sysBpmsTask.e_TypeLU.UserTask, null, (int)sysBpmsThreadTask.e_StatusLU.New).LastOrDefault();
return(new BeginTaskResponseModel(string.Join(",", result.Item2), true, ((sysBpmsThread)result.Item1.CurrentObject)?.ID, threadTask?.ID));;
}
else
{
return(new BeginTaskResponseModel(result.Item1.GetErrors(), false, null, null));
}
}
}
}
}
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));
}
public void Delete(Guid ID)
{
sysBpmsThreadTask sysBpmsThreadTask = this.Context.sysBpmsThreadTasks.FirstOrDefault(d => d.ID == ID);
if (sysBpmsThreadTask != null)
{
this.Context.sysBpmsThreadTasks.Remove(sysBpmsThreadTask);
}
}
public PostTaskFormResponseModel PostForm(Guid threadTaskID, Guid formID, string controlId = "")
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
sysBpmsThreadTask threadTask = threadTaskService.GetInfo(threadTaskID, new string[] { nameof(sysBpmsThreadTask.Thread) });
using (ProcessEngine processEngine = new ProcessEngine(new EngineSharedModel(threadTask.ThreadID, threadTask.Thread.ProcessID, base.MyRequest.GetList(base.IsEncrypted, base.ApiSessionId).ToList(), base.ClientUserName, base.ApiSessionId)))
{
return(processEngine.PostForm(threadTaskID, formID, controlId));
}
}
}
public ThreadHistoryDTO(sysBpmsThreadTask threadTask)
{
this.ThreadTaskID = threadTask.ID;
this.ThreadTaskStartDate = threadTask.StartDate;
this.ThreadTaskEndDate = threadTask.EndDate;
this.Description = threadTask.Description;
this.OwnerUserID = threadTask.OwnerUserID;
this.ThreadTaskStatusLU = threadTask.StatusLU;
this.TaskName = threadTask.Task?.Element?.Name ?? "";
this.OwnerUser = new UserDTO(threadTask.User);
}
public ResultOperation Update(sysBpmsThreadTask ThreadTask)
{
ResultOperation resultOperation = new ResultOperation();
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <IThreadTaskRepository>().Update(ThreadTask);
this.UnitOfWork.Save();
}
return(resultOperation);
}
public KartableDTO(sysBpmsThreadTask threadTask)
{
this.ThreadTaskID = threadTask.ID;
this.ThreadTaskStartDate = threadTask.StartDate;
this.ThreadTaskEndDate = threadTask.EndDate;
this.ThreadTaskDescription = threadTask.Description;
this.OwnerUserID = threadTask.OwnerUserID;
this.ThreadTaskStatusLU = threadTask.StatusLU;
this.TaskName = threadTask.Task?.Element?.Name ?? "";
this.Thread = new ThreadDTO(threadTask.Thread);
}
public void Update(sysBpmsThreadTask threadTask)
{
//To fix 'Attaching an entity failed' error.
var local = this.Context.Set <sysBpmsThreadTask>().Local.FirstOrDefault(f => f.ID == threadTask.ID);
if (local != null)
{
this.Context.Entry(local).State = EntityState.Detached;
local = null;
}
this.Context.Entry(threadTask.Clone()).State = EntityState.Modified;
}
public bool CheckAccessByThreadTask(Domain.sysBpmsTask task, sysBpmsThreadTask threadTask, Guid?userID, List <sysBpmsDepartmentMember> list = null)
{
list = list ?? (userID.HasValue ? new DepartmentMemberService().GetList(null, null, userID) : new List <sysBpmsDepartmentMember>());
if (!string.IsNullOrWhiteSpace(threadTask.OwnerRole))
{
return((
!threadTask.IsInRole(null, (int)sysBpmsDepartmentMember.e_RoleLU.Requester) ||
base.EngineSharedModel.CurrentThread == null ||
(base.EngineSharedModel.CurrentThread?.UserID ?? Guid.Empty) == userID)
&&
list.Any(c => (string.IsNullOrWhiteSpace(threadTask.OwnerRole) || threadTask.IsInRole(c.DepartmentID, c.RoleLU))));
}
else
{
return(threadTask.OwnerUserID == userID);
}
}
/// <summary>
/// this method check whether current user has access to this task or not.
/// </summary>
/// <param name="userId">set to currnet User ID if user has logined otherwise set to null</param>
/// <returns></returns>
public (bool, string) CheckAccess(Guid threadTaskID, Guid?userId, Guid processId, bool isPost, bool accessByTracking = false)
{
sysBpmsThreadTask threadTask = this.GetInfo(threadTaskID);
if (isPost && !new ProcessService(base.UnitOfWork).GetInfo(processId).AllowNextFlow())
{
return(false, LangUtility.Get("NotAllowNextFlow.Text", nameof(sysBpmsThreadTask)));
}
if (threadTask.StatusLU == (int)sysBpmsThreadTask.e_StatusLU.New ||
threadTask.StatusLU == (int)sysBpmsThreadTask.e_StatusLU.Ongoing)
{
if (threadTask.OwnerUserID.HasValue && threadTask.OwnerUserID == userId)
{
return(true, "");
}
if (userId.HasValue)
{
List <sysBpmsDepartmentMember> listDepartmentMember = new DepartmentMemberService(base.UnitOfWork).GetList(null, null, userId.Value);
if (listDepartmentMember.Any(c => threadTask.GetDepartmentRoles.Any(d => (!d.Item1.HasValue || d.Item1 == c.DepartmentID) && d.Item2.ToIntObj() == c.RoleLU)))
{
return(true, "");
}
}
else
{
if (!threadTask.Thread.UserID.HasValue && !threadTask.OwnerUserID.HasValue && string.IsNullOrWhiteSpace(threadTask.OwnerRole))
{
return(true, "");
}
}
if (threadTask.Task.UserTaskRuleModel?.AccessType != (int)UserTaskRuleModel.e_UserAccessType.Static &&
threadTask.Task.UserTaskRuleModel?.AccessType != (int)UserTaskRuleModel.e_UserAccessType.Variable)
{
return(true, "");
}
if (accessByTracking && threadTask.Task.IsInRole(null, (int)sysBpmsDepartmentMember.e_RoleLU.Requester))
{
return(true, "");
}
}
return(false, LangUtility.Get("AccessError.Text", nameof(sysBpmsThreadTask)));
}
public object PostPopUp(Guid threadTaskID, Guid formID, string controlId = "")
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
using (DynamicFormService dynamicFormService = new DynamicFormService())
{
sysBpmsThreadTask threadTask = threadTaskService.GetInfo(threadTaskID, new string[] { nameof(sysBpmsThreadTask.Thread) });
using (ProcessEngine ProcessEngine = new ProcessEngine(new EngineSharedModel(threadTask.ThreadID, threadTask.Thread.ProcessID, this.MyRequest.GetList(dynamicFormService.GetInfo(formID).ConfigXmlModel.IsEncrypted, base.ApiSessionId).ToList(), base.ClientUserName, base.ApiSessionId)))
{
PostTaskFormResponseModel responseVM = ProcessEngine.PostForm(threadTaskID, formID, controlId);
if (!responseVM.IsSuccess)
{
return(new EngineFormResponseDTO(redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel), reloadForm: false,
null, false, messageList: responseVM.ListMessageModel, false));
}
else
{
if (responseVM.IsSubmit)
{
return(new EngineFormResponseDTO(
redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel), reloadForm: false,
listDownloadModel: responseVM.ListDownloadModel,
isSubmit: true,
responseVM.ListMessageModel, true
));
}
else
{
return(new EngineFormResponseDTO(
redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel), reloadForm: true,
listDownloadModel: responseVM.ListDownloadModel,
isSubmit: false,
responseVM.ListMessageModel
));
}
}
}
}
}
}
public void BeginTask_Recruitment_Process_With_Local_Variable_ShouldPassSuccessfully()
{
//Arrange
string userName = "******";
using (ProcessEngine processEngine = new ProcessEngine(new EngineSharedModel(currentThread: null, currentProcessID: new Guid("3E9E69D2-9232-4F07-8B63-08FBDD778F45"), baseQueryModel: new List <QueryModel>(), currentUserName: userName, apiSessionId: "")))
{
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
using (UserService userService = new UserService())
{
//Act
(ResultOperation result, List <MessageModel> messageList) = processEngine.StartProcess(userService.GetInfo(userName)?.ID);
//Assert
Assert.True(result.IsSuccess);
sysBpmsThreadTask threadTask = threadTaskService.GetList(((sysBpmsThread)result.CurrentObject).ID, (int)sysBpmsTask.e_TypeLU.UserTask, null, (int)sysBpmsThreadTask.e_StatusLU.New).LastOrDefault();
Assert.NotNull(threadTask);
}
}
}
}
/// <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 void SetAccessInfoTo(sysBpmsThreadTask threadTask, Domain.sysBpmsTask task, EngineSharedModel engineSharedModel)
{
if (task.OwnerTypeLU.HasValue)
{
switch ((sysBpmsTask.e_OwnerTypeLU)task.OwnerTypeLU)
{
case sysBpmsTask.e_OwnerTypeLU.User:
switch ((UserTaskRuleModel.e_UserAccessType)task.UserTaskRuleModel.AccessType)
{
case UserTaskRuleModel.e_UserAccessType.Static:
threadTask.UpdateAccessInfo(task.UserID.ToGuidObj(), null);
break;
case UserTaskRuleModel.e_UserAccessType.Variable:
Guid?variableUserID = new DataManageEngine(engineSharedModel, base.UnitOfWork).GetValueByBinding(task.UserTaskRuleModel.Variable).ToGuidObjNull();
if (!variableUserID.HasValue)
{
throw new Exception(LangUtility.Get("UserNotFound.Text", nameof(sysBpmsThreadTask)));
}
threadTask.UpdateAccessInfo(variableUserID, null);
break;
}
break;
case sysBpmsTask.e_OwnerTypeLU.Role:
switch ((UserTaskRuleModel.e_RoleAccessType)task.UserTaskRuleModel.AccessType)
{
case UserTaskRuleModel.e_RoleAccessType.Static:
//if this userTask must be seen by requester user, this add thread userId to new threadTask
if (task.IsInRole(null, (int)sysBpmsDepartmentMember.e_RoleLU.Requester))
{
threadTask.UpdateAccessInfo(engineSharedModel.CurrentThread?.UserID, null);
}
else
{
threadTask.UpdateAccessInfo(null, task.GetDepartmentRoles);
}
break;
case UserTaskRuleModel.e_RoleAccessType.Variable:
string roleName = new DataManageEngine(engineSharedModel, base.UnitOfWork).GetValueByBinding(task.UserTaskRuleModel.Variable).ToStringObj();
if (string.IsNullOrWhiteSpace(roleName))
{
throw new Exception(LangUtility.Get("RoleNotFound.Text", nameof(sysBpmsThreadTask)));
}
task.SetRoleDepartment(roleName, task.UserTaskRuleModel.SpecificDepartmentId);
//if this userTask must be seen by requester user, this add thread userId to new threadTask
if (task.IsInRole(null, (int)sysBpmsDepartmentMember.e_RoleLU.Requester))
{
threadTask.UpdateAccessInfo(engineSharedModel.CurrentThread?.UserID, null);
}
else
{
threadTask.UpdateAccessInfo(null, task.GetDepartmentRoles);
}
break;
case UserTaskRuleModel.e_RoleAccessType.CorrespondentRole:
Guid?userId = task.UserTaskRuleModel.UserType == (int)UserTaskRuleModel.e_UserType.CurrentUserID ? new UserService(base.UnitOfWork).GetInfo(engineSharedModel.CurrentUserName ?? "")?.ID : engineSharedModel.CurrentThread?.UserID;
Guid?departmentId = new AccessCodeHelper(base.UnitOfWork).GetDepartmentHierarchyByUserId(userId.ToGuidObj(), task.UserTaskRuleModel.RoleCode.ToIntObj(), task.UserTaskRuleModel.GoUpDepartment);
if (!departmentId.HasValue)
{
throw new Exception(LangUtility.Get("OrganizationNotFound.Text", nameof(sysBpmsThreadTask)));
}
threadTask.UpdateAccessInfo(null, new List <Tuple <Guid?, string> >()
{
new Tuple <Guid?, string>(departmentId, task.UserTaskRuleModel.RoleCode)
});
break;
}
break;
}
}
else
{
throw new Exception(LangUtility.Get("NextNoAccessSetting.Text", nameof(sysBpmsThreadTask)));
}
}
public void Add(sysBpmsThreadTask ThreadTask)
{
ThreadTask.ID = Guid.NewGuid();
this.Context.sysBpmsThreadTasks.Add(ThreadTask);
}
public object PostIndex(Guid?applicationPageId = null, Guid?threadTaskID = null, string controlId = "", Guid?stepID = null, bool?goNext = null)
{
SingleActionSettingDTO setting = base.GetSetting();
if (setting.ProcessID.HasValue)
{
#region .:: Thread ::.
PostTaskFormResponseModel responseVM = null;
//If bpms engine is in different domain.
if (!string.IsNullOrWhiteSpace(setting.WebApiAddress))
{
EngineProcessProxy engineProcessProxy = new EngineProcessProxy(setting.WebApiAddress, setting.WebServicePass, base.ClientUserName, ApiUtility.GetIPAddress(), base.ApiSessionId, this.IsEncrypted);
responseVM = engineProcessProxy.PostTaskForm(threadTaskID.Value, controlId, stepID.Value, goNext, base.MyRequest.GetList(false, string.Empty).ToList());
}
else
{
//If engine is in same domain, call it directly.
using (ThreadTaskService threadTaskService = new ThreadTaskService())
{
sysBpmsThreadTask threadTask = threadTaskService.GetInfo(threadTaskID.Value, new string[] { nameof(sysBpmsThreadTask.Thread) });
using (ProcessEngine processEngine = new ProcessEngine(new EngineSharedModel(threadTask.Thread, threadTask.Thread.ProcessID, base.MyRequest.GetList(this.IsEncrypted, base.ApiSessionId).ToList(), base.ClientUserName, base.ApiSessionId)))
{
responseVM = processEngine.PostTaskForm(threadTask.ID, stepID.Value, goNext, controlId);
}
}
}
if (!responseVM.IsSuccess)
{
return(new EngineFormResponseDTO(redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel), reloadForm: false,
null, false, messageList: responseVM.ListMessageModel, false));
}
else
{
if (responseVM.IsSubmit)
{
if (responseVM.IsNextPrevious == true)
{
return(new EngineFormResponseDTO(
redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel),
reloadForm: true,
listDownloadModel: responseVM.ListDownloadModel,
messageList: responseVM.ListMessageModel
)
{
StepID = responseVM.StepID.Value,
});
}
else
{
return new EngineFormResponseDTO(
redirectUrl: string.IsNullOrWhiteSpace(base.GetRedirectUrl(responseVM.RedirectUrlModel)) ? "CartableManage" :
base.GetRedirectUrl(responseVM.RedirectUrlModel), reloadForm: setting.ProcessEndFormID.HasValue,
listDownloadModel: responseVM.ListDownloadModel,
messageList: responseVM.ListMessageModel
)
{
EndAppPageID = setting.ProcessEndFormID,
StepID = responseVM?.StepID,
}
};
}
else
{
return new EngineFormResponseDTO(
redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel),
reloadForm: true,
listDownloadModel: responseVM.ListDownloadModel,
messageList: responseVM.ListMessageModel
)
{
StepID = responseVM.StepID.Value,
}
};
}
#endregion
}
else
{
#region .:: Application ::.
PostFormResponseModel responseVM = null;
//if bpms engine is in different domain
if (!string.IsNullOrWhiteSpace(setting.WebApiAddress))
{
EngineApplicationProxy engineApplicationProxy = new EngineApplicationProxy(setting.WebApiAddress, setting.WebServicePass, base.ClientUserName, ApiUtility.GetIPAddress(), base.ApiSessionId, this.IsEncrypted);
responseVM = engineApplicationProxy.PostForm(applicationPageId.Value, controlId, base.MyRequest.GetList(false, string.Empty).ToList());
}
else
{
EngineSharedModel engineSharedModel = new EngineSharedModel(applicationPageId.Value, base.MyRequest.GetList(this.IsEncrypted, base.ApiSessionId).ToList(), base.ClientUserName, base.ApiSessionId);
using (ApplicationPageEngine applicationPageEngine = new ApplicationPageEngine(engineSharedModel))
responseVM = applicationPageEngine.PostForm(controlId);
}
if (!responseVM.IsSuccess)
{
return(new EngineFormResponseDTO(base.GetRedirectUrl(responseVM.RedirectUrlModel), false, null, false, responseVM?.ListMessageModel, false));
}
else
{
return
(new EngineFormResponseDTO(
redirectUrl: base.GetRedirectUrl(responseVM.RedirectUrlModel),
reloadForm: false,
listDownloadModel: responseVM.ListDownloadModel, isSubmit: responseVM.IsSubmit,
responseVM.ListMessageModel, submittedHtmlMessage: setting.AppPageSubmitMessage
));
}
#endregion
}
}
public ResultOperation SaveIntoDataBase(ContentHtml contentHtml, sysBpmsThreadTask threadTask, List <VariableModel> setExternalVariable, string threadTaskDescription)
{
ResultOperation resultOperation = new ResultOperation();
try
{
base.BeginTransaction();
//First set variable according to elements.
//resultOperation = this.SetValuesToElements(contentHtml);
//Then set external variables, filled by user defined actions.
if (setExternalVariable != null)
{
foreach (var item in setExternalVariable)
{
foreach (var dataModel in item.Items)
{
foreach (var val in dataModel.ToList())
{
this.SetValueByBinding(val.Key, val.Value);
}
}
}
}
if (resultOperation.IsSuccess)
{
resultOperation = this.SaveInto();
}
if (resultOperation.IsSuccess)
{
DocumentEngine documentEngine = new DocumentEngine(base.EngineSharedModel, base.UnitOfWork);
foreach (FileUploadHtml item in contentHtml.Rows.SelectMany(r => (r is RowHtml ? ((RowHtml)r).Columns : ((AccordionHtml)r).GetListColumn()).SelectMany(d => d.children.Where(f => f is FileUploadHtml).ToList())))
{
if (resultOperation.IsSuccess)
{
sysBpmsVariable variable = item.VariableId.ToGuidObjNull() == null ? null :
new VariableService(base.UnitOfWork).GetInfo(item.VariableId.ToGuidObj());
Guid?entityId = (variable != null && this.SetDataList.ContainsKey(variable.Name)) ? this.SetDataList[variable?.Name].GetValue <Guid>("ID") : (Guid?)null;
Guid?entityDefId = variable?.EntityDefID;
resultOperation = documentEngine.IsValid(item, variable, entityId, entityDefId, base.EngineSharedModel.CurrentUserName);
if (resultOperation.IsSuccess)
{
resultOperation = documentEngine.SaveFile(item, variable, entityId, entityDefId, "", base.EngineSharedModel.CurrentUserName);
}
}
}
}
if (resultOperation.IsSuccess)
{
if (!string.IsNullOrWhiteSpace(this.ThreadTaskDescription))
{
threadTask.Update(this.ThreadTaskDescription);
new ThreadTaskService(base.UnitOfWork).Update(threadTask);
}
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
public List <sysBpmsThreadTask> GetMultiInstanceTask(Domain.sysBpmsTask task, EngineSharedModel engineSharedModel)
{
sysBpmsThreadTask threadTask = null;
List <sysBpmsThreadTask> list = new List <sysBpmsThreadTask>();
switch ((sysBpmsTask.e_OwnerTypeLU)task.OwnerTypeLU)
{
case sysBpmsTask.e_OwnerTypeLU.User:
switch ((UserTaskRuleModel.e_UserAccessType)task.UserTaskRuleModel.AccessType)
{
case UserTaskRuleModel.e_UserAccessType.Static:
case UserTaskRuleModel.e_UserAccessType.Variable:
string userId = task.UserID;
if (task.UserTaskRuleModel.AccessType == (int)UserTaskRuleModel.e_UserAccessType.Variable)
{
userId = new DataManageEngine(engineSharedModel, base.UnitOfWork).GetValueByBinding(task.UserTaskRuleModel.Variable).ToStringObj();
}
int i = 0;
foreach (string item in userId.Split(','))
{
threadTask = new sysBpmsThreadTask();
threadTask.Update(engineSharedModel.CurrentThreadID.Value, task.ID, DateTime.Now.AddSeconds(i++), null, string.Empty, 0, (int)sysBpmsThreadTask.e_StatusLU.New);
threadTask.UpdateAccessInfo(item.ToGuidObj(), null);
list.Add(threadTask);
}
break;
}
break;
case sysBpmsTask.e_OwnerTypeLU.Role:
switch ((UserTaskRuleModel.e_RoleAccessType)task.UserTaskRuleModel.AccessType)
{
case UserTaskRuleModel.e_RoleAccessType.Static:
case UserTaskRuleModel.e_RoleAccessType.Variable:
if (task.UserTaskRuleModel.AccessType == (int)UserTaskRuleModel.e_RoleAccessType.Variable)
{
task.SetRoleDepartment(new DataManageEngine(engineSharedModel, base.UnitOfWork).GetValueByBinding(task.UserTaskRuleModel.Variable).ToStringObj(), task.UserTaskRuleModel.SpecificDepartmentId);
}
foreach (var item in task.GetDepartmentRoles)
{
List <Guid> users = new DepartmentMemberService(base.UnitOfWork).GetList(item.Item1, item.Item2.ToIntObj(), null).Select(c => c.UserID).ToList();
//It is used for sequential task.
int i = 0;
foreach (Guid uId in users)
{
threadTask = new sysBpmsThreadTask();
threadTask.Update(engineSharedModel.CurrentThreadID.Value, task.ID, DateTime.Now.AddSeconds(i++), null, string.Empty, 0, (int)sysBpmsThreadTask.e_StatusLU.New);
threadTask.UpdateAccessInfo(uId, null);
list.Add(threadTask);
}
}
break;
case UserTaskRuleModel.e_RoleAccessType.CorrespondentRole:
Guid?userId = task.UserTaskRuleModel.UserType == (int)UserTaskRuleModel.e_UserType.CurrentUserID ? new UserService(base.UnitOfWork).GetInfo(engineSharedModel.CurrentUserName ?? "")?.ID : engineSharedModel.CurrentThread?.UserID;
Guid?departmentId = new AccessCodeHelper(base.UnitOfWork).GetDepartmentHierarchyByUserId(userId.ToGuidObj(), task.UserTaskRuleModel.RoleCode.ToIntObj(), task.UserTaskRuleModel.GoUpDepartment);
if (!departmentId.HasValue)
{
throw new Exception(LangUtility.Get("OrganizationNotFound.Text", nameof(sysBpmsThreadTask)));
}
{
List <Guid> users = new DepartmentMemberService(base.UnitOfWork).GetList(departmentId, task.UserTaskRuleModel.RoleCode.ToIntObj(), null).Select(c => c.UserID).ToList();
//It is used for sequential task.
int i = 0;
foreach (Guid uId in users)
{
threadTask = new sysBpmsThreadTask();
threadTask.Update(engineSharedModel.CurrentThreadID.Value, task.ID, DateTime.Now.AddSeconds(i++), null, string.Empty, 0, (int)sysBpmsThreadTask.e_StatusLU.New);
threadTask.UpdateAccessInfo(uId, null);
list.Add(threadTask);
}
}
break;
}
break;
}
return(list);
}
