/// <summary>
/// 获取审批意见
/// </summary>
/// <param name="eaid">被审批对象的Id</param>
/// <returns></returns>
public List <ApprovalSolution> GetApprovalSolutions(int eaid)
{
DrillApprovalSolution drill = new DrillApprovalSolution();
string userId = WorkflowRuntime.Current.GetService <IIdentityService>().GetUserIdentity().GetUserId();
string rootName = WorkflowRuntime.Current.DefineService.GetRoot(this.applicationName);
List <ApprovalRole> roles = WorkflowUtility.GetUserRoles(rootName, userId);
if (roles == null || roles.Count == 0)
{
//没有角色用户,不能看任何记录
return(new List <ApprovalSolution>());
}
if (this.solutionFilters != null && this.solutionFilters.Count >= 0)
{
ApprovalRole role = roles[0];
foreach (IApprovalSolutionFilter one in this.solutionFilters)
{
one.SetValues(rootName, role, userId);
drill.Filters.Add(one);
}
}
return(drill.GetInfo(this.applicationName, eaid));
}
/// <summary>
/// 获取某用户对某实例执行某动作时的角色，如用户无执行该动作的权限，返回null
/// </summary>
/// <param name="instance">工作流实例</param>
/// <param name="userId">用户的Id</param>
/// <param name="actionName">执行动作</param>
/// <returns></returns>
public virtual ApprovalRole GetActionRole(WorkflowInstance instance, string userId, string actionName)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (string.IsNullOrEmpty(userId))
{
throw new ArgumentNullException("userId");
}
if (string.IsNullOrEmpty(actionName))
{
throw new ArgumentNullException("actionName");
}
bool isOwner = IsOwner(instance, userId);
ApprovalEvent approvalEvent = ((StateMachineWorkflowInstance)instance).CurrentState.GetEventByName(actionName);
foreach (EventRole role in approvalEvent.Roles)
{
if (IsAuthorized(userId, approvalEvent, isOwner, role))
{
return(WorkflowUtility.GetUserRoleByName(instance.Workflow, role.Name));
}
}
return(null);
}
/// <summary>
/// 获取某工作流程的某任务列表
/// </summary>
/// <param name="workflowName">工作流名称</param>
/// <param name="taskName">任务名称</param>
/// <returns></returns>
public TaskList GetTask(string workflowName, string taskName)
{
List<ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userIdentity.GetUserId());
List<StateMachineWorkflowInstance> instanceList = new List<StateMachineWorkflowInstance>();
foreach (ApprovalRole role in roles)
{
instanceList.AddRange(CreateProcess(workflowName, role).GetInstanceList(taskName));
}
return new TaskList(taskName, ItemProcessor.GenerateTaskTable(instanceList));
}
/// <summary>
/// 获取某流程的所有任务列表
/// </summary>
/// <param name="workflowName">流程名称</param>
/// <returns></returns>
public TaskList[] GetTaskListsByWorkflow(string workflowName)
{
List<TaskList> result = new List<TaskList>();
List<ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userIdentity.GetUserId());
string[] taskNames = GetTaskNames(workflowName);
foreach (string taskName in taskNames)
{
result.Add(GetTask(workflowName, taskName));
}
return result.ToArray();
}
/// <summary>
/// 获取某用户对某流程的角色-实例集合字典
/// </summary>
/// <param name="workflowName">流程名称</param>
/// <param name="userId">用户Id</param>
/// <param name="startDate">其实时间</param>
/// <param name="endDate">终止时间</param>
/// <returns></returns>
private InstanceCollection DistillInstances(string workflowName, string userId, DateTime startDate, DateTime endDate)
{
List <ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userId);
IUserIdentity userIdentity = identityService.GetUserIdentity(userId);
InstanceCollection rtn = new InstanceCollection();
//对本流程中每一个角色遍历得到实例集合后合并入角色-实例集合字典
foreach (ApprovalRole role in roles)
{
rtn.AddRange(DistillInstances(workflowName, userId, role.Name, startDate, endDate));
}
return(rtn);
}
/// <summary>
/// 获取某用户对某流程的任务列表
/// </summary>
/// <param name="userId">用户Id</param>
/// <param name="startDate">其实时间</param>
/// <param name="endDate">终止时间</param>
/// <returns></returns>
public InstanceCollection DistillInstances(string userId, DateTime startDate, DateTime endDate)
{
InstanceCollection instances = new InstanceCollection();
foreach (string workflowName in this.workflowNames)
{
//对每一个流程中每一个角色遍历得到实例集合后合并入角色-实例集合字典
List <ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userId);
foreach (ApprovalRole role in roles)
{
instances.AddRange(DistillInstances(workflowName, userId, role.Name, startDate, endDate));
}
}
return(instances);
}
/// <summary>
/// 获取某流程的可以撤销操作的任务列表
/// </summary>
/// <returns></returns>
public TaskList GetAllowedCancelTask(string workflowName, string taskName)
{
List<ITaskItem> taskItemsList = new List<ITaskItem>();
List<ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userIdentity.GetUserId());
List<StateMachineWorkflowInstance> instanceList = new List<StateMachineWorkflowInstance>();
foreach (ApprovalRole role in roles)
{
if (!string.IsNullOrEmpty(role.Name))
{
instanceList.AddRange(CreateProcess(workflowName, role).GetCancelAllowedTaskList());
}
}
TaskList list = new TaskList("a." + taskName, ItemProcessor.GenerateTaskTable(instanceList));
return list;
}
/// <summary>
/// 获取某流程的所有任务的名称
/// </summary>
/// <param name="workflowName">流程的名称</param>
/// <returns></returns>
public string[] GetTaskNames(string workflowName)
{
List<ApprovalRole> roles = WorkflowUtility.GetUserRoles(workflowName, userIdentity.GetUserId());
List<string> taskNameList = new List<string>();
foreach (ApprovalRole role in roles)
{
List<string> taskList = CreateProcess(workflowName, role).GetTaskNameList();
foreach (string taskName in taskList)
{
if (!taskNameList.Contains(taskName))
taskNameList.Add(taskName);
}
}
taskNameList.Sort();
return taskNameList.ToArray();
}
/// <summary>
/// 获取实例的操作项目集合,方法是从工作流配置xml文件中定义的操作(动作),如果是作为工具条形式提取,那么自动<see cref="GetToolbarAddtionActionItems"/>方法,附加额外的自定义项目.
/// </summary>
/// <param name="instance">某实例</param>
/// <param name="isTooBar">if set to <c>true</c> 工具条形式提取.</param>
/// <returns></returns>
public List <ITaskActionItem> GetInstanceActionItems(StateMachineWorkflowInstance instance, bool isTooBar)
{
List <ITaskActionItem> items = new List <ITaskActionItem>();
List <ApprovalRole> roles = WorkflowUtility.GetUserRoles(instance.WorkflowName, userIdentity.GetUserId());
//如是任务栏，则先添加任务栏相关的动作项目
if (isTooBar)
{
items.AddRange(GetToolbarAddtionActionItems(instance));
}
//遍历当前用户所有角色，添加每个角色对应的动作项目
foreach (ApprovalRole role in roles)
{
items.AddRange(GetInstanceActionItems(instance, role));
}
return(items);
}
/// <summary>
/// Gets all roles.
/// </summary>
/// <returns></returns>
public static string[] GetAllRoles(string applicationName)
{
string[] workflows = WorkflowRuntime.Current.DefineService.GetAllWorkflowDefineName(applicationName);
List <string> roles = new List <string>();
foreach (string workflowName in workflows)
{
List <ApprovalRole> allRoles = WorkflowUtility.GetAllWorkflowRoles(workflowName);
foreach (ApprovalRole role in allRoles)
{
if (!roles.Contains(role.Name))
{
roles.Add(role.Name);
}
}
}
return(roles.ToArray());
}
/// <summary>
/// Checks this instance.
/// </summary>
public void Check(string applicationName)
{
List <string> roles = new List <string>(WorkflowUtility.GetAllRoles(applicationName));
foreach (string key in optionsDic.Keys)
{
string[] roleNames = optionsDic[key].RoleNames;
if (roleNames != null && roleNames.Length < 0)
{
foreach (string roleName in roleNames)
{
if (!roles.Contains(roleName))
{
throw new Exception(string.Format("AgentConfig 配置错误！ role '{0}' 不存在于工作流中！ ", roleName));
}
}
}
}
}
/// <summary>
/// Gets the batch process list.
/// </summary>
/// <param name="workflowName">Name of the workflow.</param>
/// <param name="batchProcessType">Type of the batch process.</param>
/// <returns></returns>
public virtual TaskList GetBatchProcessList(string workflowName, BatchProcessType batchProcessType)
{
StateMachineWorkflow workflow = (StateMachineWorkflow)WorkflowRuntime.Current.GetService<IWorkFlowDefinePersistService>().GetWorkflowDefine(workflowName);
string stateName = string.Empty;
ApprovalRole role = null;
if (batchProcessType == BatchProcessType.Receive)
{
//获取操作为“接收”所在的状态名称
foreach (ApprovalState state in workflow.States)
{
foreach (ApprovalEvent approvalEvent in state.Events)
{
if (approvalEvent.Name == "接收")
{
role = WorkflowUtility.GetUserRoleByName(workflowName, approvalEvent.Roles[0].Name);
stateName = state.Name;
}
}
}
}
else if (batchProcessType == BatchProcessType.Approve)
{
//遍历工作流状态，找到下一状态为工作流终止状态的状态名
foreach (ApprovalState state in workflow.States)
{
foreach (ApprovalEvent approvalEvent in state.Events)
{
if (approvalEvent.NextStateNames != null && approvalEvent.NextStateNames.Length > 0 && approvalEvent.NextStateNames[0] == workflow.EndState)
{
role = WorkflowUtility.GetUserRoleByName(workflowName, approvalEvent.Roles[0].Name);
stateName = state.Name;
}
}
}
}
else
throw new ArgumentException("batchProcessType");
ApprovalProcess process = CreateProcess(workflowName, role);
//获取所有在该状态下的工作流实例
List<StateMachineWorkflowInstance> instanceList = process.GetList(new string[] { stateName });
return new TaskList("a." + batchProcessType.ToString(), new List<ITaskItem>(ItemProcessor.GenerateTaskTable(instanceList)));
}
/// <summary>
/// 获取角色和对应实例集合的键-值对
/// </summary>
/// <param name="workflowName">流程名称</param>
/// <param name="userId">用户Id</param>
/// <param name="roleName">角色名称</param>
/// <param name="startDate">时间段起始时间</param>
/// <param name="endDate">时间段截止时间</param>
/// <returns></returns>
private InstanceCollection DistillInstances(string workflowName, string userId, string roleName, DateTime startDate, DateTime endDate)
{
IUserIdentity userIdentity = identityService.GetUserIdentity(userId);
//获取流程对应的审批角色对象，并从角色-提取者字典中获取角色对应的提取者
InstanceCollection instances = new InstanceCollection();
ApprovalRole role = WorkflowUtility.GetUserRoleByName(workflowName, roleName);
if (role != null)
{
//用户不在该角色
if (!userInRole.IsUserInRole(userIdentity.GetUserId(), role.Name))
{
throw new ApplicationException(string.Format("{0} is not in role {1}", userIdentity.GetUserId(), role.Name));
}
//取得角色的任务提取器
TaskDistiller distiller = GetRoleDistiller(roleName);
instances.AddRange(distiller.Distill(workflowName, userIdentity, role, startDate, endDate));
}
return(instances);
}
/// <summary>
/// 从RoleConfg项目中生成服务
/// </summary>
/// <param name="config">The config.</param>
/// <param name="applicationName">此TaskService实例对应的应用名称.</param>
internal TaskService(ServiceConfig config, string applicationName)
: this()
{
//获取该应用的所有工作流名称.
IWorkFlowDefinePersistService defineService = WorkflowRuntime.Current.GetService <IWorkFlowDefinePersistService>();
this.workflowNames = defineService.GetAllWorkflowDefineName(applicationName);
this.taskName = config.TaskName;
this.name = config.Name;
this.mergeRoles = config.AllMerge;
if (config.DefaultItem == null)
{
throw new ConfigurationErrorsException(string.Format("Cann't found Default roleConfig!"));
}
this.defaultDistiller = InitTaskDistiller(config.DefaultItem);
if (defaultDistiller.InstanceDistillers == null)
{
throw new ConfigurationErrorsException(string.Format("default distillers \"{0}\" can not be empty!", config.Name));
}
if (defaultDistiller.Filters == null)
{
throw new ConfigurationErrorsException(string.Format("default filters \"{0}\" can not be empty!", config.Name));
}
if (defaultDistiller.ItemDistiller == null)
{
throw new ConfigurationErrorsException(string.Format("default itemDistiller \"{0}\" is not exist!", config.Name));
}
if (defaultDistiller.Render == null)
{
throw new ConfigurationErrorsException(string.Format("default taskRender \"{0}\" is not exist!", config.Name));
}
distillersMap = new Dictionary <string, TaskDistiller>();
if (config.Items != null && config.Items.Length > 0)
{
//遍历每个角色配置项目生成提取者，如果提取者
foreach (RoleConfigItem item in config.Items)
{
TaskDistiller distiller = InitTaskDistiller(item);
//如果提取者集合为空，则使用缺省提取者集合
if (distiller.InstanceDistillers == null || distiller.InstanceDistillers.Length == 0)
{
distiller.InstanceDistillers = defaultDistiller.InstanceDistillers;
}
//如果过滤器为空，则使用缺省过滤器集合
if (distiller.Filters == null || distiller.Filters.Length == 0)
{
distiller.Filters = defaultDistiller.Filters;
}
if (distiller.ItemDistiller == null)
{
distiller.ItemDistiller = defaultDistiller.ItemDistiller;
}
if (distiller.Render == null)
{
distiller.Render = defaultDistiller.Render;
}
if (string.IsNullOrEmpty(item.Name))
{
throw new ConfigurationErrorsException("");
}
//把角色字串拆解为角色数组
string[] o = item.Name.Split(";,；，".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
//添加到角色-提取器字典中
foreach (string s in o)
{
if (!distillersMap.ContainsKey(s))
{
distillersMap[s] = distiller;
}
}
}
}
//校验角色字典，对不存在角色抛出异常
List <string> roles = new List <string>(WorkflowUtility.GetAllRoles(applicationName));
foreach (string key in distillersMap.Keys)
{
if (!roles.Contains(key))
{
throw new ConfigurationErrorsException(string.Format("There isn't a role called '{0}' in workflow's definiton files", key));
}
}
}
//获取审批角色的service
private ApprovalRole GetApprovalRoleByName(string name)
{
return(WorkflowUtility.GetUserRoleByName(workflowName, name));
}
