写在前面：本人文采不好，零星写过几篇随笔，但都不尽人意，本着共同学习共同进步的原则，还是打算把近期开发的一个通用流程的软件拿出来与大家分享。本流程软件能满足鄙人接触到了解到的一般的流程实现（由于接触到的流程有限，以及对流程理解的不够透彻，流程引擎中不免有设计不足或考虑不周，也希望大神们能多多指点），如果读者在阅读或使用过程中遇到什么问题或有什么想法，希望能拿出来与大家分享，我们共同去学习去完善这套流程引擎。本随笔打算只涉及流程引擎部分，可视化流程设计随后做单独的随笔推出。写作水平有限，望读者多多体谅...（如有问题可随时联系笔者。邮箱:455274752@qq.com）。欢迎加入流程交流群：251834323
一、需求
开发一套通用流程引擎软件，在主软件可以通过简单的注册、引用，即可完成软件流程部门的设计开发。
二、抽象解决方案
1.通过EntityFramework的CodeFirst实现流程有关的数据库表的创建。
2.通过SilverLight实现流程的可视化操作。
三、项目结构说明
四、项目结构分析及代码
一、Entities流程实体
定义流程相关的数据库实体。
1.WorkflowInitializer.cs 初始化数据库类，定义创建数据库时的默认数据。相关类定义如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Data.Entity; 4 using System.Linq; 5 using System.Text; 6 using Workflow.Entities; 7 8 namespace Workflow.Entities 9 { 10 /// <summary> 11 /// 初始化数据库数据 12 /// </summary> 13 public class WorkflowInitializer : DropCreateDatabaseIfModelChanges<WorkflowDB> 14 { 15 /// <summary> 16 /// 重写数据库初始化方法 17 /// </summary> 18 /// <param name="context"></param> 19 protected override void Seed(WorkflowDB context) 20 { 21 var modules = new List<ModuleList> { 22 new ModuleList{ModuleName="模版一",ModuleExplain="模版一"} 23 }; 24 modules.ForEach(i => context.ModuleLists.Add(i)); 25 context.SaveChanges(); 26 27 var mains = new List<WorkflowMain> { 28 new WorkflowMain { WorkflowName = "流程一",WorkflowStatus="1",ModuleID=1,Owner="qdq",WorkflowExplain="主流程说明",IsDefault=true } 29 }; 30 mains.ForEach(i => context.WorkflowMains.Add(i)); 31 context.SaveChanges(); 32 33 var details = new List<WorkflowDetailed> { 34 new WorkflowDetailed{Top_Y=10,Left_X=10,SetpExplain="开始",StepStatus="1",Deadline=3,Nunciator="qdq", 35 IsCirculation=false,ProcessingPersonnel="qdq",ProcessingPersonnelMode="Person",WorkflowID=1,StepID=0, 36 StepName="开始",UpStep=null,NextStep=1,ProcessingMode="1"}, 37 new WorkflowDetailed{Top_Y=200,Left_X=200,SetpExplain="步骤一",StepStatus="1",Deadline=3,Nunciator="qdq", 38 IsCirculation=false,ProcessingPersonnel="qdq",ProcessingPersonnelMode="Person",WorkflowID=1,StepID=1, 39 StepName="步骤一",UpStep=-1,NextStep=2,ProcessingMode="1"}, 40 new WorkflowDetailed{Top_Y=350,Left_X=350,SetpExplain="步骤二",StepStatus="1",Deadline=3,Nunciator="qdq,cyl", 41 IsCirculation=false,ProcessingPersonnel="qdq",ProcessingPersonnelMode="Person",WorkflowID=1,StepID=2, 42 StepName="步骤二",UpStep=-1,NextStep=-1,ProcessingMode="1"}, 43 new WorkflowDetailed{Top_Y=500,Left_X=500,SetpExplain="结束",StepStatus="1",Deadline=3,Nunciator="qdq", 44 IsCirculation=false,ProcessingPersonnel="qdq",ProcessingPersonnelMode="Person",WorkflowID=1,StepID=-1, 45 StepName="结束",UpStep=null,NextStep=0,ProcessingMode="1"} 46 }; 47 details.ForEach(i => context.WorkflowDetaileds.Add(i)); 48 context.SaveChanges(); 49 50 var tasks = new List<TaskList> { 51 new TaskList{ MessageType=1,TaskSN=1,StepStatus="1",HandleType=1,HandleStatus=true,HandlePerson="qdq", 52 HandleTime=DateTime.Now,Receive=DateTime.Now,Opinion="同意",WorkflowDetailed_ID=2,FromID="20130001"} 53 }; 54 tasks.ForEach(i => context.TaskLists.Add(i)); 55 context.SaveChanges(); 56 57 var annexs = new List<AnnexList> { 58 new AnnexList{AnnexAddress="测试",AnnexName="测试",TaskList_ID=1} 59 }; 60 annexs.ForEach(i => context.AnnexLists.Add(i)); 61 context.SaveChanges(); 62 63 base.Seed(context); 64 } 65 } 66 }
2.WorkflowDB.cs 继承System.Data.Entity.DbContext 定义流程引擎数据库上下文类。相关类定义如下：
1 using System.Collections.Generic; 2 using System.Data.Entity; 3 using System.ComponentModel.DataAnnotations; 4 5 namespace Workflow.Entities 6 { 7 /// <summary> 8 /// 数据上下文 9 /// </summary> 10 public class WorkflowDB : DbContext 11 { 12 //name指定连接字符串,否则默认为类名(如果有多个连接字符串,此处选取第一个) 13 /// <summary> 14 /// 构造函数 15 /// </summary> 16 public WorkflowDB() 17 //: base("name=WorkflowDB") 18 : base("Data Source=.;Initial Catalog=WorkflowDB;User ID=sa;Password=1234;Integrated Security=True") 19 //: base("name=" + System.Configuration.ConfigurationManager.ConnectionStrings[1].Name) 20 { } 21 /// <summary> 22 /// 模块实体列表 23 /// </summary> 24 public DbSet<ModuleList> ModuleLists { get; set; } 25 /// <summary> 26 /// 流程实体列 27 /// </summary> 28 public DbSet<WorkflowMain> WorkflowMains { get; set; } 29 /// <summary> 30 /// 步骤实体列表 31 /// </summary> 32 public DbSet<WorkflowDetailed> WorkflowDetaileds { get; set; } 33 /// <summary> 34 /// 任务实体列表 35 /// </summary> 36 public DbSet<TaskList> TaskLists { get; set; } 37 /// <summary> 38 /// 附件实体列表 39 /// </summary> 40 public DbSet<AnnexList> AnnexLists { get; set; } 41 } 42 }
3.ModuleList.cs 模块类，主应用程序包含多个模块应用流程时，有此处区分具体模块需应用的具体流程。相关类定义如下：
1 using System; 2 using System.Collections.Generic; 3 using System.ComponentModel.DataAnnotations; 4 using System.ComponentModel.DataAnnotations.Schema; 5 using System.Linq; 6 using System.Text; 7 8 namespace Workflow.Entities 9 { 10 public class ModuleList 11 { 12 // id标识 13 private int _ModuleID; 14 // 模块说明 15 private string _ModuleExplain; 16 /// <summary> 17 /// 所包含的流程列表 18 /// </summary> 19 public ICollection<WorkflowMain> WorkflowMains { get; set; } 20 // 模块名称 21 private string _ModuleName; 22 23 /// <summary> 24 /// 模块名称 25 /// </summary> 26 [Required(ErrorMessage="模块名称为必填"),MaxLength(100)] 27 public string ModuleName 28 { 29 get { return _ModuleName; } 30 set { _ModuleName = value; } 31 } 32 33 /// <summary> 34 /// 模块说明 35 /// </summary> 36 [MaxLength(500)] 37 public string ModuleExplain 38 { 39 get { return _ModuleExplain; } 40 set { _ModuleExplain = value; } 41 } 42 43 /// <summary> 44 /// id标识 45 /// </summary> 46 [Key,DatabaseGenerated(DatabaseGeneratedOption.Identity)] 47 public int ModuleID 48 { 49 get { return _ModuleID; } 50 set { _ModuleID = value; } 51 } 52 53 } 54 }
4.WorkflowMain.cs 流程主表类，定义流程相关的属性。相关类定义如下：
1 using System.Collections.Generic; 2 using System.Data.Entity; 3 using System.ComponentModel.DataAnnotations; 4 using System.ComponentModel.DataAnnotations.Schema; 5 6 namespace Workflow.Entities 7 { 8 public partial class WorkflowMain 9 { 10 // 流程编号 11 private int _WorkflowID; 12 // 流程名称 13 private string _WorkflowName; 14 // 是否为默认流程 15 private bool _IsDefault; 16 // 流程的状态(1正常2暂停3废弃) 17 private string _WorkflowStatus; 18 // 流程说明 19 private string _WorkflowExplain; 20 // 流程所属人 21 private string _Owner; 22 private int _ModuleID; 23 24 /// <summary> 25 /// 流程的状态(1正常2暂停3废弃) 26 /// </summary> 27 [Required,MaxLength(1)] 28 public string WorkflowStatus 29 { 30 get { return _WorkflowStatus; } 31 set { _WorkflowStatus = value; } 32 } 33 34 /// <summary> 35 /// 流程详细步骤表 36 /// </summary> 37 public ICollection<WorkflowDetailed> WorkflowDetaileds { get; set; } 38 39 /// <summary> 40 /// 所属模块 41 /// </summary> 42 [ForeignKey("ModuleID")] 43 public ModuleList ModuleList { get; set; } 44 45 /// <summary> 46 /// 所属模块ID 47 /// </summary> 48 [Required] 49 public int ModuleID 50 { 51 get { return _ModuleID; } 52 set { _ModuleID = value; } 53 } 54 55 /// <summary> 56 /// 流程所属人 57 /// </summary> 58 [MaxLength(20)] 59 public string Owner 60 { 61 get { return _Owner; } 62 set { _Owner = value; } 63 } 64 65 /// <summary> 66 /// 流程说明 67 /// </summary> 68 [MaxLength(500)] 69 public string WorkflowExplain 70 { 71 get { return _WorkflowExplain; } 72 set { _WorkflowExplain = value; } 73 } 74 75 /// <summary> 76 /// 流程编号 77 /// </summary> 78 [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] 79 public int WorkflowID 80 { 81 get { return _WorkflowID; } 82 set { _WorkflowID = value; } 83 } 84 85 /// <summary> 86 /// 流程名称 87 /// </summary> 88 [Required(ErrorMessage = "流程名称为必填"),MaxLength(30)] 89 public string WorkflowName 90 { 91 get { return _WorkflowName; } 92 set { _WorkflowName = value; } 93 } 94 95 /// <summary> 96 /// 是否为默认流程 97 /// </summary> 98 public bool IsDefault 99 { 100 get { return _IsDefault; } 101 set { _IsDefault = value; } 102 } 103 104 } 105 }
5.WorkflowDetailed.cs 流程子表类，定义流程步骤的相关属性。相关类定义如下：
1 using System.Collections.Generic; 2 using System.Data.Entity; 3 using System.ComponentModel.DataAnnotations; 4 using System.ComponentModel.DataAnnotations.Schema; 5 using System; 6 7 namespace Workflow.Entities 8 { 9 public partial class WorkflowDetailed 10 { 11 public WorkflowDetailed() { } 12 13 public WorkflowDetailed(int workflow, int stepid,string stepname) 14 { 15 _WorkflowID = workflow; 16 _StepID = stepid; 17 _StepName = stepname; 18 _UpStep = -1;//默认审批不通过进入结束流程 19 _NextStep = stepid + 1;//默认+1 20 _ProcessingMode = "100%"; 21 //_MainProcessingMode = "100%"; 22 _ProcessingPersonnelMode = "Person"; 23 _ProcessingPersonnel = ""; 24 _IsCirculation = false; 25 _Nunciator = ""; 26 _Deadline = 7; 27 _StepStatus = "1"; 28 } 29 30 // id标识 31 private int _ID; 32 // 流程编号 33 private int _WorkflowID; 34 // 步骤编号 35 private int _StepID; 36 // 步骤名称 37 private string _StepName; 38 // 验证失败返回的步骤，审批不同意和环形审批使用 39 private int? _UpStep; 40 // 验证通过进入的步骤序号 41 private int? _NextStep; 42 // 流程处理 验证是否通过的模式(正数=通过人数,负数=不通过人数,百分数=通过率) 43 private string _ProcessingMode; 44 // 处理人员的类型(人员 角色 部门等) 45 private string _ProcessingPersonnelMode; 46 // 处理具体人员(人员 角色 部门等) 47 private string _ProcessingPersonnel; 48 // 是否运行流转 49 private bool _IsCirculation; 50 // 具体告知人 51 private string _Nunciator; 52 // 告知人的过期时间 单位/天 53 private int _Deadline; 54 // 流程的状态(1正常2暂停3废弃) 55 private string _StepStatus; 56 // 条件表达式(根据条件判断下一步骤 格式如：7>@p?1:2)优先级大于NextStep 57 private string _Conditions; 58 // 步骤说明 59 private string _SetpExplain; 60 // 距离左侧的距离 X轴坐标 61 private double? _Left_X; 62 // 距离顶部的距离 Y轴坐标 63 private double? _Top_Y; 64 65 /// <summary> 66 /// 距离顶部的距离 Y轴坐标 67 /// </summary> 68 public double? Top_Y 69 { 70 get { return _Top_Y; } 71 set { _Top_Y = value; } 72 } 73 74 /// <summary> 75 /// 距离左侧的距离 X轴坐标 76 /// </summary> 77 public double? Left_X 78 { 79 get { return _Left_X; } 80 set { _Left_X = value; } 81 } 82 83 /// <summary> 84 /// 任务列表 85 /// </summary> 86 public ICollection<TaskList> TaskLists { get; set; } 87 /// <summary> 88 /// 流程主表 89 /// </summary> 90 [ForeignKey("WorkflowID")] 91 public WorkflowMain WorkflowMain { get; set; } 92 93 /// <summary> 94 /// 步骤说明 95 /// </summary> 96 [MaxLength(500)] 97 public string SetpExplain 98 { 99 get { return _SetpExplain; } 100 set { _SetpExplain = value; } 101 } 102 103 /// <summary> 104 /// 条件表达式(根据条件判断下一步骤 格式如：7>@p?1:2)优先级大于NextStep 105 /// </summary> 106 [MaxLength(100)] 107 public string Conditions 108 { 109 get { return _Conditions; } 110 set { _Conditions = value; } 111 } 112 113 /// <summary> 114 /// 流程的状态(1正常2暂停3废弃) 115 /// </summary> 116 [Required,MaxLength(1)] 117 public string StepStatus 118 { 119 get { return _StepStatus; } 120 set { _StepStatus = value; } 121 } 122 123 124 /// <summary> 125 /// 告知人的过期时间 单位/天 126 /// </summary> 127 public int Deadline 128 { 129 get { return _Deadline; } 130 set { _Deadline = value; } 131 } 132 133 /// <summary> 134 /// 具体告知人 135 /// </summary> 136 [MaxLength(500)] 137 public string Nunciator 138 { 139 get { return _Nunciator; } 140 set { _Nunciator = value; } 141 } 142 143 /// <summary> 144 /// 是否运行流转 145 /// </summary> 146 public bool IsCirculation 147 { 148 get { return _IsCirculation; } 149 set { _IsCirculation = value; } 150 } 151 152 /// <summary> 153 /// 处理具体人员(人员 角色 部门等) 154 /// </summary> 155 [MaxLength(500)] 156 public string ProcessingPersonnel 157 { 158 get { return _ProcessingPersonnel; } 159 set { _ProcessingPersonnel = value; } 160 } 161 162 /// <summary> 163 /// 处理人员的类型(人员 角色 部门等) 164 /// </summary> 165 [Required(ErrorMessage = "处理人员的类型为必填"), MaxLength(100)] 166 public string ProcessingPersonnelMode 167 { 168 get { return _ProcessingPersonnelMode; } 169 set { _ProcessingPersonnelMode = value; } 170 } 171 172 /// <summary> 173 /// id标识 174 /// </summary> 175 [Key,DatabaseGenerated(DatabaseGeneratedOption.Identity)] 176 public int ID 177 { 178 get { return _ID; } 179 set { _ID = value; } 180 } 181 182 /// <summary> 183 /// 流程编号 184 /// </summary> 185 [Required] 186 public int WorkflowID 187 { 188 get { return _WorkflowID; } 189 set { _WorkflowID = value; } 190 } 191 192 /// <summary> 193 /// 步骤编号 194 /// </summary> 195 [Required(ErrorMessage="步骤编号")] 196 public int StepID 197 { 198 get { return _StepID; } 199 set { _StepID = value; } 200 } 201 202 /// <summary> 203 /// 步骤名称 204 /// </summary> 205 [Required(ErrorMessage="步骤名称"),MaxLength(30)] 206 public string StepName 207 { 208 get { return _StepName; } 209 set { _StepName = value; } 210 } 211 212 /// <summary> 213 /// 验证失败返回的步骤，审批不同意和环形审批使用 214 /// </summary> 215 public int? UpStep 216 { 217 get { return _UpStep; } 218 set { _UpStep = value; } 219 } 220 221 /// <summary> 222 /// 验证通过进入的步骤序号 223 /// </summary> 224 public int? NextStep 225 { 226 get { return _NextStep; } 227 set { _NextStep = value; } 228 } 229 230 /// <summary> 231 /// 流程处理验证是否通过的模式(正数=通过人数,负数=不通过人数,百分数=通过率) 232 /// </summary> 233 [Required(ErrorMessage = "通过模式为必填"),MaxLength(10)] 234 public string ProcessingMode 235 { 236 get { return _ProcessingMode; } 237 set { _ProcessingMode = value; } 238 } 239 240 } 241 }
6.TaskList.cs 任务表，定义针对处理人的相关任务信息。相关类定义如下：
1 using System; 2 using System.Collections.Generic; 3 using System.ComponentModel.DataAnnotations; 4 using System.ComponentModel.DataAnnotations.Schema; 5 using System.Linq; 6 using System.Text; 7 8 namespace Workflow.Entities 9 { 10 public class TaskList 11 { 12 // id标识 13 private int _ID; 14 // 表单ID 15 private string _FromID; 16 // 步骤ID 17 private int _WorkflowDetailed_ID; 18 // 处理意见 19 private string _Opinion; 20 // 接收时间 21 private DateTime _ReceiveTime; 22 // 处理时间 23 private DateTime? _HandleTime; 24 // 处理人（告知人） 25 private string _HandlePerson; 26 // 处理状态（查看状态） 27 private bool _HandleStatus; 28 // 处理类型（1同意，2不同意） 29 private int? _HandleType; 30 // 流程状态(主要用于暂停时(1正常2暂停3废弃)) 31 private string _StepStatus; 32 // 上层任务id 33 private int? _UpTask; 34 // 任务序号 35 private int _TaskSN; 36 // 消息类型1处理类型2告知类型 37 private int _MessageType; 38 /// <summary> 39 /// 所属步骤表 40 /// </summary> 41 [ForeignKey("WorkflowDetailed_ID")] 42 public WorkflowDetailed WorkflowDetailed { get; set; } 43 /// <summary> 44 /// 附件表 45 /// </summary> 46 public ICollection<AnnexList> AnnexLists { get; set; } 47 48 /// <summary> 49 /// 消息类型1处理类型2告知类型 50 /// </summary> 51 public int MessageType 52 { 53 get { return _MessageType; } 54 set { _MessageType = value; } 55 } 56 57 /// <summary> 58 /// 任务序号 59 /// </summary> 60 public int TaskSN 61 { 62 get { return _TaskSN; } 63 set { _TaskSN = value; } 64 } 65 66 /// <summary> 67 /// 上层任务id 68 /// </summary> 69 public int? UpTask 70 { 71 get { return _UpTask; } 72 set { _UpTask = value; } 73 } 74 /// <summary> 75 /// 流程状态(主要用于暂停时(1正常2暂停3废弃)) 76 /// </summary> 77 [Required, MaxLength(1)] 78 public string StepStatus 79 { 80 get { return _StepStatus; } 81 set { _StepStatus = value; } 82 } 83 84 /// <summary> 85 /// 处理类型（1同意，2不同意） 86 /// </summary> 87 public int? HandleType 88 { 89 get { return _HandleType; } 90 set { _HandleType = value; } 91 } 92 93 /// <summary> 94 /// 处理状态 95 /// </summary> 96 [Required] 97 public bool HandleStatus 98 { 99 get { return _HandleStatus; } 100 set { _HandleStatus = value; } 101 } 102 103 /// <summary> 104 /// 处理人 105 /// </summary> 106 [Required] 107 public string HandlePerson 108 { 109 get { return _HandlePerson; } 110 set { _HandlePerson = value; } 111 } 112 113 /// <summary> 114 /// 处理时间 115 /// </summary> 116 public DateTime? HandleTime 117 { 118 get { return _HandleTime; } 119 set { _HandleTime = value; } 120 } 121 /// <summary> 122 /// 接收时间 123 /// </summary> 124 [Required] 125 public DateTime Receive 126 { 127 get { return _ReceiveTime; } 128 set { _ReceiveTime = value; } 129 } 130 131 /// <summary> 132 /// 处理意见 133 /// </summary> 134 public string Opinion 135 { 136 get { return _Opinion; } 137 set { _Opinion = value; } 138 } 139 140 /// <summary> 141 /// 步骤ID 142 /// </summary> 143 [Required] 144 public int WorkflowDetailed_ID 145 { 146 get { return _WorkflowDetailed_ID; } 147 set { _WorkflowDetailed_ID = value; } 148 } 149 150 /// <summary> 151 /// 表单ID 152 /// </summary> 153 [Required] 154 public string FromID 155 { 156 get { return _FromID; } 157 set { _FromID = value; } 158 } 159 160 /// <summary> 161 /// id标识 162 /// </summary> 163 [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] 164 public int ID 165 { 166 get { return _ID; } 167 set { _ID = value; } 168 } 169 } 170 }
7.AnnexList.cs 附件表，针对任务处理时上传附件的需求。相关类定义如下：
1 using System; 2 using System.Collections.Generic; 3 using System.ComponentModel.DataAnnotations; 4 using System.ComponentModel.DataAnnotations.Schema; 5 using System.Linq; 6 using System.Text; 7 8 namespace Workflow.Entities 9 { 10 public class AnnexList 11 { 12 // id标识 13 private int _ID; 14 // 所属任务表ID 15 private int _TaskList_ID; 16 // 原始附件名 17 private string _AnnexName; 18 // 附件地址 19 private string _AnnexAddress; 20 // 备注 21 private string _Remark; 22 /// <summary> 23 /// 所属的任务表 24 /// </summary> 25 [ForeignKey("TaskList_ID")] 26 public TaskList TaskList { get; set; } 27 28 /// <summary> 29 /// 备注 30 /// </summary> 31 [MaxLength(500)] 32 public string Remark 33 { 34 get { return _Remark; } 35 set { _Remark = value; } 36 } 37 38 /// <summary> 39 /// 附件地址 40 /// </summary> 41 [Required,MaxLength(200)] 42 public string AnnexAddress 43 { 44 get { return _AnnexAddress; } 45 set { _AnnexAddress = value; } 46 } 47 48 /// <summary> 49 /// 原始附件名 50 /// </summary> 51 [Required,MaxLength(300)] 52 public string AnnexName 53 { 54 get { return _AnnexName; } 55 set { _AnnexName = value; } 56 } 57 58 /// <summary> 59 /// 所属任务表ID 60 /// </summary> 61 [Required] 62 public int TaskList_ID 63 { 64 get { return _TaskList_ID; } 65 set { _TaskList_ID = value; } 66 } 67 68 /// <summary> 69 /// id标识 70 /// </summary> 71 [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] 72 public int ID 73 { 74 get { return _ID; } 75 set { _ID = value; } 76 } 77 78 } 79 }
二、Abstract 接口
定义外部访问的接口类。
1.ConcreteFactory.cs 工厂类，对外提供接口的实例。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace Workflow.Abstract 7 { 8 public class ConcreteFactory 9 { 10 /// <summary> 11 /// 创建具体实现的类的实例 12 /// </summary> 13 /// <typeparam name="T">接口类型</typeparam> 14 /// <typeparam name="T2">具体实现</typeparam> 15 /// <returns></returns> 16 public static T CreateConcrete<T,T2>() where T2:T 17 { 18 return (T)Activator.CreateInstance<T2>(); 19 } 20 } 21 }
2.Enums.cs 定义相关的枚举。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace Workflow.Abstract 7 { 8 public class Enums 9 { 10 /// <summary> 11 /// 任务处理人员的类型(弃用，改全局list) 12 /// </summary> 13 public enum ProcessingPersonnelModeEnum 14 { 15 /// <summary> 16 /// 人员 17 /// </summary> 18 Person = 1, 19 /// <summary> 20 /// 角色 21 /// </summary> 22 Role = 2, 23 /// <summary> 24 /// 部门 25 /// </summary> 26 Department = 3, 27 /// <summary> 28 /// 将来指定 29 /// </summary> 30 Hereafter = 4 31 }; 32 33 /// <summary> 34 /// 流程状态 35 /// </summary> 36 public enum StepStatus 37 { 38 /// <summary> 39 /// 正常 40 /// </summary> 41 Normal = 1, 42 /// <summary> 43 /// 暂停 44 /// </summary> 45 Suspend = 2, 46 /// <summary> 47 /// 废弃 48 /// </summary> 49 Discard = 3 50 }; 51 52 /// <summary> 53 /// 流程的错误类型 54 /// </summary> 55 public enum WorkflowErrorType 56 { 57 /// <summary> 58 /// 正确流程 59 /// </summary> 60 Normal = -1, 61 /// <summary> 62 /// 存在未闭环的步骤 63 /// </summary> 64 UnClosedLoop = -2, 65 /// <summary> 66 /// 存在未使用的节点（合并到UnClosedLoop）条件的下一步太多，不好验证 67 /// </summary> 68 UnUseNode = -3, 69 /// <summary> 70 /// 并步骤 存在不统一的下一级节点 71 /// </summary> 72 UnUnified = -4, 73 /// <summary> 74 /// 不统一的处理模式 75 /// </summary> 76 UnUnifiedMode = -5, 77 /// <summary> 78 /// 空流程 79 /// </summary> 80 EmptyWorkflow = -6 81 } 82 } 83 }
3. I*Operation.cs 对应数据库表的相关操作。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Entities; 6 7 namespace Workflow.Abstract 8 { 9 public interface IModuleOperation 10 { 11 /// <summary> 12 /// 添加实体 13 /// </summary> 14 /// <param name="modulelist"></param> 15 /// <returns></returns> 16 int ModuleAdd(ModuleList modulelist); 17 /// <summary> 18 /// 删除实体 19 /// </summary> 20 /// <param name="ModuleID"></param> 21 /// <returns></returns> 22 int ModuleDel(int ModuleID); 23 /// <summary> 24 /// 修改实体 25 /// </summary> 26 /// <param name="modulelist"></param> 27 /// <returns></returns> 28 int ModuleUpdate(ModuleList modulelist); 29 /// <summary> 30 /// 获得实体 31 /// </summary> 32 /// <param name="ModuleID"></param> 33 /// <returns></returns> 34 ModuleList GetModel(int ModuleID); 35 /// <summary> 36 /// 获得实体列表 37 /// </summary> 38 /// <returns></returns> 39 List<ModuleList> GetModuleList(); 40 /// <summary> 41 /// 获得所属流程列表 42 /// </summary> 43 /// <returns></returns> 44 List<WorkflowMain> GetWorkflowMainList(int ModuleID); 45 /// <summary> 46 /// 根据模块名称获取模块编号(0代表未找到) 47 /// </summary> 48 /// <param name="ModuleName">模块名称</param> 49 /// <returns>模块编号(0代表未找到)</returns> 50 int GetModuleID(string ModuleName); 51 } 52 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Entities; 6 7 namespace Workflow.Abstract 8 { 9 public interface IWorkflowMainOperation 10 { 11 /// <summary> 12 /// 添加实体 13 /// </summary> 14 /// <param name="workflowmain"></param> 15 /// <returns></returns> 16 int WorkflowMainAdd(WorkflowMain workflowmain); 17 /// <summary> 18 /// 删除实体 19 /// </summary> 20 /// <param name="WorkflowID"></param> 21 /// <returns></returns> 22 int WorkflowMainDel(int WorkflowID); 23 /// <summary> 24 /// 修改实体 25 /// </summary> 26 /// <param name="workflowmain"></param> 27 /// <returns></returns> 28 int WorkflowMainUpdate(WorkflowMain workflowmain); 29 /// <summary> 30 /// 获得实体 31 /// </summary> 32 /// <param name="WorkflowID"></param> 33 /// <returns></returns> 34 WorkflowMain GetModel(int WorkflowID); 35 /// <summary> 36 /// 获得实体列表 37 /// </summary> 38 /// <returns></returns> 39 List<WorkflowMain> GetWorkflowMainList(); 40 /// <summary> 41 /// 获得所属步骤列表 42 /// </summary> 43 /// <returns></returns> 44 List<WorkflowDetailed> GetWorkflowDetailedList(int WorkflowID); 45 /// <summary> 46 /// 根据流程名称获取流程编号(0代表未找到) 47 /// </summary> 48 /// <param name="WorkflowName">流程名称</param> 49 /// <returns>流程编号(0代表未找到)</returns> 50 int GetWorkflowID(string WorkflowName); 51 } 52 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Entities; 6 7 namespace Workflow.Abstract 8 { 9 public interface IWorkflowDetailedOperation 10 { 11 /// <summary> 12 /// 添加实体 13 /// </summary> 14 /// <param name="workflowdetailed"></param> 15 /// <returns></returns> 16 int WorkflowDetailedAdd(WorkflowDetailed workflowdetailed); 17 /// <summary> 18 /// 删除实体 19 /// </summary> 20 /// <param name="ID"></param> 21 /// <returns></returns> 22 int WorkflowDetailedDel(int ID); 23 /// <summary> 24 /// 修改实体 25 /// </summary> 26 /// <param name="workflowdetailed"></param> 27 /// <returns></returns> 28 int WorkflowDetailedUpdate(WorkflowDetailed workflowdetailed); 29 /// <summary> 30 /// 获得实体 31 /// </summary> 32 /// <param name="ID"></param> 33 /// <returns></returns> 34 WorkflowDetailed GetModel(int ID); 35 /// <summary> 36 /// 获得实体列表 37 /// </summary> 38 /// <returns></returns> 39 List<WorkflowDetailed> GetWorkflowDetailedList(); 40 /// <summary> 41 /// 获得所属任务列表 42 /// </summary> 43 /// <returns></returns> 44 List<TaskList> GetTaskList(int ID); 45 46 /// <summary> 47 /// 为某流程增加下一步的步骤(-1主流程不存在0还未发送开始结束流程) 48 /// </summary> 49 /// <param name="WorkflowID">流程ID</param> 50 /// <returns>-1主流程不存在0还未发送开始结束流程</returns> 51 int GetNextStepID(int WorkflowID); 52 53 /// <summary> 54 /// 为某流程增加开始步骤(-1主流程不存在0已存在此步骤or新增的步骤ID) 55 /// </summary> 56 /// <param name="WorkflowID">流程ID</param> 57 /// <returns>-1主流程不存在0已存在此步骤or新增的步骤ID</returns> 58 int StartStepAdd(int WorkflowID); 59 60 /// <summary> 61 /// 为某流程增加结束步骤(-1主流程不存在0已存在此步骤or新增的步骤ID) 62 /// </summary> 63 /// <param name="WorkflowID">流程ID</param> 64 /// <returns>-1主流程不存在0已存在此步骤or新增的步骤ID</returns> 65 int EndStepAdd(int WorkflowID); 66 67 /// <summary> 68 /// 验证流程的合法性 69 /// </summary> 70 /// <param name="WorkflowID">流程ID</param> 71 /// <returns>错误信息的枚举</returns> 72 Enums.WorkflowErrorType VerifyWorkflow(int WorkflowID); 73 74 /// <summary> 75 /// 验证流程的合法性 76 /// </summary> 77 /// <param name="lst">步骤列表</param> 78 /// <returns>错误信息的枚举</returns> 79 Enums.WorkflowErrorType VerifyWorkflow(List<WorkflowDetailed> lst); 80 81 /// <summary> 82 /// 设为结束步骤 83 /// </summary> 84 /// <param name="ID">被设为结束的步骤ID</param> 85 /// <returns>是否成功</returns> 86 bool SetEndStep(int ID); 87 88 /// <summary> 89 /// 设为结束步骤 90 /// </summary> 91 /// <param name="WorkflowID">流程ID</param> 92 /// <param name="StepID">步骤ID</param> 93 /// <returns>是否成功</returns> 94 bool SetEndStep(int WorkflowID,int StepID); 95 96 /// <summary> 97 /// 更改告知人 98 /// </summary> 99 /// <param name="ID">步骤ID</param> 100 /// <param name="Nunciator">告知对象</param> 101 /// <returns>是否成功</returns> 102 bool UpNunciator(int ID, string Nunciator); 103 104 /// <summary> 105 /// 更改告知人 106 /// </summary> 107 /// <param name="WorkflowID">流程ID</param> 108 /// <param name="StepID">步骤ID</param> 109 /// <param name="Nunciator">告知对象</param> 110 /// <returns>是否成功</returns> 111 bool UpNunciator(int WorkflowID, int StepID, string Nunciator); 112 113 /// <summary> 114 /// 更改下一步骤 115 /// </summary> 116 /// <param name="ID">需要更改的步骤ID</param> 117 /// <param name="NextStep">要更改为的步骤ID</param> 118 /// <returns></returns> 119 bool UpNextStep(int ID, int NextStep); 120 121 /// <summary> 122 /// 更改下一步骤 123 /// </summary> 124 /// <param name="WorkflowID">流程ID</param> 125 /// <param name="StepID">步骤ID</param> 126 /// <param name="NextStep">要更改为的步骤ID</param> 127 /// <returns></returns> 128 bool UpNextStep(int WorkflowID, int StepID, int NextStep); 129 } 130 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Entities; 6 7 namespace Workflow.Abstract 8 { 9 /// <summary> 10 /// 任务相关操作 11 /// </summary> 12 public interface ITaskListOperation 13 { 14 /// <summary> 15 /// 添加实体 16 /// </summary> 17 /// <param name="tasklist"></param> 18 /// <returns></returns> 19 int TaskListAdd(TaskList tasklist); 20 /// <summary> 21 /// 删除实体 22 /// </summary> 23 /// <param name="ID"></param> 24 /// <returns></returns> 25 int TaskListDel(int ID); 26 /// <summary> 27 /// 修改实体 28 /// </summary> 29 /// <param name="tasklist"></param> 30 /// <returns></returns> 31 int TaskListUpdate(TaskList tasklist); 32 /// <summary> 33 /// 修改审批意见 34 /// </summary> 35 /// <param name="taskid">任务id</param> 36 /// <param name="Opinion">审批意见</param> 37 /// <param name="HandleType">处理类型（1同意2不同意）</param> 38 /// <returns>影响的行数</returns> 39 int TaskListUpdate(int taskid, string Opinion, int HandleType); 40 /// <summary> 41 /// 修改某人对应某表单当前正在执行任务的审批意见 42 /// </summary> 43 /// <param name="FormID">表单ID</param> 44 /// <param name="WorkflowID">流程ID</param> 45 /// <param name="Person">处理人</param> 46 /// <param name="Opinion">审批意见</param> 47 /// <param name="HandleType">处理类型（1同意2不同意）</param> 48 /// <returns>影响的行数</returns> 49 int TaskListUpdate(string FormID, int WorkflowID, string Person, string Opinion, int HandleType); 50 /// <summary> 51 /// 获得实体 52 /// </summary> 53 /// <param name="ID"></param> 54 /// <returns></returns> 55 TaskList GetModel(int ID); 56 /// <summary> 57 /// 获得实体列表 58 /// </summary> 59 /// <returns></returns> 60 List<TaskList> GetTaskList(); 61 /// <summary> 62 /// 获得所属附件列表 63 /// </summary> 64 /// <returns></returns> 65 List<AnnexList> GetAnnexList(int ID); 66 /// <summary> 67 /// 修改过期的公告（如果处理时间为（发送时间+过期天数）则为未看过） 68 /// </summary> 69 int UpExpire(); 70 /// <summary> 71 /// 任务流转 72 /// </summary> 73 /// <param name="taskid">待流转的任务ID</param> 74 /// <param name="HandlePerson">流转后的处理人</param> 75 /// <returns></returns> 76 TaskList TaskCirculation(int taskid, string HandlePerson); 77 /// <summary> 78 /// 任务审批并流转 79 /// </summary> 80 /// <param name="taskid">待流转的任务ID</param> 81 /// <param name="Opinion">处理意见</param> 82 /// <param name="HandlePerson">流转后的处理人</param> 83 /// <returns></returns> 84 TaskList TaskCirculation(int taskid, string Opinion, string HandlePerson); 85 /// <summary> 86 /// 添加审批人员(只能操作正在进行的步骤) 87 /// </summary> 88 /// <param name="FormID">表单ID</param> 89 /// <param name="WorkflowDetailed_ID">步骤ID</param> 90 /// <param name="HandlePerson">要新增的处理人</param> 91 /// <returns></returns> 92 TaskList AddHandlePerson(string FormID, int WorkflowDetailed_ID, string HandlePerson); 93 /// <summary> 94 /// 添加审批人员(只能操作正在进行的步骤) 95 /// </summary> 96 /// <param name="FormID">表单ID</param> 97 /// <param name="WorkflowID">流程ID</param> 98 /// <param name="StepID">步骤ID</param> 99 /// <param name="HandlePerson">要新增的处理人</param> 100 /// <returns></returns> 101 TaskList AddHandlePerson(string FormID, int WorkflowID, int StepID, string HandlePerson); 102 /// <summary> 103 /// 移除审批人员(只能操作正在进行的步骤) 104 /// </summary> 105 /// <param name="FormID">表单ID</param> 106 /// <param name="WorkflowDetailed_ID">步骤ID</param> 107 /// <param name="HandlePerson">要新增的处理人</param> 108 /// <returns></returns> 109 bool RemoveHandlePerson(string FormID, int WorkflowDetailed_ID, string HandlePerson); 110 /// <summary> 111 /// 移除审批人员(只能操作正在进行的步骤) 112 /// </summary> 113 /// <param name="FormID">表单ID</param> 114 /// <param name="WorkflowID">流程ID</param> 115 /// <param name="StepID">步骤ID</param> 116 /// <param name="HandlePerson">要新增的处理人</param> 117 /// <returns></returns> 118 bool RemoveHandlePerson(string FormID, int WorkflowID, int StepID, string HandlePerson); 119 /// <summary> 120 /// 获得某人的流程状态为正常的任务列表 121 /// </summary> 122 /// <param name="psersonid">处理人工号</param> 123 /// <param name="HandleStatus">True为已处理任务False为未处理任务NULL为全部</param> 124 /// <returns></returns> 125 List<TaskList> GetPersonTask(string psersonid, bool? HandleStatus); 126 /// <summary> 127 /// 获取某一个表单只对某流程的任务列表 128 /// </summary> 129 /// <param name="FormID">表单ID</param> 130 /// <param name="WorkflowID">流程ID</param> 131 /// <returns>任务列表</returns> 132 List<TaskList> GetByFormTaskList(string FormID, int WorkflowID); 133 } 134 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Entities; 6 7 namespace Workflow.Abstract 8 { 9 public interface IAnnexListOperation 10 { 11 /// <summary> 12 /// 添加实体 13 /// </summary> 14 /// <param name="annexlist"></param> 15 /// <returns></returns> 16 int AnnexListAdd(AnnexList annexlist); 17 /// <summary> 18 /// 删除实体 19 /// </summary> 20 /// <param name="ID"></param> 21 /// <returns></returns> 22 int AnnexListDel(int ID); 23 /// <summary> 24 /// 修改实体 25 /// </summary> 26 /// <param name="tasklist"></param> 27 /// <returns></returns> 28 int AnnexListUpdate(AnnexList annexlist); 29 /// <summary> 30 /// 获得实体 31 /// </summary> 32 /// <param name="ID"></param> 33 /// <returns></returns> 34 AnnexList GetModel(int ID); 35 /// <summary> 36 /// 获得实体列表 37 /// </summary> 38 /// <returns></returns> 39 List<AnnexList> GetAnnexList(); 40 } 41 }
4.IWorkflowOperation.cs 流程的总体操作。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace Workflow.Abstract 7 { 8 public interface IWorkflowOperation 9 { 10 /// <summary> 11 /// 判断此表单的此流程是否已经存在任务表中true存在false不存在 12 /// </summary> 13 /// <param name="WorkflowID">流程ID</param> 14 /// <param name="FormID">表单ID</param> 15 /// <returns></returns> 16 bool IsExistTask(int WorkflowID, string FormID); 17 18 /// <summary> 19 /// 判断是否此步骤是否为将来指定(如果为将来自定需要指定处理人) 20 /// </summary> 21 /// <param name="WorkflowDetailed_ID"></param> 22 /// <returns></returns> 23 bool IsHereafter(int WorkflowDetailed_ID); 24 25 /// <summary> 26 /// 判断是否此步骤是否为将来指定(如果为将来自定需要指定处理人) 27 /// </summary> 28 /// <param name="WorkflowID"></param> 29 /// <param name="StepID"></param> 30 /// <returns></returns> 31 bool IsHereafter(int WorkflowID, int StepID); 32 33 /// <summary> 34 /// 根据一个表单开始一个流程 35 /// </summary> 36 /// <param name="WorkflowID">流程ID</param> 37 /// <param name="FormID">表单ID</param> 38 /// <param name="HandlePerson">可选参数，如果类型为将来指定的话传入具体处理人</param> 39 /// <returns></returns> 40 bool SendStartWorkflow(int WorkflowID, string FormID, string HandlePerson = ""); 41 42 /// <summary> 43 /// 发送下一级审批（返回已发送流程的步骤号,返回-1表示流程结束0表示不需要发送-2还未发送开始流程-3表示未知错误-4审核不通过 流程终止） 44 /// </summary> 45 /// <param name="WorkflowID">流程ID</param> 46 /// <param name="FormID">表单ID</param> 47 /// <param name="Condition">条件数值,可选参数，只有需要条件的时候才传入</param> 48 /// <param name="HandlePerson">可选参数，如果类型为将来指定的话传入具体处理人</param> 49 /// <returns>返回发送的审批ID,返回-1表示流程结束</returns> 50 int SendNextWorkflow(int WorkflowID, string FormID, string Condition = "", string HandlePerson = ""); 51 52 /// <summary> 53 /// 发送表单的结束流程 54 /// </summary> 55 /// <param name="WorkflowID">流程ID</param> 56 /// <param name="FormID">表单ID</param> 57 /// <returns></returns> 58 bool SendEndWorkflow(int WorkflowID, string FormID); 59 60 /// <summary> 61 /// （-2流程不通过而结束-1流程通过而结束0发送成功(包含发送成功和不需要发送) 62 /// 1开始流程发送失败2下一级流程发送失败3结束流程发送失败） 63 /// 使用此方法只需要考虑流程是否结束 64 /// </summary> 65 /// <param name="WorkflowID">流程ID</param> 66 /// <param name="FormID">表单ID</param> 67 /// <param name="Condition">条件数值(会根据流程判断是否需要条件),可选参数，只有需要条件的时候才传入</param> 68 /// <param name="HandlePerson">可选参数，如果类型为将来指定的话传入具体处理人</param> 69 /// <returns>（-1流程结束0发送成功1开始流程发送失败2下一级流程发送失败3结束流程发送失败4未知错误）</returns> 70 int SendWorkflow(int WorkflowID, string FormID, string Condition = "", string HandlePerson = ""); 71 72 /// <summary> 73 /// 获取待发送处理人的列表(逗号分割)可能多步骤同一序号 74 /// </summary> 75 /// <param name="WorkflowID">流程ID</param> 76 /// <param name="StepID">步骤ID</param> 77 /// <param name="HandlePerson">可选参数，如果类型为将来指定的话传入具体处理人</param> 78 /// <returns></returns> 79 List<string> GetHandlePerson(int WorkflowID, int StepID, string HandlePerson = ""); 80 81 /// <summary> 82 /// 获取待发送告知人的列表(逗号分割)可能多步骤同一序号 83 /// </summary> 84 /// <param name="WorkflowID">流程ID</param> 85 /// <param name="StepID">步骤ID</param> 86 /// <returns></returns> 87 List<string> GetNunciatorPerson(int WorkflowID, int StepID); 88 89 /// <summary> 90 /// 获取下一级的任务序号 91 /// </summary> 92 /// <param name="WorkflowID"></param> 93 /// <param name="FormID"></param> 94 /// <returns></returns> 95 int GetTaskSN(int WorkflowID, string FormID); 96 97 /// <summary> 98 /// 获取真正进行的步骤实体(如果为空说明还未发送) 99 /// </summary> 100 /// <param name="WorkflowID"></param> 101 /// <param name="FormID"></param> 102 /// <returns></returns> 103 Workflow.Entities.WorkflowDetailed GetCurrentStep(int WorkflowID, string FormID); 104 } 105 }
5.IPersonList.cs 具体应用程序需实现的权限相关的人员接口。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace Workflow.Abstract 7 { 8 public interface IPersonList 9 { 10 /// <summary> 11 /// 根据具体处理类型获取处理人列表（逗号分割的批量数据）重复项内部已处理 12 /// </summary> 13 /// <param name="processingpersonnel">具体处理人(人员，角色，或部门)逗号分割</param> 14 /// <returns></returns> 15 List<string> GetPersonList(string processingpersonnel); 16 17 /// <summary> 18 /// 实现接口的具体类，获取其对应的键值对列表 19 /// </summary> 20 /// <returns></returns> 21 IDictionary<string, string> GetGlobalKeyValue(); 22 } 23 }
6.PersonnelMode.cs 全局角色类型，通过单例模式实现对应用程序全局人员类型的管理。代码如下：
1 using System; 2 using System.Collections; 3 using System.Collections.Generic; 4 using System.Linq; 5 using System.Text; 6 using Workflow.Concrete; 7 8 namespace Workflow.Abstract 9 { 10 public class PersonnelMode 11 { 12 private static PersonnelMode uniqueinstence; 13 private IDictionary<string, IPersonList> PersonnelModeList = new Dictionary<string, IPersonList>(); 14 private PersonnelMode() 15 { 16 //添加类型为人的类型 17 PersonnelModeList.Add("Person", ConcreteFactory.CreateConcrete<IPersonList, PersonPersonnelMode>()); 18 //添加类型为角色的类型 19 //需扩展 20 } 21 /// <summary> 22 /// 获取类是实例（会不会丢失后期注册的类型,如果会，则单例模式写法有漏洞） 23 /// </summary> 24 /// <returns></returns> 25 public static PersonnelMode GetInstance() 26 { 27 if (uniqueinstence == null) 28 uniqueinstence = new PersonnelMode(); 29 return uniqueinstence; 30 } 31 /// <summary> 32 /// 获取全局类型列表 33 /// </summary> 34 /// <returns></returns> 35 public IDictionary<string, IPersonList> GetPersonnelModeList() 36 { 37 return PersonnelModeList; 38 } 39 } 40 }
三、Concrete接口的实现
对接口的具体实现。
1. *Operation.cs 对应数据库表的相关操作。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Abstract; 6 using Workflow.Entities; 7 8 namespace Workflow.Concrete 9 { 10 public class ModuleOperation:IModuleOperation 11 { 12 private WorkflowDB db = null; 13 14 public ModuleOperation() 15 { 16 db = new WorkflowDB(); 17 } 18 19 int IModuleOperation.ModuleAdd(ModuleList modulelist) 20 { 21 db.ModuleLists.Add(modulelist); 22 if (db.SaveChanges() > 0) 23 return modulelist.ModuleID; 24 else 25 return 0; 26 } 27 28 int IModuleOperation.ModuleDel(int ModuleID) 29 { 30 var module = db.ModuleLists.FirstOrDefault(item => item.ModuleID == ModuleID); 31 if (module != null) 32 db.ModuleLists.Remove(module); 33 return db.SaveChanges(); 34 } 35 36 int IModuleOperation.ModuleUpdate(ModuleList modulelist) 37 { 38 db.Entry(modulelist).State = System.Data.Entity.EntityState.Modified; 39 return db.SaveChanges(); 40 } 41 42 ModuleList IModuleOperation.GetModel(int ModuleID) 43 { 44 return db.ModuleLists.FirstOrDefault(item => item.ModuleID == ModuleID); 45 } 46 47 List<ModuleList> IModuleOperation.GetModuleList() 48 { 49 return db.ModuleLists.ToList(); 50 } 51 52 List<WorkflowMain> IModuleOperation.GetWorkflowMainList(int ModuleID) 53 { 54 return db.WorkflowMains.Where(item => item.ModuleID == ModuleID).ToList(); 55 } 56 57 int IModuleOperation.GetModuleID(string ModuleName) 58 { 59 var module = db.ModuleLists.FirstOrDefault(item => item.ModuleName == ModuleName); 60 if (module != null) 61 return module.ModuleID; 62 else 63 return 0; 64 } 65 } 66 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Abstract; 6 using Workflow.Entities; 7 8 namespace Workflow.Concrete 9 { 10 public class WorkflowMainOperation : IWorkflowMainOperation 11 { 12 private WorkflowDB db = null; 13 public WorkflowMainOperation() 14 { 15 db = new WorkflowDB(); 16 } 17 18 int IWorkflowMainOperation.WorkflowMainAdd(WorkflowMain workflowmain) 19 { 20 db.WorkflowMains.Add(workflowmain); 21 if (db.SaveChanges() > 0) 22 return workflowmain.WorkflowID; 23 else 24 return 0; 25 } 26 27 int IWorkflowMainOperation.WorkflowMainDel(int WorkflowID) 28 { 29 var workflowmain = db.WorkflowMains.FirstOrDefault(item => item.WorkflowID == WorkflowID); 30 if (workflowmain != null) 31 db.WorkflowMains.Remove(workflowmain); 32 return db.SaveChanges(); 33 } 34 35 int IWorkflowMainOperation.WorkflowMainUpdate(WorkflowMain workflowmain) 36 { 37 db.Entry(workflowmain).State = System.Data.Entity.EntityState.Modified; 38 return db.SaveChanges(); 39 } 40 41 WorkflowMain IWorkflowMainOperation.GetModel(int WorkflowID) 42 { 43 return db.WorkflowMains.FirstOrDefault(item => item.WorkflowID == WorkflowID); 44 } 45 46 List<WorkflowMain> IWorkflowMainOperation.GetWorkflowMainList() 47 { 48 return db.WorkflowMains.ToList(); 49 } 50 51 List<WorkflowDetailed> IWorkflowMainOperation.GetWorkflowDetailedList(int WorkflowID) 52 { 53 return db.WorkflowDetaileds.Where(item => item.WorkflowID == WorkflowID).ToList(); 54 } 55 56 int IWorkflowMainOperation.GetWorkflowID(string WorkflowName) 57 { 58 var workflow = db.WorkflowMains.FirstOrDefault(item => item.WorkflowName == WorkflowName); 59 if (workflow != null) 60 return workflow.WorkflowID; 61 else 62 return 0; 63 } 64 } 65 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Text.RegularExpressions; 6 using Workflow.Abstract; 7 using Workflow.Entities; 8 9 namespace Workflow.Concrete 10 { 11 public class WorkflowDetailedOperation : IWorkflowDetailedOperation 12 { 13 private WorkflowDB db = null; 14 public WorkflowDetailedOperation() 15 { 16 db = new WorkflowDB(); 17 } 18 19 int IWorkflowDetailedOperation.WorkflowDetailedAdd(WorkflowDetailed workflowdetailed) 20 { 21 //下一步不为空时下一步不能为本步，上一步不为空时上一步不能为本步，均不为空时上一步不能为下一步 22 if ((workflowdetailed.NextStep != null && workflowdetailed.NextStep == workflowdetailed.StepID) 23 || (workflowdetailed.UpStep != null && workflowdetailed.UpStep == workflowdetailed.StepID) 24 || (workflowdetailed.NextStep != null && workflowdetailed.UpStep != null && 25 workflowdetailed.UpStep == workflowdetailed.NextStep || (workflowdetailed.UpStep == -1 && workflowdetailed.NextStep == -1))) 26 return 0; 27 db.WorkflowDetaileds.Add(workflowdetailed); 28 if (db.SaveChanges() > 0) 29 return workflowdetailed.ID; 30 else 31 return 0; 32 } 33 34 int IWorkflowDetailedOperation.WorkflowDetailedDel(int ID) 35 { 36 var workflowdetailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == ID); 37 if (workflowdetailed != null) 38 db.WorkflowDetaileds.Remove(workflowdetailed); 39 return db.SaveChanges(); 40 } 41 42 int IWorkflowDetailedOperation.WorkflowDetailedUpdate(WorkflowDetailed workflowdetailed) 43 { 44 db.Entry(workflowdetailed).State = System.Data.Entity.EntityState.Modified; 45 return db.SaveChanges(); 46 } 47 48 WorkflowDetailed IWorkflowDetailedOperation.GetModel(int ID) 49 { 50 return db.WorkflowDetaileds.FirstOrDefault(item => item.ID == ID); 51 } 52 53 List<WorkflowDetailed> IWorkflowDetailedOperation.GetWorkflowDetailedList() 54 { 55 return db.WorkflowDetaileds.ToList(); 56 } 57 58 List<TaskList> IWorkflowDetailedOperation.GetTaskList(int WorkflowDetailed_ID) 59 { 60 return db.TaskLists.Where(item => item.WorkflowDetailed_ID == WorkflowDetailed_ID).ToList(); 61 } 62 63 64 int IWorkflowDetailedOperation.GetNextStepID(int WorkflowID) 65 { 66 var main = db.WorkflowMains.FirstOrDefault(item => item.WorkflowID == WorkflowID); 67 if (main == null) 68 return -1;//主流程不存在 69 var detail = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID); 70 if (detail == null) 71 return 0;//还未发送开始结束流程 72 return db.WorkflowDetaileds.Where(item => item.WorkflowID == WorkflowID).Max(item => item.StepID) + 1;//正常 73 } 74 75 int IWorkflowDetailedOperation.StartStepAdd(int WorkflowID) 76 { 77 var main = db.WorkflowMains.FirstOrDefault(item => item.WorkflowID == WorkflowID); 78 if (main == null) 79 return -1;//主流程不存在 80 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == 0); 81 if (detailed != null) 82 return 0;//已存在此流程 83 return ConcreteFactory.CreateConcrete<IWorkflowDetailedOperation, WorkflowDetailedOperation>() 84 .WorkflowDetailedAdd(new WorkflowDetailed(WorkflowID, 0, "开始")); 85 } 86 87 int IWorkflowDetailedOperation.EndStepAdd(int WorkflowID) 88 { 89 var main = db.WorkflowMains.FirstOrDefault(item => item.WorkflowID == WorkflowID); 90 if (main == null) 91 return -1;//主流程不存在 92 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == -1); 93 if (detailed != null) 94 return 0;//已存在此流程 95 return ConcreteFactory.CreateConcrete<IWorkflowDetailedOperation, WorkflowDetailedOperation>() 96 .WorkflowDetailedAdd(new WorkflowDetailed(WorkflowID, -1, "结束")); 97 } 98 99 Enums.WorkflowErrorType IWorkflowDetailedOperation.VerifyWorkflow(int WorkflowID) 100 { 101 //获取流程的步骤列表(倒叙排列，优化流程验证) 102 var detaileds = db.WorkflowDetaileds.Where(item => item.WorkflowID == WorkflowID).OrderByDescending(i=>i.StepID).ToList(); 103 //1流程步数小于等于两步的为空流程 104 if (detaileds.Count <= 2) 105 return Enums.WorkflowErrorType.EmptyWorkflow; 106 107 #region 暂时取消 108 ////2如果存在同步时判断总的处理模式MainProcessingMode 109 ////及下一步是否合适（并时nextstep要同串时可能根据不同步骤进入不同下一步） 110 ////获取包含记录的步骤id 111 //var gr = from i in detaileds 112 // group i by i.StepID into g 113 // where g.Count() > 1 114 // select g; 115 ////循环步骤id 116 //foreach (var g in gr) 117 //{ 118 // //获取所属步骤的列表 119 // var dets = detaileds.Where(i => i.StepID == g.Key).ToList(); 120 // //验证列表内的处理模式是否相同 121 // var MainProcessingMode = dets[0].MainProcessingMode; 122 // var NextStep = dets[0].NextStep; 123 // foreach (var d in dets) 124 // { 125 // if (d.MainProcessingMode != MainProcessingMode) 126 // return Enums.WorkflowErrorType.UnUnifiedMode; 127 // //如果模式为非1即为可能并流程，则NextStep需统一 128 // if (MainProcessingMode != "1") 129 // if (d.NextStep != NextStep) 130 // return Enums.WorkflowErrorType.UnUnified; 131 // } 132 //} 133 #endregion 134 135 //已经验证通过的节点id列表 136 var detailedids = new List<int>(); 137 //3循环所有节点( 验证节点的有效性) 138 foreach (var d in detaileds) 139 { 140 switch (VerifyStepID(detaileds, d,detailedids)) 141 { 142 case -1: detailedids.Add(d.ID); break; 143 case -2: return Enums.WorkflowErrorType.UnClosedLoop; 144 //case -3: return Enums.WorkflowErrorType.UnUseNode; 145 case -3: return Enums.WorkflowErrorType.UnClosedLoop; 146 case -4: return Enums.WorkflowErrorType.UnUnified; 147 case -5: return Enums.WorkflowErrorType.UnUnifiedMode; 148 case -6: return Enums.WorkflowErrorType.EmptyWorkflow; 149 } 150 } 151 152 return Enums.WorkflowErrorType.Normal; 153 } 154 155 Enums.WorkflowErrorType IWorkflowDetailedOperation.VerifyWorkflow(List<WorkflowDetailed> lst) 156 { 157 //获取流程的步骤列表(倒叙排列，优化流程验证) 158 var detaileds = lst.OrderByDescending(i => i.StepID).ToList(); 159 //1流程步数小于等于两步的为空流程 160 if (detaileds.Count <= 2) 161 return Enums.WorkflowErrorType.EmptyWorkflow; 162 163 //已经验证通过的节点id列表(此处应用的为步骤号) 164 var detailedids = new List<int>(); 165 //3循环所有节点( 验证节点的有效性) 166 foreach (var d in detaileds) 167 { 168 switch (VerifyStepID(detaileds, d, detailedids)) 169 { 170 case -1: detailedids.Add(d.StepID); break; 171 case -2: return Enums.WorkflowErrorType.UnClosedLoop; 172 //case -3: return Enums.WorkflowErrorType.UnUseNode; 173 case -3: return Enums.WorkflowErrorType.UnClosedLoop; 174 case -4: return Enums.WorkflowErrorType.UnUnified; 175 case -5: return Enums.WorkflowErrorType.UnUnifiedMode; 176 case -6: return Enums.WorkflowErrorType.EmptyWorkflow; 177 } 178 } 179 180 return Enums.WorkflowErrorType.Normal; 181 } 182 183 /// <summary> 184 /// 根据步骤ID获取下一步的ID（-1为正常流程，其它为有错误） 185 /// </summary> 186 /// <returns></returns> 187 public int VerifyStepID(List<WorkflowDetailed> detaileds, WorkflowDetailed detailed ,List<int> lstids)//id不为空的时候才调用此方法 188 { 189 //验证通过条件是否存在 190 if (detailed.Conditions == null || detailed.Conditions == "") 191 { 192 #region 验证条件为空的 193 //如果验证条件不存在，并且下一步为-1（结束），则此节点为合理节点 194 if (detailed.NextStep == -1) 195 { 196 return -1;//递归调用的出口 197 } 198 else//如果节点不为-1则判断节点的节点 199 { 200 //判断下一个节点是否为空 201 if (detailed.NextStep == null) 202 return Enums.WorkflowErrorType.UnClosedLoop.GetHashCode(); 203 else//如果下一个节点不为空，则继续判断 204 { 205 //指向的下一级节点不存在 206 var det = detaileds.FirstOrDefault(item => item.StepID == detailed.NextStep); 207 if (det == null) 208 { 209 return Enums.WorkflowErrorType.UnClosedLoop.GetHashCode(); 210 } 211 else//指向的下一级节点存在,则进行验证 212 { 213 //判断验证列表里面是否存在，如果存在直接返回-1 214 if (lstids.Contains(det.StepID))//此判断为提高效率 215 return -1; 216 else 217 return VerifyStepID(detaileds, det, lstids); 218 } 219 } 220 } 221 #endregion 222 } 223 else//验证条件存在 224 { 225 #region 验证条件不为空 226 var ids = GetNextIDs(detailed.Conditions); 227 //如果下一级不为空切找不到下一级节点,则返回未闭环节点 228 if (ids.Count <= 0) 229 { 230 return Enums.WorkflowErrorType.UnClosedLoop.GetHashCode(); 231 } 232 else 233 { 234 //定义默认标记 235 bool bo = true; 236 foreach (var id in ids) 237 { 238 //验证不通过的情况，存在更改标准为false，不存在默认为true; 239 if (id != -1) 240 { 241 //指向的下一级节点不存在 242 var det = detaileds.FirstOrDefault(item => item.StepID == id); 243 if (det == null) 244 { 245 bo = false; 246 } 247 else//指向的下一级节点存在,则进行验证 248 { 249 //如果待验证步骤不在已经验证的列表中（在就不用继续验证了） 250 if (!lstids.Contains(det.StepID))//此句只为提高效率 251 //还不为-1 有错误 252 if (VerifyStepID(detaileds, det, lstids) != -1) 253 bo = false; 254 } 255 } 256 } 257 if (bo) 258 return -1;//正常流程 259 else 260 return Enums.WorkflowErrorType.UnClosedLoop.GetHashCode(); 261 } 262 #endregion 263 } 264 } 265 266 /// <summary> 267 /// 根据条件获取下一步的列表 268 /// </summary> 269 /// <param name="Conditions"></param> 270 /// <returns></returns> 271 public List<int> GetNextIDs(string Conditions) 272 { 273 var ids = new List<int>(); 274 275 string Pattern = @"?(-?d+)|:(-?d+)"; 276 MatchCollection Matches = Regex.Matches(Conditions, Pattern, RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture); 277 foreach (var m in Matches) 278 { 279 ids.Add(int.Parse(m.ToString().Trim(':').Trim('?'))); 280 } 281 return ids; 282 } 283 284 bool IWorkflowDetailedOperation.SetEndStep(int ID) 285 { 286 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == ID); 287 detailed.NextStep = -1; 288 return db.SaveChanges() > 0; 289 } 290 291 bool IWorkflowDetailedOperation.SetEndStep(int WorkflowID, int StepID) 292 { 293 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 294 detailed.NextStep = -1; 295 return db.SaveChanges() > 0; 296 } 297 298 bool IWorkflowDetailedOperation.UpNunciator(int ID, string Nunciator) 299 { 300 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == ID); 301 detailed.Nunciator = Nunciator; 302 return db.SaveChanges() > 0; 303 } 304 305 bool IWorkflowDetailedOperation.UpNunciator(int WorkflowID, int StepID, string Nunciator) 306 { 307 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 308 detailed.Nunciator = Nunciator; 309 return db.SaveChanges() > 0; 310 } 311 312 bool IWorkflowDetailedOperation.UpNextStep(int ID, int NextStep) 313 { 314 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == ID); 315 detailed.NextStep = NextStep; 316 return db.SaveChanges() > 0; 317 } 318 319 bool IWorkflowDetailedOperation.UpNextStep(int WorkflowID, int StepID, int NextStep) 320 { 321 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 322 detailed.NextStep = NextStep; 323 return db.SaveChanges() > 0; 324 } 325 } 326 }
1 using System; 2 using System.Collections.Generic; 3 using System.Data.Entity; 4 using System.Linq; 5 using System.Text; 6 using Workflow.Abstract; 7 using Workflow.Entities; 8 9 namespace Workflow.Concrete 10 { 11 public class TaskListOperation : ITaskListOperation 12 { 13 private WorkflowDB db = null; 14 public TaskListOperation() 15 { 16 db = new WorkflowDB(); 17 } 18 19 int ITaskListOperation.TaskListAdd(TaskList tasklist) 20 { 21 db.TaskLists.Add(tasklist); 22 if (db.SaveChanges() > 0) 23 return tasklist.ID; 24 else 25 return 0; 26 } 27 28 int ITaskListOperation.TaskListDel(int ID) 29 { 30 var tasklist = db.TaskLists.FirstOrDefault(item => item.ID == ID); 31 if (tasklist != null) 32 db.TaskLists.Remove(tasklist); 33 return db.SaveChanges(); 34 } 35 36 int ITaskListOperation.TaskListUpdate(TaskList tasklist) 37 { 38 db.Entry(tasklist).State = System.Data.Entity.EntityState.Modified; 39 return db.SaveChanges(); 40 } 41 42 int ITaskListOperation.TaskListUpdate(int taskid, string Opinion, int HandleType) 43 { 44 var tasklist = db.TaskLists.FirstOrDefault(item => item.ID == taskid); 45 if (tasklist != null) 46 { 47 tasklist.Opinion = Opinion; 48 tasklist.HandleTime = DateTime.Now; 49 tasklist.HandleStatus = true; 50 tasklist.HandleType = HandleType; 51 db.Entry(tasklist).State = System.Data.Entity.EntityState.Modified; 52 } 53 return db.SaveChanges(); 54 } 55 56 int ITaskListOperation.TaskListUpdate(string FormID, int WorkflowID, string Person, string Opinion, int HandleType) 57 { 58 var current = Workflow.Abstract.ConcreteFactory.CreateConcrete<IWorkflowOperation, WorkflowOperation>().GetCurrentStep(WorkflowID, FormID); 59 if (current != null) 60 { 61 var tasks = db.TaskLists.Where(item => item.HandlePerson == Person && item.FromID == FormID && item.WorkflowDetailed_ID == current.ID); 62 foreach (var task in tasks) 63 { 64 task.Opinion = Opinion; 65 task.HandleTime = DateTime.Now; 66 task.HandleStatus = true; 67 task.HandleType = HandleType; 68 db.Entry(task).State = System.Data.Entity.EntityState.Modified; 69 } 70 return db.SaveChanges(); 71 } 72 return 0; 73 } 74 75 TaskList ITaskListOperation.GetModel(int ID) 76 { 77 return db.TaskLists.FirstOrDefault(item => item.ID == ID); 78 } 79 80 List<TaskList> ITaskListOperation.GetTaskList() 81 { 82 return db.TaskLists.ToList(); 83 } 84 85 List<AnnexList> ITaskListOperation.GetAnnexList(int TaskList_ID) 86 { 87 return db.AnnexLists.Where(item => item.TaskList_ID == TaskList_ID).ToList(); 88 } 89 90 int ITaskListOperation.UpExpire() 91 { 92 //获取需要修改的任务列表 93 var tasks = db.TaskLists.Where(item => item.HandleTime == null && item.MessageType == 2 94 && DbFunctions.AddDays(item.Receive, item.WorkflowDetailed.Deadline) < DateTime.Now).ToList(); 95 //如果过期天数为0，则为不过期 96 tasks = tasks.Where(item => item.WorkflowDetailed.Deadline != 0).ToList(); 97 98 foreach (var task in tasks) 99 { 100 var Deadline = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == task.WorkflowDetailed_ID).Deadline; 101 task.HandleTime = task.Receive.AddDays(Deadline); 102 task.HandleStatus = true; 103 task.Opinion = "过期"; 104 } 105 return db.SaveChanges(); 106 } 107 108 TaskList ITaskListOperation.TaskCirculation(int taskid, string HandlePerson) 109 { 110 var task = db.TaskLists.FirstOrDefault(item => item.ID == taskid); 111 if (task == null) 112 return null; 113 else 114 { 115 //根据旧创建新任务 116 var newtask = task; 117 //原始任务处理 118 task.Opinion = "流转"; 119 task.HandleStatus = true; 120 task.HandleTime = DateTime.Now; 121 db.SaveChanges(); 122 //新任务赋值 123 newtask.UpTask = taskid; 124 newtask.Receive = DateTime.Now; 125 newtask.HandleStatus = false;//用于已经审批的流转 126 newtask.Opinion = null; 127 newtask.HandleTime = null; 128 db.TaskLists.Add(newtask); 129 if (db.SaveChanges() > 0) 130 return newtask; 131 else 132 return null; 133 } 134 } 135 136 TaskList ITaskListOperation.TaskCirculation(int taskid, string Opinion, string HandlePerson) 137 { 138 var task = db.TaskLists.FirstOrDefault(item => item.ID == taskid); 139 if (task == null) 140 return null; 141 else 142 { 143 //根据旧创建新任务 144 var newtask = task; 145 //原始任务处理 146 task.Opinion = Opinion; 147 task.HandleStatus = true; 148 task.HandleTime = DateTime.Now; 149 db.SaveChanges(); 150 //新任务赋值 151 newtask.UpTask = taskid; 152 newtask.Receive = DateTime.Now; 153 newtask.HandleStatus = false;//用于已经审批的流转 154 newtask.Opinion = null; 155 newtask.HandleTime = null; 156 db.TaskLists.Add(newtask); 157 if (db.SaveChanges() > 0) 158 return newtask; 159 else 160 return null; 161 } 162 } 163 164 //获取一个实例，根据实例修改添加 165 TaskList ITaskListOperation.AddHandlePerson(string FormID, int WorkflowDetailed_ID, string HandlePerson) 166 { 167 var oldtasks = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed_ID).ToList(); 168 //判断要添加的处理人是否已经在审批列表,类型为处理类型，非通知类型 169 var HasPerson = oldtasks.Where(item => item.HandlePerson == HandlePerson && item.MessageType == 1); 170 //存在用于复制的对象并且添加人不在已存在的列表中 171 if (oldtasks.Count() > 0 && HasPerson.Count() <= 0) 172 { 173 var newtask = oldtasks.FirstOrDefault(); 174 newtask.HandlePerson = HandlePerson; 175 newtask.Receive = DateTime.Now; 176 newtask.Opinion = null; 177 newtask.HandleTime = null; 178 newtask.HandleStatus = false; 179 newtask.UpTask = null; 180 newtask.MessageType = 1; 181 db.TaskLists.Add(newtask); 182 if (db.SaveChanges() > 0) 183 return newtask; 184 } 185 return null; 186 } 187 188 TaskList ITaskListOperation.AddHandlePerson(string FormID, int WorkflowID, int StepID, string HandlePerson) 189 { 190 var oldtasks = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID 191 && item.WorkflowDetailed.StepID == StepID).ToList(); 192 //判断要添加的处理人是否已经在审批列表,类型为处理类型，非通知类型 193 var HasPerson = oldtasks.Where(item => item.HandlePerson == HandlePerson && item.MessageType == 1); 194 //存在用于复制的对象并且添加人不在已存在的列表中 195 if (oldtasks.Count() > 0 && HasPerson.Count() <= 0) 196 { 197 var newtask = oldtasks.FirstOrDefault(); 198 newtask.HandlePerson = HandlePerson; 199 newtask.Receive = DateTime.Now; 200 newtask.Opinion = null; 201 newtask.HandleTime = null; 202 newtask.HandleStatus = false; 203 newtask.UpTask = null; 204 newtask.MessageType = 1; 205 db.TaskLists.Add(newtask); 206 if (db.SaveChanges() > 0) 207 return newtask; 208 } 209 return null; 210 } 211 //最后一个审批人不允许删除 212 bool ITaskListOperation.RemoveHandlePerson(string FormID, int WorkflowDetailed_ID, string HandlePerson) 213 { 214 var tasks = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed_ID && item.MessageType == 1); 215 //多于一条记录的时候才允许移除，否则移除失败 216 if (tasks.Count() > 1) 217 { 218 var task = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed_ID 219 && item.HandlePerson == HandlePerson && item.MessageType == 1); 220 //移除多条 221 db.TaskLists.RemoveRange(task); 222 return db.SaveChanges() > 0; 223 } 224 return false; 225 } 226 227 bool ITaskListOperation.RemoveHandlePerson(string FormID, int WorkflowID, int StepID, string HandlePerson) 228 { 229 var tasks = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID 230 && item.WorkflowDetailed.StepID == StepID); 231 //多余一条记录的时候才允许移除，否则移除失败 232 if (tasks.Count() > 1) 233 { 234 var task = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID 235 && item.WorkflowDetailed.StepID == StepID && item.HandlePerson == HandlePerson); 236 //移除多条 237 db.TaskLists.RemoveRange(task); 238 return db.SaveChanges() > 0; 239 } 240 return false; 241 } 242 243 List<TaskList> ITaskListOperation.GetPersonTask(string psersonid, bool? HandleStatus) 244 { 245 if (HandleStatus == null) 246 return db.TaskLists.Where(item => item.HandlePerson == psersonid && item.StepStatus == "1").ToList(); 247 else 248 return db.TaskLists.Where(item => item.HandlePerson == psersonid && item.StepStatus == "1" && item.HandleStatus == HandleStatus).ToList(); 249 } 250 251 List<TaskList> ITaskListOperation.GetByFormTaskList(string FormID, int WorkflowID) 252 { 253 return db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID) 254 .OrderBy(item => item.TaskSN).ToList(); 255 } 256 } 257 }
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Abstract; 6 using Workflow.Entities; 7 8 namespace Workflow.Concrete 9 { 10 public class AnnexListOperarion : IAnnexListOperation 11 { 12 private WorkflowDB db = null; 13 public AnnexListOperarion() 14 { 15 db = new WorkflowDB(); 16 } 17 18 int IAnnexListOperation.AnnexListAdd(AnnexList annexlist) 19 { 20 db.AnnexLists.Add(annexlist); 21 if (db.SaveChanges() > 0) 22 return annexlist.ID; 23 else 24 return 0; 25 } 26 27 int IAnnexListOperation.AnnexListDel(int ID) 28 { 29 var annexlist = db.AnnexLists.FirstOrDefault(item => item.ID == ID); 30 if (annexlist != null) 31 db.AnnexLists.Remove(annexlist); 32 return db.SaveChanges(); 33 } 34 35 int IAnnexListOperation.AnnexListUpdate(AnnexList annexlist) 36 { 37 db.Entry(annexlist).State = System.Data.Entity.EntityState.Modified; 38 return db.SaveChanges(); 39 } 40 41 AnnexList IAnnexListOperation.GetModel(int ID) 42 { 43 return db.AnnexLists.FirstOrDefault(item => item.ID == ID); 44 } 45 46 List<AnnexList> IAnnexListOperation.GetAnnexList() 47 { 48 return db.AnnexLists.ToList(); 49 } 50 } 51 }
2.WorkflowOperation.cs 流程的总体操作。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Abstract; 6 using Workflow.Entities; 7 8 namespace Workflow.Concrete 9 { 10 public class WorkflowOperation:IWorkflowOperation 11 { 12 private WorkflowDB db = null; 13 private IWorkflowOperation wo = null; 14 public WorkflowOperation() 15 { 16 db = new WorkflowDB(); 17 wo = (IWorkflowOperation)this;// ConcreteFactory.CreateConcrete<IWorkflowOperation, WorkflowOperation>(); 18 } 19 20 //判断某流程某表单是否存在任务表 21 bool IWorkflowOperation.IsExistTask(int WorkflowID, string FormID) 22 { 23 return db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID).Count() > 0; 24 } 25 26 bool IWorkflowOperation.IsHereafter(int WorkflowDetailed_ID) 27 { 28 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == WorkflowDetailed_ID); 29 if (detailed.ProcessingPersonnelMode == "Hereafter") 30 return true; 31 else 32 return false; 33 } 34 35 bool IWorkflowOperation.IsHereafter(int WorkflowID, int StepID) 36 { 37 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 38 if (detailed.ProcessingPersonnelMode == "Hereafter") 39 return true; 40 else 41 return false; 42 } 43 44 bool IWorkflowOperation.SendStartWorkflow(int WorkflowID, string FormID, string HandlePerson) 45 { 46 ////判断是否已经发送,如果已经发送返回失败 47 //if (wo.IsExistTask(WorkflowID, FormID)) 48 // return false; 49 //如果不存在发送的任务则发送,否则返回发送失败 50 if(!wo.IsExistTask(WorkflowID,FormID)) 51 { 52 //定义模版任务实例 53 var taskmodel = new TaskList(); 54 taskmodel.FromID = FormID; 55 taskmodel.Receive = DateTime.Now; 56 taskmodel.HandleStatus = false; 57 //如果主表不存在开始的步骤，抛出失败 58 var startdetailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == 0); 59 if (startdetailed == null) 60 return false; 61 //开始节点赋值 62 taskmodel.TaskSN = 0; 63 taskmodel.WorkflowDetailed_ID = startdetailed.ID; 64 taskmodel.StepStatus = startdetailed.StepStatus; 65 //发送注册到开始节点的告知人员 66 if (startdetailed.Nunciator != null && startdetailed.Nunciator != "") 67 { 68 SendPerson(wo.GetNunciatorPerson(WorkflowID, 0), 2, taskmodel); 69 } 70 //获取主表下一级节点 71 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == startdetailed.NextStep); 72 if (detailed == null) 73 return false; 74 //一级节点赋值 75 taskmodel.TaskSN = 1; 76 taskmodel.WorkflowDetailed_ID = detailed.ID; 77 taskmodel.StepStatus = detailed.StepStatus; 78 //发送一级步骤节点的告知人 79 if (detailed.Nunciator != null && detailed.Nunciator != "") 80 { 81 SendPerson(wo.GetNunciatorPerson(WorkflowID, detailed.StepID), 2, taskmodel); 82 } 83 //发送一级步骤节点的审批人 84 return SendPerson(wo.GetHandlePerson(WorkflowID, detailed.StepID, HandlePerson), 1, taskmodel) > 0; 85 } 86 return false; 87 } 88 89 //发送下一级审批（返回已发送流程的步骤号,返回-1表示流程结束0表示不需要发送-2还未发送开始流程-3表示未知错误-4审核不通过 流程终止） 90 int IWorkflowOperation.SendNextWorkflow(int WorkflowID, string FormID, string Condition, string HandlePerson) 91 { 92 //获取正在走流程的步骤 93 var task = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID) 94 .OrderByDescending(it => it.TaskSN).FirstOrDefault(); 95 if (task == null) 96 return -2;//还未发送开始流程 97 var detailed = db.WorkflowDetaileds.FirstOrDefault(item => item.ID == task.WorkflowDetailed_ID); 98 99 //判断是否应该发送下一级 100 int ispermit = IsPermitSendNext(detailed, FormID, task.TaskSN); 101 //是否允许发送 3为不允许发送 102 if (ispermit != 3) 103 { 104 //允许发送的情况有两种，通过的和不通过的 105 //对本级未处理的记录做相应的处理（删除）告知的未删除 106 var detaileds = db.TaskLists.Where(item => item.WorkflowDetailed_ID == detailed.ID && item.Opinion == null 107 && item.HandleTime == null && item.MessageType == 1); 108 foreach (var d in detaileds) 109 { 110 db.TaskLists.Remove(d); 111 } 112 db.SaveChanges(); 113 //发送下一级 114 //获取下一级步骤号 115 int nextstep = GetNextStepID(detailed, ispermit, Condition); 116 //不通过并下一节点为结束 对上一级的审批处理，如果不通过后为结束节点则直接结束，如果为其它节点则正常走（环形流程） 117 //环形审批失败后还需要继续发送！！ 118 if (ispermit == 2 && nextstep == -1) 119 return -4; 120 //通过的下一级为-1结束的话也直接返回-1，再交由SendEndWorkflow处理 121 if (nextstep == -1) 122 return -1; 123 //定义模版任务实例 124 var taskmodel = new TaskList(); 125 taskmodel.FromID = FormID; 126 taskmodel.Receive = DateTime.Now; 127 taskmodel.HandleStatus = false; 128 //获取主表下一级节点 129 var det = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == nextstep); 130 if (det == null) 131 return -3; 132 133 //下一级节点赋值 134 taskmodel.TaskSN = wo.GetTaskSN(det.WorkflowID, FormID); 135 taskmodel.WorkflowDetailed_ID = det.ID; 136 taskmodel.StepStatus = det.StepStatus; 137 //发送下一级步骤节点的告知人 138 if (det.Nunciator != null && det.Nunciator != "") 139 { 140 SendPerson(wo.GetNunciatorPerson(WorkflowID, det.StepID), 2, taskmodel); 141 } 142 //发送下一级步骤节点的审批人 143 if (SendPerson(wo.GetHandlePerson(WorkflowID, det.StepID, HandlePerson), 1, taskmodel) > 0) 144 { 145 //获取发送成功的步骤的步骤号(肯定不能为结束节点，到此都是已经发送完毕) 146 return nextstep;// GetNextStepID(det, Condition); 147 } 148 else 149 return -3; 150 } 151 else 152 { 153 return 0;//不需要发送 154 } 155 } 156 157 bool IWorkflowOperation.SendEndWorkflow(int WorkflowID, string FormID) 158 { 159 //定义模版任务实例 160 var taskmodel = new TaskList(); 161 taskmodel.FromID = FormID; 162 taskmodel.Receive = DateTime.Now; 163 taskmodel.HandleStatus = false; 164 //流程序号赋值为最大的 165 taskmodel.TaskSN = wo.GetTaskSN(WorkflowID, FormID); 166 //如果主表不存在结束的步骤，抛出失败 167 var startdetailed = db.WorkflowDetaileds.FirstOrDefault(item => item.WorkflowID == WorkflowID && item.StepID == -1); 168 if (startdetailed == null) 169 return false; 170 //结束节点赋值 171 taskmodel.WorkflowDetailed_ID = startdetailed.ID; 172 taskmodel.StepStatus = startdetailed.StepStatus; 173 //发送注册到结束节点的告知人员 174 if (startdetailed.Nunciator != null && startdetailed.Nunciator != "") 175 { 176 return SendPerson(wo.GetNunciatorPerson(WorkflowID, -1), 2, taskmodel) > 0; 177 } 178 return false; 179 } 180 181 //（-2流程不通过而结束-1流程通过而结束0发送成功(包含发送成功和不需要发送)1开始流程发送失败2下一级流程发送失败3结束流程发送失败） 182 int IWorkflowOperation.SendWorkflow(int WorkflowID, string FormID, string Condition, string HandlePerson) 183 { 184 //判断是否已经发送 185 if (wo.IsExistTask(WorkflowID, FormID)) 186 { 187 //发送下一步 188 int num = wo.SendNextWorkflow(WorkflowID, FormID, Condition, HandlePerson); 189 //该发送结束流程 190 if (num == -1) 191 { 192 if (!wo.SendEndWorkflow(WorkflowID, FormID)) 193 return 3;//结束流程发送失败 194 else 195 return -1;//流程结束 196 } 197 else if (num == -4)//审批不通过，直接结束流程 198 { 199 return -2; 200 } 201 else if (num == 0 || num > 0)//不需要发送或发送成功均为发送成功 202 { 203 return 0; 204 } 205 else//发送失败 206 { 207 return 2;//下一级发送失败 208 } 209 } 210 else 211 { 212 //发送开始 213 if (!wo.SendStartWorkflow(WorkflowID, FormID, HandlePerson)) 214 return 1;//开始流程发送失败 215 else 216 return 0; 217 } 218 } 219 220 /// <summary> 221 /// 根据条件获取某步骤的下一步骤号(为空或转换失败，均一NextStep为准)不同意的下一级取UpStep 222 /// </summary> 223 /// <param name="WorkflowDetailed">步骤实体</param> 224 /// <param name="ispermit">1通过的下一步2不通过的下一步</param> 225 /// <param name="Condition">条件</param> 226 /// <returns></returns> 227 private int GetNextStepID(WorkflowDetailed WorkflowDetailed, int ispermit, string Condition) 228 { 229 //不通过的下一步 230 if (ispermit == 2) 231 { 232 if (WorkflowDetailed.UpStep == null) 233 return -1; 234 else 235 return (int)WorkflowDetailed.UpStep; 236 } 237 //通过的下一步 238 if (WorkflowDetailed.Conditions != null && WorkflowDetailed.Conditions != "") 239 { 240 try 241 { 242 //根据条件表达式获取下一步步骤 243 return Qi_DQ.Math.MyEvaluator.EvaluateToInteger(WorkflowDetailed.Conditions.Replace("@p", Condition)); 244 } 245 catch (Exception ex) 246 { 247 return (int)WorkflowDetailed.NextStep; 248 } 249 } 250 return (int)WorkflowDetailed.NextStep; 251 } 252 253 /// <summary> 254 /// 获取下一级的任务序号 255 /// </summary> 256 /// <param name="WorkflowID"></param> 257 /// <param name="FormID"></param> 258 /// <returns></returns> 259 int IWorkflowOperation.GetTaskSN(int WorkflowID, string FormID) 260 { 261 var detailed = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID) 262 .OrderByDescending(it => it.TaskSN).FirstOrDefault(); 263 if (detailed != null) 264 return detailed.TaskSN + 1; 265 else 266 return 0; 267 } 268 269 /// <summary> 270 /// 获取真正进行的步骤实体(如果为空说明还未发送) 271 /// </summary> 272 /// <param name="WorkflowID"></param> 273 /// <param name="FormID"></param> 274 /// <returns></returns> 275 WorkflowDetailed IWorkflowOperation.GetCurrentStep(int WorkflowID, string FormID) 276 { 277 var detailed = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed.WorkflowID == WorkflowID) 278 .OrderByDescending(it => it.TaskSN).FirstOrDefault(); 279 if (detailed != null) 280 return db.WorkflowDetaileds.FirstOrDefault(item => item.ID == detailed.WorkflowDetailed_ID); 281 else 282 return null; 283 } 284 285 /// <summary> 286 /// 判断是否允许发送下一级审批1通过允许发送2失败允许发送3不允许发送 287 /// </summary> 288 /// <param name="WorkflowDetailed">流程实体</param> 289 /// <param name="FormID">表单ID</param> 290 /// <param name="TaskSN">任务序号，防止环形审批的上次任务处理对下次的影响</param> 291 /// <returns></returns> 292 private int IsPermitSendNext(WorkflowDetailed WorkflowDetailed, string FormID, int TaskSN) 293 { 294 //判断是否已经符合通过条件 295 int num = 0; 296 if (int.TryParse(WorkflowDetailed.ProcessingMode, out num))//数字的形式 297 { 298 if (num > 0)//通过多少人 299 { 300 //已经审批通过的人数 301 var tgnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 302 && item.HandleStatus && item.HandleType == 1 && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 303 //已审批的人员大于等于设定的通过人员 304 if (tgnum >= num) 305 return 1; 306 //还未审批的人数 307 var wspnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 308 && item.Opinion == null && item.HandleType == null && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 309 //判断未审批的人数和已通过的认识和 是否还满足不通过条件，满足时为审批综合不通过，返回允许发送下一级 310 if (wspnum + tgnum < num) 311 return 2; 312 } 313 else//不通过多少人 314 { 315 //不通过的人数 316 var btgnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 317 && item.HandleStatus && item.HandleType == 2 && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 318 //不通过的人数大于等于设定的不通过人数，审批不通过，运行发送 319 if (btgnum >= System.Math.Abs(num)) 320 { 321 return 2; 322 } 323 //还未审批的人数 324 var wspnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 325 && item.Opinion == null && item.HandleType == null && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 326 //判断不通过的人数和未审批的人数和 满足不了设定的通过条件，则通过并运行发送下一级 327 if (btgnum + wspnum < System.Math.Abs(num)) 328 { 329 return 1; 330 } 331 } 332 } 333 else//百分百的形式 334 { 335 //通过的人数 336 var tgnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 337 && item.HandleStatus && item.HandleType == 1 && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 338 //还未审批的人数 339 var wspnum = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 340 && item.Opinion == null && item.HandleType == null && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 341 //总记录数 342 var count = db.TaskLists.Where(item => item.FromID == FormID && item.WorkflowDetailed_ID == WorkflowDetailed.ID 343 && item.MessageType == 1 && item.TaskSN == TaskSN).Count(); 344 //设定的百分百 345 var percent = Convert.ToInt16(WorkflowDetailed.ProcessingMode.Trim('%')); 346 //通过率大于设定值 347 if ((((double)tgnum) / ((double)count)) * 100 >= percent) 348 { 349 return 1; 350 } 351 //未审批和通过的和都不大于设定值的话就为不通过 352 if ((((double)(tgnum + wspnum)) / ((double)count)) * 100 < percent) 353 { 354 return 2; 355 } 356 } 357 358 return 3; 359 } 360 361 //总的多流程 可能多步骤同一序号(已放弃多步骤同序号) 362 List<string> IWorkflowOperation.GetHandlePerson(int WorkflowID, int StepID, string HandlePerson) 363 { 364 var lst = new List<string>(); 365 var detaileds = db.WorkflowDetaileds.Where(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 366 //判断是否存在步骤 367 if (detaileds.Count() > 0) 368 { 369 foreach (var detailed in detaileds)//多步骤同号屏弃后此处的循环多余 370 { 371 ////获取全局名称 372 //var fullname = detailed.ProcessingPersonnelMode.Replace('_', '.'); 373 ////根据枚举，异步生成对象（添加后缀避免关键字） 374 //IPersonList pl = (IPersonList)Activator.CreateInstance(Type.GetType(fullname + "Controller")); 375 376 //如果是将来指定则直接加入列表 377 if (detailed.ProcessingPersonnelMode == "Hereafter") 378 { 379 //如果为空，未指定处理人，则不添加 380 if (HandlePerson != "") 381 { 382 //逗号分割的多个人 383 lst.AddRange(HandlePerson.Split(',').ToList()); 384 } 385 } 386 else 387 { 388 //根据类型获取类型列表 389 IDictionary<string, IPersonList> PersonnelModeList = PersonnelMode.GetInstance().GetPersonnelModeList(); 390 //获取人员列表并添加到lst集合 391 lst.AddRange(PersonnelModeList[detailed.ProcessingPersonnelMode].GetPersonList(detailed.ProcessingPersonnel)); 392 } 393 } 394 } 395 return lst; 396 } 397 398 //总的多流程 可能多步骤同一序号 399 List<string> IWorkflowOperation.GetNunciatorPerson(int WorkflowID, int StepID) 400 { 401 var lst = new List<string>(); 402 var detaileds = db.WorkflowDetaileds.Where(item => item.WorkflowID == WorkflowID && item.StepID == StepID); 403 //判断是否存在步骤 404 if (detaileds.Count() > 0) 405 { 406 foreach (var detailed in detaileds) 407 { 408 if (detailed.Nunciator != null && detailed.Nunciator != "") 409 { 410 lst.AddRange(detailed.Nunciator.Split(',').ToList()); 411 } 412 } 413 } 414 return lst; 415 } 416 417 /// <summary> 418 /// 根据人员列表发送审批数据 419 /// </summary> 420 /// <param name="lst">待发送的人员列表</param> 421 /// <param name="type">1处理人2告知人</param> 422 /// <param name="taskmodel">模版类型（传入不变的数值,除人员、类型外的所有值）</param> 423 /// <returns>发送的人员数量</returns> 424 private int SendPerson(List<string> lst, int type,TaskList taskmodel) 425 { 426 int i = 0; 427 if (lst.Count > 0) 428 { 429 foreach (var p in lst.Distinct()) 430 { 431 var task = new TaskList(); 432 task = taskmodel; 433 task.HandlePerson = p; 434 task.MessageType = type; 435 db.TaskLists.Add(task); 436 db.SaveChanges(); 437 i++; 438 } 439 } 440 return i;//返回添加条数也没用到 441 } 442 } 443 }
3.PersonPersonnelMode.cs 人员类型中，人员的实现实例类。代码如下：
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using Workflow.Abstract; 6 7 namespace Workflow.Concrete 8 { 9 public class PersonPersonnelMode : IPersonList 10 { 11 /// <summary> 12 /// 获取人员列表 13 /// </summary> 14 /// <param name="processingpersonnel">逗号分割的多记录</param> 15 /// <returns></returns> 16 List<string> IPersonList.GetPersonList(string processingpersonnel) 17 { 18 var lst = new List<string>(); 19 if (processingpersonnel != null && processingpersonnel != "") 20 lst = processingpersonnel.Split(',').ToList(); 21 return lst; 22 } 23 24 /// <summary> 25 /// 实现接口的具体类，获取其对应的键值对列表 26 /// </summary> 27 /// <returns></returns> 28 IDictionary<string, string> IPersonList.GetGlobalKeyValue() 29 { 30 IDictionary<string, string> d = new Dictionary<string, string>(); 31 d.Add("qdq", "人员1"); 32 d.Add("cyl", "人员2"); 33 d.Add("dxh","人员三"); 34 return d; 35 } 36 } 37 }
四、MyEvaluator.cs 执行表达式或方法，返回结果的类。
相关代码如下：
1 using System; 2 using System.Data; 3 using System.Configuration; 4 using System.Text; 5 using System.CodeDom.Compiler; 6 using Microsoft.CSharp; 7 using System.Reflection; 8 9 namespace Qi_DQ.Math 10 { 11 /// <summary> 12 /// 本类用来将字符串转为可执行文本并执行 13 /// </summary> 14 public class MyEvaluator 15 { 16 #region 构造函数 17 18 /// <summary> 19 /// 可执行串的构造函数 20 /// </summary> 21 /// <param name="items"> 22 /// 可执行字符串数组 23 /// </param> 24 public MyEvaluator(EvaluatorItem[] items) 25 { 26 ConstructEvaluator(items); //调用解析字符串构造函数进行解析 27 } 28 29 /// <summary> 30 /// 可执行串的构造函数 31 /// </summary> 32 /// <param name="returnType">返回值类型</param> 33 /// <param name="expression">执行表达式</param> 34 /// <param name="name">执行字符串名称</param> 35 public MyEvaluator(Type returnType, string expression, string name) 36 { 37 //创建可执行字符串数组 38 EvaluatorItem[] items = { new EvaluatorItem(returnType, expression, name) }; 39 ConstructEvaluator(items); //调用解析字符串构造函数进行解析 40 } 41 42 /// <summary> 43 /// 可执行串的构造函数 44 /// </summary> 45 /// <param name="item">可执行字符串项</param> 46 public MyEvaluator(EvaluatorItem item) 47 { 48 EvaluatorItem[] items = { item };//将可执行字符串项转为可执行字符串项数组 49 ConstructEvaluator(items); //调用解析字符串构造函数进行解析 50 } 51 52 /// <summary> 53 /// 解析字符串构造函数 54 /// </summary> 55 /// <param name="items">待解析字符串数组</param> 56 private void ConstructEvaluator(EvaluatorItem[] items) 57 { 58 //创建C#编译器实例 59 CodeDomProvider provider = CodeDomProvider.CreateProvider("C#"); 60 61 //过时了 62 //ICodeCompiler comp = provider.CreateCompiler(); 63 64 //编译器的传入参数 65 CompilerParameters cp = new CompilerParameters(); 66 cp.ReferencedAssemblies.Add("system.dll"); //添加程序集 system.dll 的引用 67 cp.ReferencedAssemblies.Add("system.data.dll"); //添加程序集 system.data.dll 的引用 68 cp.ReferencedAssemblies.Add("system.xml.dll"); //添加程序集 system.xml.dll 的引用 69 cp.GenerateExecutable = false; //不生成可执行文件 70 cp.GenerateInMemory = true; //在内存中运行 71 72 StringBuilder code = new StringBuilder(); //创建代码串 73 /* 74 * 添加常见且必须的引用字符串 75 */ 76 code.Append("using System; "); 77 code.Append("using System.Data; "); 78 code.Append("using System.Data.SqlClient; "); 79 code.Append("using System.Data.OleDb; "); 80 code.Append("using System.Xml; "); 81 82 code.Append("namespace SSEC.Math { "); //生成代码的命名空间为EvalGuy，和本代码一样 83 84 code.Append(" public class _Evaluator { "); //产生 _Evaluator 类，所有可执行代码均在此类中运行 85 foreach (EvaluatorItem item in items) //遍历每一个可执行字符串项 86 { 87 code.AppendFormat(" public {0} {1}() ", //添加定义公共函数代码 88 item.ReturnType.Name, //函数返回值为可执行字符串项中定义的返回值类型 89 item.Name); //函数名称为可执行字符串项中定义的执行字符串名称 90 code.Append("{ "); //添加函数开始括号 91 code.AppendFormat("return ({0});", item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值 92 code.Append("}"); //添加函数结束括号 93 } 94 code.Append("} }"); //添加类结束和命名空间结束括号 95 96 //得到编译器实例的返回结果 97 CompilerResults cr = provider.CompileAssemblyFromSource(cp, code.ToString());//comp 98 99 if (cr.Errors.HasErrors) //如果有错误 100 { 101 StringBuilder error = new StringBuilder(); //创建错误信息字符串 102 error.Append("编译有错误的表达式: "); //添加错误文本 103 foreach (CompilerError err in cr.Errors) //遍历每一个出现的编译错误 104 { 105 error.AppendFormat("{0}/n", err.ErrorText); //添加进错误文本，每个错误后换行 106 } 107 throw new Exception("编译错误: " + error.ToString());//抛出异常 108 } 109 Assembly a = cr.CompiledAssembly; //获取编译器实例的程序集 110 _Compiled = a.CreateInstance("SSEC.Math._Evaluator"); //通过程序集查找并声明 SSEC.Math._Evaluator 的实例 111 } 112 #endregion 113 114 #region 公有成员 115 /// <summary> 116 /// 执行字符串并返回整型值 117 /// </summary> 118 /// <param name="name">执行字符串名称</param> 119 /// <returns>执行结果</returns> 120 public int EvaluateInt(string name) 121 { 122 return (int)Evaluate(name); 123 } 124 /// <summary> 125 /// 执行字符串并返回双精度值 126 /// </summary> 127 /// <param name="name">执行字符串名称</param> 128 /// <returns>执行结果</returns> 129 public double EvaluateDouble(string name) 130 { 131 return (double)Evaluate(name); 132 } 133 /// <summary> 134 /// 执行字符串并返回长整型数值 135 /// </summary> 136 /// <param name="name">执行字符串名称</param> 137 /// <returns>执行结果</returns> 138 public long EvaluateLong(string name) 139 { 140 return (long)Evaluate(name); 141 } 142 /// <summary> 143 /// 执行字符串并返回十进制数值 144 /// </summary> 145 /// <param name="name">执行字符串名称</param> 146 /// <returns>执行结果</returns> 147 public decimal EvaluateDecimal(string name) 148 { 149 return (decimal)Evaluate(name); 150 } 151 /// <summary> 152 /// 执行字符串并返回字符串型值 153 /// </summary> 154 /// <param name="name">执行字符串名称</param> 155 /// <returns>执行结果</returns> 156 public string EvaluateString(string name) 157 { 158 return (string)Evaluate(name); 159 } 160 /// <summary> 161 /// 执行字符串并返回布尔型值 162 /// </summary> 163 /// <param name="name">执行字符串名称</param> 164 /// <returns>执行结果</returns> 165 public bool EvaluateBool(string name) 166 { 167 return (bool)Evaluate(name); 168 } 169 /// <summary> 170 /// 执行字符串并返 object 型值 171 /// </summary> 172 /// <param name="name">执行字符串名称</param> 173 /// <returns>执行结果</returns> 174 public object Evaluate(string name) 175 { 176 MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用 177 return mi.Invoke(_Compiled, null); //执行 mi 所引用的方法 178 } 179 #endregion 180 181 #region 静态成员 182 /// <summary> 183 /// 执行表达式并返回整型值 184 /// </summary> 185 /// <param name="code">要执行的表达式</param> 186 /// <returns>运算结果</returns> 187 static public int EvaluateToInteger(string code) 188 { 189 MyEvaluator eval = new MyEvaluator(typeof(int), code, staticMethodName);//生成 Evaluator 类的对像 190 return (int)eval.Evaluate(staticMethodName); //执行并返回整型数据 191 } 192 /// <summary> 193 /// 执行表达式并返回双精度值 194 /// </summary> 195 /// <param name="name">执行字符串名称</param> 196 /// <returns>执行结果</returns> 197 static public double EvaluateToDouble(string code) 198 { 199 MyEvaluator eval = new MyEvaluator(typeof(double), code, staticMethodName);//生成 Evaluator 类的对像 200 return (double)eval.Evaluate(staticMethodName); 201 } 202 /// <summary> 203 /// 执行表达式并返回长整型数值 204 /// </summary> 205 /// <param name="name">执行字符串名称</param> 206 /// <returns>执行结果</returns> 207 static public long EvaluateToLong(string code) 208 { 209 MyEvaluator eval = new MyEvaluator(typeof(long), code, staticMethodName);//生成 Evaluator 类的对像 210 return (long)eval.Evaluate(staticMethodName); 211 } 212 /// <summary> 213 /// 执行表达式并返回十进制数值 214 /// </summary> 215 /// <param name="name">执行字符串名称</param> 216 /// <returns>执行结果</returns> 217 static public decimal EvaluateToDecimal(string code) 218 { 219 MyEvaluator eval = new MyEvaluator(typeof(decimal), code, staticMethodName);//生成 Evaluator 类的对像 220 return (decimal)eval.Evaluate(staticMethodName); 221 } 222 /// <summary> 223 /// 执行表达式并返回字符串型值 224 /// </summary> 225 /// <param name="code">要执行的表达式</param> 226 /// <returns>运算结果</returns> 227 static public string EvaluateToString(string code) 228 { 229 MyEvaluator eval = new MyEvaluator(typeof(string), code, staticMethodName);//生成 Evaluator 类的对像 230 return (string)eval.Evaluate(staticMethodName); //执行并返回字符串型数据 231 } 232 /// <summary> 233 /// 执行表达式并返回布尔型值 234 /// </summary> 235 /// <param name="code">要执行的表达式</param> 236 /// <returns>运算结果</returns> 237 static public bool EvaluateToBool(string code) 238 { 239 MyEvaluator eval = new MyEvaluator(typeof(bool), code, staticMethodName);//生成 Evaluator 类的对像 240 return (bool)eval.Evaluate(staticMethodName); //执行并返回布尔型数据 241 } 242 /// <summary> 243 /// 执行表达式并返回 object 型值 244 /// </summary> 245 /// <param name="code">要执行的表达式</param> 246 /// <returns>运算结果</returns> 247 static public object EvaluateToObject(string code) 248 { 249 MyEvaluator eval = new MyEvaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像 250 return eval.Evaluate(staticMethodName); //执行并返回 object 型数据 251 } 252 #endregion 253 254 #region 私有成员 255 /// <summary> 256 /// 静态方法的执行字符串名称 257 /// </summary> 258 private const string staticMethodName = "__foo"; 259 /// <summary> 260 /// 用于动态引用生成的类，执行其内部包含的可执行字符串 261 /// </summary> 262 object _Compiled = null; 263 #endregion 264 } 265 266 267 /// <summary> 268 /// 可执行字符串项（即一条可执行字符串） 269 /// </summary> 270 public class EvaluatorItem 271 { 272 /// <summary> 273 /// 返回值类型 274 /// </summary> 275 public Type ReturnType; 276 /// <summary> 277 /// 执行表达式 278 /// </summary> 279 public string Expression; 280 /// <summary> 281 /// 执行字符串名称 282 /// </summary> 283 public string Name; 284 /// <summary> 285 /// 可执行字符串项构造函数 286 /// </summary> 287 /// <param name="returnType">返回值类型</param> 288 /// <param name="expression">执行表达式</param> 289 /// <param name="name">执行字符串名称</param> 290 public EvaluatorItem(Type returnType, string expression, string name) 291 { 292 ReturnType = returnType; 293 Expression = expression; 294 Name = name; 295 } 296 } 297 }
五、关键技术点剖析
1.不同的软件可能包含不同人员类型（如流程审批中可能需要组织机构中的部门经理，还可能需要角色中的计划员等）。
解决方案：提供统一的接口（IPersonList），具体的应用程序实现接口，并在全局变量PersonnelModeList中注册接口实现类的实例。
2.条件步骤的具体选择（如在满足条件一的情况下走步骤一，而在满足条件二的时候可能需要走步骤二）。
解决方案：提供可行性表达式的方法，根据执行表达式的结果确定具体的步骤（如(10>@p?1:2)会根据传入的p的值确定是走步骤一还是走步骤二）。
六、总结
因并没有与具体的表单设计引擎相关联，流程引擎中必然存在许多不足的地方，比如，条件步骤的具体选择就存在很大的局限性，无法直接设置某个属性的值去做条件判断从而确定具体的步骤。
由于笔者知识面的局限性，引擎中可能还存在笔者没有考虑到的因素，望读者们能与笔者共同发现引擎中的不足以及寻找最佳的解决方案。或者读者对现有的代码结构、解决方案等有好的意见均可与笔者沟通（联系方式见上↑）。
注：相关源码会在下一篇的可视化流程设计中一并给出，有兴趣的读者请关注。
相关文章连接：
可视化流程设计——流程设计器演示(基于Silverlight)：http://www.cnblogs.com/qidq/p/Workflow_Silverlight.html
流程引擎及流程设计器的嵌入方式：http://www.cnblogs.com/qidq/p/3499769.html