stream.cs

很不错的公文流转系统

					if(tmpNode.NodeType!=2)
					{
						this.errorMessage="第一个工作点类型应为公文起草";
						return false;
					}
				}
			}
			//保存修改
			if(this.streamDef==null||this.streamDef=="")
				this.streamDef=System.Guid.NewGuid().ToString()+".config";	
			try
			{
				oXmlDocument.Save(OI.Modules.Config.GetSetting("stream")+"\\"+streamDef);
			}
			catch(System.Exception e)
			{
				throw new AppException("保存工作流失败",e);
			}
			return true;
		}
		/// <summary>
		/// 删除工作流节点
		/// </summary>
		/// <param name="nodeId">工作流节点ID</param>
		/// <returns>成功或失败</returns>
		public bool DeleteNode(int nodeId)
		{
			int newNodeId;//新的节点
			//开始节点和完成节点不能被删除
			string str="//NodeId[.='"+nodeId.ToString()+"']";
			System.Xml.XmlNode oXmlNode=this.oXmlDocument.DocumentElement.SelectSingleNode(str);
			if(oXmlNode==null)
			{
				this.errorMessage="节点不存在";
				return false;
			}
			
			oXmlNode=oXmlNode.ParentNode;
			newNodeId=System.Int32.Parse(oXmlNode.SelectSingleNode("NextNodeId").InnerText);
			int nodeType;
			try
			{
				nodeType=System.Int32.Parse(oXmlNode.SelectSingleNode("NodeType").Attributes.Item(0).Value);
			}
			catch
			{
				throw new AppException("获取节点NodeTypeId属性出错");
			}
			OI.Data.NodeTypes.NodeType oNodeType=new OI.Data.NodeTypes.NodeType();
			if(oNodeType.Search(nodeType))
			{
				if(oNodeType.NodeTypeName=="开始")
				{
					this.errorMessage="不能删除开始节点";
					return false;
				}
				if(oNodeType.NodeTypeName=="完成")
				{
					this.errorMessage="不能删除完成节点";
					return false;
				}
			}
			
			
			//删除当前节点
			oXmlNode.RemoveAll();
			this.oXmlDocument.DocumentElement.RemoveChild(oXmlNode);
			//更新其他节点，把所有指向当前节点更新为下一节点
			
			System.Xml.XmlNodeList oXmlNodeList;
			str="//NextNodeId[.='"+nodeId.ToString()+"']";
			oXmlNodeList=this.oXmlDocument.DocumentElement.SelectNodes(str);
			foreach(System.Xml.XmlNode onode in oXmlNodeList)
			{
				onode.InnerText=newNodeId.ToString();
			}
			
			try
			{
				this.oXmlDocument.Save(OI.Modules.Config.GetSetting("stream")+"\\"+streamDef);
			}
			catch(System.Exception e)
			{
				throw new AppException("保存工作流失败",e);
			}
			
			return true;
		}
		
		/// <summary>
		/// 将一个Stream.Node转换为XmlElement
		/// </summary>
		/// <param name="node">工作流节点</param>
		/// <returns>XmlElement</returns>
		private System.Xml.XmlElement GetXmlNode(Node node)
		{
			//开始添加节点
			System.Xml.XmlElement nodeElement=oXmlDocument.CreateElement("Node");
			//添加NodeId节点
			System.Xml.XmlElement nodeIdElement=oXmlDocument.CreateElement("NodeId");
			nodeIdElement.InnerText=node.NodeId.ToString();
			nodeElement.AppendChild(nodeIdElement);
			//添加NodeName节点
			System.Xml.XmlElement nodeName=oXmlDocument.CreateElement("NodeName");
			nodeName.InnerText=node.NodeName;
			nodeElement.AppendChild(nodeName);
			//添加NodeType节点
			System.Xml.XmlElement nodeType=oXmlDocument.CreateElement("NodeType");
			nodeType.InnerText=node.NodeTypeName;
			nodeType.SetAttribute("NodeTypeId",((int)node.NodeType).ToString());
			nodeElement.AppendChild(nodeType);

			//添加Handers节点
			System.Xml.XmlElement handers=oXmlDocument.CreateElement("Handers");			
			for(int i=0;i<node.Handers.Length;i++)
			{
				if(node.Handers[i]>0)
				{
					System.Xml.XmlElement hander=oXmlDocument.CreateElement("Hander");
					hander.SetAttribute("HanderId",node.Handers[i].ToString());
					handers.AppendChild(hander);
				}
			}
			nodeElement.AppendChild(handers);
			
			//添加NextNodeId节点
			if(node.NextNodeId>0)
			{
				System.Xml.XmlElement nextNodeId=oXmlDocument.CreateElement("NextNodeId");
				nextNodeId.InnerText=node.NextNodeId.ToString();
				nodeElement.AppendChild(nextNodeId);
			}
			//添加CanDisAgree节点
				System.Xml.XmlElement canDisAgree=oXmlDocument.CreateElement("CanDisAgree");
				if(node.CanDisAgree)
					canDisAgree.InnerText="1";
				else
					canDisAgree.InnerText="0";
				nodeElement.AppendChild(canDisAgree);
			//添加CanRefuse节点
				System.Xml.XmlElement canRefuse=oXmlDocument.CreateElement("CanRefuse");
				if(node.CanRefuse)
					canRefuse.InnerText="1";
				else
					canRefuse.InnerText="0";
				nodeElement.AppendChild(canRefuse);
			//添加CanCheck节点
				System.Xml.XmlElement canCheck=oXmlDocument.CreateElement("CanCheck");
				if(node.CanCheck)
					canCheck.InnerText="1";
				else
					canCheck.InnerText="0";
				nodeElement.AppendChild(canCheck);
			//添加Time节点
			System.Xml.XmlElement time=oXmlDocument.CreateElement("Time");
			time.InnerText=node.Time.ToString();
			nodeElement.AppendChild(time);
			//添加FlowType节点
			System.Xml.XmlElement flowType=oXmlDocument.CreateElement("FlowType");
			flowType.InnerText=((int)node.FlowType).ToString();
			nodeElement.AppendChild(flowType);
			//添加HanderDescription节点
			System.Xml.XmlElement handerdescription=oXmlDocument.CreateElement("HanderDescription");
			handerdescription.InnerText=node.HanderDescription;
			nodeElement.AppendChild(handerdescription);
			//将添加的Node节点加入到文档根节点中
			oXmlDocument.DocumentElement.AppendChild(nodeElement);
			

			return nodeElement;
		}
		public Node[] NodeIdList()
		{
			System.Xml.XmlNodeList oXmlNodeList=oXmlDocument.DocumentElement.SelectNodes("//Node");
			Node[] nodes=new Node[oXmlNodeList.Count];
			for(int i=0;i<oXmlNodeList.Count;i++)
			{
				nodes[i]=this.FindNodeById(System.Int32.Parse(oXmlNodeList[i].SelectSingleNode("NodeId").InnerText));
			}			
			return nodes;
		}
		public Node FindNodeById(int nodeId)
		{
			string str="//NodeId[.='"+nodeId.ToString()+"']";
			
			System.Xml.XmlNode oXmlNode=this.oXmlDocument.DocumentElement.SelectSingleNode(str);
			
			if(oXmlNode!=null)
			{
				oXmlNode=oXmlNode.ParentNode;
				Node objNode=new Node();

				//NodeId
				if(oXmlNode.SelectSingleNode("NodeId")!=null)
					objNode.NodeId=System.Int32.Parse(oXmlNode.SelectSingleNode("NodeId").InnerText);
				//NodeName
				if(oXmlNode.SelectSingleNode("NodeName")!=null)
					objNode.NodeName=oXmlNode.SelectSingleNode("NodeName").InnerText;
				//NodeType
				if(oXmlNode.SelectSingleNode("NodeType")!=null)
					objNode.NodeType=System.Int32.Parse(oXmlNode.SelectSingleNode("NodeType").Attributes.Item(0).Value);
				//NextNodeId
				if(oXmlNode.SelectSingleNode("NextNodeId")!=null)
					objNode.NextNodeId=System.Int32.Parse(oXmlNode.SelectSingleNode("NextNodeId").InnerText);
				//CanDisAgree
				if(oXmlNode.SelectSingleNode("CanDisAgree")!=null)
					objNode.CanDisAgree=System.Convert.ToBoolean(System.Int32.Parse(oXmlNode.SelectSingleNode("CanDisAgree").InnerText));
				//CanRefuse
				if(oXmlNode.SelectSingleNode("CanRefuse")!=null)
					objNode.CanRefuse=System.Convert.ToBoolean(System.Int32.Parse(oXmlNode.SelectSingleNode("CanRefuse").InnerText));
				//CanCheck
				if(oXmlNode.SelectSingleNode("CanCheck")!=null)
					objNode.CanCheck=System.Convert.ToBoolean(System.Int32.Parse(oXmlNode.SelectSingleNode("CanCheck").InnerText));
				//Time
				if(oXmlNode.SelectSingleNode("Time")!=null)
					objNode.Time=System.Int32.Parse(oXmlNode.SelectSingleNode("Time").InnerText);
				//FlowType
				if(oXmlNode.SelectSingleNode("FlowType")!=null)
					objNode.FlowType=(OI.Business.Stream.Node.FlowTypes)System.Int32.Parse((oXmlNode.SelectSingleNode("FlowType").InnerText));
				//HanderDescription
				if(oXmlNode.SelectSingleNode("HanderDescription")!=null)
					objNode.HanderDescription=oXmlNode.SelectSingleNode("HanderDescription").InnerText;

				//

					System.Collections.ArrayList oArrayList=new ArrayList();
					if(oXmlNode.SelectSingleNode("Handers")!=null)
					{
						foreach(System.Xml.XmlNode o in oXmlNode.SelectSingleNode("Handers").ChildNodes)
						{
							if(o.Name=="Hander")
							{
								oArrayList.Add(System.Int32.Parse(o.Attributes["HanderId"].Value));
							}

						}
					}
					int[] handers=new int[oArrayList.Count];
					for(int i=0;i<oArrayList.Count;i++)
					{
						handers[i]=System.Int32.Parse(oArrayList[i].ToString());
					}
					objNode.Handers=handers;
				
				return objNode;	
			}
			return null;
		}
		
		public class Node
		{
			
			public enum FlowTypes{AnyOne,EveryOne};//流转方式,AnyOne为任何一人完成继续，EveryOne为全部人处理完成继续
			private int nodeType;
			private string nodeName;
			private int nodeId;
			private int[] handers;
			private int nextNodeId;
			private bool canDisAgree;
			private bool canRefuse;
			private bool canCheck;
			private int time;
			private FlowTypes flowType;
			private string handerdescription;
			

			/// <summary>
			/// 工作流节点构造函数
			/// </summary>
			public Node()
			{

			}
			/// <summary>
			/// 工作流节点构造函数
			/// </summary>
			/// <param name="nodeId">节点ID</param>
			/// <param name="nodeType">节点类型</param>
			/// <param name="nodeName">节点名称</param>
			/// <param name="handers">处理人ID</param>
			/// <param name="nextNodeId">下一节点ID</param>
			/// <param name="canDisAgree">可否退签</param>
			/// <param name="canRefuse">可否撤消</param>
			/// <param name="canCheck">可否校对</param>
			/// <param name="flowType">流转类别</param>			
			/// <param name="time">期限</param>
			public Node(int nodeId,int nodeType,string nodeName,int[] handers,int nextNodeId,bool canDisAgree,bool canRefuse,bool canCheck,OI.Business.Stream.Node.FlowTypes flowType,int time,string handerdescription)
			{
				this.nodeId=nodeId;
				this.nodeType=nodeType;
				this.nodeName=nodeName;
				this.handers=handers;
				this.nextNodeId=nextNodeId;
				this.canDisAgree=canDisAgree;
				this.canRefuse=canRefuse;		
				this.time=time;
				this.canCheck=canCheck;
				this.flowType=flowType;
				this.handerdescription=handerdescription;
			}
			/// <summary>
			/// 工作点说明
			/// </summary>
			public string HanderDescription
			{
				get
				{
					return this.handerdescription;
				}
				set
				{
					this.handerdescription=value;
				}
			}
			/// <summary>
			/// 工作流流转方式
			/// </summary>
			public FlowTypes FlowType
			{
				get
				{
					return this.flowType;
				}
				set
				{
					this.flowType=value;
				}
			}
			/// <summary>
			/// 指示是否可进行校核，加入批注和修订
			/// </summary>
			public bool CanCheck
			{
				get
				{
					return this.canCheck;
				}
				set
				{
					this.canCheck=value;
				}
			}
			/// <summary>
			/// 工作点期限，按天数算，如为零则没有期限
			/// </summary>
			public int Time
			{
				get
				{
					return this.time;
				}
				set
				{
					if(value>=0)
						this.time=value;
				}
			}
			
			
			/// <summary>
			/// 节点类型
			/// </summary>
			public int NodeType
			{
				get
				{
					return nodeType;
				}
				set
				{
					this.nodeType=value;
				}
			}
			/// <summary>
			/// 节点类型名称，只读
			/// </summary>
			public string  NodeTypeName 
			{
				get
				{

					OI.Data.NodeTypes.NodeType oNodeType=new OI.Data.NodeTypes.NodeType();
					if(oNodeType.Search(this.nodeType))
						return oNodeType.NodeTypeName;
					return "";					
				}
			}
			/// <summary>
			/// 节点名称
			/// </summary>
			public string NodeName
			{
				get
				{
					return this.nodeName;
				}
				set
				{
					this.nodeName=value;
				}
			}
			/// <summary>
			/// 节点ID
			/// </summary>
			public int NodeId
			{
				get
				{
					return this.nodeId;
				}
				set
				{
					this.nodeId=value;
				}
			}
			/// <summary>
			/// 处理人ID列表，只读
			/// </summary>
			public int[] Handers
			{
				get
				{
					return this.handers;
				}
				set
				{
					this.handers=value;
				}
			}
			/// <summary>
			/// 下一节点ID
			/// </summary>
			public int NextNodeId
			{
				get
				{
					return this.nextNodeId;
				}
				set
				{
					this.nextNodeId=value;
				}
			}
			/// <summary>
			/// 可否退签
			/// </summary>
			public bool CanDisAgree
			{
				get
				{
					return this.canDisAgree;
				}
				set
				{
					this.canDisAgree=value;
				}
			}
			/// <summary>
			/// 可否撤消
			/// </summary>
			public bool CanRefuse
			{
				get
				{
					return this.canRefuse;
				}
				set
				{
					this.canRefuse=value;
				}
			}
		}
	

	}
}