/// <summary> /// Get Task Parameters /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="taskOid">Task Oid</param> /// <returns>List of PropertyInfo</returns> private IEnumerable <PropertyInfo> GetTaskParameters(IFlowTasksUnitOfWork uofw, Guid taskOid) { return(uofw.TaskInParameters.Find(tp => tp.TaskDefinition.TaskOid == taskOid, tp => tp.Property) .Select(tp => new PropertyInfo { Name = tp.Property.Name, Value = tp.Property.Value, Type = tp.Property.Type }).ToList()); }
/// <summary> /// Next Tasks For User Query /// </summary> /// <param name="uofw">Uofw</param> /// <param name="user">User</param> /// <param name="workflowOid">WorkflowOid</param> /// <param name="domain">Domain</param> /// <param name="searchFor">SearchFor</param> /// <returns></returns> private IQueryable <TaskDefinition> NextTasksForUserQuery(IFlowTasksUnitOfWork uofw, string user, Guid workflowOid, string domain, string searchFor) { var handOverNone = HandOverStatus.None.ToString(); var handOverBack = HandOverStatus.HandedBack.ToString(); var handOverOver = HandOverStatus.HandedOver.ToString(); var q = from t in uofw.TaskDefinitions.AsQueryable() .Include("WorkflowDefinition") join tu in uofw.TaskUsers.AsQueryable() on new { JoinProperty1 = t.TaskDefinitionId, JoinProperty2 = user } equals new { JoinProperty1 = tu.TaskDefinitionId, JoinProperty2 = tu.User } into tug from lotu in tug.DefaultIfEmpty() join tuh in uofw.TaskUserHandOvers.AsQueryable() on new { JoinProperty1 = t.TaskDefinitionId, JoinProperty2 = user } equals new { JoinProperty1 = tuh.TaskDefinitionId, JoinProperty2 = tuh.User } into tuhg from lotuh in tuhg.DefaultIfEmpty() where (workflowOid == Guid.Empty || t.WorkflowDefinition.WorkflowOid == workflowOid) && (string.IsNullOrEmpty(domain) || t.WorkflowDefinition.Domain == domain) && (string.IsNullOrEmpty(searchFor) || t.Title.Contains(searchFor)) && (string.IsNullOrEmpty(t.AcceptedBy) || t.AcceptedBy.Equals(user, StringComparison.OrdinalIgnoreCase)) && ( ((string.IsNullOrEmpty(t.HandedOverStatus) || t.HandedOverStatus.Equals(handOverNone, StringComparison.OrdinalIgnoreCase)) && lotu.User.Equals(user, StringComparison.OrdinalIgnoreCase)) || (t.HandedOverStatus.Equals(handOverBack, StringComparison.OrdinalIgnoreCase) && lotu.InUse && lotu.User.Equals(user, StringComparison.OrdinalIgnoreCase)) || (t.HandedOverStatus.Equals(handOverOver, StringComparison.OrdinalIgnoreCase) && lotuh.InUse && lotuh.User.Equals(user, StringComparison.OrdinalIgnoreCase)) ) select t; return(q); }
/// <summary> /// Add Properties /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="domain">Domain</param> /// <param name="wfc">Workflow Code</param> /// <param name="wfd">Workflow Definition</param> /// <param name="properties">Properties</param> private void AddProperties(IFlowTasksUnitOfWork uofw, string domain, WorkflowCode wfc, WorkflowDefinition wfd, IEnumerable <PropertyInfo> properties) { var wfps = uofw.WorkflowProperties.Find(wfp => wfp.WorkflowCode.Code == wfc.Code && (wfp.Domain == domain || string.IsNullOrEmpty(wfp.Domain)), wfp => wfp.Property); foreach (var p in wfps) { uofw.WorkflowInParameters.Insert( CreateWorkflowInParameter( CreateProperty(p.Property.Name, p.Property.Value, p.Property.Type), wfd)); } // Add properties from the parameter if (properties != null) { // Don't copy properties twice var workflowPropsName = wfps.Select(wfp => wfp.Property.Name); var distinctProp = properties.Where(p => !workflowPropsName.Contains(p.Name)).Select(p => p); foreach (var p in distinctProp) { uofw.WorkflowInParameters.Insert( CreateWorkflowInParameter( CreateProperty(p.Name, p.Value, p.Type), wfd)); } } }
/// <summary> /// Initialize Place Holders /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="tkd">Task Definition</param> /// <param name="taskInfo">Task Info</param> private void InitializePlaceHolders(IFlowTasksUnitOfWork uofw, TaskDefinition tkd, TaskInfo taskInfo) { var parameters = GetTaskParameters(uofw, taskInfo.TaskOid); var propertyInfos = parameters.ToList(); tkd.Title = PlaceHolder.ReplacePlaceHolderParameter(taskInfo.Title, propertyInfos); tkd.Description = PlaceHolder.ReplacePlaceHolderParameter(taskInfo.Description, propertyInfos); }
/// <summary> /// Set Parameters /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="workflowDefinition">Workflow Definition</param> /// <param name="taskDefinition">Task Definition</param> /// <param name="properties">Properties</param> private void SetParameters(IFlowTasksUnitOfWork uofw, WorkflowDefinition workflowDefinition, TaskDefinition taskDefinition, IEnumerable <PropertyInfo> properties) { // Read pre-defined workflow parameters var workflowParameters = uofw.WorkflowInParameters.Find(wp => wp.WorkflowDefinition.WorkflowDefinitionId == workflowDefinition.WorkflowDefinitionId, wp => wp.Property); // Read pre-defined task properties var taskProperties = uofw.TaskProperties.Find(tp => tp.WorkflowCode.Code == workflowDefinition.WorkflowCode.Code && tp.TaskCode == taskDefinition.TaskCode, tp => tp.Property); // Keep track of property added var parametersAdded = new List <string>(); // Add "global" task properties foreach (var p in taskProperties) { uofw.TaskInParameters.Insert( CreateTaskInParameter(p.Property, taskDefinition)); parametersAdded.Add(p.Property.Name); } // Add "global" workflow parameters foreach (var p in workflowParameters) { if (parametersAdded.Contains(p.Property.Name)) { continue; } uofw.TaskInParameters.Insert( CreateTaskInParameter(p.Property, taskDefinition)); parametersAdded.Add(p.Property.Name); } // Add "user" task properties if (properties != null) { foreach (var p in properties) { if (parametersAdded.Contains(p.Name)) { continue; } uofw.TaskInParameters.Insert( CreateTaskInParameter( CreateProperty(p.Name, p.Value, p.Type), taskDefinition)); parametersAdded.Add(p.Name); } } }
/// <summary> /// Delete Properties /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="tkp">Task Properties</param> /// <param name="tkwfProp">Workflow Properties</param> /// <param name="tkwfInParam">Workflow In Parameters</param> /// <param name="tkwfOutParam">Workflow Out Parameters</param> private void DeleteProperties(IFlowTasksUnitOfWork uofw, List <Property> tkp, List <Property> tkwfProp, List <Property> tkwfInParam, List <Property> tkwfOutParam) { // Delete all the property a part from the ones in : // WorkflowProperties and WorkflowInParameters and WorkflowOutParameters // I need those properties when I want to manualy restart // the workflow foreach (var p in tkp) { if (!tkwfProp.Contains(p) && !tkwfInParam.Contains(p) && !tkwfOutParam.Contains(p)) { uofw.Properties.Delete(p); } } }
/// <summary> /// Topics For User /// </summary> /// <param name="uofw">Uofw</param> /// <param name="user">User</param> /// <param name="topicId">TopicId</param> /// <param name="title">Title</param> /// <param name="status"></param> /// <param name="withReplies"></param> /// <returns></returns> private IQueryable <TopicUser> TopicsForUser(IFlowTasksUnitOfWork uofw, string user, int topicId, string title, string status, bool withReplies) { var q = from tu in uofw.TopicUsers.AsQueryable() .Include("TopicStatus") .Include("TopicMessage") .Include("TopicMessage.Topic") where (withReplies || tu.TopicMessage.IsTopic) && tu.User.Equals(user, StringComparison.OrdinalIgnoreCase) && (topicId == 0 || tu.TopicMessage.Topic.TopicId == topicId) && (string.IsNullOrEmpty(title) || tu.TopicMessage.Topic.Title.Contains(title)) && (string.IsNullOrEmpty(status) || tu.TopicStatus.Status.Equals(status, StringComparison.OrdinalIgnoreCase)) select tu; return(q); }
/// <summary> /// Initialize Users /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="tkd">Task Definition</param> /// <param name="taskInfo">Task Info</param> /// <param name="domain">Domain</param> private void InitializeUsers(IFlowTasksUnitOfWork uofw, TaskDefinition tkd, TaskInfo taskInfo, string domain) { bool foundUser = false; foreach (var u in ParseUsers.GetListUsersName(_usersService, domain, taskInfo.AssignedToUsers)) { uofw.TaskUsers.Insert(CreateTaskUser(tkd, u)); foundUser = true; } foreach (var u in ParseUsers.GetListUsersName(_usersService, domain, taskInfo.HandOverUsers)) { uofw.TaskUserHandOvers.Insert(CreateTaskUserHandHover(tkd, u)); foundUser = true; } if (!foundUser) { throw new Exception("No valid user found"); } }
/// <summary> /// Create Notification /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="wfd">Workflow Definition</param> /// <param name="notificationInfo">Notification Info</param> /// <param name="user">User</param> private void CreateNotification(IFlowTasksUnitOfWork uofw, WorkflowDefinition wfd, NotificationInfo notificationInfo, string user) { TaskDefinition tkd; tkd = new TaskDefinition { UiCode = "ReadNotification", TaskCode = NotificationCode, TaskOid = notificationInfo.TaskOid, WorkflowDefinition = wfd, Title = notificationInfo.Title, Description = notificationInfo.Description, AcceptedBy = user, DefaultResult = "OK" }; uofw.TaskDefinitions.Insert(tkd); // not implemented yet. do we need it? //InitializePlaceHolders(uofw, tkd, notificationInfo); InitializeNotificationToUsers(uofw, tkd, user); uofw.Commit(); }
/// <summary> /// Initialize Notification To Users /// </summary> /// <param name="uofw">Unit of Work</param> /// <param name="tkd">Task Definition</param> /// <param name="user">User</param> private void InitializeNotificationToUsers(IFlowTasksUnitOfWork uofw, TaskDefinition tkd, string user) { uofw.TaskUsers.Insert(CreateTaskUser(tkd, user)); }