/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：F_PC_0203.cs
 *      2.功能描述：生产线配置编辑界面
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      王鑫          2015/03/27            1.00            新建
 *******************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using System.Linq;

using Dongke.IBOSS.Basics.FlowSetting;
using Dongke.IBOSS.PRD.Basics.BaseControls;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Client.CommonModule;
using Dongke.IBOSS.PRD.WCF.Proxys;
using Dongke.IBOSS.PRD.WCF.Proxys.PCModuleService;
using Dongke.IBOSS.PRD.WCF.DataModels;

namespace Dongke.IBOSS.PRD.Client.PCModule
{
    /// <summary>
    /// 生产线配置
    /// </summary>
    public partial class F_PC_0203 : FormBase
    {
        #region 成员变量

        private int _lineID = -1;                       //生产线ID
        private string _lineCode;                       //生产线编码
        private string _lineName;                       //生产线名称
        private string _remarks;                        //备注
        private int _valueflag;                         //启用、禁用标记
        private Constant.FormMode _editStatus;          //窗体编辑状态
        private List<int> _IDList = new List<int>();    // ID集合
        private DataSet productionDataSet = null;       //生产配置数据集
        private int _ValueFlagRow = 0;                  //工序标识禁用的行数
        private DateTime _optimestamp;                  // 时间戳
        private string _productionlinecode;             //保存成功后回显的生产线编码
        private int? _nodeno;                            //节点唯一值
        FlowNode _currentnode = null;                   //当前弹出节点
        private bool _hasClose = false;
        #endregion

        #region 属性

        /// <summary>
        /// 生产配置数据
        /// </summary>
        public DataSet ProductionDataSet
        {
            get
            {
                return this.productionDataSet;
            }
            set
            {
                this.productionDataSet = value;
            }
        }

        /// <summary>
        /// ID集合
        /// </summary>
        public List<int> IDList
        {
            get { return _IDList; }
            set { _IDList = value; }
        }

        /// <summary>
        /// 时间戳
        /// </summary>
        public DateTime OPTimeStamp
        {
            get
            {
                return _optimestamp;
            }
            set
            {
                _optimestamp = value;
            }
        }

        /// <summary>
        /// 保存成功后回显的生产线编码
        /// </summary>
        public string ProductionlineCode
        {
            get
            {
                return _productionlinecode;
            }
            set
            {
                _productionlinecode = value;
            }
        }
        #endregion

        #region 构造函数

        public F_PC_0203(Constant.FormMode editStatus, int lineID, string lineCode, string lineName, string remarks, int valueflag)
        {
            InitializeComponent();
            this._lineID = lineID;
            this._lineCode = lineCode;
            this._lineName = lineName;
            this._remarks = remarks;
            this._valueflag = valueflag;
            this._editStatus = editStatus;
        }

        public F_PC_0203(Constant.FormMode editStatus, int lineID, string lineCode, string lineName, string remarks, int valueflag, int? nodeno)
        {
            InitializeComponent();
            this._lineID = lineID;
            this._lineCode = lineCode;
            this._lineName = lineName;
            this._remarks = remarks;
            this._valueflag = valueflag;
            this._editStatus = editStatus;
            this._nodeno = nodeno;
        }

        #endregion

        #region 事件

