/// <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));
}