        /// <summary>
        /// 窗体加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void F_PC_0203_Load(object sender, System.EventArgs e)
        {
            this.txtLineCode.Focus();
            // 查询数据
            this.ProductionDataSet = PCModuleProxy.Service.GetProductionLineDetail(this._lineID);

            // tableName 要与 Dongke.IBOSS.PRD.Service.ConfigModuleLogic.ConfigModuleLogic的GetProductionLineDetail方法定义的名称对应
            // 加载生产线信息
            DataTable lineTable = this.ProductionDataSet.Tables["lineTable"];
            // 画图
            if (lineTable != null && lineTable.Rows.Count > 0)
            {
                this.flowBox.LoadFlow((byte[])(lineTable.Rows[0]["FlowXML"]));
                this.OPTimeStamp = Convert.ToDateTime(lineTable.Rows[0]["OPTimeStamp"]);
            }
            //加载画布大小给文本框
            this.txtFlowWidth.Text = this.flowBox.CanvasSize.Width.ToString();
            this.txtFlowHeigth.Text = this.flowBox.CanvasSize.Height.ToString();

            // 加载工序信息
            DataTable procedureTable = this.ProductionDataSet.Tables["procedureTable"];
            _ValueFlagRow = procedureTable.Select("ValueFlag=0").Length;

            DataView dv = procedureTable.DefaultView;
            dv.RowFilter = "ValueFlag=1";

            procedureTable = dv.ToTable();

            foreach (FlowNode node in this.flowBox.AllNodes)
            {
                DataRow[] dr1 = procedureTable.Select("NodeNo=" + node.ItemID);
                if (node.ItemID == this._nodeno)
                {
                    this._nodeno = node.ItemID;
                    this._currentnode = node;
                }
                if (dr1.Length > 0)
                {
                    node.NodeImageType = Convert.ToInt32(dr1[0]["ProcedureModel"]);//工序模型为了给双击事件弹出对应的窗体
                }
                if (node.NodeImageType == 1)
                {
                    if (Convert.ToInt32(dr1[0]["modeltype"]) == Constant.ProcedureModelType.IntoKiln.GetHashCode())
                    {
                        node.NodeImage = new Bitmap(this.GetType(), "images.入窑64-01.png");
                    }
                    else if (Convert.ToInt32(dr1[0]["modeltype"]) == Constant.ProcedureModelType.LoadCar.GetHashCode())
                    {
                        node.NodeImage = new Bitmap(this.GetType(), "images.装车64-01.png");
                    }
                    else if (Convert.ToInt32(dr1[0]["modeltype"]) == Constant.ProcedureModelType.UnloadCar.GetHashCode())
                    {
                        node.NodeImage = new Bitmap(this.GetType(), "images.卸车64-01.png");
                    }
                    else
                    {
                        node.NodeImage = new Bitmap(this.GetType(), "images.newflow.png");
                    }
                }
                else
                {
                    node.NodeImage = new Bitmap(this.GetType(), "images.newflowcheck.png");
                }
                if (Convert.ToInt32(dr1[0]["MustFlag"].ToString()) == 1)
                {
                    node.CanSkip = false;
                }
                else
                {
                    node.CanSkip = true;
                }
                node.Code = dr1[0]["ProcedureCode"].ToString();
                node.Name = dr1[0]["ProcedureName"].ToString();
                node.Remark = dr1[0]["Remarks"].ToString();
                ProcedureEntity procedureEntity = new ProcedureEntity();//工序

                procedureEntity.ProcedureID = Convert.ToInt32(dr1[0]["ProcedureID"].ToString());
                procedureEntity.ProcedureCode = dr1[0]["ProcedureCode"].ToString();
                procedureEntity.ProcedureName = dr1[0]["ProcedureName"].ToString();
                procedureEntity.ProcedureModel = Convert.ToInt32(dr1[0]["ProcedureModel"].ToString());
                procedureEntity.ModelType = Convert.ToInt32(dr1[0]["modeltype"].ToString());
                procedureEntity.NodeType = Convert.ToInt32(dr1[0]["nodetype"].ToString());
                procedureEntity.MustFlag = Convert.ToInt32(dr1[0]["MustFlag"].ToString());
                procedureEntity.CollectType = Convert.ToInt32(dr1[0]["CollectType"].ToString());
                procedureEntity.PieceType = Convert.ToInt32(dr1[0]["PieceType"].ToString());
                procedureEntity.IsSpecialRework = Convert.ToInt32(dr1[0]["isspecialrework"].ToString());

                //xuwei add 2019-10-17
                procedureEntity.IsSemireWork = Convert.ToInt32(dr1[0]["isSemireWork"].ToString());

                procedureEntity.OrganizationID = Convert.ToInt32(dr1[0]["OrganizationID"].ToString());
                procedureEntity.Remarks = dr1[0]["Remarks"].ToString();
                procedureEntity.NodeNo = Convert.ToInt32(dr1[0]["NodeNo"]);
                procedureEntity.MissPriority = Convert.ToInt32(dr1[0]["misspriority"]);
                procedureEntity.DisplayNo = Convert.ToInt32(dr1[0]["DisplayNo"]);
                procedureEntity.UnDo = Convert.ToInt32(dr1[0]["UNDOFLAG"]);
                procedureEntity.DeliverType = Convert.ToInt32(dr1[0]["DeliverType"]);
                procedureEntity.BarCodePrintCopies = Convert.ToInt32(dr1[0]["BarCodePrintCopies"]);
                procedureEntity.BarCodeFlag = Convert.ToInt32(dr1[0]["BarCodeFlag"]);
                //if (dr1[0]["LogoID"] != DBNull.Value)
                //{
                //    procedureEntity.LogoID = Convert.ToInt32(dr1[0]["LogoID"]);
                //}
                // 对应产品信息
                DataRow[] goodsRows = this.ProductionDataSet.Tables["procedureGoodsTable"].Select("NodeNo =" + node.ItemID);
                if (goodsRows != null && goodsRows.Length > 0)
                {

                    procedureEntity.ProcedureGoodsTable = goodsRows.CopyToDataTable();
                    procedureEntity.ProcedureGoodsTable.TableName = "procedureGoodsTable";
                }
                else
                {
                    procedureEntity.ProcedureGoodsTable = this.ProductionDataSet.Tables["procedureGoodsTable"].Clone();
                }
                // 工序对应工号表
                DataRow[] userRows = this.ProductionDataSet.Tables["procedureUserTable"].Select("NodeNo =" + node.ItemID);
                if (userRows != null && userRows.Length > 0)
                {
                    procedureEntity.ProcedureUserTable = userRows.CopyToDataTable();
                    procedureEntity.ProcedureUserTable.TableName = "procedureUserTable";
                }
                else
                {
                    procedureEntity.ProcedureUserTable = this.ProductionDataSet.Tables["procedureUserTable"].Clone();
                }
                // 工序对应缺陷表(在检验工序中能检验出来的缺陷。)
                DataRow[] defectRows = this.ProductionDataSet.Tables["procedureDefectTable"].Select("NodeNo =" + node.ItemID);
                if (defectRows != null && defectRows.Length > 0)
                {
                    procedureEntity.ProcedureDefectTable = defectRows.CopyToDataTable();
                    procedureEntity.ProcedureDefectTable.TableName = "procedureDefectTable";
                }
                else
                {
                    procedureEntity.ProcedureDefectTable = this.ProductionDataSet.Tables["procedureDefectTable"].Clone();
                }
                // 生产工序对应缺陷表
                DataRow[] defectProcedureJobsRows = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Select("NodeNo =" + node.ItemID);
                if (defectProcedureJobsRows != null && defectProcedureJobsRows.Length > 0)
                {
                    procedureEntity.DefectProcedureJobsTable = defectProcedureJobsRows.CopyToDataTable();
                    procedureEntity.DefectProcedureJobsTable.TableName = "defectProcedureJobsTable";
                }
                else
                {
                    procedureEntity.DefectProcedureJobsTable = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Clone();
                }

                // 工序对应窑炉
                DataRow[] kilnRows = this.ProductionDataSet.Tables["procedureKilnTable"].Select("NodeNo =" + node.ItemID);
                if (kilnRows != null && kilnRows.Length > 0)
                {
                    procedureEntity.ProcedureKilnTable = kilnRows.CopyToDataTable();
                    procedureEntity.ProcedureKilnTable.TableName = "procedureKilnTable";
                }
                else
                {
                    procedureEntity.ProcedureKilnTable = this.ProductionDataSet.Tables["procedureKilnTable"].Clone();
                }

                node.TagNonSerialized = procedureEntity;
            }



            //for (int i = 0; i < procedureTable.Rows.Count; i++)
            //{
            //    #region 加载工序信息
            //    FlowNode node = (FlowNode)this.flowBox.AllNodes[i];
            //    //if (node.NodeImageType == int.Parse(procedureTable.Rows[i]["ProcedureModel"].ToString()))
            //    //{
            //    node.NodeImageType = int.Parse(procedureTable.Rows[i]["ProcedureModel"].ToString());//工序模型为了给双击事件弹出对应的窗体
            //    //}
            //    if (node.NodeImageType == 1)
            //    {
            //        if (int.Parse(procedureTable.Rows[i]["modeltype"].ToString()) == Constant.ProcedureModelType.IntoKiln.GetHashCode())
            //        {
            //            node.NodeImage = new Bitmap(this.GetType(), "images.入窑64-01.png");
            //        }
            //        else if (int.Parse(procedureTable.Rows[i]["modeltype"].ToString()) == Constant.ProcedureModelType.LoadCar.GetHashCode())
            //        {
            //            node.NodeImage = new Bitmap(this.GetType(), "images.装车64-01.png");
            //        }
            //        else if (int.Parse(procedureTable.Rows[i]["modeltype"].ToString()) == Constant.ProcedureModelType.UnloadCar.GetHashCode())
            //        {
            //            node.NodeImage = new Bitmap(this.GetType(), "images.卸车64-01.png");
            //        }
            //        else
            //        {
            //            node.NodeImage = new Bitmap(this.GetType(), "images.newflow.png");
            //        }
            //    }
            //    else
            //    {
            //        node.NodeImage = new Bitmap(this.GetType(), "images.newflowcheck.png");
            //    }
            //    if (int.Parse(procedureTable.Rows[i]["MustFlag"].ToString()) == 1)
            //    {
            //        node.CanSkip = true;
            //    }
            //    else
            //    {
            //        node.CanSkip = false;
            //    }
            //    node.Code = procedureTable.Rows[i]["ProcedureCode"].ToString();
            //    node.Name = procedureTable.Rows[i]["ProcedureName"].ToString();
            //    node.Remark = procedureTable.Rows[i]["Remarks"].ToString();
            //    ProcedureEntity procedureEntity = new ProcedureEntity();//工序

            //    procedureEntity.ProcedureID = int.Parse(procedureTable.Rows[i]["ProcedureID"].ToString());
            //    procedureEntity.ProcedureCode = procedureTable.Rows[i]["ProcedureCode"].ToString();
            //    procedureEntity.ProcedureName = procedureTable.Rows[i]["ProcedureName"].ToString();
            //    procedureEntity.ProcedureModel = int.Parse(procedureTable.Rows[i]["ProcedureModel"].ToString());
            //    procedureEntity.ModelType = int.Parse(procedureTable.Rows[i]["modeltype"].ToString());
            //    procedureEntity.NodeType = int.Parse(procedureTable.Rows[i]["nodetype"].ToString());
            //    procedureEntity.MustFlag = int.Parse(procedureTable.Rows[i]["MustFlag"].ToString());
            //    procedureEntity.CollectType = int.Parse(procedureTable.Rows[i]["CollectType"].ToString());
            //    procedureEntity.PieceType = int.Parse(procedureTable.Rows[i]["PieceType"].ToString());
            //    procedureEntity.IsSpecialRework = int.Parse(procedureTable.Rows[i]["isspecialrework"].ToString());
            //    procedureEntity.OrganizationID = int.Parse(procedureTable.Rows[i]["OrganizationID"].ToString());
            //    procedureEntity.Remarks = procedureTable.Rows[i]["Remarks"].ToString();
            //    procedureEntity.NodeNo = Convert.ToInt32(procedureTable.Rows[i]["NodeNo"]);
            //    // 对应产品信息
            //    DataRow[] goodsRows = this.ProductionDataSet.Tables["procedureGoodsTable"].Select("NodeNo =" + procedureTable.Rows[i]["NodeNo"].ToString());
            //    if (goodsRows != null && goodsRows.Length > 0)
            //    {

            //        procedureEntity.ProcedureGoodsTable = goodsRows.CopyToDataTable();
            //        procedureEntity.ProcedureGoodsTable.TableName = "procedureGoodsTable";
            //    }
            //    else
            //    {
            //        procedureEntity.ProcedureGoodsTable = this.ProductionDataSet.Tables["procedureGoodsTable"].Clone();
            //    }

            //    // 工序对应工号表
            //    DataRow[] userRows = this.ProductionDataSet.Tables["procedureUserTable"].Select("NodeNo =" + procedureTable.Rows[i]["NodeNo"].ToString());
            //    if (userRows != null && userRows.Length > 0)
            //    {
            //        procedureEntity.ProcedureUserTable = userRows.CopyToDataTable();
            //        procedureEntity.ProcedureUserTable.TableName = "procedureUserTable";
            //    }
            //    else
            //    {
            //        procedureEntity.ProcedureUserTable = this.ProductionDataSet.Tables["procedureUserTable"].Clone();
            //    }

            //    // 工序对应缺陷表(在检验工序中能检验出来的缺陷。)
            //    DataRow[] defectRows = this.ProductionDataSet.Tables["procedureDefectTable"].Select("NodeNo =" + procedureTable.Rows[i]["NodeNo"].ToString());
            //    if (defectRows != null && defectRows.Length > 0)
            //    {
            //        procedureEntity.ProcedureDefectTable = defectRows.CopyToDataTable();
            //        procedureEntity.ProcedureDefectTable.TableName = "procedureDefectTable";
            //    }
            //    else
            //    {
            //        procedureEntity.ProcedureDefectTable = this.ProductionDataSet.Tables["procedureDefectTable"].Clone();
            //    }

            //    // 生产工序对应缺陷表
            //    DataRow[] defectProcedureJobsRows = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Select("NodeNo =" + procedureTable.Rows[i]["NodeNo"].ToString());
            //    if (defectProcedureJobsRows != null && defectProcedureJobsRows.Length > 0)
            //    {
            //        procedureEntity.DefectProcedureJobsTable = defectProcedureJobsRows.CopyToDataTable();
            //        procedureEntity.DefectProcedureJobsTable.TableName = "defectProcedureJobsTable";
            //    }
            //    else
            //    {
            //        procedureEntity.DefectProcedureJobsTable = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Clone();
            //    }
            //    node.TagNonSerialized = procedureEntity;
            //    #endregion
            //}
            this.flowBox.RefreshItems();
            this.txtLineCode.Text = this._lineCode;
            this.txtLineName.Text = this._lineName;
            this.flowBox.NodeDoubleClick += flowBox_NodeDoubleClick;
            //if(this._currentnode!=null)
            //{
            //    if (this._currentnode.NodeImageType == 2)
            //    {
            //        F_PC_0206 frm0206 = new F_PC_0206(this._currentnode, this.flowBox);
            //        frm0206.ShowDialog();
            //    }
            //    else
            //    {
            //        F_PC_0207 frm0207 = new F_PC_0207(this._currentnode, this.flowBox);
            //        frm0207.ShowDialog();
            //    }
            //    this.flowBox.RefreshItems();
            //}
        }

        /// <summary>
        /// 节点双击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void flowBox_NodeDoubleClick(object sender, NodeEventArgs e)
        {
            if (e.Node.NodeImageType == 2)
            {
                F_PC_0206 frm0206 = new F_PC_0206(e.Node, this.flowBox);
                if (this._editStatus == Constant.FormMode.Edit)
                {
                    frm0206.IsReadOnlyCode = true;
                }
                frm0206.ShowDialog();
            }
            else
            {
                F_PC_0207 frm0207 = new F_PC_0207(e.Node, this.flowBox);
                if (this._editStatus == Constant.FormMode.Edit)
                {
                    frm0207.IsReadOnlyCode = true;
                }
                frm0207.ShowDialog();
            }
            this.flowBox.RefreshItems();
        }

        /// <summary>
        /// 设置按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnFlowSetting_Click(object sender, System.EventArgs e)
        {
            try
            {
                int w = Convert.ToInt32(txtFlowWidth.Text);
                int h = Convert.ToInt32(txtFlowHeigth.Text);
                this.flowBox.CanvasSize = new Size(w, h);
                this.flowBox.SaveFlow();
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        /// <summary>
        /// 计件模型按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnPiece_Click(object sender, EventArgs e)
        {
            try
            {

                FlowNode n = this.flowBox.DrawingNode();
                n.NodeImageType = 1;//计件模型
                ProcedureEntity entity = new ProcedureEntity();

                entity.NodeNo = n.ItemID;//(this.flowBox.AllNodes.Count - this.flowBox.DeletedNodes.Count) + _ValueFlagRow;
                entity.ProcedureCode = n.ItemID.ToString();
                entity.ProcedureName = n.Name;
                entity.CollectType = 1;
                entity.MustFlag = 1;
                entity.ProcedureModel = 1;
                entity.PieceType = 1;
                entity.ProcedureGoodsTable = this.ProductionDataSet.Tables["procedureGoodsTable"].Clone();
                entity.ProcedureUserTable = this.ProductionDataSet.Tables["procedureUserTable"].Clone();
                entity.ProcedureDefectTable = this.ProductionDataSet.Tables["procedureDefectTable"].Clone();
                entity.DefectProcedureJobsTable = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Clone();
                entity.ProcedureKilnTable = this.ProductionDataSet.Tables["procedureKilnTable"].Clone();
                n.TagNonSerialized = entity;
                n.NodeImage = this.btnPiece.BackgroundImage;
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        /// <summary>
        /// 检验模型按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCheck_Click(object sender, EventArgs e)
        {
            try
            {
                FlowNode n = this.flowBox.DrawingNode();
                n.NodeImageType = 2;//检验模型
                ProcedureEntity entity = new ProcedureEntity();
                entity.NodeNo = n.ItemID;//(this.flowBox.AllNodes.Count - this.flowBox.DeletedNodes.Count) + _ValueFlagRow;
                entity.ProcedureCode = n.ItemID.ToString();
                entity.ProcedureName = n.Name;
                entity.CollectType = 1;
                entity.MustFlag = 1;
                entity.ProcedureModel = 2;
                entity.PieceType = 1;
                entity.ProcedureGoodsTable = this.ProductionDataSet.Tables["procedureGoodsTable"].Clone();
                entity.ProcedureUserTable = this.ProductionDataSet.Tables["procedureUserTable"].Clone();
                entity.ProcedureDefectTable = this.ProductionDataSet.Tables["procedureDefectTable"].Clone();
                entity.DefectProcedureJobsTable = this.ProductionDataSet.Tables["defectProcedureJobsTable"].Clone();
                n.TagNonSerialized = entity;
                n.NodeImage = this.btnCheck.BackgroundImage;
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        /// <summary>
        /// 直接按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnLine_Click(object sender, EventArgs e)
        {
            FlowLine n = this.flowBox.DrawingLine();
            if (n == null)
            {
                MessageBox.Show(this.flowBox.BoxMode.ToString());
                return;
            }
            n.ShowName = false;
        }

        /// <summary>
        /// 保存按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                bool check = this.flowBox.CheckFlow();

                bool isRefresh = false;
                if (this._editStatus == Constant.FormMode.Edit)
                {
                    if (this.flowBox.DeletedNodes.Count > 0)
                    {
                        FlowNode[] flow = this.flowBox.DeletedNodes.ToArray();
                        for (int i = 0; i < flow.Length; i++)
                        {
                            bool isDelete = PCModuleProxy.Service.GetAllowDelete(((ProcedureEntity)flow[i].TagNonSerialized).ProcedureID);
                            if (isDelete)
                            {
                                this.flowBox.UndeleteNodeByNodeCode(flow[i].ItemCode);
                                MessageBox.Show(((ProcedureEntity)flow[i].TagNonSerialized).ProcedureName + "有在产产品不能删除",
                                    this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                                isRefresh = true;//
                                break;
                            }
                        }
                    }
                    this.flowBox.RefreshItems();
                }
                if (isRefresh)
                {
                    this.flowBox.CheckFlow();
                }
                // 校验
                if (!this.CheckIntegrity2())
                {
                    return;
                }
                this.SetPorcessFlow2(); //这个方法为干补也做了修改

                ProductionLineEntity productionLine = new ProductionLineEntity();
                if (this._editStatus == Constant.FormMode.Edit)
                {
                    productionLine.ProductionLineID = this._lineID;
                }
                else
                {
                    productionLine.ProductionLineID = 0;
                }

                productionLine.FlowXML = this.flowBox.SaveFlowXml();
                productionLine.ProductionLineCode = this.txtLineCode.Text.Trim();
                productionLine.ProductionLineName = this.txtLineName.Text.Trim();
                productionLine.Remarks = this._remarks;
                productionLine.OPTimeStamp = OPTimeStamp;
                // 节点对象
                List<ProcedureEntity> nodeList = new List<ProcedureEntity>();
                for (int i = 0; i < this.flowBox.AllNodes.Count; i++)
                {
                    FlowNode node = (FlowNode)this.flowBox.AllNodes[i];
                    ProcedureEntity procedure = node.TagNonSerialized as ProcedureEntity;
                    if (this._editStatus == Constant.FormMode.Edit)
                    {
                        if (node.NodeState == FlowNodeState.Added)
                        {
                            procedure.ProcedureState = 1;
                        }
                        else if (node.NodeState == FlowNodeState.Deleted)
                        {
                            procedure.ProcedureState = 2;
                        }
                        else
                        {
                            procedure.ProcedureState = 0;
                        }
                        nodeList.Add(procedure);
                    }
                    else
                    {
                        //新建或者是新建复制
                        if (node.NodeState == FlowNodeState.Added)
                        {
                            procedure.ProcedureState = 1;
                            nodeList.Add(procedure);
                        }
                        else if (node.NodeState == FlowNodeState.Deleted)
                        {
                            procedure.ProcedureState = 2;
                        }
                        else
                        {
                            procedure.ProcedureState = 0;
                            nodeList.Add(procedure);
                        }

                    }
                    //nodeList.Add(procedure);
                }

                //productionLine.ProcedureList = nodeList.ToArray();
                productionLine.ProcedureList = nodeList;
                int result = PCModuleProxy.Service.SaveProductionLine(productionLine);
                if (result > Constant.INT_IS_ZERO)
                {
                    IDList.Add(result);
                    this.ProductionlineCode = txtLineCode.Text;
                    MessageBox.Show(string.Format(Messages.MSG_CMN_I001, FormTitles.F_PC_0202, Constant.OPERATE_SAVE),
                        this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                    _hasClose = true;
                    this.DialogResult = DialogResult.OK;
                }
                else if (result == Constant.RETURN_IS_DATACHANGED)
                {
                    MessageBox.Show(Messages.MSG_CMN_W012,
                        this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                else if (result == Constant.RETURN_IS_EXIST)
                {
                    MessageBox.Show(string.Format(Messages.MSG_CMN_W006, "生产线编码"),
                        this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                else if (result == -10)
                {
                    MessageBox.Show("工序总数量超过了授权数量，如需增加授权，请联系东科。",
                        this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                else
                {
                    MessageBox.Show(string.Format(Messages.MSG_CMN_W001, FormTitles.F_PC_0202, Constant.OPERATE_SAVE),
                        this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                this.Close();
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        /// <summary>
        /// 关闭按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnClose_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        /// <summary>
        /// 画面关闭前提示
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void F_PC_0203_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (_hasClose)
            {
                return;
            }

            DialogResult dialogResult = MessageBox.Show("确定要放弃对生产线的编辑，并关闭画面",
                this.Text,
                MessageBoxButtons.OKCancel,
                MessageBoxIcon.Question,
                MessageBoxDefaultButton.Button2);
            if (dialogResult == DialogResult.Cancel)
            {
                e.Cancel = true;
            }
        }

        /// <summary>
        /// 导出图片
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExpImage_Click(object sender, EventArgs e)
        {
            try
            {
                saveFileDialog1.FileName = this.txtLineName.Text + ".png";
                DialogResult dr = saveFileDialog1.ShowDialog();
                if (dr != System.Windows.Forms.DialogResult.OK)
                {
                    return;
                }

                Bitmap b = new Bitmap(this.flowBox.CanvasImage);
                this.flowBox.CanvasControl.DrawToBitmap(b, new Rectangle(0, 0, b.Width, b.Height));
                b.Save(saveFileDialog1.FileName, System.Drawing.Imaging.ImageFormat.Png);
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }
        #endregion

        #region 私有方法

        /// <summary>
        /// 向前工序校验是否满足入窑工序
        /// </summary>
        /// <param name="node"></param>
        /// <param name="modelType"></param>
        private string BackIntoKilnCheck(FlowNode checkNode, FlowNode backNode)
        {
            if (backNode.InLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_INTOKILN + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_LOADCAR + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in backNode.InLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是装窑车的工序才符合入窑工序
                if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar)
                {
                    continue;
                }
                // 窑车补件工序除外
                if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.CarAdd)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_INTOKILN + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_LOADCAR + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = BackIntoKilnCheck(checkNode, line.NodeBegin);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验装窑车后是入窑工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="ForwardNode"></param>
        /// <returns></returns>
        private string ForwardLoadCarCheck(FlowNode checkNode, FlowNode ForwardNode)
        {
            if (ForwardNode.OutLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_LOADCAR + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_INTOKILN + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in ForwardNode.OutLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是入窑的工序才符合装窑车工序

                if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_LOADCAR + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_INTOKILN + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = ForwardLoadCarCheck(checkNode, line.NodeEnd);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验入窑后是出窑工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="ForwardNode"></param>
        /// <returns></returns>
        private string ForwardIntoKilnCheck(FlowNode checkNode, FlowNode ForwardNode)
        {
            if (ForwardNode.OutLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_INTOKILN + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_OUTKILN + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in checkNode.OutLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是出窑的工序才符合出窑工序
                if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_INTOKILN + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_OUTKILN + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = ForwardIntoKilnCheck(checkNode, line.NodeEnd);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验出窑工序后是卸窑车工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="ForwardNode"></param>
        /// <returns></returns>
        private string ForwardOutKilnCheck(FlowNode checkNode, FlowNode ForwardNode)
        {
            if (ForwardNode.OutLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_OUTKILN + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_UNLOADCAR + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in ForwardNode.OutLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是出窑的工序才符合出窑工序

                if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln
                    || ((ProcedureEntity)line.NodeEnd.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_OUTKILN + "工序，在后续工序流程中必须要经过" + Constant.PROCEDURE_UNLOADCAR + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = ForwardOutKilnCheck(checkNode, line.NodeEnd);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验出窑前工序是入窑工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="backNode"></param>
        /// <returns></returns>
        private string BackOutKilnCheck(FlowNode checkNode, FlowNode backNode)
        {
            if (backNode.InLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_OUTKILN + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_INTOKILN + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in backNode.InLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是入窑的工序才符合出窑工序
                if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_OUTKILN + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_INTOKILN + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = BackOutKilnCheck(checkNode, line.NodeBegin);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验卸窑车工序前工序是出窑工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="backNode"></param>
        /// <returns></returns>
        private string BackUnloadCarCheck(FlowNode checkNode, FlowNode backNode)
        {
            if (backNode.InLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_UNLOADCAR + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_OUTKILN + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in backNode.InLines)
            {
                // 只有最近 装窑车 入窑 出窑 卸窑车 工序中是入窑的工序才符合出窑工序
                if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.OutKiln)
                {
                    continue;
                }
                else if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.IntoKiln
                    || ((ProcedureEntity)line.NodeBegin.TagNonSerialized).ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_UNLOADCAR + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_OUTKILN + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = BackUnloadCarCheck(checkNode, line.NodeBegin);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验入窑前检验工序前工序是装窑车工序
        /// </summary>
        /// <param name="checkNode"></param>
        /// <param name="backNode"></param>
        /// <returns></returns>
        private string BackIntoKilnCheckCheck(FlowNode checkNode, FlowNode backNode)
        {
            if (backNode.InLines.Count == 0)
            {
                return string.Format("节点【{0}】是" + Constant.PROCEDURE_INTOKILNCHECK + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_LOADCAR + "工序！", checkNode.Name);
            }

            foreach (FlowLine line in backNode.InLines)
            {
                // 只有最近 装窑车工序才符合入窑前检验工序

                ProcedureEntity procedureEntity = line.NodeBegin.TagNonSerialized as ProcedureEntity;

                if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.LoadCar)
                {
                    continue;
                }
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.LoadCar
                    || procedureEntity.ModelType == (int)Constant.ProcedureModelType.IntoKiln
                    || procedureEntity.ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {
                    return string.Format("节点【{0}】是" + Constant.PROCEDURE_UNLOADCAR + "工序，在工序流程中必须先经过" + Constant.PROCEDURE_OUTKILN + "工序！", checkNode.Name);
                }

                // 递归校验下一个节点
                string err = BackIntoKilnCheckCheck(checkNode, line.NodeBegin);

                if (!string.IsNullOrEmpty(err))
                {
                    return err;
                }
            }
            return null;
        }

        /// <summary>
        /// 校验回环节点
        /// </summary>
        /// <param name="dic"></param>
        /// <param name="node"></param>
        /// <returns></returns>
        private bool LoopNodeCheck(FlowNode checkNode, FlowNode nextNode)
        {
            // 说明以后y有回环连接
            if (checkNode.Equals(nextNode))
            {
                return false;
            }
            else if (nextNode == null)
            {
                nextNode = checkNode;
            }
            if (checkNode.NextNodes.Contains(nextNode))
            {
                return true;
            }
            else
            {
                // 校验的节点放置到可到工序中，包括本身节点。
                checkNode.NextNodes.Add(nextNode);
            }
            // 下一个节点
            foreach (FlowLine line in nextNode.OutLines)
            {
                if (!LoopNodeCheck(checkNode, line.NodeEnd))
                {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// 元素的完整性检查
        /// </summary>
        public bool CheckIntegrity()
        {
            if (this.flowBox.CheckedNodes.Count == 0) //不包括删除的
            {
                MessageBox.Show("请配置工序节点！", "Error");
                return false;
            }

            // 连线校验
            for (int i = 0; i < this.flowBox.CheckedLines.Count; i++)
            {
                FlowLine line = (FlowLine)this.flowBox.CheckedLines[i];
                //开始端点没有连接
                if (line.NodeBegin == null)
                {
                    MessageBox.Show("连线【" + line.Name + "】开始端点没有连接节点！", "Error");
                    //line.Content = "开始端点没有连接节点";
                    // 选中该线
                    //SetSelectLine(line);
                    return false;
                }
                else if (line.NodeEnd == null)
                {
                    MessageBox.Show("连线【" + line.Name + "】结束端点没有连接节点！", "Error");
                    //line.Content = "结束端点没有连接节点";
                    //选中该线
                    //SetSelectLine(line);
                    return false;
                }

                //校验是否有2个以上的线开始端点和结束端点连接的都是一个节点（重复连接）
                for (int j = i + 1; j < this.flowBox.CheckedLines.Count; j++)
                {
                    FlowLine nextLine = (FlowLine)this.flowBox.CheckedLines[j];

                    if (line.NodeBegin.Equals(nextLine.NodeBegin)
                        && line.NodeEnd.Equals(nextLine.NodeEnd))
                    {
                        MessageBox.Show("连线【" + line.Name + "】与连线【" + nextLine.Name + "】属于重复连接节点！", "Error");
                        //line.Content = "连线与连线【" + nextLine.Content + "】属于重复连接节点";
                        //选中该线
                        //SetSelectLine(line);
                        return false;
                    }
                }
            }

            //结束节点的数量
            int endCount = 0;
            for (int i = 0; i < this.flowBox.CheckedNodes.Count; i++)
            {
                FlowNode node = (FlowNode)this.flowBox.CheckedNodes[i];

                ProcedureEntity procedureEntity = node.TagNonSerialized as ProcedureEntity;
                // 必填项校验
                if (procedureEntity.OrganizationID <= 0)
                {
                    MessageBox.Show("节点【" + node.Name + "】的组织机构不能为空！", "Error");
                    // 选中该节点
                    //SetSelectNode(node);
                    return false;
                }
                // 校验回环节点
                //node.NextNodes = new List<FlowNode>();
                if (!LoopNodeCheck(node, null))
                {
                    MessageBox.Show("有循环节点存在，请重新设置！", "Error");
                    return false;
                }

                // 开始节点
                if (node.InLines.Count == 0)
                {
                    // 开始节点校验
                    // 孤立的节点
                    if (node.OutLines.Count == 0)
                    {
                        MessageBox.Show("节点【" + node.Name + "】是孤立工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }
                    // 开始节点不能是成验和入窑前检验节点
                    else if (node.NodeImageType != 1)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】不能是成品检验或者入窑前检验工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;

                    }
                    if (procedureEntity.MustFlag == Constant.ProcedureMustFlag.NonMust.GetHashCode())
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】不能是非必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    // 开始工序必须为交坯或特殊返工工序
                    // 注释 先不做校验
                    //if (node.ProcedureEntity.IsSpecialRework != 1 && node.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.DeliverAdobe)
                    //{
                    //    MessageForm.Show("开始节点【" + node.NodeText + "】必须为交坯或特殊返工工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //} 

                    // 开始节点如果是特定返工工序就必须与（标准计件或装窑车）组合
                    else if (procedureEntity.IsSpecialRework == (int)Constant.SpecialReworkFlag.Yes
                        && procedureEntity.ModelType != (int)Constant.ProcedureModelType.Normal
                        && procedureEntity.ModelType != (int)Constant.ProcedureModelType.LoadCar)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】是特定返工工序时，工序类别必须是" + Constant.PROCEDURE_NORMAL + "或" + Constant.PROCEDURE_LOADCAR + "！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    // 暂时不需要校验
                    // 开始节点如果是非特定返工工序那必须与交坯组合
                    //else if (node.ProcedureEntity.IsSpecialRework == 0
                    //    && node.ProcedureEntity.ModelType != 5)
                    //{
                    //    MessageForm.Show("开始节点【" + node.NodeText + "】工序类别是" + Constant.PROCEDURE_DELIVERADOBE + "时，不能是特定返工工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                    // 交坯工序必须为必须工序
                    else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.DeliverMud && procedureEntity.MustFlag == 0)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】是" + Constant.PROCEDURE_DELIVERADOBE + "工序时为必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    // 开始工序不能为窑车补件工序
                    else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.CarAdd)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】工序类别不能是" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }


                    // 开始工序标识
                    procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Begin;

                    // 特殊返工工序 将工序节点类型修改成中间工序
                    if (procedureEntity.IsSpecialRework == Constant.SpecialReworkFlag.Yes.GetHashCode())
                    {
                        procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Middle;
                    }
                }
                // 过程节点
                else
                {
                    //过程节点校验

                    #region 中间节点不能设置为特殊返工工序
                    if (procedureEntity.IsSpecialRework == (int)Constant.SpecialReworkFlag.Yes)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】不能设置为特殊返工工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    #endregion


                    #region 校验坯库工序
                    if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.AdobeStock)
                    {
                        // 坯库工序必须指向唯一一个窑车补件工序
                        if (node.OutLines.Count > 1 || node.OutLines.Count == 0)
                        {
                            MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_ADOBESTOCK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                            // 选中该节点
                            // SetSelectNode(node);
                            return false;
                        }
                        else
                        {
                            // 坯库工序所指向的节点不是窑车补件
                            ProcedureEntity ProcedureEntityEnd = node.OutLines[0].NodeEnd.TagNonSerialized as ProcedureEntity;

                            if (ProcedureEntityEnd.ModelType != (int)Constant.ProcedureModelType.CarAdd)
                            {
                                MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_ADOBESTOCK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                                // 选中该节点
                                // SetSelectNode(node);
                                return false;
                            }
                        }
                    }
                    #endregion

                    #region 入窑前检验
                    if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.IntoKilnCheck)
                    {
                        // 入窑前检验前一个工序必须是装窑车
                        string err = BackIntoKilnCheckCheck(node, node);
                        if (!string.IsNullOrEmpty(err))
                        {
                            MessageBox.Show(err, "Error");
                            // 选中该节点
                            //SetSelectNode(node);
                            return false;
                        }


                        // 入窑前检验工序必须指向唯一一个坯库工序
                        // 入窑前检验工序必须指向唯一一个窑车补件工序
                        if (node.OutLines.Count != 1)
                        {
                            MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILNCHECK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                            // 选中该节点
                            //SetSelectNode(node);
                            return false;
                        }
                        else


                            if (((ProcedureEntity)node.OutLines[0].NodeEnd.TagNonSerialized).ModelType != (int)Constant.ProcedureModelType.AdobeStock)
                            {
                                MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILNCHECK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                                // 选中该节点
                                //SetSelectNode(node);
                                return false;
                            }
                    }

                }
                    #endregion

                #region 窑车补件
                if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.CarAdd)
                {
                    if (node.InLines.Count != 1)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_CARADD
                            + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                    // 前第一个工序不是坯库
                    if (((ProcedureEntity)node.InLines[0].NodeBegin.TagNonSerialized).ModelType != (int)Constant.ProcedureModelType.AdobeStock)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_CARADD
                             + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                    // 第二个前工序既不是坯库也不是入窑前检验
                    //if (node.InLines[1].StartNode.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.AdobeStock
                    //    && node.InLines[1].StartNode.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.IntoKilnCheck)
                    //{
                    //    MessageForm.Show("中间节点【" + node.NodeText + "】是" + Constant.PROCEDURE_CARADD + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "和" + Constant.PROCEDURE_INTOKILNCHECK + "工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}
                }

                #endregion
                //装窑车工序
                if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.LoadCar)
                {

                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_LOADCAR + "工序，要求为必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                    // 校验装窑车后是入窑工序
                    string err = ForwardLoadCarCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                }
                // 入窑工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.IntoKiln)
                {

                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILN + "工序，要求为必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }


                    // 校验入窑工序前工序是否经过装窑车
                    string err = BackIntoKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }


                    // 校验入窑工序后工序是出窑工序
                    //err = ForwardIntoKilnCheck(node, node);
                    //if (!string.IsNullOrEmpty(err))
                    //{
                    //    MessageForm.Show(err, "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                }
                // 出窑工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.OutKiln)
                {

                    //if (node.ProcedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    //{
                    //    MessageForm.Show("中间节点【" + node.NodeText + "】是" + Constant.PROCEDURE_OUTKILN + "工序，要求为必须工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}


                    // 校验出窑前工序是入窑工序
                    string err = BackOutKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }


                    //校验出窑工序后工序是卸窑车工序
                    err = ForwardOutKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                }
                // 卸窑车工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {

                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_UNLOADCAR + "工序，要求为必须工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }


                    //校验卸窑车前工序是出窑工序
                    //string err = BackUnloadCarCheck(node, node);
                    //if (!string.IsNullOrEmpty(err))
                    //{
                    //    MessageForm.Show(err, "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                }
                // 过程节点
                if (node.OutLines.Count > 0)
                {
                    // 过程（中间）工序标识
                    procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Middle;
                }
                // 结束节点
                else
                {
                    endCount++;
                    // 结束工序标识
                    procedureEntity.NodeType = (int)Constant.ProcedureNodeType.End;

                    //if (endCount > 1)
                    //{
                    //    MessageBox.Show("生产线只能有一个结束节点！", "Error");
                    //    // 选中该节点
                    //    // SetSelectNode(node);
                    //    return false;
                    //}
                }

            }
            return true;
        }

        /// <summary>
        /// 设置工序前后所到达的工序
        /// </summary>
        public void SetPorcessFlow()
        {
            foreach (var item in this.flowBox.CheckedNodes)
            {
                FlowNode node = (FlowNode)item;
                List<ProcedureFlowEntity> flowList = new List<ProcedureFlowEntity>();

                // 后工序，可以到达的下一个节点
                SetArrive(node, node, flowList);
                // 前工序，能到达此工序的工序
                SetFrom(node, node, flowList);
                //((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = flowList.ToArray();
                ((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = flowList;

            }
        }

        /// <summary>
        /// 后工序，可以到达的下一个节点
        /// </summary>
        /// <param name="node"></param>
        /// <param name="nextNode"></param>
        private void SetArrive(FlowNode node, FlowNode nextNode, List<ProcedureFlowEntity> flowList)
        {
            foreach (FlowLine line in nextNode.OutLines)
            {
                if (flowList.Where(p => p.ArriveNodeNo == (line.NodeEnd.TagNonSerialized as ProcedureEntity).NodeNo).Count() == 0)
                {
                    // 添加
                    flowList.Add(new ProcedureFlowEntity()
                    {
                        FlowFlag = (int)Constant.FlowFlag.Next,
                        ArriveNodeNo = (line.NodeEnd.TagNonSerialized as ProcedureEntity).NodeNo,
                    });
                    //ItemID
                }

                // 非必须工序 可以到达下一个节点
                if (((ProcedureEntity)line.NodeEnd.TagNonSerialized).MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                {
                    SetArrive(node, line.NodeEnd, flowList);
                }
            }
        }
        /// <summary>
        /// 前工序，能到达此工序的工序
        /// </summary>
        /// <param name="node"></param>
        /// <param name="fromNode"></param>
        private void SetFrom(FlowNode node, FlowNode fromNode, List<ProcedureFlowEntity> flowList)
        {
            foreach (FlowLine line in fromNode.InLines)
            {
                //if (flowList.Where(p => p.ArriveNodeNo == line.NodeEnd.ItemID).Count() == 0)
                if (flowList.Where(p => p.ArriveNodeNo == (line.NodeBegin.TagNonSerialized as ProcedureEntity).NodeNo).Count() == 0)
                {
                    // 添加
                    flowList.Add(new ProcedureFlowEntity()
                    {
                        FlowFlag = (int)Constant.FlowFlag.Previous,
                        ArriveNodeNo = (line.NodeBegin.TagNonSerialized as ProcedureEntity).NodeNo,

                    });
                    //line.NodeBegin.ItemID
                }

                // 非必须工序 可以到达下一个节点
                if (((ProcedureEntity)line.NodeBegin.TagNonSerialized).MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                {
                    SetFrom(node, line.NodeBegin, flowList);
                }
            }
        }

        /// <summary>
        /// 元素的完整性检查(干补)
        /// </summary>
        public bool CheckIntegrity2()
        {
            if (this.flowBox.CheckedNodes.Count == 0) //不包括删除的
            {
                MessageBox.Show("请配置工序节点！", "Error");
                return false;
            }

            // 连线校验
            for (int i = 0; i < this.flowBox.CheckedLines.Count; i++)
            {
                FlowLine line = (FlowLine)this.flowBox.CheckedLines[i];
                //开始端点没有连接
                if (line.NodeBegin == null)
                {
                    MessageBox.Show("连线【" + line.Name + "】开始端点没有连接节点！", "Error");
                    //line.Content = "开始端点没有连接节点";
                    // 选中该线
                    //SetSelectLine(line);
                    return false;
                }
                else if (line.NodeEnd == null)
                {
                    MessageBox.Show("连线【" + line.Name + "】结束端点没有连接节点！", "Error");
                    //line.Content = "结束端点没有连接节点";
                    //选中该线
                    //SetSelectLine(line);
                    return false;
                }

                //干补判断

                if (line.NodeBegin != null)
                {
                    if (((ProcedureEntity)line.NodeBegin.TagNonSerialized as ProcedureEntity).ModelType == 8)
                    {
                        MessageBox.Show("连线【" + line.Name + "】开始端点不能连接干补节点！", "Error");
                        return false;
                    }
                    // wangx 2017-7-20
                    if (((ProcedureEntity)line.NodeEnd.TagNonSerialized as ProcedureEntity).ModelType == 8)
                    {
                        MessageBox.Show("连线【" + line.Name + "】结束端点不能连接干补节点！", "Error");
                        return false;
                    }

                    if (((ProcedureEntity)line.NodeEnd.TagNonSerialized as ProcedureEntity).ModelType == 9)
                    {
                        MessageBox.Show("连线【" + line.Name + "】结束端点不能连接回收节点！", "Error");
                        return false;
                    }
                    // wangx 2017-7-20 end
                  
                }
                else if (line.NodeEnd != null)
                {
                    if (((ProcedureEntity)line.NodeBegin.TagNonSerialized as ProcedureEntity).ModelType == 8)
                    {
                        MessageBox.Show("连线【" + line.Name + "】结束端点不能连接干补节点！", "Error");
                        return false;
                    }
                    
                }

                //干补判断


                //校验是否有2个以上的线开始端点和结束端点连接的都是一个节点（重复连接）
                for (int j = i + 1; j < this.flowBox.CheckedLines.Count; j++)
                {
                    FlowLine nextLine = (FlowLine)this.flowBox.CheckedLines[j];

                    if (line.NodeBegin.Equals(nextLine.NodeBegin)
                        && line.NodeEnd.Equals(nextLine.NodeEnd))
                    {
                        MessageBox.Show("连线【" + line.Name + "】与连线【" + nextLine.Name + "】属于重复连接节点！", "Error");
                        //line.Content = "连线与连线【" + nextLine.Content + "】属于重复连接节点";
                        //选中该线
                        //SetSelectLine(line);
                        return false;
                    }
                }
            }
            DataTable procedureTable = this.ProductionDataSet.Tables["procedureTable"];
            if (this._ValueFlagRow > 0)
            {
                bool existProcedureCode = false;
                string ProcedureCode = "";
                string ProcedureName = "";
                for (int i = 0; i < this.flowBox.CheckedNodes.Count; i++)
                {
                    FlowNode node = (FlowNode)this.flowBox.CheckedNodes[i];

                    ProcedureEntity procedureEntity = node.TagNonSerialized as ProcedureEntity;
                    DataRow[] dr = procedureTable.Select("ValueFlag=0 and ProcedureCode='" + procedureEntity.ProcedureCode + "'");
                    if (dr.Length > 0)
                    {
                        existProcedureCode = true;
                        ProcedureCode = procedureEntity.ProcedureCode;
                        ProcedureName = procedureEntity.ProcedureName;
                        break;
                    }
                }
                if (existProcedureCode)
                {
                    MessageBox.Show(ProcedureName + "工序【" + ProcedureCode + "】编码已经存在！", "Error");
                    return false;
                }
            }

            //结束节点的数量
            int endCount = 0;
            for (int i = 0; i < this.flowBox.CheckedNodes.Count; i++)
            {
                FlowNode node = (FlowNode)this.flowBox.CheckedNodes[i];

                ProcedureEntity procedureEntity = node.TagNonSerialized as ProcedureEntity;

                // 必填项校验
                if (procedureEntity.OrganizationID <= 0)
                {
                    MessageBox.Show("节点【" + node.Name + "】的组织机构不能为空！", "Error");
                    // 选中该节点
                    //SetSelectNode(node);
                    return false;
                }
                // 校验回环节点
                //node.NextNodes = new List<FlowNode>();
                if (!LoopNodeCheck(node, null))
                {
                    MessageBox.Show("有循环节点存在，请重新设置！", "Error");
                    return false;
                }
                // 开始节点
                if (node.InLines.Count == 0)
                {
                    // 开始节点校验
                    // 孤立的节点
                    //if (node.OutLines.Count == 0)
                    if (node.OutLines.Count == 0 && procedureEntity.ModelType != 8)
                    {
                        MessageBox.Show("节点【" + node.Name + "】是孤立工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }
                    // 开始节点不能是成验和入窑前检验节点
                    else if (node.NodeImageType != 1)
                    {
                        //if (procedureEntity.ModelType!= 0)
                        //{
                        MessageBox.Show("开始节点【" + node.Name + "】不能是成品检验或者入窑前检验工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                        // }

                    }
                    // 开始节点可以非必须
                    //if (procedureEntity.MustFlag == Constant.ProcedureMustFlag.NonMust.GetHashCode())
                    //{
                    //    MessageBox.Show("开始节点【" + node.Name + "】不能是非必须工序！", "Error");
                    //    // 选中该节点
                    //    //SetSelectNode(node);
                    //    return false;
                    //}
                    // 开始工序必须为交坯或特殊返工工序
                    // 注释 先不做校验
                    //if (node.ProcedureEntity.IsSpecialRework != 1 && node.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.DeliverAdobe)
                    //{
                    //    MessageForm.Show("开始节点【" + node.NodeText + "】必须为交坯或特殊返工工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //} 

                    // 开始节点如果是特定返工工序就必须与（标准计件或装窑车）组合
                    else if (procedureEntity.IsSpecialRework == (int)Constant.SpecialReworkFlag.Yes
                        && procedureEntity.ModelType != (int)Constant.ProcedureModelType.Normal
                        && procedureEntity.ModelType != (int)Constant.ProcedureModelType.LoadCar)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】是特定返工工序时，工序类别必须是" + Constant.PROCEDURE_NORMAL + "或" + Constant.PROCEDURE_LOADCAR + "！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    // 暂时不需要校验
                    // 开始节点如果是非特定返工工序那必须与交坯组合
                    //else if (node.ProcedureEntity.IsSpecialRework == 0
                    //    && node.ProcedureEntity.ModelType != 5)
                    //{
                    //    MessageForm.Show("开始节点【" + node.NodeText + "】工序类别是" + Constant.PROCEDURE_DELIVERADOBE + "时，不能是特定返工工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                    // 交坯工序必须为必须工序
                    else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.DeliverMud && procedureEntity.MustFlag == 0)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】是" + Constant.PROCEDURE_DELIVERADOBE + "工序时为必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    // 开始工序不能为窑车补件工序
                    else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.CarAdd)
                    {
                        MessageBox.Show("开始节点【" + node.Name + "】工序类别不能是" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }


                    // 开始工序标识
                    procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Begin;

                    // 特殊返工工序 将工序节点类型修改成中间工序
                    if (procedureEntity.IsSpecialRework == Constant.SpecialReworkFlag.Yes.GetHashCode())
                    {
                        procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Middle;
                    }
                }
                // 过程节点
                else
                {
                    //过程节点校验

                    #region 中间节点不能设置为特殊返工工序
                    if (procedureEntity.IsSpecialRework == (int)Constant.SpecialReworkFlag.Yes)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】不能设置为特殊返工工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }
                    #endregion

                    #region 校验坯库工序
                    if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.AdobeStock)
                    {
                        // 坯库工序必须指向唯一一个窑车补件工序
                        if (node.OutLines.Count > 1 || node.OutLines.Count == 0)
                        {
                            MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_ADOBESTOCK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                            // 选中该节点
                            // SetSelectNode(node);
                            return false;
                        }
                        else
                        {
                            // 坯库工序所指向的节点不是窑车补件
                            ProcedureEntity ProcedureEntityEnd = node.OutLines[0].NodeEnd.TagNonSerialized as ProcedureEntity;

                            if (ProcedureEntityEnd.ModelType != (int)Constant.ProcedureModelType.CarAdd)
                            {
                                MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_ADOBESTOCK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_CARADD + "工序！", "Error");
                                // 选中该节点
                                // SetSelectNode(node);
                                return false;
                            }
                        }
                    }
                    #endregion

                    #region 入窑前检验
                    if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.IntoKilnCheck)
                    {
                        // 入窑前检验前一个工序必须是装窑车
                        string err = BackIntoKilnCheckCheck(node, node);
                        if (!string.IsNullOrEmpty(err))
                        {
                            MessageBox.Show(err, "Error");
                            // 选中该节点
                            //SetSelectNode(node);
                            return false;
                        }


                        // 入窑前检验工序必须指向唯一一个坯库工序
                        // 入窑前检验工序必须指向唯一一个窑车补件工序
                        if (node.OutLines.Count != 1)
                        {
                            MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILNCHECK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                            // 选中该节点
                            //SetSelectNode(node);
                            return false;
                        }
                        // wangxin 2015/4/16  
                        //else


                        //    if (((ProcedureEntity)node.OutLines[0].NodeEnd.TagNonSerialized).ModelType != (int)Constant.ProcedureModelType.AdobeStock)
                        //    {
                        //        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILNCHECK + "工序，要求必须指向唯一一个" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                        //        // 选中该节点
                        //        //SetSelectNode(node);
                        //        return false;
                        //    }
                        // wangxin 2015/4/16 end
                    }
                    #endregion
                }


                #region 窑车补件
                if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.CarAdd)
                {
                    // wangxin 2015/4/16  
                    //if (node.InLines.Count != 1)
                    //{
                    //    MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_CARADD
                    //        + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                    //    // 选中该节点
                    //    //SetSelectNode(node);
                    //    return false;
                    //}


                    // 前第一个工序不是坯库
                    //if (((ProcedureEntity)node.InLines[0].NodeBegin.TagNonSerialized).ModelType != (int)Constant.ProcedureModelType.AdobeStock)
                    //{
                    //    MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_CARADD
                    //         + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "工序！", "Error");
                    //    // 选中该节点
                    //    //SetSelectNode(node);
                    //    return false;
                    //}
                    // wangxin 2015/4/16   end 

                    // 第二个前工序既不是坯库也不是入窑前检验
                    //if (node.InLines[1].StartNode.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.AdobeStock
                    //    && node.InLines[1].StartNode.ProcedureEntity.ModelType != (int)Constant.ProcedureModelType.IntoKilnCheck)
                    //{
                    //    MessageForm.Show("中间节点【" + node.NodeText + "】是" + Constant.PROCEDURE_CARADD + "工序，要求前工序必须是" + Constant.PROCEDURE_ADOBESTOCK + "和" + Constant.PROCEDURE_INTOKILNCHECK + "工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}
                }

                #endregion

                #region 装窑车工序
                if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.LoadCar)
                {

                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_LOADCAR + "工序，要求为必须工序！", "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                    // modify 2015/06/01 wangx begin
                    //// 校验装窑车后是入窑工序
                    //string err = ForwardLoadCarCheck(node, node);
                    //if (!string.IsNullOrEmpty(err))
                    //{
                    //    MessageBox.Show(err, "Error");

                    //    return false;
                    //}
                    // modify 2015/06/01 wangx end

                }
                #endregion

                #region 入窑工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.IntoKiln)
                {
                    // modify 2015/06/01 wangx begin
                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        // MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_INTOKILN + "工序，要求为必须工序！", "Error");
                        // return false;
                    }
                    // modify 2015/06/01 wangx end

                    // 校验入窑工序前工序是否经过装窑车
                    string err = BackIntoKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }


                    // 校验入窑工序后工序是出窑工序
                    //err = ForwardIntoKilnCheck(node, node);
                    //if (!string.IsNullOrEmpty(err))
                    //{
                    //    MessageForm.Show(err, "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                }
                #endregion

                #region 出窑工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.OutKiln)
                {

                    //if (node.ProcedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    //{
                    //    MessageForm.Show("中间节点【" + node.NodeText + "】是" + Constant.PROCEDURE_OUTKILN + "工序，要求为必须工序！", "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}


                    // 校验出窑前工序是入窑工序
                    string err = BackOutKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }


                    //校验出窑工序后工序是卸窑车工序
                    err = ForwardOutKilnCheck(node, node);
                    if (!string.IsNullOrEmpty(err))
                    {
                        MessageBox.Show(err, "Error");
                        // 选中该节点
                        //SetSelectNode(node);
                        return false;
                    }

                }
                #endregion

                #region 卸窑车工序
                else if (procedureEntity.ModelType == (int)Constant.ProcedureModelType.UnloadCar)
                {

                    if (procedureEntity.MustFlag == (int)Constant.ProcedureMustFlag.NonMust)
                    {
                        MessageBox.Show("中间节点【" + node.Name + "】是" + Constant.PROCEDURE_UNLOADCAR + "工序，要求为必须工序！", "Error");
                        // 选中该节点
                        // SetSelectNode(node);
                        return false;
                    }


                    //校验卸窑车前工序是出窑工序
                    //string err = BackUnloadCarCheck(node, node);
                    //if (!string.IsNullOrEmpty(err))
                    //{
                    //    MessageForm.Show(err, "Error");
                    //    // 选中该节点
                    //    SetSelectNode(node);
                    //    return false;
                    //}

                }
                #endregion
                // 过程节点
                if (node.OutLines.Count > 0)
                {
                    // 过程（中间）工序标识
                    if (node.InLines.Count > 0)
                    {
                        if (node.CheckedNodeType == FlowNodeType.Begin)
                        { procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Begin; }
                        else{ procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Middle; }
                        
                    }
                    else
                    {
                        if (procedureEntity.IsSpecialRework == Constant.SpecialReworkFlag.Yes.GetHashCode())
                        {
                            procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Middle;
                        }
                        else
                        {
                            procedureEntity.NodeType = (int)Constant.ProcedureNodeType.Begin;
                        }
                    }
                }
                // 结束节点
                else
                {
                    if (procedureEntity.ModelType != 8)
                    {
                        //this._procedureEntity.NodeType != (int)Constant.ProcedureNodeType.End
                        if (procedureEntity.ModelType == (int)Dongke.IBOSS.PRD.Basics.BaseResources.Constant.ProcedureModelType.Normal
                            && procedureEntity.UnDo == 1)
                        {
                            MessageBox.Show("结束节点" + node.Name + "不能撤销计件！", "Error");
                            return false;
                        }
                        endCount++;
                    }
                    // 结束工序标识
                    procedureEntity.NodeType = (int)Constant.ProcedureNodeType.End;

                    //if (endCount > 1)
                    //{
                    //    MessageBox.Show("生产线只能有一个结束节点！", "Error");
                    //    // 选中该节点
                    //    // SetSelectNode(node);
                    //    return false;
                    //}
                }

            }
            return true;
        }

        /// <summary>
        /// 设置工序前后所到达的工序
        /// </summary>
        public void SetPorcessFlow2()
        {
            foreach (var item in this.flowBox.CheckedNodes)
            {
                FlowNode node = (FlowNode)item;
                List<ProcedureFlowEntity> flowList = new List<ProcedureFlowEntity>();

                // 后工序，可以到达的下一个节点
                SetArrive(node, node, flowList);
                // 前工序，能到达此工序的工序
                SetFrom(node, node, flowList);

                //((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = flowList.ToArray();
                if (((ProcedureEntity)node.TagNonSerialized).ModelType == 8)//干补
                {
                    ((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = null;
                    ((ProcedureEntity)node.TagNonSerialized).NodeType = 2;
                }
                else
                {
                    if (((ProcedureEntity)node.TagNonSerialized).ModelType == 9)//回收
                    {
                        ((ProcedureEntity)node.TagNonSerialized).NodeType = 2;
                    }
                    //((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = flowList.ToArray();
                    ((ProcedureEntity)node.TagNonSerialized).ProcedureFlowDetailList = flowList;
                }
            }
        }
        #endregion
    }
}