using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Resources;
using CommonLib;
using DBFactory;
using ICommLayer;
using CommLayerFactory;
using System.Globalization;
using System.Net;
namespace WcfControlMonitorLib
{
    /// <summary>
    /// Creator:Richard.liu
    /// 获得设备状态类
    /// 
    /// 需要做的工作：
    /// 1.下位机给上位机发送设备（任务）状态信息（正在执行状态或者报警的设备所处调度路径的F_SerialNumber》=当前值）
    /// 2.（单独处理）下位机给上位机发送条码信息（托盘条码，烟箱一号工程码）
    /// 3.（单独处理）下位机给上位机发送现场控制触摸屏申请信号：1-重发当前设备指令
    ///     2-申请修改当前设备所执行任务的目标位置
    /// 4.跟踪货物运行到的位置（多个调度任务在执行同一个调度任务，取有探物的为当前位置）
    ///     并且判断是否存在提前触发任务
    /// 5.获取调度任务的优先策略判断：最短路径优先，
    /// 入库优先携带出库，出库优先携带入库等
    /// 6.任务号传递到当前设备时，把本路径的前一设备的运行锁解除，
    ///     同时把当前设备加运行锁
    /// 7.（根据故障点单独处理）调度路径是否可用的分析以及给管理进行反馈
    /// 8.（单独处理）创建自动调度任务
    /// 9.动画显示设备状态
    /// </summary>
    public class CGetState
    {
        public static event CDataSourceChangeEventHandler DataChange;
        public static void OnDataChange(object sender, CDataChangeEventArgs e)
        {
            if (DataChange != null)
            {
                DataChange(sender, e);
            }
        }
        public static event RefreshMonitorEventHandler RefreshMonitor;
        public static void OnRefreshMonitor(RefreshMonitorEventArgs e)
        {
            if (RefreshMonitor != null)
            {
                RefreshMonitor(e);
            }
        }
        char[] dd = new char[1] { '.' };//20101124
        //string[] DS;//20101124
        StringBuilder sql = new StringBuilder();
        Model.MError errs;
        Model.MDevice devinfo;
        Model.MDevice devinfo1;
        ISendDeviceOrder sdo;
        StringBuilder[] wv = { new StringBuilder("2") };
        StringBuilder[] witemnames = { new StringBuilder("") };
        IGetDeviceState gds;
        CCommonFunction ccf = new CCommonFunction();
        DBOperator dbo = CStaticClass.dbo;
        DBOperator dboM = CStaticClass.dboM;
        //20100108
        CControl ccl = new CControl();
        string _CGetStateError = "";//监控调度类错误说明
        public string CGetStateError
        {
            get { return _CGetStateError; }
            set
            {
                _CGetStateError = value;
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", _CGetStateError);
                OnRefreshMonitor(rmea);
            }
        }
        public int[] _States;
        int _fid;
        int _mti;
        //int _relativeFID;
        //int _iotype=0;
        //int _endnode=0;
        /// <summary>
        /// 获得所有正在执行设备的状态
        /// </summary>
        public CGetState()
        {
            dbo.Open();
            if (dboM.Open() == false)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "连接管理数据库失败！！！");
                OnRefreshMonitor(rmea);
            }

        }

        /// <summary>
        /// 获得反馈信息
        ///电器反馈该设备的"完成"时 删除设备指令 , 解除设备表占用状态F_LockedState=0；
        ///路径明细表F_LockedDeviceIndex里的所有对应设备索引解锁;
        /// 
        ///判断是最后一个设备指令吗? 是,回写调度任务IO_Control的FSTATUS=2即"搬运完成";
        /// T_Manage_Task的正在执行状态FSTATUS=2 ；
        /// </summary>
        /// <returns></returns>
        public void GetDeviceState()
        {

            DataView dv = new DataView();

            DataView dvm = new DataView();

            DataView dvmo = new DataView();

            DataView dd = new DataView();
            try
            {

                int devKind;

                int DeviceIdx;
                int TaskIdx = 0;

                //20100617增加和管理交互虚拟设备,类型30
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_DeviceIndex,F_DeviceKindIndex,F_MaxSendCount,F_SendInterval FROM T_Base_Device WHERE (F_DeviceKindIndex = 1) OR (F_DeviceKindIndex = 2) OR (F_DeviceKindIndex = 4) OR (F_DeviceKindIndex = 7) OR (F_DeviceKindIndex = 6) OR (F_DeviceKindIndex = 30)");
                dd = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                for (int j = 0; j < dd.Count; j++)
                {

                    DeviceIdx = Convert.ToInt32(dd[j]["F_DeviceIndex"]);
                    devKind = Convert.ToInt32(dd[j]["F_DeviceKindIndex"]);
                    //20100609
                    devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);

                    //20091107
                    #region 发送后规定时间内没报开始或者读取数据成功需要进行超时重发，重发超限时报错
                    if (devKind == 6) //延吉烟厂只有AGV需要重新发送
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("select F_MonitorIndex,F_DeviceIndex,F_SendCount,F_StartTime,F_Status,F_AgvNo from T_Monitor_Task where F_DeviceIndex=").Append(DeviceIdx).Append(" and f_status=1 and F_SendFlag='1'");
                        dvmo = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20100905只重发主任务
                        if (dvmo.Count > 0)
                        {//20110510
                            TaskIdx = Convert.ToInt32(dvmo[0]["F_MonitorIndex"]);
                            int scount = Convert.ToInt32(dvmo[0]["F_SendCount"]);
                            scount++;
                            if (scount > Convert.ToInt32(dd[j]["F_MaxSendCount"]))
                            {
                                //发送次数超限报警
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Monitor_Task set F_Status=999 where F_Status<>999 and F_MonitorIndex=").Append(TaskIdx);//20110505
                                dbo.ExceSQL(sql.ToString());

                            }
                            else
                            {
                                //DateTime.Now.AddMilliseconds
                                if (dvmo[0]["F_StartTime"].ToString() != "-")
                                {
                                    if (Convert.ToDateTime(dvmo[0]["F_StartTime"].ToString().Substring(0, 19), CultureInfo.CurrentCulture).AddMilliseconds(Convert.ToDouble(dd[j]["F_SendInterval"])) <= DateTime.Now)
                                    {
                                        if (devKind == 2)
                                        {
                                            //20110510输送机零
                                            sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                                            sdo.SendDeviceOrder(0, 0, 0, DeviceIdx, 0);

                                        }
                                        if (dvmo[0]["F_AgvNo"] == DBNull.Value)
                                        {
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Base_Device set F_LockedState=0 where F_DeviceIndex=").Append(DeviceIdx);
                                            dbo.ExceSQL(sql.ToString());
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Monitor_Task set F_SendCount=").Append(scount).Append(",F_Status=0 where F_MonitorIndex=").Append(TaskIdx);
                                            dbo.ExceSQL(sql.ToString());
                                        }
                                        CommonClassLib.CCarryConvert.WriteDarkCasket("GetDeviceState", "超时重发", DeviceIdx.ToString(), "设备指令索引：" + TaskIdx.ToString() + "发送后，一直没有报告执行或者完成，重新发送命令！");
                                    }
                                }
                            }
                        }
                    }
                    #endregion

                    #region 优化调度
                    //if (devinfo.NeedOptimize.ToString() == "1" )
                    //{//此设备需要优化调度，直接到表：T_Monitor_Task_Child查找设备状态
                    //    sqlNO = "SELECT F_MonitorIndex, F_DeviceIndex, F_Status FROM T_Monitor_Task_Child WHERE (F_Status = 1) AND (F_MonitorIndex = " + TaskIdx + ")";
                    //    dvNO = dbo.ExceSQL(sqlNO).Tables[0].DefaultView ;
                    //    if (dvNO.Count > 0)
                    //    {
                    //        DeviceIdx = Convert.ToInt32(dvNO[0]["F_DeviceIndex"]);
                    //        GetKindDeviceState(TaskIdx, DeviceIdx,Convert.ToInt32( dv[i]["F_RouteID"]));
                    //        continue;
                    //    }
                    //    else
                    //    {
                    //        continue;
                    //    }

                    //}
                    #endregion
                    //AGV //20100609
                    if ((dd[j]["F_DeviceKindIndex"].ToString() == "6") || (devinfo.SerialPort > 0)) continue;
                    //条码扫描仪比对条码值;
                    if (dd[j]["F_DeviceKindIndex"].ToString() == "7")
                    {

                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        sql.Remove(0, sql.Length);
                        sql.Append("select * from T_Monitor_Task where (F_DeviceIndex=").Append(DeviceIdx).Append(") and F_Status>=1");

                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            TaskIdx = Convert.ToInt32(dv[0]["F_MonitorIndex"]);
                            int FID = Convert.ToInt32(dv[0]["F_ManageTaskIndex"]);
                            int Taskind = Convert.ToInt32(dv[0]["F_ManageTASKKINDINDEX"]);
                            //string oldDevice = "1201";
                            //string oldCell = "-";
                            //int cno = 0;
                            //string cCell = "-";

                            #region 条码比对处理
                            //    //gds = CommModeCreate.CreateGetDeviceState(DeviceIdx);
                            //    sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                            //    witemnames[0] = "DB2,byte" + Convert.ToString((devinfo.Dbw2Address + 0));
                            //    string gdata = CStaticClass.GetStringData(DeviceIdx);
                            //    if (dv[0]["F_DeviceCommandIndex"].ToString() == "1")//条码比对;
                            //    {
                            //        #region 条码比对

                            //        CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "CGetDeviceState", DeviceIdx.ToString(), gdata);
                            //        wv[0] = "2";
                            //        sdo.WriteDBData(witemnames, wv);
                            //        //管理建议如果gdata=="0000000000"放行到机台，真正错码的送到原货位
                            //        if ((gdata == dv[0]["F_TxtParam"].ToString().ToUpper()) || (gdata == "\0\0\0\0\0\0\0\0\0\0"))
                            //        {
                            //            ActionComplete(DeviceIdx, TaskIdx,1);
                            //            //刷新监控中心显示
                            //        }
                            //        else
                            //        {
                            //            if (FrmControlMonitor.FormInstance.GetObjectText("tsStatus").IndexOf("设备索引:" + DeviceIdx + ",条码比对错误；故障发生时间：" + DateTime.Now.ToString("u")) < 0)
                            //            {
                            //                FrmControlMonitor.FormInstance.FlashPanit("tsStatus", "设备索引:" + DeviceIdx + ",条码比对错误；故障发生时间：" + DateTime.Now.ToString("u"), true);

                            //            }
                            //            ActionError(DeviceIdx, TaskIdx, 30);
                            //            dbo.ExceSQL("update T_Base_Device set F_LockedState=0 where F_LockedState=" + TaskIdx);
                            //            //改到人工处理处（辅料1201）：记住调度任务索引FID生成当前位置到1201,同时上报管理系统错误码，异常完成：本地管理表FERRORCODE=990
                            //            
                            //            if (DeviceIdx == 1603)//残盘回库
                            //            {
                            //                //残盘扫描直接回库
                            //                ActionComplete(DeviceIdx, TaskIdx, 1);
                            //                continue;
                            //            }
                            //            else if (DeviceIdx == 1604)//机台呼叫出库
                            //            {
                            //                cno = 1222;
                            //                dvm = dbo.ExceSQL("SELECT FSTARTDEVICE, FSTARTCELL FROM T_Manage_Task WHERE (FID = " + FID + ") AND (F_ManageTaskKindIndex = " + Taskind + ")").Tables[0].DefaultView;
                            //                if (dvm.Count > 0)
                            //                {
                            //                    oldCell = dvm[0]["FSTARTCELL"].ToString();
                            //                    oldDevice = dvm[0]["FSTARTDEVICE"].ToString();
                            //                }
                            //                else
                            //                {
                            //                    oldDevice = "1201";
                            //                    oldCell = "-";
                            //                }
                            //            }
                            //            else if  (DeviceIdx == 3604) 
                            //            {
                            //                oldDevice = "3229";
                            //                oldCell = "-";
                            //                cno = 3272;
                            //            }
                            //            else if  (DeviceIdx == 4601) 
                            //            {
                            //                oldDevice = "3229";
                            //                oldCell = "-";
                            //                cno = 4218;
                            //            }

                            //            else
                            //            {//不需要改路径的直接报告异常完成
                            //                dbo.ExceSQL("update T_Manage_Task set FExceptionNO=" + Model.CGeneralFunction.TASKABEND + " where (F_ManageTaskKindIndex = " + Taskind + ") AND (FID = " + FID + ")");
                            //                ActionComplete(DeviceIdx, TaskIdx, 1);
                            //                continue;

                            //            }



                            //            dbo.ExceSQL("DELETE FROM T_Manage_Task WHERE (F_ManageTaskKindIndex = "+Taskind+") AND (FID = "+FID+")");
                            //            dbo.ExceSQL("DELETE FROM T_Monitor_Task WHERE (F_ManageTaskIndex = " + FID + ") AND (F_ManageTASKKINDINDEX = " + Taskind + ")");
                            //            //20090902修改库房索引ccf.GetWarehouseIndex()
                            //            sql = "INSERT INTO T_Manage_Task" +
                            //            "(FID, F_ManageTaskKindIndex,FPALLETBARCODE,FMANAGETASKTYPE,FCONTROLTASKTYPE, FTASKLEVEL, FISRETURN," +
                            //            "FSTARTWAREHOUSE,FENDWAREHOUSE, FSTARTCELL, FSTARTDEVICE, FENDDEVICE, FENDCELL, " +
                            //            "FSTATUS, FBEGTIME, FIntoStepOK,FExceptionNO)" +
                            //            "VALUES (" + FID + "," + Taskind + ",'0000000000','1','1','1','1','" + ccf.GetWarehouseIndex() + "','" + ccf.GetWarehouseIndex() + "','-'," + cno + ",'" + oldDevice + "','" + oldCell + "','0','" + DateTime.Now.ToString("u") + "','0'," + Model.CGeneralFunction.TASKABEND + ")";
                            //            dbo.ExceSQL(sql);   

                            //            continue;
                            //        }
                            //        #endregion
                            //    }
                            //    else if (dv[0]["F_DeviceCommandIndex"].ToString() == "2")//叠盘后条码扫描申请任务;
                            //    {
                            //        #region 叠盘后条码扫描申请任务

                            //        if ((gdata == "\0\0\0\0\0\0\0\0\0\0") || (gdata == null))
                            //        { 
                            //            gdata = "0000000000";

                            //        }
                            //        int dcode=0;
                            //        if (DeviceIdx == 1603)
                            //        {
                            //            dcode = 1220;
                            //        }
                            //        else
                            //        {
                            //            continue;
                            //        }
                            //        DataView dvbc = dboM.ExceSQL("SELECT DEVICE_CODE,STOCK_BARCODE FROM IO_CONTROL_APPLY WHERE APPLY_TASK_STATUS=0 and DEVICE_CODE=" + dcode + " and (STOCK_BARCODE = '" + gdata + "')").Tables[0].DefaultView;
                            //        if (dvbc.Count > 0)
                            //        {
                            //            continue;
                            //        }
                            //        //20090915
                            //        string Sql = "SELECT STOCK_BARCODE from IO_CONTROL where STOCK_BARCODE='" + gdata + "' and CONTROL_STATUS<100";
                            //        DataView dvs = dboM.ExceSQL(Sql).Tables[0].DefaultView;
                            //        if (dvs.Count > 0)
                            //        {

                            //            continue;
                            //        }

                            //        //向管理申请入库任务
                            //        int fid = dboM.GetManageTableIndex("IO_CONTROL_APPLY");
                            //        string dtime = DateTime.Now.ToString("u");
                            //        dtime = dtime.Substring(0, dtime.Length - 1);
                            //        sql = "INSERT INTO IO_CONTROL_APPLY(CONTROL_APPLY_ID,CONTROL_APPLY_TYPE, DEVICE_CODE, STOCK_BARCODE, APPLY_TASK_STATUS, CREATE_TIME,CONTROL_APPLY_REMARK)VALUES " +
                            //            "(" + fid + ",1," + dcode + ",'" + gdata + "',0,'" + dtime + "',2)";
                            //        dboM.ExceSQL(sql);
                            //        //20090918
                            //        ActionComplete(DeviceIdx, TaskIdx, 1);
                            //        wv[0] = "2";
                            //        sdo.WriteDBData(witemnames, wv);
                            //        #endregion
                            //    }
                            #endregion


                        }




                    }
                    else if (dd[j]["F_DeviceKindIndex"].ToString() == "30")
                    {//20100617增加和管理交互虚拟设备,类型30
                        sql.Remove(0, sql.Length);
                        sql.Append("select * from T_Monitor_Task where (F_DeviceIndex=").Append(DeviceIdx).Append(") and F_Status>=1");

                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            TaskIdx = Convert.ToInt32(dv[0]["F_MonitorIndex"]);
                            gds = CommModeCreate.CreateGetDeviceState(DeviceIdx);
                            int[] states = gds.GetDeviceState(DeviceIdx, TaskIdx);
                            if (states != null)
                            {
                                if (states[1] == Model.CGeneralFunction.TASKOUTCONFIRM)
                                {
                                    ActionComplete(DeviceIdx, TaskIdx, 0);
                                }
                            }
                        }
                    }
                    else//其它类型设备
                    {

                        GetKindDeviceState(TaskIdx, DeviceIdx, 0);

                    }


                }



                //20090920
                #region 处理死锁问题
                ActionDeadLock();
                #endregion

            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "获取设备状态时：" + ex.StackTrace + ex.Message);
                OnRefreshMonitor(rmea);

            }
            finally
            {//20091107
                dv.Dispose();
                dvm.Dispose();
                dvmo.Dispose();
                dd.Dispose();

            }

        }
        /// <summary>
        /// 设备报告空闲
        /// </summary>
        /// <param name="DeviceIdx"></param>
        public void ActionIdle(int DeviceIdx)
        {

        }
        /// <summary>
        /// 报告完成
        ///电器反馈该设备的"完成"时 删除设备指令 , 解除设备表占用状态F_LockedState=0；
        ///路径明细表F_LockedDeviceIndex里的所有对应设备索引解锁
        /// 修改或解除调度逻辑预约锁；
        ///判断是否为调度任务的最后一个设备指令？是,回写调度任务IO_Control的Control_STATUS=999即"搬运完成";
        ///删除T_Manage_Task的正在执行状态FSTATUS=2的任务，修改ST_CELL表的货位状态 ；
        /// </summary>
        /// <param name="DeviceIdx">设备索引</param>
        /// <param name="TaskIdx">设备指令索引</param>
        ///<param name="ClearZero">是否向设备发送清零命令:1清零；900撤销整个调度任务；999手工报告调度任务完成</param>
        public void ActionComplete(int DeviceIdx, int TaskIdx, int ClearZero)
        {
            if (TaskIdx == 0) return;
            devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
            if (DeviceIdx == 32008 && ClearZero == 1)
            {
                sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);

                sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0);
                return;
            }
            int devKind = ccf.GetDeviceKindIdx(DeviceIdx);
            //20100305
            int[] zxy = ccf.GetCoordinatesFromMonitorTask(TaskIdx);
            StringBuilder zxystr = new StringBuilder();
            if (zxy != null)
            {
                zxystr.Append((zxy[3].ToString().Length == 1 ? "0" + zxy[3].ToString() : zxy[3].ToString())).Append("-").Append(
                    ((zxy[4].ToString().Length == 1) ? ("0" + zxy[4].ToString()) : (zxy[4].ToString()))).Append("-").Append(
                    ((zxy[5].ToString().Length == 1) ? ("0" + zxy[5].ToString()) : (zxy[5].ToString())));
            }


            int order = ccf.GetDeviceOrderFromMonitor(TaskIdx);
            if (order == -1)
            {
                CGetStateError = DeviceIdx + "上报的任务号:" + TaskIdx + "在调度系统已经没有记录！";
                return;
            }
            if (GetManage_Kind(TaskIdx) == false) return;
            int ControlType = ccf.GetFCONTROLTASKTYPEFromManageTask(_mti, _fid);
            string useawayfork = Model.CGeneralFunction.GetUseAwayFork(TaskIdx);
            string barcode = ccf.GetBarCodeFromMonitor(TaskIdx);
            int enddevice = ccf.GetEndDeviceFromManage(_mti, _fid);
            int nexttaskindex = ccf.GetNextMonitorTaskIndex(TaskIdx);
            string controlbatch = ccf.GetControlBatchFromManageTask(_mti, _fid);
            int errrcode = ccf.GetExceptionNOFromManageTask(_fid, _mti);
            //20100710
            int AgvNextDeviceKind = 0;
            if ((devKind == 6) && (order == 2))
            {
                AgvNextDeviceKind = ccf.GetDeviceKindIdx(zxy[4]);
            }

            #region 判断输送机误报完成信号

            if (devKind == 2)
            {//20120409判断输送机误报完成信号

                sql.Clear();
                sql.Append("SELECT T_Base_Device.F_DeviceIndex from T_Base_Device,T_Monitor_Task where T_Base_Device.F_DeviceIndex=T_Monitor_Task.F_DeviceIndex and F_DeviceKindIndex=2 AND F_MonitorIndex = ").Append(TaskIdx);
                object obd = dbo.GetSingle(sql.ToString());
                if (obd == null)
                {//不是输送机任务
                    return;
                }
                else
                {
                    if (Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(obd)).S7Connection != devinfo.S7Connection)
                    {//不是同层输送机任务
                        return;
                    }
                }

            }

            #endregion

            //20100108
            DataView dvman = new DataView();
            DataView dv = new DataView();
            DataView dvlane = new DataView();
            DataView dvr = new DataView();
            string dtime = string.Empty;
            //20121303增加RGV送货完成时的临近取货F_NearGetDevice优先级提高，先执行
            #region RGV送货完成时的临近取货站台的取货任务优先执行
            if ((devKind == 4) && (order == 3))
            {
                int SendDev = zxy[0];
                object obrgv = dbo.GetSingle(string.Format("SELECT F_NearGetDevice FROM T_Base_RGV_Gate WHERE (F_RGVGateDeviceIndex = {0}) AND (F_NearGetDevice > 0)", SendDev));
                if (obrgv != null)
                {//判断DeviceIdx在站台obrgv的取货任务是否是队列中第一个任务且等待执行
                    dv = dbo.ExceSQL(string.Format("SELECT F_ManageTASKKINDINDEX, F_ManageTaskIndex, F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex = {0}) AND (F_NumParam1 = {1}) and F_DeviceCommandIndex=2 and  F_Status=0 and  F_MonitorTaskLevel<>10", DeviceIdx, Convert.ToInt32(obrgv))).Tables[0].DefaultView;
                    for (int i = 0; i < dv.Count; i++)
                    {
                        dvr = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_ManageTASKKINDINDEX={0} and F_ManageTaskIndex={1} order by F_MonitorIndex asc", Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dv[i]["F_ManageTASKINDEX"]))).Tables[0].DefaultView;
                        if (dvr.Count > 0)
                        {
                            if (dvr[0]["F_MonitorIndex"].ToString() == dv[i]["F_MonitorIndex"].ToString())
                            {
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Monitor_Task set F_MonitorTaskLevel=10 where F_ManageTASKKINDINDEX=").Append(Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"])).Append(" and F_ManageTaskIndex=").Append(Convert.ToInt32(dv[i]["F_ManageTASKINDEX"])).Append(" and F_DeviceIndex=").Append(DeviceIdx);
                                dbo.ExceSQL(sql.ToString());

                                break;
                            }
                        }
                    }
                }
            }
            #endregion

            #region 出库优先携带入库优先策略的处理或者入库优先携带出库优先策略的处理（入出库交替）
            int Pri = ccf.SelectTaskPriPrecept();
            //20091016
            if (((Pri == 21) || (Pri == 12)) && (devKind == 1) && (ccf.GetFCONTROLTASKTYPEFromManageTask(_mti, _fid) == 2))//堆垛机出库优先并且携带入库任务
            {
                sql.Remove(0, sql.Length);
                sql.Append("select * from T_Manage_Task where FTASKLEVEL=10 and FSTACK = ").Append(DeviceIdx).Append(" AND (FCONTROLTASKTYPE = 1) AND (FIntoStepOK = '1') ");

                //20100108
                dvman = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dvman.Count <= 0)
                {//20130122首先看是否有同侧同巷道的入库堆垛机等待任务
                    if (GetNearDeviceInputTask(DeviceIdx, zxystr.ToString()) == false)
                    {
                        //没有了，随便找个入库任务吧
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT FID, F_ManageTaskKindIndex, FCONTROLTASKTYPE FROM T_Manage_Task WHERE (FSTACK = ").Append(DeviceIdx).Append(") AND (FCONTROLTASKTYPE = 1) AND (FIntoStepOK = '1') order by FTASKLEVEL desc, F_ManageTaskKindIndex desc,FID asc");

                        dvman = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        for (int ii = 0; ii < dvman.Count; ii++)
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("select * from T_Monitor_Task where F_ManageTASKKINDINDEX=" + dvman[ii]["F_ManageTASKKINDINDEX"] + " and F_ManageTaskIndex=" + dvman[ii]["FID"] + " order by F_MonitorIndex asc");

                            //20100108
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                int stackkind = ccf.GetDeviceKindIdx(Convert.ToInt32(dv[0]["F_DeviceIndex"]));
                                if (stackkind == 1)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Monitor_Task set F_MonitorTaskLevel=10 where F_ManageTASKKINDINDEX=").Append(dvman[ii]["F_ManageTASKKINDINDEX"]).Append(" and F_ManageTaskIndex=").Append(dvman[ii]["FID"]);
                                    dbo.ExceSQL(sql.ToString());
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Manage_Task set FTASKLEVEL=10 where F_ManageTASKKINDINDEX=").Append(dvman[ii]["F_ManageTASKKINDINDEX"]).Append(" and FID=").Append(dvman[ii]["FID"]);
                                    dbo.ExceSQL(sql.ToString());

                                    break;
                                }
                            }
                        }
                    }
                }
            }
            #endregion

            //dbo.TransBegin();
            try
            {
                int tsorder = 0;
                int fid = _fid;
                int mti = _mti;
                int relativeFID = ccf.GetRELATIVECONTORLIDFromManageTask(mti, fid);
                if (relativeFID == -1) relativeFID = 0;
                string cap;
                if ((ClearZero != Model.CGeneralFunction.TASKDELETE) && (errrcode != Model.CGeneralFunction.TASKDELETE))//20120102删除调度任务不置
                {
                    #region 20111222南京14所三楼入暂存库顶升机报告完成改道处理
                    //string Upok = "32029,32033,32042,32046";
                    //if (Upok.IndexOf(DeviceIdx.ToString()) >= 0)
                    //{
                    //    //替换堆垛机取货的取货坐标F_NumParam2，提前检测 F_AheadDetect                             
                    //    dvr = dbo.ExceSQL(string.Format("SELECT TOP 1 F_ManageTASKKINDINDEX,F_ManageTaskIndex,F_MonitorIndex, F_DeviceIndex,F_NumParam1,F_NumParam2,F_NumParam3 FROM T_Monitor_Task WHERE F_ManageTASKKINDINDEX={0} and F_ManageTaskIndex={1} and (F_MonitorIndex > {2}) ORDER BY F_MonitorIndex",mti,fid, TaskIdx)).Tables[0].DefaultView;
                    //    if (dvr.Count > 0)
                    //    {
                    //        StringBuilder zxystr1 = new StringBuilder();
                    //        zxystr1.Append((dvr[0]["F_NumParam1"].ToString().Length == 1 ? "0" + dvr[0]["F_NumParam1"].ToString() : dvr[0]["F_NumParam1"].ToString())).Append("-").Append(
                    //                ((dvr[0]["F_NumParam2"].ToString().Length == 1) ? ("0" + dvr[0]["F_NumParam2"].ToString()) : (dvr[0]["F_NumParam2"].ToString()))).Append("-").Append(
                    //                ((dvr[0]["F_NumParam3"].ToString().Length == 1) ? ("0" + dvr[0]["F_NumParam3"].ToString()) : (dvr[0]["F_NumParam3"].ToString())));

                    //        int laneGatedev = GetLaneGateDevice(Convert.ToInt32(dvr[0]["F_DeviceIndex"]), zxystr1.ToString());
                    //        object[] ob = new object[6] { GetStackGetXCoordinateFromLaneGate(Convert.ToInt32(dvr[0]["F_DeviceIndex"]), DeviceIdx), Convert.ToInt32(dvr[0]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dvr[0]["F_ManageTaskIndex"]), Convert.ToInt32(dvr[0]["F_DeviceIndex"]), laneGatedev, DeviceIdx };
                    //        sql.Clear();
                    //        sql.Append(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{4}', '{5}'),F_NumParam2 = {0} WHERE (F_ManageTASKKINDINDEX ={1}) and (F_ManageTaskIndex={2}) and (F_DeviceIndex={3})", ob));
                    //        dbo.ExecuteSql(sql.ToString());

                    //    }
                    //}
                    #endregion

                    #region 20110929双叉入库站台在报告完成时，分配任务货叉、进入双叉配对等待
                    //如果是手工报告的双叉入库站台的送出完成，需要根据T_Base_PLC_Ask等待配对情况来指定货物已经到达近叉（已经有关联远叉站台任务进入等待配对）还是远叉（没有关联远叉站台任务进入等待配对）站台
                    //如果近叉和远叉站台都有任务进入等待状态，不允许再报告完成，一定是程序逻辑混乱或者人工非法报完成
                    #region 南京14所和RGV交接的长转链条机与双叉堆垛机取货顶升机的特殊处理

                    //string CorrelRGV = "12008,12016,12024,32008,32016,32024,42008,42016,42024";
                    //if (CorrelRGV.IndexOf(DeviceIdx.ToString()) >= 0)
                    //{//42008手工报告输送机接货完成：
                    //    //有42008开始时间比TaskIdx早的存在，存在则return
                    //    if (ccf.IfHaveEarlyTask(TaskIdx, DeviceIdx) == true) return;
                    //    //如果有关联任务存在：return；

                    //    //1、如果有等待关联的,分配近叉42007;
                    //    sql.Remove(0, sql.Length);
                    //    sql.Append("select F_DeviceIndex from T_Base_PLC_Ask where F_TaskIndex>0 and F_Remark<>'' and  (F_DeviceIndex=").Append((int)(DeviceIdx - 1)).Append(" or F_DeviceIndex=").Append((int)(DeviceIdx - 3)).Append(")");
                    //    if (dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView.Count > 0)
                    //    {//已经进入多叉关联等待状态
                    //        DeviceIdx = DeviceIdx - 1;
                    //        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                    //    }
                    //    else
                    //    {//2无等待关联,分配远叉42005
                    //        DeviceIdx = DeviceIdx - 3;
                    //        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                    //    }

                    //}

                    #endregion

                    #region 是否为多叉堆垛机取货站台

                    //if (ccf.IfMutiForkStackGetDevice(DeviceIdx)==true && order==6)
                    //{//双叉顶升站台入库任务，提前检测是单独的
                    //    string UseAwayFork = GetUseAwayForkFromLaneGate(DeviceIdx);
                    //    int oldDevice = ccf.GetOldDevcieFromStackCorr(mti,fid,TaskIdx);//获得拆分时指定的旧站台号
                    //    bool Ifwait = true;

                    //        #region 替换已经分配的设备及其堆垛机坐标和提前检测

                    //        sql.Remove(0, sql.Length);
                    //        sql.Append("select F_TaskIndex from T_Base_PLC_Ask where F_TaskIndex=0 and F_Remark='' and F_DeviceIndex=").Append(DeviceIdx);
                    //        if (dbo.GetSingle(sql.ToString()) != null)
                    //        {//分配货叉，进入多叉关联等待状态

                    //            sql.Remove(0, sql.Length);
                    //            sql.Append("update T_Manage_Task set FUseAwayFork='").Append(UseAwayFork).Append("' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and FID=").Append(fid).Append("");
                    //            dbo.ExecuteSql(sql.ToString());
                    //            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_UseAwayFork = '{0}' WHERE (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", UseAwayFork, fid, mti));
                    //            //替换堆垛机取货的取货坐标F_NumParam2，提前检测 F_AheadDetect  
                    //            //20120906
                    //            int stackno = 0;
                    //            object[] ob = new object[5] { oldDevice, DeviceIdx, fid, mti, TaskIdx };
                    //            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '{1}') WHERE (F_ManageTaskIndex ={2}) AND (F_ManageTASKKINDINDEX ={3}) AND (F_MonitorIndex >{4})", ob));
                    //            dvr = dbo.ExceSQL(string.Format("SELECT TOP 1 F_ManageTASKKINDINDEX,F_ManageTaskIndex,F_MonitorIndex, F_DeviceIndex FROM T_Monitor_Task WHERE F_ManageTASKKINDINDEX={0} and F_ManageTaskIndex={1} and (F_MonitorIndex > {2}) ORDER BY F_MonitorIndex",mti,fid, TaskIdx)).Tables[0].DefaultView;
                    //            if (dvr.Count > 0)
                    //            {
                    //                stackno = Convert.ToInt32(dvr[0]["F_DeviceIndex"]);
                    //                //替换坐标
                    //                ob = new object[4] { GetStackGetXCoordinateFromLaneGate(Convert.ToInt32(dvr[0]["F_DeviceIndex"]), DeviceIdx), Convert.ToInt32(dvr[0]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dvr[0]["F_ManageTaskIndex"]), Convert.ToInt32(dvr[0]["F_DeviceIndex"]) };
                    //                dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam2 = {0} WHERE (F_ManageTASKKINDINDEX ={1}) and (F_ManageTaskIndex={2}) and (F_DeviceIndex={3})", ob));

                    //                #region 极限货位单叉执行20111230
                    //                string ccell = ccf.IfLimitCellChangeFork(Convert.ToInt32(dvr[0]["F_MonitorIndex"]), Convert.ToInt32(dvr[0]["F_DeviceIndex"]));
                    //                if (ccell != "-")
                    //                {
                    //                    ccf.ChangeEndCellCode(Convert.ToInt32(dvr[0]["F_MonitorIndex"]), ccell, Convert.ToInt32(dvr[0]["F_DeviceIndex"]));
                    //                    Ifwait = false;

                    //                }
                    //                #endregion

                    //                #region 比自己货叉序号大一的关联设备，且没有等待任务，自己无需等待
                    //                sql.Clear();
                    //                sql.Append("SELECT F_LaneGateDeviceIndex FROM T_Base_Lane_Gate where f_correldeviceindex like '%").Append(DeviceIdx.ToString()).Append("%' and f_useawayfork='").Append(Convert.ToInt32( Convert.ToInt32( UseAwayFork)+1)).Append("'");
                    //                object largedev = dbo.GetSingle(sql.ToString());
                    //                if (largedev != null)//如果比自己叉序号大一的关联设备存在
                    //                {
                    //                    sql.Remove(0, sql.Length);
                    //                    sql.Append("select F_TaskIndex from T_Base_PLC_Ask where F_TaskIndex=0 and F_Remark='' and F_DeviceIndex=").Append(Convert.ToInt32( largedev));
                    //                    if (dbo.GetSingle(sql.ToString()) != null)
                    //                    {
                    //                        //比自己叉序号大一的关联设备没等待关联，自己也不等待关联了
                    //                        Ifwait = false;
                    //                    }
                    //                }
                    //                #endregion

                    //            }
                    //            if (Ifwait == true)
                    //            {
                    //                dtime = DateTime.Now.ToString("u");
                    //                dtime = dtime.Substring(0, dtime.Length - 1);
                    //                //20120906只有最大叉号的任务需要等待，其余叉只填写任务号，不填写等待开始时间
                    //                Model.MDevice mstack = Model.CGetInfo.GetDeviceInfo(stackno);
                    //                if (mstack != null)
                    //                {
                    //                    if (mstack.ForkAmount.ToString() != UseAwayFork)
                    //                    {
                    //                        dtime = "";
                    //                    }
                    //                }
                    //                sql.Remove(0, sql.Length);

                    //                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=").Append(nexttaskindex).Append(",F_Remark='").Append(dtime).Append("' where (F_DeviceIndex=").Append(DeviceIdx).Append(")");
                    //                dbo.ExecuteSql(sql.ToString());
                    //            }

                    //        }
                    //        else
                    //        {//已经有近叉进入多叉关联等待状态，电气逻辑混乱？？？不允许报告完成
                    //            return;
                    //        }

                    //        #endregion

                    //}

                    #endregion

                    #endregion
                }

                //20101011
                #region 补充逻辑预约锁的解锁（此调度任务的此设备的最后一个命令需要解锁，有关联任务的改为关联任务预约）

                if ((devKind == 1) || (devKind == 4))
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("select count(F_MonitorIndex) as counts from T_Monitor_Task ").Append(
                        " where F_ManageTaskIndex =").Append(fid).Append(" and F_ManageTaskKindIndex= ").Append(mti).Append(" and F_DeviceIndex=").Append(DeviceIdx);
                    object ob = dbo.GetSingle(sql.ToString());
                    if (Convert.ToInt32(ob) == 1)
                    {

                        #region 有管理任务存在，增加关联任务预约锁//20100710
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT T_Manage_Task.FID FROM T_Manage_Task ,T_Monitor_Task where T_Manage_Task.FID<>").Append(fid).Append(" and   T_Manage_Task.F_ManageTaskKindIndex = T_Monitor_Task.F_ManageTASKKINDINDEX AND T_Manage_Task.FID = T_Monitor_Task.F_ManageTaskIndex  and (T_Manage_Task.F_RELATIVECONTORLID = ").Append(relativeFID).Append(") AND (T_Manage_Task.F_ManageTaskKindIndex = ").Append(mti).Append(") and F_DeviceIndex=").Append(DeviceIdx).Append("");
                        ob = dbo.GetSingle(sql.ToString());
                        if ((ob != null) && (devinfo.IfCorrelDoubleFork == "1"))
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mti.ToString() + ob.ToString())).Append(" where F_ManTaskReserve=").Append((mti.ToString() + fid.ToString())).Append(" and F_DeviceIndex=" + DeviceIdx);
                            dbo.ExceSQL(sql.ToString());
                        }
                        else
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=0 where F_ManTaskReserve=").Append((mti.ToString() + fid.ToString())).Append(" and F_DeviceIndex=").Append(DeviceIdx);
                            dbo.ExceSQL(sql.ToString());
                            sql.Remove(0, sql.Length);
                            //sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=-1").Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and (FID=").Append(fid).Append(" or F_RELATIVECONTORLID=").Append(fid).Append(")");
                            //dbo.ExecuteSql(sql.ToString());

                        }
                        
                        #region 堆垛机送货的输送机解逻辑预约锁
                        //20120409
                        int stackdev = 0;
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (devinfo.VirtualStack > 0)
                        {//20111231
                            stackdev = devinfo.VirtualStack;
                        }
                        else
                        {
                            stackdev = DeviceIdx;
                        }
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT T_Base_Lane_Gate.F_LaneGateDeviceIndex from T_Base_Lane_Gate,T_Base_LaneInfo ").Append(
                            " where T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex and T_Base_Lane_Gate.F_ZXY='").Append(zxystr).Append("' ").Append(
                            "  and T_Base_LaneInfo.F_StackIndex=").Append(stackdev);
                        dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dvlane.Count > 0)
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=0 where F_DeviceIndex=").Append(dvlane[0]["F_LaneGateDeviceIndex"]);
                            dbo.ExceSQL(sql.ToString());
                        }
                        #endregion

                        #endregion
                    }
                }
                if (DeviceIdx == 12038 || DeviceIdx == 12029)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("update T_Base_Device set F_ManTaskReserve=0 where F_ManTaskReserve=").Append((mti.ToString() + fid.ToString()));
                    dbo.ExceSQL(sql.ToString());
                }
                #endregion

                if ((errrcode == Model.CGeneralFunction.TASKCHANGESTACK) && (devinfo.VirtualStack > 0) && (order == 5))//20101011换货叉处理
                {//解除关联任务，更换堆垛机，追加两个任务，倒库位取货，送到真实货位，管理任务的FExceptionNO==null
                    if (AppendStackMoveCellOperate(mti, fid, DeviceIdx, TaskIdx) == false) return;
                }

                //20100108
                sql.Remove(0, sql.Length);
                sql.Append("select count(F_MonitorIndex) as counts from T_Monitor_Task ").Append(
                    " where F_ManageTaskIndex =").Append(fid).Append(" and F_ManageTaskKindIndex= ").Append(mti);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    int rowco = 0;


                    #region 最后一个调度任务的处理

                    if ((Convert.ToInt32(dv[0]["counts"]) == 1)) //20091016
                    {
                        //固定路径模式
                        //调度任务的fid的最后一个监控分解任务完成
                        #region 双向出入口亮灯
                        //if ((devKind == 2) && (order == 6 || order == 2) ) 
                        //{
                        //    DataView dvv = dbo.ExceSQL("select * from T_Manage_Task where FENDDEVICE =" + DeviceIdx.ToString()).Tables[0].DefaultView;
                        //    if (dvv.Count <= 1)
                        //    {
                        //        //已经没有其它出库到该站台的任务了
                        //        Model.MDevice devinfo_light = new Model.MDevice();
                        //        switch (DeviceIdx)
                        //        {
                        //            case 12001:
                        //                devinfo_light = Model.CGetInfo.GetDeviceInfo(17001);
                        //                break;
                        //            case 12002:
                        //                devinfo_light = Model.CGetInfo.GetDeviceInfo(17002);
                        //                break;
                        //            case 12003:
                        //                devinfo_light = Model.CGetInfo.GetDeviceInfo(17003);
                        //                break;
                        //            case 12004:
                        //                devinfo_light = Model.CGetInfo.GetDeviceInfo(17004);
                        //                break;

                        //        }
                        //        StringBuilder[] wv = { new StringBuilder("2") };
                        //        StringBuilder[] witemnames = { new StringBuilder("") };
                        //        witemnames[0].Clear();
                        //        witemnames[0].Append(Model.CGeneralFunction.DBSend).Append(".").Append(Convert.ToString(devinfo_light.Dbw1Address + 0)).Append(",b");//20130510
                        //        wv[0].Clear();
                        //        wv[0].Append("1");

                        //        sdo = CommModeCreate.CreateSendDeviceOrder(devinfo_light.DeviceIndex);
                        //        sdo.WriteDBData(witemnames, wv, devinfo_light.S7Connection);

                        //        CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "出入库模式", devinfo_light.DeviceIndex.ToString(), "已经没有该站台的出库任务！");
                        //    }
                        //}
                        #endregion
                        if (mti == 1)
                        {
                            cap = "调度任务";
                            //完成FSTATUS=999；970堆垛机送货重故障异常完成；980堆垛机取空故障异常完成；990条码扫描异常完成；
                            //调度撤销删除调度任务900;950送到拆盘机的不是空托盘组;940人工暂停出库任务
                            //20090902
                            if ((errrcode >= 900) || (ClearZero == Model.CGeneralFunction.TASKDELETE))//异常完成
                            {
                                //if(errrcode== Model.CGeneralFunction.TASKDELETE)
                                //    ClearZero = errrcode;
                                if (ClearZero == Model.CGeneralFunction.TASKDELETE && errrcode != Model.CGeneralFunction.TASKEMPTYOUTPUT)
                                    errrcode = ClearZero;
                                else if (errrcode == Model.CGeneralFunction.TASKREPEATINPUT)
                                {
                                    errrcode = Model.CGeneralFunction.TASKREPEATINPUT;//聊城修改，以前是Model.CGeneralFunction.TASKFINISH
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set ERROR_TEXT='堆垛机的送货重故障异常完成' where CONTROL_ID=").Append(fid);
                                    dboM.ExceSQL(sql.ToString());
                                }
                                else if (errrcode == Model.CGeneralFunction.TASKEMPTYOUTPUT)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set ERROR_TEXT='堆垛机取空故障异常完成' where CONTROL_ID=").Append(fid);
                                    dboM.ExceSQL(sql.ToString());
                                }
                                else if (errrcode == Model.CGeneralFunction.TASKABEND)
                                {
                                    ////20120224南京14所异常完成需要插入IO_CONTROL_APPLY
                                    //dtime = DateTime.Now.ToString("u");
                                    //dtime.Remove(dtime.Length - 1, 1);
                                    //StringBuilder sb = new StringBuilder("01");
                                    //if (enddevice == 32025)
                                    //{
                                    //    sb = new StringBuilder("03");
                                    //}
                                    //else
                                    //{
                                    //    sb = new StringBuilder("04");
                                    //}

                                    //int apptype = 3;
                                    //object[] ob = new object[8] { apptype, enddevice, barcode, 0, dtime, "", sb.ToString(), fid };
                                    //try
                                    //{
                                    //    dboM.ExecuteSql(string.Format("INSERT INTO IO_CONTROL_APPLY( CONTROL_APPLY_TYPE,DEVICE_CODE, STOCK_BARCODE, APPLY_TASK_STATUS, CREATE_TIME,CONTROL_APPLY_REMARK,WAREHOUSE_CODE,CONTROL_ID)VALUES ({0},{1},'{2}',{3},'{4}','{5}','{6}',{7})", ob));
                                    //}
                                    //catch (Exception ex)
                                    //{
                                    //    RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "扫码异常，向管理申请时发生错误：" + ex.Message);
                                    //    OnRefreshMonitor(rmea);

                                    //}

                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set ERROR_TEXT='条码比对错误异常完成' where CONTROL_ID=").Append(fid);
                                    dboM.ExceSQL(sql.ToString());
                                }
                                else if (errrcode == Model.CGeneralFunction.TASKTYPEERROR)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set ERROR_TEXT='送到拆盘机的不是空托盘组' where CONTROL_ID=").Append(fid);
                                    dboM.ExceSQL(sql.ToString());
                                }
                                else if (errrcode == Model.CGeneralFunction.TASKSTOPOUTPUT)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set ERROR_TEXT='人工暂停出库任务' where CONTROL_ID=").Append(fid);
                                    dboM.ExceSQL(sql.ToString());
                                }
                                else if (ClearZero == Model.CGeneralFunction.TASKDELETE)
                                    errrcode = ClearZero;
                                //20100304

                                switch (CStaticClass.ManDBFactory)
                                {
                                    case "OracleDBFactory":
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME =sysdate, CONTROL_STATUS=").Append(errrcode).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());

                                        break;
                                    case "SQLServerDBFactory":
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME =GETDATE(), CONTROL_STATUS=").Append(errrcode).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());
                                        break;
                                    case "OleDBFactory":
                                        dtime = DateTime.Now.ToString("u");
                                        dtime = dtime.Substring(0, dtime.Length - 1);
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME ='").Append(dtime).Append("', CONTROL_STATUS=").Append(errrcode).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());
                                        break;
                                }
                                if (rowco > 0)
                                {
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("ActionComplete", "给管理上报完成:" + errrcode.ToString(), ",条码[" + barcode + "]", ",CONTROL_ID:" + fid);
                                }

                            }
                            else
                            {
                                //完成FSTATUS=999
                                switch (CStaticClass.ManDBFactory)
                                {
                                    case "OracleDBFactory":
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME =sysdate, CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKFINISH).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());
                                        break;
                                    case "SQLServerDBFactory":
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME =GETDATE(), CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKFINISH).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());
                                        break;
                                    case "OleDBFactory":
                                        dtime = DateTime.Now.ToString("u");
                                        dtime = dtime.Substring(0, dtime.Length - 1);
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update IO_Control set CONTROL_END_TIME ='").Append(dtime).Append("', CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKFINISH).Append(" where CONTROL_ID=").Append(fid);
                                        rowco = dboM.ExecuteSql(sql.ToString());
                                        break;
                                }
                                if (rowco > 0)
                                {
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("ActionComplete", "给管理上报完成:" + Model.CGeneralFunction.TASKFINISH.ToString(), ",条码[" + barcode + "]", ",CONTROL_ID:" + fid);
                                }

                            }
                        }
                        else if (mti == 4)
                        {
                            cap = "手工任务";
                        }
                        else
                        {
                            cap = "临时任务";
                        }
                        if ((errrcode == Model.CGeneralFunction.TASKCHANGEFORK) && (devKind == 1) && (devinfo.IfCorrelDoubleFork == "1"))//20101011换货叉处理
                        {//解除关联任务，更换货叉，追加两个任务，倒库位取货，送到真实货位，管理任务的FExceptionNO==null
                            if (AppendMoveCellOperate(mti, fid, DeviceIdx, TaskIdx) == false) return;
                        }
                        else
                        {//20101011
                            //回写管理表//20091128
                            if ((ClearZero == Model.CGeneralFunction.TASKDELETE) || (ClearZero == Model.CGeneralFunction.TASKSTOPOUTPUT))//调度撤销删除调度任务900；人工暂停出库任务940
                            {
                                ReturnManageInfo(fid, mti, cap, false);
                            }
                            else
                            {
                                ReturnManageInfo(fid, mti, cap, true);
                            }
                        }
                    }
                    #endregion
                }

                //被这个任务号锁定的设备全部解锁
                sql.Remove(0, sql.Length);
                sql.Append("update T_Base_Device set F_LockedState=0 where F_LockedState=").Append(TaskIdx);
                dbo.ExceSQL(sql.ToString());
                //被这个任务号逻辑有物的全部解开
                sql.Remove(0, sql.Length);
                sql.Append("update T_Base_Device set F_HaveGoods=0  where F_HaveGoods=").Append(TaskIdx);
                dbo.ExceSQL(sql.ToString());
                if ((ClearZero != Model.CGeneralFunction.TASKDELETE) && (errrcode != Model.CGeneralFunction.TASKDELETE))//20120102删除调度任务不置逻辑有物
                {
                    #region 堆垛机接货输送机完成时逻辑无货20100710
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_LaneGateDeviceIndex  FROM T_Base_Lane_Gate where F_LaneGateDeviceIndex=").Append(DeviceIdx);
                    dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dvlane.Count > 0)
                    {
                        //if (zxy[3] == 0)//20110608
                        //{
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Base_Device set F_HaveGoods=0  where F_HaveGoods=").Append(TaskIdx);
                        dbo.ExceSQL(sql.ToString());
                        //}
                    }
                    else
                    {//AGV接货输送机完成时逻辑无货20100710
                        //sql.Remove(0, sql.Length);
                        //sql.Append("SELECT F_AGVGateDeviceIndex  FROM T_Base_AGV_Gate where F_AGVGateDeviceIndex=").Append(DeviceIdx);
                        //dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        //if (dvlane.Count > 0)
                        //{
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Base_Device set F_HaveGoods=0  where F_HaveGoods=").Append(TaskIdx);
                        dbo.ExceSQL(sql.ToString());
                        //}
                    }
                    #endregion

                    #region 堆垛机放货、AGV逻辑有物和取货后顶升下降的处理;在输送机取货，置输送机逻辑无物20101011

                    if ((devKind == 1) && ((order == 4) || (order == 5) || (order == 6)))//20101011
                    {

                        bool sh = false;//20101011
                        bool qh = false;//20101011
                        if (order == 5) sh = true;//20101011
                        if (order == 4) qh = true;//20101011
                        if (order == 6)//20101011
                        {
                            sh = true;
                            qh = true;
                        }
                        int stackdev = 0;
                        if (devinfo.VirtualStack > 0)
                        {//20111231
                            stackdev = devinfo.VirtualStack;
                        }
                        else
                        {
                            stackdev = DeviceIdx;
                        }
                        if (sh == true)//20101011
                        {
                            //20090918给堆垛机送货的输送机增加逻辑有物
                            ////20100609改为使用巷道表关联

                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT T_Base_Lane_Gate.F_LaneGateDeviceIndex from T_Base_Lane_Gate,T_Base_LaneInfo ").Append(
                                " where T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex and T_Base_Lane_Gate.F_ZXY='").Append(zxystr).Append("' ").Append(
                                "  and T_Base_LaneInfo.F_StackIndex=").Append(stackdev);
                            dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvlane.Count > 0)
                            {
                                #region 20120518如果是倒叉货位nexttaskindex取比当前任务小的第一个任务
                                if (ccf.IfChangeForkCell(stackdev, zxystr.ToString()) == true)
                                {
                                    nexttaskindex = ccf.GetPriorMonitorTaskIndex(TaskIdx);

                                }
                                #endregion

                                sql.Remove(0, sql.Length);//20120409只有输送机置为逻辑有物
                                sql.Append("update T_Base_Device set F_HaveGoods=").Append(nexttaskindex).Append(" where F_DeviceKindIndex=2 and F_DeviceIndex=").Append(dvlane[0]["F_LaneGateDeviceIndex"]);
                                dbo.ExceSQL(sql.ToString());
                            }
                        }
                        if (qh == true)//在输送机取货，置输送机逻辑无物//20101011
                        {

                            zxystr.Remove(0, zxystr.Length);
                            zxystr.Append((zxy[0].ToString().Length == 1 ? "0" + zxy[0].ToString() : zxy[0].ToString())).Append("-").Append(
                                ((zxy[1].ToString().Length == 1) ? ("0" + zxy[1].ToString()) : (zxy[1].ToString()))).Append("-").Append(
                                ((zxy[2].ToString().Length == 1) ? ("0" + zxy[2].ToString()) : (zxy[2].ToString())));
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_LifterDown,F_ChangeForkCell,T_Base_Lane_Gate.F_LaneGateDeviceIndex from T_Base_Lane_Gate,T_Base_LaneInfo ").Append(
                                " where T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex and T_Base_Lane_Gate.F_ZXY='").Append(zxystr).Append("' ").Append(
                                "  and T_Base_LaneInfo.F_StackIndex=").Append(stackdev);
                            dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvlane.Count > 0)
                            {

                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_Device set F_HaveGoods=0 where F_DeviceIndex=").Append(dvlane[0]["F_LaneGateDeviceIndex"]);
                                dbo.ExceSQL(sql.ToString());
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=0,F_Remark='' where F_DeviceIndex=").Append(dvlane[0]["F_LaneGateDeviceIndex"]);
                                dbo.ExecuteSql(sql.ToString());//20101011
                                #region 堆垛机在顶升机取货完成时，发送顶升机的下降动作9;//20120906倒库和辊道输送机设备不发送【下降】
                                //if ((dvlane[0]["F_LifterDown"].ToString() == "1"))//(ClearZero >= 1) && 
                                //{//高端的发送到UCode，F_NumParam1是顶升设备,F_NumParam4是顶升设备
                                //    int hidx = ccf.GetTempManageIdx();//20110510
                                //    int hmidx = ccf.GetMonitorIndex(hidx, 2);
                                //    string ah = "";
                                //    int sdev = 0, begindev = 0, arrdev = 0;
                                //    int ucode = ccf.GetUCodeFromDeviceGD(Convert.ToInt32(dvlane[0]["F_LaneGateDeviceIndex"]));
                                //    if (ucode > 0)
                                //    {
                                //        sdev = ucode;
                                //        begindev = Convert.ToInt32(dvlane[0]["F_LaneGateDeviceIndex"]);
                                //        arrdev = Convert.ToInt32(dvlane[0]["F_LaneGateDeviceIndex"]);

                                //    }
                                //    else
                                //    {

                                //        sdev = Convert.ToInt32(dvlane[0]["F_LaneGateDeviceIndex"]);
                                //        begindev = 0;
                                //        arrdev = 0;
                                //        ah = string.Format("D-{0}.6;I{0}", sdev.ToString());
                                //    }

                                //    sql.Remove(0, sql.Length);
                                //    sql.Append("insert into T_Monitor_Task(F_MonitorTaskLevel,F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex,").
                                //            Append("F_DeviceIndex,F_DeviceCommandIndex,F_UseAwayFork,F_AheadDetect,F_TxtParam,F_NumParam1,F_NumParam4) ").
                                //            Append("values(2,").Append(GetRouteIDsub(sdev)).Append(",").
                                //            Append(hidx).Append(",2,").Append(hmidx).Append(",").Append(sdev).
                                //             Append(",9,'-','").Append(ah).Append("','").Append(ccf.GetBarCodeFromMonitor(TaskIdx)).Append("',").Append(begindev).Append(",").Append(arrdev).Append(")");//20110510
                                //    dbo.ExecuteSql(sql.ToString());

                                //}
                                #endregion
                            }
                        }
                    }

                    else if ((devKind == 6) && (order == 3) && (AgvNextDeviceKind == 2))//AGV向输送机放货20100710
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Base_Device set F_HaveGoods=").Append(nexttaskindex).Append(" where F_DeviceIndex=").Append(zxy[4]);
                        dbo.ExceSQL(sql.ToString());
                    }



                    #endregion
                }
                else
                {
                    #region 删除堆垛机取货，取消多叉关联

                    if ((devKind == 1) && (order == 4))//20120312
                    {
                        int stackdev = 0;
                        if (devinfo.VirtualStack > 0)
                        {//20111231
                            stackdev = devinfo.VirtualStack;
                        }
                        else
                        {
                            stackdev = DeviceIdx;
                        }
                        zxystr.Remove(0, zxystr.Length);
                        zxystr.Append((zxy[0].ToString().Length == 1 ? "0" + zxy[0].ToString() : zxy[0].ToString())).Append("-").Append(
                            ((zxy[1].ToString().Length == 1) ? ("0" + zxy[1].ToString()) : (zxy[1].ToString()))).Append("-").Append(
                            ((zxy[2].ToString().Length == 1) ? ("0" + zxy[2].ToString()) : (zxy[2].ToString())));
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT F_LifterDown,F_ChangeForkCell,T_Base_Lane_Gate.F_LaneGateDeviceIndex from T_Base_Lane_Gate,T_Base_LaneInfo ").Append(
                            " where T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex and T_Base_Lane_Gate.F_ZXY='").Append(zxystr).Append("' ").Append(
                            "  and T_Base_LaneInfo.F_StackIndex=").Append(stackdev);
                        dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dvlane.Count > 0)
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_PLC_Ask set F_TaskIndex=0,F_Remark='' where F_TaskIndex=").Append(TaskIdx).Append(" and F_DeviceIndex=").Append(dvlane[0]["F_LaneGateDeviceIndex"]);
                            dbo.ExecuteSql(sql.ToString());

                        }
                    }
                    #endregion
                }

                #region 嘉兴电力四楼的三个单元中的放行单元的同批号最后一箱通过42664后清除记录批号
                //20120906  42664的F_BoxBarcode记录批号，F_TaskIndex记录放行单元号
                if (DeviceIdx == 42664 && enddevice == 42639)
                {
                    if (IFSameStartDeviceControlBatchLastBox(mti, fid, DeviceIdx) == true)
                    {
                        dbo.ExecuteSql(string.Format("UPDATE T_Base_PLC_Ask SET F_TaskIndex = 0, F_BoxBarcode = '' WHERE (F_DeviceIndex = {0})", DeviceIdx));
                    }
                }
                #endregion
                #region 嘉兴电力进入码垛通道的批号变化时通知电气，不一样时，更新批号，给电气写入1,2代表不同批次
                //20120906  码垛通道入口输送机32620 42639;F_BoxBarcode记录批号,F_HaveFirstProject=1,2
                if (DeviceIdx == 32620 || DeviceIdx == 42639)
                {

                    SendBarCodePLC(barcode, DeviceIdx);
                    tsorder = ControlBatchAlterSendPLC(controlbatch, DeviceIdx);

                }
                #endregion
                //20130510
                if (DeviceIdx == 123061 || DeviceIdx == 123121)
                {//称重清零
                    dbo.ExecuteSql(string.Format("UPDATE T_Base_PLC_Ask SET F_BoxBarcode = '0' WHERE (F_DeviceIndex = {0})", DeviceIdx));
                }

                #region 保留AGV、RGV、堆垛机接驳口的输送机的条码20140109
                bool saveBarcode = false;
                sql.Clear();
                sql.Append("SELECT F_AGVGateDeviceIndex FROM T_Base_AGV_Gate where F_AGVGateDeviceIndex=").Append(DeviceIdx);
                if (dbo.GetSingle(sql.ToString()) != null)
                {
                    saveBarcode = true;
                }
                sql.Clear();
                sql.Append("SELECT F_RGVGateDeviceIndex FROM T_Base_RGV_Gate where F_RGVGateDeviceIndex=").Append(DeviceIdx);
                if (dbo.GetSingle(sql.ToString()) != null)
                {
                    saveBarcode = true;
                }
                sql.Clear();
                sql.Append("SELECT F_LaneGateDeviceIndex FROM T_Base_Lane_Gate where F_LaneGateDeviceIndex=").Append(DeviceIdx);
                if (dbo.GetSingle(sql.ToString()) != null)
                {
                    saveBarcode = true;
                }
                if (saveBarcode == true)
                {
                    dbo.ExecuteSql(string.Format("UPDATE T_Base_Device SET F_PALLETBARCODE =  '{0}' WHERE (F_DeviceIndex = {1})", barcode, DeviceIdx));//20140309
                }
                #endregion
                sql.Remove(0, sql.Length);
                sql.Append("delete from T_Monitor_Task   where F_MonitorIndex=").Append(TaskIdx);
                dbo.ExceSQL(sql.ToString());
                //dbo.TransCommit();
                //给PLC发送应答头是2，其余都是零
                //根据设备类型判断错误编号


                if (ClearZero == 1)
                {
                    if (mti == 1)
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("UPDATE IO_CONTROL  SET  ERROR_TEXT =''  WHERE CONTROL_ID=").Append(fid).Append(" and CONTROL_STATUS<900");
                        dboM.ExceSQL(sql.ToString());
                    }


                    if ((devKind == 1) || (devKind == 6)) //堆垛机、AGV
                    {

                        sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                        sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0);
                    }
                    else
                    {//输送机、RGV故障清零
                        //20130221增加对RGV，AGV等取货站台的应答保护：只有DeviceIdx出口有货时才应答
                        //if (devKind == 2 && UnAccordResponse(DeviceIdx)==true ) { }
                        //else
                        //{
                        sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);

                        sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0);
                        //witemnames[0].Clear();
                        //witemnames[0].Append(Model.CGeneralFunction.DBSend).Append(".").Append(Convert.ToString(devinfo.Dbw1Address + 0)).Append(",b");//20130510
                        //wv[0].Clear();
                        //wv[0].Append("2");
                        ////sdo = CommModeCreate.CreateSendDeviceOrder(devinfo.DeviceIndex);
                        //sdo.WriteDBData(witemnames, wv, devinfo.S7Connection);

                        //}
                    }


                }
                CDataChangeEventArgs dcea = new CDataChangeEventArgs(null, null);
                OnDataChange("ActionComplete", dcea);

            }
            catch (Exception ex)
            {
                //dbo.TransRollback();
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", string.Format("报告完成时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rmea);
            }
            finally
            {//20100108
                //dvman.Dispose() ;
                //dv.Dispose();
                //dvlane.Dispose() ;
                //dvr.Dispose();
            }
        }

        private bool UnAccordResponse(int DeviceIdx)
        {//20130221
            DataView dv = new DataView();
            bool ifCheckHaveGoods = false;
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_AGVGateDeviceIndex FROM T_Base_AGV_Gate WHERE (F_AGVGateDeviceIndex = {0})", DeviceIdx)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    ifCheckHaveGoods = true;
                }
                if (ifCheckHaveGoods == false)
                {
                    dv = dbo.ExceSQL(string.Format("SELECT F_RGVGateDeviceIndex FROM T_Base_RGV_Gate WHERE (F_RGVGateDeviceIndex = {0})", DeviceIdx)).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        ifCheckHaveGoods = true;
                    }
                }
                if (ifCheckHaveGoods == true)
                {
                    devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                    if (CStaticClass.GetDevicePhotoelectric(devinfo.BindingDeviceOut) != 1) return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", string.Format("报告完成,UnAccordResponse时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rmea);
                return false;
            }
            finally
            {
                dv.Dispose();
            }
        }

        private bool GetNearDeviceInputTask(int DeviceIdx, string zxystr)
        {
            DataView dv = new DataView();
            DataView dvm = new DataView();
            DataView dm = new DataView();
            try
            {
                int stackdev = 0;
                devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                if (devinfo.VirtualStack > 0)
                {//20111231
                    stackdev = devinfo.VirtualStack;
                }
                else
                {
                    stackdev = DeviceIdx;
                }
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_LaneIndex, F_ZXY, F_NearDevice from T_Base_Lane_Gate,T_Base_LaneInfo ").Append(
                    " where T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex and T_Base_Lane_Gate.F_ZXY='").Append(zxystr).Append("' ").Append(
                    "  and T_Base_LaneInfo.F_StackIndex=").Append(stackdev);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    dv = dbo.ExceSQL(string.Format("SELECT F_LaneIndex, F_ZXY, F_NearDevice from T_Base_Lane_Gate where F_LaneIndex={0} and F_NearDevice={1}",
                        Convert.ToInt32(dv[0]["F_LaneIndex"]), Convert.ToInt32(dv[0]["F_NearDevice"]))).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {//堆垛机在这些货位的取货任务是否为第一个设备指令
                        char[] cc = new char[1] { '-' };
                        string[] sp; int z = 0, x = 0, y = 0;
                        object[] ob = new object[4];

                        for (int i = 0; i < dv.Count; i++)
                        {
                            sp = dv[i]["F_ZXY"].ToString().Split(cc);
                            z = Convert.ToInt32(sp[0]);
                            x = Convert.ToInt32(sp[1]);
                            y = Convert.ToInt32(sp[2]);
                            ob[0] = DeviceIdx;
                            ob[1] = z;
                            ob[2] = x;
                            ob[3] = y;
                            dvm = dbo.ExceSQL(string.Format("SELECT F_ManageTASKKINDINDEX, F_ManageTaskIndex, F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex = {0}  and F_DeviceCommandIndex=4 and F_Status=0) AND (F_NumParam1 = {1}) AND (F_NumParam2 = {2}) AND (F_NumParam3 = {3})  order by F_MonitorIndex asc", ob)).Tables[0].DefaultView;
                            if (dvm.Count > 0)
                            {
                                dm = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex,F_ManageTASKKINDINDEX, F_ManageTaskIndex FROM T_Monitor_Task where F_ManageTASKKINDINDEX={0} and  F_ManageTaskIndex={1} order by   F_MonitorIndex asc", Convert.ToInt32(dvm[0]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dvm[0]["F_ManageTASKINDEX"]))).Tables[0].DefaultView;
                                if (dm.Count > 0)
                                {
                                    if (dm[0]["F_MonitorIndex"].ToString() == dvm[0]["F_MonitorIndex"].ToString())
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Monitor_Task set F_MonitorTaskLevel=10 where F_ManageTASKKINDINDEX=").Append(dvm[0]["F_ManageTASKKINDINDEX"]).Append(" and F_ManageTaskIndex=").Append(dvm[0]["F_ManageTaskIndex"]);
                                        dbo.ExceSQL(sql.ToString());
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Manage_Task set FTASKLEVEL=10 where F_ManageTASKKINDINDEX=").Append(dvm[0]["F_ManageTASKKINDINDEX"]).Append(" and FID=").Append(dvm[0]["F_ManageTaskIndex"]);
                                        dbo.ExceSQL(sql.ToString());
                                        return true;
                                    }
                                }
                            }

                        }

                    }
                }
                return false;
            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", string.Format("报告完成时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rmea);
                return false;
            }
            finally
            {
                dv.Dispose();
                dvm.Dispose();
            }

        }

        private int ControlBatchAlterSendPLC(string conbatch, int DeviceIdx)
        {//码垛批次号对应设备：DeviceIdx+“5”
            DataView dv = new DataView();
            int order = 0;
            try
            {
                devinfo = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(DeviceIdx.ToString() + "5"));

                dv = dbo.ExceSQL(string.Format("SELECT F_BoxBarcode, F_HaveFirstProject FROM T_Base_PLC_Ask WHERE (F_DeviceIndex = {0})", devinfo.DeviceIndex)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {//F_BoxBarcode正在码垛的批号；F_HaveFirstProject上次给PLC写入的值1,2
                    if (dv[0]["F_BoxBarcode"].ToString() != conbatch)
                    {//批号不相同
                        //witemnames = new StringBuilder[1] { new StringBuilder("DB1,byte" + devinfo.Dbw1Address.ToString()) };
                        //wv = new StringBuilder[1] { new StringBuilder("2") };
                        if (dv[0]["F_HaveFirstProject"].ToString() == "1")
                        {//写入2
                            //wv[0].Clear();
                            //wv[0].Append("2");
                            order = 2;
                            //sdo = CommLayerFactory.CommModeCreate.CreateSendDeviceOrder(devinfo.DeviceIndex);
                            //if (sdo.WriteDBData(witemnames, wv) == true)
                            //{
                            //    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "码垛批次号写入", DeviceIdx.ToString(), "批次：" + conbatch.ToString() + ",2");

                            dbo.ExceSQL(string.Format("update T_Base_PLC_Ask set F_BoxBarcode='{1}',F_HaveFirstProject = '2'  WHERE (F_DeviceIndex = {0})", devinfo.DeviceIndex, conbatch));
                            //}
                            //else
                            //{
                            //    RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成ControlBatchAlterSendPLC时：{0}", "码垛批次号写入失败！"));
                            //    OnRefreshMonitor(rme);
                            //}
                        }
                        else
                        {//写入1
                            //witemnames = new StringBuilder[1] { new StringBuilder("DB1,byte" + devinfo.Dbw1Address.ToString()) };
                            //wv = new StringBuilder[1] { new StringBuilder("1") };
                            //wv[0].Clear();
                            //wv[0].Append("1");
                            order = 1;
                            //sdo = CommLayerFactory.CommModeCreate.CreateSendDeviceOrder(devinfo.DeviceIndex);
                            //if (sdo.WriteDBData(witemnames, wv) == true)
                            //{
                            //    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "码垛批次号写入", DeviceIdx.ToString(), "批次：" + conbatch.ToString() + ",1");

                            dbo.ExceSQL(string.Format("update T_Base_PLC_Ask set F_BoxBarcode='{1}',F_HaveFirstProject = '1'  WHERE (F_DeviceIndex = {0})", devinfo.DeviceIndex, conbatch));
                            //}
                            //else
                            //{
                            //    RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成ControlBatchAlterSendPLC时：{0}", "码垛批次号写入失败！"));
                            //    OnRefreshMonitor(rme);
                            //}
                        }
                    }
                    else
                    {//批号相同
                        //witemnames = new StringBuilder[1] { new StringBuilder("DB1,byte" + devinfo.Dbw1Address.ToString()) };
                        //wv = new StringBuilder[1] { new StringBuilder("1") };
                        //wv[0].Clear();
                        //wv[0].Append(dv[0]["F_HaveFirstProject"].ToString());
                        order = Convert.ToInt32(dv[0]["F_HaveFirstProject"]);
                        //sdo = CommLayerFactory.CommModeCreate.CreateSendDeviceOrder(devinfo.DeviceIndex);
                        //if (sdo.WriteDBData(witemnames, wv) == true)
                        //{
                        //    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "码垛批次号写入", DeviceIdx.ToString(), "批次：" + conbatch.ToString() + ",1");

                        //dbo.ExceSQL(string.Format("update T_Base_PLC_Ask set F_BoxBarcode='{1}',F_HaveFirstProject = '1'  WHERE (F_DeviceIndex = {0})", devinfo.DeviceIndex, conbatch));
                        //}
                        //else
                        //{
                        //    RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成ControlBatchAlterSendPLC时：{0}", "码垛批次号写入失败！"));
                        //    OnRefreshMonitor(rme);
                        //}
                    }
                }
                else
                {
                    RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成ControlBatchAlterSendPLC时：{0}", "设备不存在！"));
                    OnRefreshMonitor(rme);

                }
                return order;
            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成ControlBatchAlterSendPLC时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rme);
                return 0;
            }
            finally
            {
                dv.Dispose();
            }
        }
        private void SendBarCodePLC(string barcode, int DeviceIdx)
        {//码垛口来料箱条码号对应设备：DeviceIdx+“6”
            DataView dv = new DataView();
            try
            {
                dbo.ExceSQL(string.Format("update T_Base_PLC_Ask set F_remark='{0}'   WHERE (F_DeviceIndex = {1})", barcode, DeviceIdx));
                //devinfo = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(DeviceIdx.ToString() + "6"));
                //witemnames = new StringBuilder[devinfo.Dbw1SendLength];
                //wv = new StringBuilder[devinfo.Dbw1SendLength];
                //byte[] bytebc = ASCIIEncoding.ASCII.GetBytes(barcode);
                //for (int i = 0; i < devinfo.Dbw1SendLength; i++)
                //{
                //    witemnames[i] = new StringBuilder("DB1,byte" + (devinfo.Dbw1Address + i).ToString());
                //    if (i < bytebc.Length)
                //    {
                //        wv[i] = new StringBuilder(bytebc[i].ToString());
                //    }
                //    else
                //    {
                //        wv[i] = new StringBuilder("0");
                //    }
                //}

                //sdo = CommLayerFactory.CommModeCreate.CreateSendDeviceOrder(devinfo.DeviceIndex);
                //sdo.WriteDBData(witemnames, wv);
                //CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "码垛口到位料箱条码", DeviceIdx.ToString(), "条码：" + barcode.ToString());

                //return;


            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成IFSameStartDeviceControlBatchLastBox时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rme);
                return;
            }
            finally
            {
                dv.Dispose();
            }
        }
        private bool IFSameStartDeviceControlBatchLastBox(int mti, int fid, int endconveyor)
        {
            DataView dv = new DataView();
            try
            {
                string startdev = string.Empty, conbatch = string.Empty;
                dv = dbo.ExceSQL(string.Format("SELECT FSTARTDEVICE, FCONTORL_BATCH FROM T_Manage_Task WHERE (F_ManageTaskKindIndex ={0}) AND (FID = {1})", mti, fid)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    startdev = dv[0]["FSTARTDEVICE"].ToString();
                    conbatch = dv[0]["FCONTORL_BATCH"].ToString();
                }
                else
                {
                    return false;
                }
                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex FROM T_Manage_Task,T_Monitor_Task where T_Manage_Task.F_ManageTaskKindIndex = T_Monitor_Task.F_ManageTASKKINDINDEX AND FID = F_ManageTaskIndex and (FSTARTDEVICE = '{0}') AND (FCONTORL_BATCH = '{1}') AND (T_Monitor_Task.F_NumParam4 = {2})", startdev, conbatch, endconveyor)).Tables[0].DefaultView;
                if (dv.Count == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }

            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理报完成IFSameStartDeviceControlBatchLastBox时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rme);
                return false;
            }
            finally
            {
                dv.Dispose();
            }
        }

        private int GetLaneGateDevice(int stackDevice, string zxy)
        {//20120820
            DataView dv = new DataView();
            try
            {
                devinfo = Model.CGetInfo.GetDeviceInfo(stackDevice);
                if (devinfo.VirtualStack > 0)
                {
                    stackDevice = devinfo.VirtualStack;
                }
                dv = dbo.ExceSQL(string.Format("SELECT T_Base_Lane_Gate.F_LaneGateDeviceIndex FROM T_Base_Lane_Gate ,T_Base_LaneInfo WHERE  T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex And (T_Base_LaneInfo.F_StackIndex = {0}) AND (T_Base_Lane_Gate.F_ZXY = '{1}')", stackDevice, zxy)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0][0]);
                }
                else
                {
                    return -1;
                }
            }

            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        /// <summary>
        /// 处理由于多线程产生死锁的SQL语句
        /// </summary>
        public void ActionDeadLock()
        {//20100108
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("select * from T_DeadLock where f_flag=0 order by f_id asc");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                for (int i = 0; i < dv.Count; i++)
                {
                    try
                    {
                        dbo.ExceSQL(dv[i]["f_SQL"].ToString());
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_DeadLock set f_flag=1 where f_id=").Append(dv[i]["f_id"]);
                        dbo.ExceSQL(sql.ToString());
                    }
                    catch
                    {
                        continue;
                    }
                }
            }//20100108
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }


        /// <summary>
        /// 回写设备错误状态字（IO_Control,T_Manage_Task,T_Monitor_task）
        /// </summary>
        /// <param name="DeviceIdx">设备索引</param>
        /// <param name="TaskIdx">设备指令索引</param>
        /// <param name="ErrId">错误编号</param>
        public void ActionError(int DeviceIdx, int TaskIdx, int ErrId)
        {
            //dbo.TransBegin();
            //20100108
            DataView dvmon = new DataView();
            DataTable dt = new DataTable();
            DataView dv0 = new DataView();
            DataView dvm = new DataView();
            DataView dvIO = new DataView();
            DataRowView dr = null;


            try
            {
                devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                int devKind = ccf.GetDeviceKindIdx(DeviceIdx);
                CDataChangeEventArgs dcea = new CDataChangeEventArgs(null, null);
                //090915
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task where  F_Status =1 and F_DeviceIndex =").Append(DeviceIdx);

                //20100108
                dvmon = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if ((dvmon.Count > 0) && (TaskIdx == 0))
                {
                    TaskIdx = Convert.ToInt32(dvmon[0]["F_MonitorIndex"]);
                }

                #region 有过记录的故障设备的任务号，不再重复处理

                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_DeviceIndex FROM T_Base_Device where F_DeviceIndex=").Append(DeviceIdx).Append(" and F_ErrorTaskNo=").Append(TaskIdx);

                //20100108
                dt = dbo.ExceSQL(sql.ToString()).Tables[0];
                if (dt.Rows.Count >= 1)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("update T_Monitor_Task set F_Status= ").Append(ErrId).Append("  where (F_MonitorIndex= ").Append(TaskIdx).Append(") and ((F_Status<> ").Append(ErrId).Append(") and (F_Status<> 3 and F_Status>0))");//20121203
                    int errc = dbo.ExecuteSql(sql.ToString());
                    if (errc > 0)//20110603
                    {

                        OnDataChange("ActionError", dcea);
                    }
                    int[] corrtaskindex = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, devKind);
                    if ((corrtaskindex != null) && (CStaticClass.DeviceErrorAutoModifyRoutePath == "0"))
                    {//20120328
                        for (int i = 0; i < corrtaskindex.GetLength(0); i++)
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Monitor_Task set F_Status= ").Append(ErrId).Append("  where (F_MonitorIndex= ").Append(corrtaskindex[i]).Append(") and ((F_Status<> ").Append(ErrId).Append(") and (F_Status<> 3 and F_Status>0))");//20121203
                            dbo.ExecuteSql(sql.ToString());

                        }
                    }
                    return;
                }

                #endregion

                if (GetManage_Kind(TaskIdx) == false) return;
                int fid = _fid;
                int mti = _mti;
                if (fid <= 0) return;

                #region 通用故障处理

                errs = Model.CGetInfo.GetErrorInfo(Convert.ToInt32(devKind.ToString() + ErrId.ToString()));
                if (errs != null)
                {

                    if (errs.ErrorIndex > 0)
                    {

                        RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("notifyIcon1", string.Format("警告:{0},{1},发生故障：{2}", devinfo.DeviceName, DeviceIdx, errs.ErrorName));
                        OnRefreshMonitor(rmea);

                        if (mti == 1)
                        {
                            //宁波地铁故障给管理报3
                            sql.Remove(0, sql.Length);
                            sql.Append("update IO_Control set CONTROL_STATUS=3,ERROR_TEXT='").Append(devinfo.DeviceName).Append(",").Append(DeviceIdx).Append(errs.ErrorName).Append("' where CONTROL_ID=").Append(fid);
                            dboM.ExceSQL(sql.ToString());
                        }
                        //20100108
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT F_DeviceIndex, F_ErrorIndex FROM T_Base_Device_Error_Log Where F_ManageTaskNo=").Append(fid).Append(" and F_DeviceIndex=").Append(DeviceIdx).Append(" and F_ErrorIndex=").Append(errs.ErrorIndex);
                        dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv0.Count > 0)
                        {//20091107
                            sql.Remove(0, sql.Length);
                            sql.Append("UPDATE T_Base_Device_Error_Log SET F_DateTime ='").Append(DateTime.Now.ToString("u")).Append("'  Where F_DeviceIndex=").Append(DeviceIdx).Append(" and F_ErrorIndex=").Append(errs.ErrorIndex).Append(" and F_ManageTaskNo=").Append(fid);
                            dbo.ExceSQL(sql.ToString());
                        }
                        else
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("INSERT INTO T_Base_Device_Error_Log (F_ManageTaskNo,F_DeviceIndex, F_ErrorIndex, F_DateTime) VALUES (").Append(fid).Append(",").Append(DeviceIdx).Append(",").Append(errs.ErrorIndex).Append(",'").Append(DateTime.Now.ToString("u")).Append("')");
                            dbo.ExceSQL(sql.ToString());
                        }
                    }
                }


                sql.Remove(0, sql.Length);
                sql.Append("update T_Monitor_Task set F_Status= ").Append(ErrId).Append("  where F_MonitorIndex= ").Append(TaskIdx).Append(" and (F_Status<> 3 and F_Status>0)");//20121203
                dbo.ExceSQL(sql.ToString());
                //记录发生故障的设备正在执行的任务号
                sql.Remove(0, sql.Length);
                sql.Append("update T_Base_Device set F_ErrorTaskNo= ").Append(TaskIdx).Append("  where F_DeviceIndex= ").Append(DeviceIdx);
                dbo.ExceSQL(sql.ToString());
                sql.Remove(0, sql.Length);
                if (errs != null)
                {//20160501
                    sql.Append("update T_Manage_Task set FERRORCODE='").Append(devinfo.DeviceName).Append(",").Append(DeviceIdx).Append(errs.ErrorName).Append("' where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                }
                else
                {
                    sql.Append("update T_Manage_Task set FERRORCODE='").Append(devinfo.DeviceName).Append(",").Append(DeviceIdx).Append("故障:").Append(ErrId).Append("' where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                }
                dbo.ExceSQL(sql.ToString());

                #endregion

                if (CStaticClass.DeviceErrorAutoModifyRoutePath == "1")
                {//故障自动改道处理

                    #region 堆垛机异常处理（取空和送重）
                    if ((devKind == 1))//堆垛机
                    {
                        int[] mforkMoninfo = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, devKind);
                        StringBuilder rcontrolidstr = new StringBuilder(); StringBuilder errusefork = new StringBuilder();
                        Model.MIOControlStatus mioc = Model.CGetInfo.GetIOControlStatus(ErrId);
                        if (devinfo.IfCorrelDoubleFork == "1")
                        {//多叉
                            char[] cc = new char[1] { ',' };

                            string[] errforks = mioc.ForkNo.Split(cc);
                            for (int i = 0; i < errforks.GetLength(0); i++)
                            {
                                errusefork.Append(" FUseAwayFork='").Append(errforks[i]).Append("' or ");
                            }
                            errusefork.Remove(errusefork.Length - 3, 3);
                            int relcontrolid = ccf.GetRELATIVECONTORLIDFromManageTask(mti, fid);
                            rcontrolidstr.Clear();
                            if (relcontrolid > 0)
                            {//20130704
                                rcontrolidstr.Append(" F_RELATIVECONTORLID =  ").Append(relcontrolid);
                            }
                            else
                            {
                                rcontrolidstr.Append(" FID =  ").Append(fid);
                            }
                        }
                        else
                        {//单叉
                            errusefork.Clear();
                            errusefork.Append(" 1=1 ");
                            rcontrolidstr.Append(" FID =  ").Append(fid);
                        }
                        if (mioc != null && mioc.StatusCode.IndexOf("STACKEMPTYOUTPUT") >= 0)//堆垛机的出库取空处理
                        {
                            #region 堆垛机的取空处理,删除故障任务;异常完成980
                            int[] zxy = ccf.GetCoordinatesFromMonitorTask(TaskIdx);
                            StringBuilder zxystr = new StringBuilder();
                            if (zxy != null)
                            {
                                //堆垛机取货坐标
                                zxystr.Append((zxy[0].ToString().Length == 1 ? "0" + zxy[0].ToString() : zxy[0].ToString())).Append("-").Append(
                                    ((zxy[1].ToString().Length == 1) ? ("0" + zxy[1].ToString()) : (zxy[1].ToString()))).Append("-").Append(
                                    ((zxy[2].ToString().Length == 1) ? ("0" + zxy[2].ToString()) : (zxy[2].ToString())));
                            }
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_ZXY FROM T_Base_Lane_Gate WHERE (F_ZXY = '").Append(zxystr).Append("')");
                            dvIO = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvIO.Count > 0)
                            {//巷道的出入口输送机对应的货位不处理取空报警
                                return;
                            }
                            sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                            sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0);
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT FID FROM T_Manage_Task WHERE (").Append(rcontrolidstr.ToString()).Append(") AND (F_ManageTaskKindIndex = ").Append(mti).Append(") and (").Append(errusefork).Append(" )");
                            dvm = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            for (int m = 0; m < dvm.Count; m++)
                            {
                                fid = Convert.ToInt32(dvm[m]["FID"]);
                                //删除任务后报告异常完成980
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Monitor_Task set F_STATUS=-1 where F_ManageTaskKindIndex=").Append(mti).Append(" and F_ManageTaskIndex=").Append(fid).Append(" and F_STATUS=0");
                                dbo.ExceSQL(sql.ToString());
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Manage_Task set FExceptionNO=").Append(Model.CGeneralFunction.TASKEMPTYOUTPUT).Append(" where (F_ManageTaskKindIndex = ").Append(mti).Append(") AND (FID = ").Append(fid).Append(")");
                                dbo.ExceSQL(sql.ToString());

                                sql.Remove(0, sql.Length);
                                sql.Append("select * from T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                                dvIO = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                for (int i = 0; i < dvIO.Count; i++)
                                {
                                    ActionComplete(Convert.ToInt32(dvIO[i]["F_DeviceIndex"]), Convert.ToInt32(dvIO[i]["F_MonitorIndex"]), Model.CGeneralFunction.TASKDELETE);

                                }
                            }
                            #region 多叉关联的已经取货完成的任务报完成
                            if (mforkMoninfo != null && devinfo.IfCorrelDoubleFork == "1")
                            {
                                foreach (int rtask in mforkMoninfo)
                                {
                                    ActionComplete(DeviceIdx, rtask, 1);
                                }
                            }
                            #endregion
                            #endregion
                        }
                        else if (mioc != null && mioc.StatusCode.IndexOf("STACKREPEATINPUT") >= 0)//堆垛机的入库送货重
                        {
                            #region 堆垛机的送货重，需要改路径处理;异常完成970

                            #region 自动在库内更换新货位

                            #region 堆垛机的送货重需要改路径处理
                            //20091107
                            //20100108
                            dvIO = dboM.ExceSQL("select CONTROL_ID, CONTROL_STATUS from IO_Control where (CONTROL_ID = " + fid + ") AND ((CONTROL_STATUS=" + Model.CGeneralFunction.TASKREPEATINPUT + ") or (CONTROL_STATUS=" + Model.CGeneralFunction.TASKALTERROUTEREPLY + "))").Tables[0].DefaultView;
                            if (dvIO.Count <= 0)
                            {
                                //向管理申请修改任务
                                //20100108
                                dvm = dbo.ExceSQL("select * from T_Manage_Task WHERE (FID = " + fid + ") AND (F_ManageTASKKINDINDEX =" + mti + ")").Tables[0].DefaultView;
                                if (dvm.Count > 0)
                                {
                                    string fwarehouse = dvm[0]["FSTARTWAREHOUSE"].ToString();
                                    int flane = Convert.ToInt32(dvm[0]["FLANEWAY"]);
                                    string fcode = dvm[0]["FENDCELL"].ToString();
                                    if (ccf.QueryCellIfExit(fwarehouse, flane, fcode) == true)
                                    {
                                        //20091128
                                        //20100108
                                        dr = dvm[0];
                                        //20100108
                                        //DV = dboM.ExceSQL("select IO_CONTROL_APPLY_SEQ.NEXTVAL FROM DUAL").Tables[0].DefaultView;
                                        //int id = dboM.GetManageTableIndex("IO_CONTROL_APPLY");

                                        string dtime = DateTime.Now.ToString("u");
                                        dtime = dtime.Substring(0, dtime.Length - 1);
                                        dboM.TransBegin();
                                        try
                                        {

                                            if (CStaticClass.ManDBFactory == "OracleDBFactory")
                                            {

                                                dboM.ExceSQL("update IO_Control set CONTROL_STATUS=" + Model.CGeneralFunction.TASKREPEATINPUT + ",ERROR_TEXT='" + DeviceIdx + errs.ErrorName + ";原货位：" + "'||END_DEVICE_CODE where CONTROL_ID=" + fid);
                                            }
                                            else
                                            {
                                                dboM.ExceSQL("update IO_Control set CONTROL_STATUS=" + Model.CGeneralFunction.TASKREPEATINPUT + ",ERROR_TEXT='" + DeviceIdx + errs.ErrorName + ";原货位：" + "'+END_DEVICE_CODE where CONTROL_ID=" + fid);
                                                //dboM.TransCommit();
                                                //dboM.ExceSQL("update IO_Control set CONTROL_STATUS=3" + ",ERROR_TEXT='" + DeviceIdx + errs.ErrorName + ";原货位：" + "'+END_DEVICE_CODE where CONTROL_ID=" + fid);
                                            }
                                            //string sql1 = "INSERT INTO IO_CONTROL_APPLY (CONTROL_APPLY_ID, CONTROL_ID,CONTROL_APPLY_TYPE, WAREHOUSE_CODE, STOCK_BARCODE, DEVICE_CODE,APPLY_TASK_STATUS, FCREATETIME, FREMARK)" +
                                            //"VALUES (" + id + "," + dr["FID"] + ",2,'" + dr["FENDWAREHOUSE"] + "','" + dr["FPALLETBARCODE"] + "','" + dr["FENDDEVICE"] + "',0,'" + dtime + "',null)";
                                            //dboM.ExceSQL(sql1);
                                            dboM.TransCommit();

                                            dbo.ExceSQL("update T_Manage_Task set FExceptionNO=" + Model.CGeneralFunction.TASKREPEATINPUT + ",FERRORCODE='" + DeviceIdx + errs.ErrorName + ";原货位：" + "'+ FENDCELL where (F_ManageTaskKindIndex = " + mti + ") AND (FID = " + fid + ")");
                                            //把ManageTaskIdx，ManageKindIdx 的调度任务全部申请改道
                                            dbo.ExceSQL("UPDATE T_Monitor_Task SET  F_Status = 3 WHERE (F_ManageTaskIndex = " + fid + ") AND (F_ManageTASKKINDINDEX =" + mti + ")");




                                        }
                                        catch (Exception ex)
                                        {
                                            _CGetStateError = "堆垛机送货时发生送重故障，改道时：" + ex.Message;
                                            dboM.TransRollback();
                                        }
                                    }
                                }
                            }//20091107
                            #endregion

                            #endregion

                            //#region 送出到人工处理口
                            ////先清零，删除故障任务，解除lockstate，然后直接改道出口
                            //System.Threading.Thread.Sleep(3000);
                            //sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                            //sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0);
                            ////20100710
                            //int[] zxy = ccf.GetCoordinatesFromMonitorTask(TaskIdx);
                            //StringBuilder zxystr = new StringBuilder();
                            //if (zxy != null)
                            //{
                            //    //堆垛机送货坐标
                            //    zxystr.Append((zxy[3].ToString().Length == 1 ? "0" + zxy[3].ToString() : zxy[3].ToString())).Append("-").Append(
                            //        ((zxy[4].ToString().Length == 1) ? ("0" + zxy[4].ToString()) : (zxy[4].ToString()))).Append("-").Append(
                            //        ((zxy[5].ToString().Length == 1) ? ("0" + zxy[5].ToString()) : (zxy[5].ToString())));
                            //}
                            //sql.Remove(0, sql.Length);
                            //sql.Append("SELECT F_ZXY FROM T_Base_Lane_Gate WHERE (F_ZXY = '").Append(zxystr.ToString()).Append("')");
                            //dvIO = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            //if (dvIO.Count > 0)
                            //{//巷道的出入口输送机对应的货位不处理送空报警
                            //    return;
                            //}
                            //sql.Clear();
                            //sql.Append("SELECT FID FROM T_Manage_Task WHERE (").Append(rcontrolidstr.ToString()).Append(") AND (F_ManageTaskKindIndex = ").Append(mti).Append(") and (").Append(errusefork).Append(" )");
                            //dvm = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            //for (int m = 0; m < dvm.Count; m++)
                            //{
                            //    fid = Convert.ToInt32(dvm[m]["FID"]);
                            //    //堆垛机的送货重，只保留堆垛机的送货任务
                            //    //是应急站台，把原来的终点改为起点改道至应急站台
                            //    int enddevice = devinfo.StackAbendOut;
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("update T_Manage_Task set FCONTROLTASKTYPE=2,FSTARTDEVICE=FENDDEVICE,FSTARTCELL=FENDCELL,FENDDEVICE=").Append(enddevice
                            //        ).Append(",FENDCELL='-',FExceptionNO=").Append(Model.CGeneralFunction.TASKREPEATINPUT).Append(" where (FID = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                            //    dbo.ExceSQL(sql.ToString());
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("select FSTARTDEVICE from T_Manage_Task where (FID = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                            //    int sdevice = Convert.ToInt32(dbo.GetSingle(sql.ToString()));
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("select FENDDEVICE from T_Manage_Task where (FID = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                            //    int edevice = Convert.ToInt32(dbo.GetSingle(sql.ToString()));

                            //    int routeidNew = CDisassembleTask.MinRouteID(sdevice, edevice, true, dvm);//20110331
                            //    if (routeidNew == -1) return;
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("DELETE FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                            //    dbo.ExceSQL(sql.ToString());
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("select * from T_Manage_Task where (FID = ").Append(fid).Append(") AND (F_ManageTASKKINDINDEX =").Append(mti).Append(")");
                            //    dvIO = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            //    if (dvIO.Count > 0)
                            //    {
                            //        dr = dvIO[0];
                            //    }
                            //    else
                            //    {
                            //        return;
                            //    }
                            //    CDisassembleTask.CreateMonitor(mti, fid, routeidNew, dr, 3);
                            //    sql.Remove(0, sql.Length);
                            //    sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(fid
                            //        ).Append(") AND (F_ManageTASKKINDINDEX = ").Append(mti).Append(") AND (F_DeviceIndex = ").Append(
                            //            DeviceIdx).Append(") AND (F_DeviceCommandIndex = 5) AND (F_RouteID = ").Append(routeidNew).Append(
                            //            ") AND (F_Status = 3)");
                            //    dvIO = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            //    if (dvIO.Count > 0)
                            //    {
                            //        sql.Remove(0, sql.Length);
                            //        sql.Append("delete from T_Monitor_Task where F_MonitorIndex<").Append(dvIO[0]["F_MonitorIndex"]).Append(" and (F_ManageTaskIndex = ").Append(
                            //            fid).Append(") AND (F_ManageTASKKINDINDEX = ").Append(mti).Append(") AND (F_Status = 3)");
                            //        dbo.ExceSQL(sql.ToString());
                            //        sql.Remove(0, sql.Length);
                            //        sql.Append("update T_Base_Device set F_LockedState=0 where F_DeviceIndex=").Append(DeviceIdx);
                            //        dbo.ExceSQL(sql.ToString());
                            //        sql.Remove(0, sql.Length);
                            //        sql.Append("update  T_Monitor_Task set F_Status =0 where (F_ManageTaskIndex = ").Append(
                            //        fid).Append(") AND (F_ManageTASKKINDINDEX = ").Append(mti).Append(") AND (F_Status = 3)");
                            //        dbo.ExceSQL(sql.ToString());
                            //    }
                            //}
                            //#region 多叉关联的已发送的送货任务需要重新发送
                            //if (mforkMoninfo != null && devinfo.IfCorrelDoubleFork == "1")
                            //{
                            //    foreach (int rtask in mforkMoninfo)
                            //    {
                            //        sql.Remove(0, sql.Length);
                            //        sql.Append("update T_Base_Device set F_LockedState=0 where F_DeviceIndex=").Append(DeviceIdx);
                            //        dbo.ExceSQL(sql.ToString());
                            //        sql.Remove(0, sql.Length);
                            //        sql.Append("update  T_Monitor_Task set F_Status =0 where F_MonitorIndex=").Append(rtask);
                            //        dbo.ExceSQL(sql.ToString());
                            //    }
                            //}
                            //#endregion
                            //#endregion
                            #endregion

                        }






                    }
                    #endregion

                    #region 高端条码扫描不正确报警需要改道至异常口
                    if ((devKind == 13 || devKind == 31) && (ErrId == 41))//40条码未读到；41条码不正确
                    {
                        int abenddevice = 0, startdev = 40100, startucode = ccf.GetUCodeFromDeviceGD(DeviceIdx);
                        if (startucode > 40100)
                        {
                            abenddevice = 42037;
                            startdev = 40100;
                        }
                        else
                        {
                            abenddevice = 32025;
                            if (startucode <= 30107)
                            {
                                startdev = 30100;
                            }
                            else
                            {
                                startdev = 30200;
                            }
                        }
                        //比对错误，改道异常处理口
                        //修改目标位置至异常口
                        object[] obj = new object[7] { mti, fid, abenddevice, Model.CGeneralFunction.TASKABEND, startdev, startucode, DeviceIdx };
                        dbo.ExecuteSql(string.Format("UPDATE T_Manage_Task SET FExceptionNO={3},FStartDEVICE ={4},FSTARTUCODE={5}, FStartCELL ='{6}',FENDDEVICE ={2}, FENDCELL ='-',  FENDUCODE =0 WHERE (F_ManageTaskKindIndex ={0}) AND (FID ={1})", obj));
                        ccf.GetUseableRouteIDSubAndModifyRoute(fid, mti, startdev);

                    }
                    #endregion
                }

                if (devinfo.UseCommonDB == "1")
                {
                    return;
                }

                OnDataChange("ActionError", dcea);

            }
            catch (Exception ex)
            {
                //dbo.TransRollback();
                RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", string.Format("向管理反馈设备错误时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rme);

            }
            finally
            {//20100108
                dvmon.Dispose();
                dt.Dispose(); ;
                dv0.Dispose();
                dvm.Dispose();
                dvIO.Dispose();
                dr = null;

            }

        }

        /// <summary>
        /// 设备开始运行：
        /// 1－根据任务号和探物情况判断任务执行的位置回写本地管理表
        /// 2－回写调度任务表的开始执行状态
        /// 3－判断是否存在提前触发任务
        /// 
        /// </summary>
        /// <param name="DeviceIdx">设备索引</param>
        /// <param name="TaskIdx">调度任务号</param>
        public void ActionStartRun(int DeviceIdx, int TaskIdx)
        {


            if (TaskIdx <= 0)
            {

                return;
            }


            int mti = ccf.GetManageTaskIndexfromMonitor(TaskIdx);
            int mtikind = ccf.GetManageTaskKindIndexFromMonitor(TaskIdx);
            //dbo.TransBegin();
            if (mti <= 0) return;
            DataView dvlane = new DataView();
            DataView dv = new DataView();
            DataView dv1 = new DataView();
            try
            {
                if (DeviceIdx == 12034)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("update T_Base_Device set F_ManTaskReserve=0 where F_ManTaskReserve=").Append((mtikind.ToString() + mti.ToString()));
                    dbo.ExceSQL(sql.ToString());
                }

                #region 修改调度任务状态20101124
                sql.Remove(0, sql.Length);
                sql.Append("update T_Monitor_Task set F_ErrorCode='', F_Status=2 where   F_MonitorIndex=" + TaskIdx);//20110505
                //20110405
                int urow = dbo.ExecuteSql(sql.ToString());
                if (urow > 0)
                {
                    devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                    int devKind = ccf.GetDeviceKindIdx(DeviceIdx);
                    int order = ccf.GetDeviceOrderFromMonitor(TaskIdx);
                    if (((devKind == 2 || devKind == 4) && (devinfo.IfClearDB1 == "1")))//20121203|| (devKind == 4)
                    {//输送机、RGV DB1清零
                        int[] sendmes = new int[5] { 0, 0, 0, DeviceIdx, 0 };
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (CStaticClass.IsEquals(devinfo.SendMessage, sendmes, 5) == false)
                        {
                            sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                            sdo.SendDeviceOrder(0, 0, 0, DeviceIdx, 0);

                        }
                    }
                    else if ((devKind == 1)) //堆垛机
                    {
                        int[] sendmes = new int[10] { 0, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0 };
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (CStaticClass.IsEquals(devinfo.SendMessage, sendmes, 10) == false)
                        {
                            sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
                            sdo.SendDeviceOrder(0, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0);
                        }
                    }

                    CDataChangeEventArgs cea = new CDataChangeEventArgs(null, null);
                    OnDataChange("ActionStartRun", cea);
                #endregion
               


                }//20110405


                #region 根据任务号和探物情况判断任务执行的位置回写本地管理表


                sql.Remove(0, sql.Length);
                sql.Append("update T_Manage_Task set FCurrentLocation=").Append(
                    DeviceIdx).Append(" where F_ManageTaskKindIndex=").Append(mtikind).Append(" and FID=").Append(mti);
                dbo.ExceSQL(sql.ToString());
                //调度任务表也记录当前位置，主要是给输送机链用
                sql.Remove(0, sql.Length);
                sql.Append("update T_Monitor_Task set F_CurrentLocation=").Append(
                    DeviceIdx).Append(" where F_MonitorIndex=").Append(TaskIdx);
                dbo.ExceSQL(sql.ToString());
                //20120518设备逻辑有物

                //20090918给堆垛机送货的输送机逻辑有物解锁F_HaveGoods=0
                //20100108
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_LaneGateDeviceIndex  FROM T_Base_Lane_Gate where F_LaneGateDeviceIndex=").Append(DeviceIdx);
                dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dvlane.Count > 0)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("update T_Base_Device set F_HaveGoods=0  where F_HaveGoods=").Append(TaskIdx);
                    dbo.ExceSQL(sql.ToString());
                }
                else
                {//20100710
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_AGVGateDeviceIndex  FROM T_Base_AGV_Gate where F_AGVGateDeviceIndex=").Append(DeviceIdx);
                    dvlane = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dvlane.Count > 0)
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Base_Device set F_HaveGoods=0  where F_HaveGoods=").Append(TaskIdx);
                        dbo.ExceSQL(sql.ToString());
                    }
                }

                #endregion
                //dbo.TransCommit();
                //RefreshControlMonitor(DeviceIdx);
                //20091107
                if (CStaticClass.MovedDeviceAheadTrigger == "1")
                {
                    #region 判断是否存在提前触发任务(设备号－调度任务号)
                    //当设备运行时，触发调度任务号运行F_AheadTrigger
                    //20100108
                    sql.Remove(0, sql.Length);
                    sql.Append("select F_AheadTrigger from T_Monitor_Task ").Append(
                        "where F_MonitorIndex=").Append(TaskIdx).Append(" and F_AheadTrigger like '").Append(DeviceIdx.ToString()).Append("-").Append("%'");
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        //发送提前触发的命令调度任务
                        char[] cc = new char[1] { '-' };
                        string[] sp = dv[0]["F_AheadTrigger"].ToString().Split(cc);
                        if (sp.GetLength(0) > 0)
                        {
                            int TriTask = Convert.ToInt32(sp[1]);
                            if (ccl.SendMonitorTask(TriTask) == true)
                            {
                                //清除触发命令
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Monitor_Task set F_AheadTrigger ='' where F_MonitorIndex=").Append(TaskIdx);
                                dbo.ExceSQL(sql.ToString());
                            }

                        }

                    }
                    #endregion
                }




            }
            catch (Exception ex)
            {
                CGetStateError = string.Format("ControlSystem.CGetState.报告执行时发生错误：{0}", ex.StackTrace + ex.Message);

            }
            finally
            {//20100108

                dvlane.Dispose();
                dv.Dispose();
            }
        }
        public bool GetManage_Kind(int taskidx)
        {//20100108
            DataSet ds = new DataSet();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_ManageTaskIndex, F_ManageTaskKindIndex, F_MonitorIndex FROM T_Monitor_Task Where F_MonitorIndex=").Append(taskidx);
                ds = dbo.ExceSQL(sql.ToString());
                if (ds.Tables[0].DefaultView.Count > 0)
                {
                    _fid = Convert.ToInt32(ds.Tables[0].DefaultView[0]["F_ManageTaskIndex"]);
                    _mti = Convert.ToInt32(ds.Tables[0].DefaultView[0]["F_ManageTaskKindIndex"]);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {//20100108
                ds.Dispose();
            }
        }





        public void ReturnManageInfo(int fid, int mti, string cap, bool IFOK)
        {
            string dtime = DateTime.Now.ToString("u");//20101028
            dtime = dtime.Substring(0, dtime.Length - 1);//20101028
            char[] cc = new char[1] { '-' };
            string[] fcc;
            DataView dv = new DataView();
            try
            {
                //200906240111增加货位记录:入库1-结束位置有货；出库2-起始位置无货；倒库3-起始位置无货，结束位置有货
                //20100108记录托盘号和大小托盘料箱
                sql.Remove(0, sql.Length);
                sql.Append("SELECT * FROM T_Manage_Task where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                string CELL_MODEL = string.Empty;
                if (string.IsNullOrEmpty(dv[0]["CELL_MODEL"].ToString()))
                {
                    CELL_MODEL = "0";
                }
                else
                {
                    CELL_MODEL = dv[0]["CELL_MODEL"].ToString();
                }
                if (dv.Count > 0)
                {
                    if (IFOK == true)
                    {

                        switch (dv[0]["FCONTROLTASKTYPE"].ToString())
                        {
                            case "1":
                                if (dv[0]["FENDCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FENDCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FCELLSTATUS = 1,FPALLETBARCODE='").Append(dv[0]["FPALLETBARCODE"]).Append("' WHERE (FLaneWay=").Append(dv[0]["FENDDEVICE"]).Append(" and F_Z='").Append(
                                    fcc[0]).Append("' and F_X='").Append(fcc[1]).Append("' and F_Y='").Append(fcc[2]).Append("')");
                                    dbo.ExceSQL(sql.ToString());
                                }
                                break;
                            case "2":
                                //cz改 出库任务记忆托盘号到数据库方便回送使用
                                if (dv[0]["FENDDEVICE"].ToString()=="22013")
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update  T_Manage_Barcode set barcode='").Append(dv[0]["FPALLETBARCODE"].ToString()).Append("',GOODS_HEIG='").Append(CELL_MODEL).Append("' where F_DeviceIndex='22013'");
                                     dbo.ExceSQL(sql.ToString());
                                    //如果当前任务是该分拣单号的最后一条任务 把分拣记录表的单号置空
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select WORK_MODE from SORTINGtemp where WORK_MODE=(select Work_Mode from T_Manage_Task where FID=").Append(fid.ToString()).Append(")");
                                    DataView tamp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (tamp.Count == 1)
                                    {
                                        sql.Clear();
                                        sql.Append("UPDATE SORTINGtemp SET WORK_MODE =NULL where F_DeviceIndex='21001'");
                                        dbo.ExceSQL(sql.ToString());

                                    }
                                }
                                if (dv[0]["FENDDEVICE"].ToString() == "12002")
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update  T_Manage_Barcode set barcode='").Append(dv[0]["FPALLETBARCODE"].ToString()).Append("',GOODS_HEIG='").Append(CELL_MODEL).Append("' where F_DeviceIndex='12002'");
                                    dbo.ExceSQL(sql.ToString());
                                    //如果当前任务是该分拣单号的最后一条任务 把分拣记录表的单号置空
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select WORK_MODE from SORTINGtemp where WORK_MODE=(select Work_Mode from T_Manage_Task where FID=").Append(fid.ToString()).Append(")");
                                    DataView tamp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (tamp.Count == 1)
                                    {
                                        sql.Clear();
                                        sql.Append("UPDATE SORTINGtemp SET WORK_MODE =NULL where F_DeviceIndex='11001'");
                                        dbo.ExceSQL(sql.ToString());

                                    }
                                }
                                
                            
                                if (dv[0]["FSTARTCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FSTARTCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FCELLSTATUS =0,FPALLETBARCODE='-' WHERE (FLaneWay=").Append(dv[0]["FSTARTDEVICE"]).Append("  and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }

                                break;
                            case "3":

                                if (dv[0]["FENDCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FENDCELL"].ToString().Split(cc);//FRUNSTATUS=0,
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FCELLSTATUS = 1,FPALLETBARCODE='").Append(dv[0]["FPALLETBARCODE"]).Append("'  WHERE (FLaneWay=").Append(dv[0]["FENDDEVICE"]).Append(" and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }
                                if (dv[0]["FSTARTCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FSTARTCELL"].ToString().Split(cc);//FRUNSTATUS=0,
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FCELLSTATUS =0,FPALLETBARCODE='-'  WHERE (FLaneWay=").Append(dv[0]["FSTARTDEVICE"]).Append("  and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }


                                break;
                            default:
                                break;
                        }


                        //20101028
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Manage_Task set FSTATUS=999,FENDTIME='").Append(dtime).Append("'  where  FID=").Append(fid).Append(" and F_ManageTaskKindIndex= ").Append(mti);
                        dbo.ExceSQL(sql.ToString());
                    }
                    else
                    {
                        switch (dv[0]["FCONTROLTASKTYPE"].ToString())
                        {
                            case "1":
                                if (dv[0]["FENDCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FENDCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FPALLETBARCODE='' WHERE (FLaneWay=").Append(dv[0]["FENDDEVICE"]).Append(" and F_Z='").Append(
                                    fcc[0]).Append("' and F_X='").Append(fcc[1]).Append("' and F_Y='").Append(fcc[2]).Append("')");
                                    dbo.ExceSQL(sql.ToString());
                                }
                                break;
                            case "2":
                                //cz改 出库任务记忆托盘号到数据库方便回送使用
                                if (dv[0]["FENDDEVICE"].ToString() == "22013")
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update  T_Manage_Barcode set barcode='").Append(dv[0]["FPALLETBARCODE"].ToString()).Append("',GOODS_HEIG='").Append(CELL_MODEL).Append("' where F_DeviceIndex='22013'");
                                    dbo.ExceSQL(sql.ToString());
                                    //如果当前任务是该分拣单号的最后一条任务 把分拣记录表的单号置空
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select WORK_MODE from SORTINGtemp where WORK_MODE=(select Work_Mode from T_Manage_Task where FID=").Append(fid.ToString()).Append(")");
                                    DataView tamp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (tamp.Count == 1)
                                    {
                                        sql.Clear();
                                        sql.Append("UPDATE SORTINGtemp SET WORK_MODE =NULL where F_DeviceIndex='21001'");
                                        dbo.ExceSQL(sql.ToString());

                                    }
                                }
                                if (dv[0]["FENDDEVICE"].ToString() == "12002")
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update  T_Manage_Barcode set barcode='").Append(dv[0]["FPALLETBARCODE"].ToString()).Append("',GOODS_HEIG='").Append(CELL_MODEL).Append("' where F_DeviceIndex='12002'");
                                    dbo.ExceSQL(sql.ToString());
                                    //如果当前任务是该分拣单号的最后一条任务 把分拣记录表的单号置空
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select WORK_MODE from SORTINGtemp where WORK_MODE=(select Work_Mode from T_Manage_Task where FID=").Append(fid.ToString()).Append(")");
                                    DataView tamp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (tamp.Count == 1)
                                    {
                                        sql.Clear();
                                        sql.Append("UPDATE SORTINGtemp SET WORK_MODE =NULL where F_DeviceIndex='11001'");
                                        dbo.ExceSQL(sql.ToString());

                                    }
                                }
                                if (dv[0]["FSTARTCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FSTARTCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FPALLETBARCODE='").Append(dv[0]["FPALLETBARCODE"]).Append("' WHERE (FLaneWay=").Append(dv[0]["FSTARTDEVICE"]).Append("  and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }
                                break;
                            case "3":
                                if (dv[0]["FENDCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FENDCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FPALLETBARCODE=''  WHERE (FLaneWay=").Append(dv[0]["FENDDEVICE"]).Append(" and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }
                                if (dv[0]["FSTARTCELL"].ToString().IndexOf("-") > 0)//20100905
                                {
                                    fcc = dv[0]["FSTARTCELL"].ToString().Split(cc);
                                    sql.Remove(0, sql.Length);
                                    sql.Append("UPDATE ST_CELL SET FRUNSTATUS=0,FPALLETBARCODE='").Append(dv[0]["FPALLETBARCODE"]).Append("'  WHERE (FLaneWay=").Append(dv[0]["FSTARTDEVICE"]).Append("  and F_Z=").Append(
                                    fcc[0]).Append(" and F_X=").Append(fcc[1]).Append(" and F_Y=").Append(fcc[2]).Append(")");
                                    dbo.ExceSQL(sql.ToString());
                                }

                                break;
                            default:
                                break;
                        }
                        //20101028
                        sql.Remove(0, sql.Length);
                        sql.Append("update T_Manage_Task set FSTATUS=900,FENDTIME='").Append(dtime).Append("'  where  FID=").Append(fid).Append(" and F_ManageTaskKindIndex= ").Append(mti);
                        dbo.ExceSQL(sql.ToString());
                    }
                }
                
                //20101028
                sql.Remove(0, sql.Length);
                sql.Append("INSERT INTO T_Manage_Task_BAK SELECT * FROM T_Manage_Task where  FID=").Append(fid).Append(" and F_ManageTaskKindIndex<>1");
                dbo.ExecuteSql(sql.ToString());
                sql.Remove(0, sql.Length);
                sql.Append("delete from T_Manage_Task   where  FID=").Append(fid).Append(" and F_ManageTaskKindIndex= ").Append(mti);
                dbo.ExceSQL(sql.ToString());
                CDataChangeEventArgs cea = new CDataChangeEventArgs(null, null);
                OnDataChange("ReturnManageInfo", cea);

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        /// <summary>
        /// 分类查找设备状态
        /// </summary>
        /// <param name="TaskIdx">设备指令索引</param>
        /// <param name="DeviceIdx">设备编号</param>
        /// <param name="State">设备状态</param>
        public void GetKindDeviceState(int TaskIdx, int DeviceIdx, int State)
        {

            int fid = ccf.GetManageTaskIndexfromMonitor(TaskIdx);
            int mti = ccf.GetManageTaskKindIndexFromMonitor(TaskIdx);
            if (fid <= 0) return;
            if (State >= 10)//故障
            {
                //回写设备错误状态字（IO_Control,T_Manage_Task,T_Monitor_task）

                ActionError(DeviceIdx, TaskIdx, State);//
                #region 多叉关联任务能同步运行的同时报告故障
                //devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                //if (devinfo.IfCorrelDoubleFork == "1")
                //{
                //    if (Model.CGeneralFunction.DoubleForkIfSync(TaskIdx, DeviceIdx, 1) == true)
                //    {
                //        string[] df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(TaskIdx, DeviceIdx);
                //        if (df != null)
                //        {
                //            ActionError(Convert.ToInt32(df[2]), Convert.ToInt32(df[0]), States[1]);
                //        }
                //    }
                //}
                #endregion
                //刷新监控中心显示

            }


            switch (ccf.GetDeviceKindIdx(DeviceIdx))
            {
                //正在运行的设备如果有探物就是说托盘运行到此设备
                //根据任务号判断是否为调度任务，改写T_Manage_Task的当前位置
                //根据任务号和当前位置判断是否有提前触发任务
                //任务号传递到当前设备时，把本路径的前一设备的运行锁解除，
                //同时把当前设备加运行锁

                case 1://堆垛机:
                    //1-正在运行 2-完成;3-要求调度重发命令;
                    //4-通知调度取消当前任务;其它值表示错误
                    if (State == 1)//开始运行
                    {//正在运行的设备如果有探物就是说托盘运行到此设备
                        ActionStartRun(DeviceIdx, TaskIdx);
                        if (mti == 1)
                        {//20100714
                            sql.Remove(0, sql.Length);
                            sql.Append("update IO_CONTROL set CONTROL_STATUS=10 where CONTROL_ID=").Append(fid);
                            dboM.ExecuteSql(sql.ToString());
                        }
                        #region 多叉关联任务，能同步的同时报告运行
                        //20100323
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (devinfo.IfCorrelDoubleFork == "1")
                        {
                            int[] corrtasks = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, 1);
                            if (corrtasks != null)
                            {
                                Dictionary<int, string[]> df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(TaskIdx, DeviceIdx);
                                if (df != null)
                                {
                                    foreach (int corrtask in corrtasks)
                                    {
                                        ActionStartRun(Convert.ToInt32(df[corrtask][2]), corrtask);
                                        if (mti == 1)
                                        {//20100714
                                            fid = ccf.GetManageTaskIndexfromMonitor(corrtask);
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update IO_CONTROL set CONTROL_STATUS=10 where CONTROL_ID=").Append(fid);
                                            dboM.ExecuteSql(sql.ToString());
                                        }
                                    }
                                }
                            }
                        }
                        #endregion
                        //刷新监控中心显示

                    }
                    if (State == 2)//报告完成,应该也有坐标
                    {//20120616
                        Dictionary<int, string[]> df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(TaskIdx, DeviceIdx);
                        int[] snyc = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, 1);
                        ActionComplete(DeviceIdx, TaskIdx, 1);

                        #region 多叉关联任务，能同步的同时报告完成；异步的直接执行关联的命令
                        //20100323
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if ((devinfo.IfCorrelDoubleFork == "1") && (df != null))
                        {

                            if (snyc != null)//20100702
                            {
                                foreach (int cortask in snyc)
                                {
                                    ActionComplete(DeviceIdx, cortask, 1);
                                    df.Remove(cortask);
                                }

                            }


                        }
                        #endregion
                    }

                    break;
                case 2://输送机

                    if (State == 1)//开始运行
                    {//正在运行的设备如果有探物就是说托盘运行到此设备
                        ActionStartRun(DeviceIdx, TaskIdx);
                        if (mti == 1)
                        {//20100714
                            sql.Remove(0, sql.Length);
                            sql.Append("update IO_CONTROL set CONTROL_STATUS=10 where CONTROL_ID=").Append(fid);
                            dboM.ExecuteSql(sql.ToString());
                        }
                        #region 多叉关联任务，能同步的同时报告运行
                        //20100323
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (devinfo.IfCorrelDoubleFork == "1")
                        {
                            int[] corrtasks = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, 2);
                            if (corrtasks != null)
                            {
                                Dictionary<int, string[]> df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(TaskIdx, DeviceIdx);
                                if (df != null)
                                {
                                    foreach (int i in corrtasks)
                                    {
                                        ActionStartRun(Convert.ToInt32(df[i][2]), i);
                                    }
                                }
                            }
                        }
                        #endregion
                        //刷新监控中心显示

                    }
                    if (State == 2)//报告完成
                    {//20120616
                        Dictionary<int, string[]> df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(TaskIdx, DeviceIdx);
                        int[] snyc = Model.CGeneralFunction.MutiForkIfSync(TaskIdx, DeviceIdx, 2);
                        ActionComplete(DeviceIdx, TaskIdx, 1);
                        //刷新监控中心显示
                        #region 多叉关联任务，能同步的同时报告完成；异步的直接执行关联的命令
                        //20100323
                        devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                        if (devinfo.IfCorrelDoubleFork == "1")
                        {

                            if ((devinfo.IfCorrelDoubleFork == "1") && (df != null))//20100702
                            {

                                if (snyc != null)
                                {
                                    foreach (int corrtask in snyc)
                                    {
                                        ActionComplete(DeviceIdx, corrtask, 1);
                                        df.Remove(corrtask);
                                    }
                                }

                            }
                        }
                        #endregion
                    }
                    #region 输送机输送超时，错误代码34//20110608

                    //string begintime = Model.CGeneralFunction.GetMonitorTaskBeginTime(TaskIdx);
                    //if (begintime != "-")
                    //{
                    //    if (Convert.ToDateTime(begintime.Substring(0, 19), CultureInfo.CurrentCulture).AddMinutes(int.Parse(CStaticClass.TransportTimeout)) <= DateTime.Now)
                    //    {
                    //        ActionError(DeviceIdx, TaskIdx, 34);
                    //    }
                    //}
                    //int moindex = ccf.GetMonitorTaskIndexFromRunTimeoutDevice(DeviceIdx);
                    //if (moindex > -1)
                    //{
                    //    ActionError(DeviceIdx, moindex, 34);
                    //}
                    #endregion
                    break;
                case 31://高端
                    if (State == 1)
                    {//正在运行的设备如果有探物就是说托盘运行到此设备
                        ActionStartRun(DeviceIdx, TaskIdx);
                        //刷新监控中心显示

                    }
                    if (State == 2)//报告完成
                    {
                        ActionComplete(DeviceIdx, TaskIdx, 1);
                        //刷新监控中心显示

                    }

                    break;
                case 4://穿梭车
                    if (State == 1)
                    {//正在运行的设备如果有探物就是说托盘运行到此设备
                        ActionStartRun(DeviceIdx, TaskIdx);
                        if (mti == 1)
                        {//20100714
                            sql.Remove(0, sql.Length);
                            sql.Append("update IO_CONTROL set CONTROL_STATUS=10 where CONTROL_ID=").Append(fid);
                            dboM.ExecuteSql(sql.ToString());
                        }
                        //刷新监控中心显示

                    }
                    if (State == 2)//报告完成
                    {
                        ActionComplete(DeviceIdx, TaskIdx, 1);
                        //刷新监控中心显示

                    }

                    break;
                case 5://叠盘机

                    break;
                case 6://AGV车

                    break;
                case 7://条码扫描仪:需要在IO_ControlDetail表比对条码值

                    break;
                case 8://称重设备：向IO_ControlDetail表写入重量值

                    break;
                case 9://站台

                    break;
                case 10://巷道

                    break;
                case 11://分拣机

                    break;
                case 12://虚拟端点

                    break;
                case 13://空设备

                    break;
                case 14://确认按钮

                    break;
                case 15://定时器

                    break;
                case 16://指示灯

                    break;
                case 17://码垛机

                    break;
                case 18://检测开关

                    break;


            }


        }


        /// <summary>
        /// 追加倒库货位至真实终点货位的取货和送货指令
        /// </summary>
        /// <param name="mti">任务类型</param>
        /// <param name="fid">调度任务索引</param>
        /// <param name="device">设备索引</param>
        /// <param name="monitorindex">设备指令索引</param>
        bool AppendMoveCellOperate(int mti, int fid, int device, int monitorindex)
        {//20120820
            DataView dv = new DataView();
            try
            {
                string newuseawayfork = string.Empty;
                sql.Remove(0, sql.Length);
                sql.Append("update T_Manage_Task set FExceptionNO=NULL where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                dbo.ExecuteSql(sql.ToString());
                sql.Remove(0, sql.Length);
                sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mti.ToString() + fid.ToString())).Append(" where  F_DeviceIndex=").Append(device);
                dbo.ExceSQL(sql.ToString());
                //获取管理任务送货坐标，当前调度任务的路径，条码，优先级；远近货叉，提前检测
                sql.Remove(0, sql.Length);
                sql.Append("SELECT FENDCELL FROM T_Manage_Task WHERE (FID = ").Append(fid).Append(") AND (F_ManageTaskKindIndex = ").Append(mti).Append(")");

                char[] cc = new char[1] { '-' };
                string[] spcell = dbo.GetSingle(sql.ToString()).ToString().Split(cc);

                sql.Remove(0, sql.Length);
                sql.Append("select F_NumParam4, F_NumParam5,F_NumParam6, F_RouteID,F_MonitorTaskLevel, F_UseAwayFork, F_TxtParam, F_AGVTask, F_AGVNextTask,F_ChangeStackCell from T_Monitor_Task where F_MonitorIndex=").Append(monitorindex);////20120820
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count <= 0) return false;
                //发送命令时根据目标位置定位货叉newuseawayfork
                newuseawayfork = "0";
                int snextq = int.Parse(dv[0]["F_AGVTask"].ToString());//20120518
                int snexts = int.Parse(dv[0]["F_AGVNextTask"].ToString());//20120518
                int lev = int.Parse(dv[0]["F_MonitorTaskLevel"].ToString());
                int routeid = int.Parse(dv[0]["F_RouteID"].ToString());
                int fnp1 = int.Parse(dv[0]["F_NumParam4"].ToString());
                int fnp2 = int.Parse(dv[0]["F_NumParam5"].ToString());
                int fnp3 = int.Parse(dv[0]["F_NumParam6"].ToString());
                string pcode = dv[0]["F_TxtParam"].ToString();
                string ChangeStackCell = dv[0]["F_ChangeStackCell"].ToString();//20120820
                StringBuilder aheaddet = new StringBuilder("I" + device.ToString());
                //根据目标货位检测货叉是否有货
                int forkno = Convert.ToInt32(ccf.GetLimitXForkNo(Convert.ToInt32(spcell[1]), ccf.GetLaneWayNoFromStack(device)));
                if (forkno > 0)
                {
                    newuseawayfork = forkno.ToString();//20140214补充货叉
                    aheaddet.Append(";D").Append(device.ToString()).Append(".").Append(Convert.ToInt32(forkno - 1));
                }
                int mindex = snextq;//20120518
                sql.Remove(0, sql.Length);
                sql.Append("INSERT INTO T_Monitor_Task (F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex, F_MonitorTaskLevel,").Append(
                    " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5,").Append(
                    " F_NumParam6, F_TxtParam, F_AheadDetect, F_UseAwayFork,f_ChangeStackCell)VALUES ").Append(
                    "(").Append(fid).Append(",").Append(mti).Append(",").Append(mindex).Append(",").Append(lev).Append(",").Append(device).Append(",4,").Append(routeid).Append(",0,").Append(fnp1).Append(",").Append(fnp2).Append(",").Append(fnp3).Append(",").Append(
                    spcell[0]).Append(",").Append(spcell[1]).Append(",").Append(spcell[2]).Append(",'").Append(pcode).Append("','").Append(aheaddet.ToString()).Append("','").Append(newuseawayfork).Append("','").Append(ChangeStackCell).Append("')");//20120820
                dbo.ExecuteSql(sql.ToString());
                mindex = snexts;//20120518
                aheaddet = new StringBuilder("I" + device.ToString());
                if (forkno > 0)
                {
                    aheaddet.Append(";D-").Append(device.ToString()).Append(".").Append(Convert.ToInt32(forkno - 1));
                }
                sql.Remove(0, sql.Length);
                sql.Append("INSERT INTO T_Monitor_Task (F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex, F_MonitorTaskLevel,").Append(
                    " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5,").Append(
                    " F_NumParam6, F_TxtParam, F_AheadDetect, F_UseAwayFork)VALUES ").Append(
                    "(").Append(fid).Append(",").Append(mti).Append(",").Append(mindex).Append(",").Append(lev).Append(",").Append(device).Append(",5,").Append(routeid).Append(",0,").Append(fnp1).Append(",").Append(fnp2).Append(",").Append(fnp3).Append(",").Append(
                    spcell[0]).Append(",").Append(spcell[1]).Append(",").Append(spcell[2]).Append(",'").Append(pcode).Append("','").Append(aheaddet.ToString()).Append("','").Append(newuseawayfork).Append("')");//20120820
                dbo.ExecuteSql(sql.ToString());
                return true;
            }

            catch (Exception ex)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", string.Format("报告完成时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rmea);
                return false;
            }
            finally
            {
                dv.Dispose();

            }

        }
        bool AppendStackMoveCellOperate(int mti, int fid, int device, int monitorindex)
        {//20120820
            string newuseawayfork = string.Empty;
            char[] cc = new char[1] { '-' };
            DataView dvl = new DataView(); DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("update T_Manage_Task set FExceptionNO=NULL where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                dbo.ExecuteSql(sql.ToString());
                //获取管理任务送货坐标，当前调度任务的路径，条码，优先级；远近货叉，提前检测
                sql.Remove(0, sql.Length);
                sql.Append("SELECT FREMARK FROM T_Manage_Task WHERE (FID = ").Append(fid).Append(") AND (F_ManageTaskKindIndex = ").Append(mti).Append(")");
                object arrcell = dbo.GetSingle(sql.ToString());
                if (arrcell == null) return false;
                string[] spcell = arrcell.ToString().Split(cc);

                sql.Remove(0, sql.Length);
                sql.Append("select F_NumParam4, F_NumParam5,F_NumParam6, F_RouteID,F_MonitorTaskLevel, F_UseAwayFork, F_TxtParam,F_AheadDetect,F_PriorMonitor,F_AGVTask,F_AGVNextTask,F_ChangeStackCell from T_Monitor_Task where F_MonitorIndex=").Append(monitorindex);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count <= 0) return false;
                //发送命令时根据目标位置定位货叉newuseawayfork
                newuseawayfork = "0";
                int lev = int.Parse(dv[0]["F_MonitorTaskLevel"].ToString());
                int routeid = int.Parse(dv[0]["F_RouteID"].ToString());
                int fnp1 = int.Parse(dv[0]["F_NumParam4"].ToString());
                int fnp2 = int.Parse(dv[0]["F_NumParam5"].ToString());
                int fnp3 = int.Parse(dv[0]["F_NumParam6"].ToString());
                string pcode = dv[0]["F_TxtParam"].ToString();
                int lifterUp = int.Parse(dv[0]["F_PriorMonitor"].ToString());
                int snextq = int.Parse(dv[0]["F_AGVTask"].ToString());
                int snexts = int.Parse(dv[0]["F_AGVNextTask"].ToString());
                string ChangeStackCell = dv[0]["F_ChangeStackCell"].ToString();
                int olddev = device;

                devinfo = Model.CGetInfo.GetDeviceInfo(device);
                int StackIndex = devinfo.VirtualStack;
                device = devinfo.MutexStack;
                StringBuilder aheaddet = new StringBuilder("I" + device.ToString());
                int laneway = 0;
                dvl = dbo.ExceSQL(string.Format("SELECT F_LaneDeviceIndex FROM  T_Base_LaneInfo WHERE (F_StackIndex = {0})", StackIndex)).Tables[0].DefaultView;
                if (dvl.Count > 0)
                {
                    laneway = Convert.ToInt32(dvl[0]["F_LaneDeviceIndex"]);
                }
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_LaneGateDeviceIndex FROM T_Base_Lane_Gate WHERE (F_ZXY = '").Append(arrcell.ToString()).Append("') and F_LaneIndex=").Append(laneway);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {//20120420高端高位信号是.2；物流输送机高位信号是.6
                    if (ccf.GetDeviceKindIdx(Convert.ToInt32(dv[0][0])) == 2)
                    {
                        aheaddet.Append(";D" + dv[0][0].ToString() + ".0;D-" + dv[0][0].ToString() + ".6;N" + dv[0][0].ToString());
                    }
                    else
                    {
                        aheaddet.Append(";D" + dv[0][0].ToString() + ".0;D-" + dv[0][0].ToString() + ".2;N" + dv[0][0].ToString());
                    }
                }
                StringBuilder aht = new StringBuilder(aheaddet.ToString());
                int forkno = Convert.ToInt32(ccf.GetLimitXForkNo(Convert.ToInt32(spcell[1]), ccf.GetLaneWayNoFromStack(device)));
                if (forkno > 0)
                {
                    newuseawayfork = forkno.ToString();//20140214补充货叉
                    aht.Append(";D").Append(device.ToString()).Append(".").Append(Convert.ToInt32(forkno - 1));
                }
                int mindex = snextq;
                sql.Remove(0, sql.Length);
                sql.Append("INSERT INTO T_Monitor_Task (F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex, F_MonitorTaskLevel,").Append(
                    " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5,").Append(
                    " F_NumParam6, F_TxtParam, F_AheadDetect, F_UseAwayFork,F_PriorMonitor,ChangeStackCell)VALUES ").Append(
                    "(").Append(fid).Append(",").Append(mti).Append(",").Append(mindex).Append(",").Append(lev).Append(",").Append(device).Append(",4,").Append(routeid).Append(",0,").Append(fnp1).Append(",").Append(fnp2).Append(",").Append(fnp3).Append(",").Append(
                    spcell[0]).Append(",").Append(spcell[1]).Append(",").Append(spcell[2]).Append(",'").Append(pcode).Append("','").Append(aht).Append("','").Append(newuseawayfork).Append("',").Append(lifterUp).Append(",'").Append(ChangeStackCell).Append("')");
                dbo.ExecuteSql(sql.ToString());
                mindex = snexts;
                sql.Remove(0, sql.Length);
                sql.Append("INSERT INTO T_Monitor_Task (F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex, F_MonitorTaskLevel,").Append(
                    " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5,").Append(
                    " F_NumParam6, F_TxtParam, F_AheadDetect, F_UseAwayFork,F_PriorMonitor)VALUES ").Append(
                    "(").Append(fid).Append(",").Append(mti).Append(",").Append(mindex).Append(",").Append(lev).Append(",").Append(device).Append(",5,").Append(routeid).Append(",0,").Append(fnp1).Append(",").Append(fnp2).Append(",").Append(fnp3).Append(",").Append(
                    spcell[0]).Append(",").Append(spcell[1]).Append(",").Append(spcell[2]).Append(",'").Append(pcode).Append("','").Append(aheaddet).Append("','").Append(newuseawayfork).Append("',").Append(lifterUp).Append(")");
                dbo.ExecuteSql(sql.ToString());
                return true;
            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", string.Format("报告完成时：{0}", ex.StackTrace + ex.Message));
                OnRefreshMonitor(rmea);
                return false;
            }
            finally
            {
                dv.Dispose();
                dvl.Dispose();
            }

        }
        int GetRouteIDsub(int device)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL("SELECT F_RouteIDSub, F_DeviceIndex, F_RouteID FROM T_Base_Route_Device where F_DeviceIndex=" + device + "").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0]["F_RouteIDSub"]);
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        string GetUseAwayForkFromLaneGate(int device)
        {//20120820
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_UseAwayFork FROM T_Base_Lane_Gate WHERE (F_LaneGateDeviceIndex = {0}) ", device)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return dv[0]["F_UseAwayFork"].ToString();
                }
                else
                {
                    return "0";
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        int GetStackGetXCoordinateFromLaneGate(int stackIndex, int devIndex)
        {
            DataView dv = new DataView();
            int LaneWay = ccf.GetLaneWayFromLaneInfo(stackIndex);
            char[] cc = new char[1] { '-' };
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("select * from T_Base_Lane_Gate where F_LaneGateDeviceIndex=").Append(devIndex).Append(" and F_LaneIndex=").Append(LaneWay);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {

                    return Convert.ToInt32(dv[0]["F_ZXY"].ToString().Split(cc)[1]);//列X
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                CGetStateError = "ControlSystem.CGetState.GetStackGetXCoordinateFromLaneGate:" + ex.StackTrace + ex.Message;
                return -1;
            }
            finally
            {
                dv.Dispose();
            }
        }
        public bool BuildHandTask(Model.HandTask Handtask, out string Errtext)
        {
            DataView dv = new DataView();
            try
            {
                string Sql = string.Empty;
                string dtime = DateTime.Now.ToString("u");
                dtime = dtime.Substring(0, dtime.Length - 1);
                string qcell = string.Empty, scell = string.Empty;
                int hidx = GetManageHandIdx();
                int hmindx = ccf.GetMonitorIndex(hidx, 4);
                int rehidx = 0, rehmindx = 0;
                int[] relfid = null;
                //20101028
                int z = 0, x = 0, y = 0, z1 = 0, x1 = 0, y1 = 0, Inworkbench = 0; ;
                int routeIDsub = GetRouteIDsub(Convert.ToInt32(Handtask._deviceIndex));

                if ((routeIDsub == -1) && (ccf.GetDeviceKindIdx(Handtask._deviceIndex) != 13) && (ccf.GetDeviceKindIdx(Handtask._deviceIndex) != 31))
                {

                    Errtext = "您选择的设备错误！";
                    return false;
                }
                #region 堆垛机
                if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 1)
                {
                    char[] cc = new char[1] { '-' };
                    string[] sp = Handtask._cellcodeBegin.Split(cc);
                    if (sp.Length >= 3)
                    {
                        z = Convert.ToInt32(sp[0]);
                        x = Convert.ToInt32(sp[1]);
                        y = Convert.ToInt32(sp[2]);

                    }
                    sp = Handtask._cellcodeEnd.Split(cc);
                    if (sp.Length >= 3)
                    {
                        z1 = Convert.ToInt32(sp[0]);
                        x1 = Convert.ToInt32(sp[1]);
                        y1 = Convert.ToInt32(sp[2]);

                    }
                }
                #endregion

                #region 物流输送机
                if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 2)
                {
                    z = Handtask._deviceIndex;
                    z1 = Convert.ToInt32(Handtask._arrowLocation);
                }
                #endregion

                if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 4)
                {//RGV
                    z = Convert.ToInt32(Handtask._arrowLocation);
                    z1 = 0;
                }

                #region 高端输送机
                if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 13)
                {
                    z = Handtask._begindeviceIndex;
                    z1 = Convert.ToInt32(Handtask._arrowLocation);
                    Inworkbench = Handtask._forkNo;
                }
                #endregion

                string useawayfork = "-"; int[] xx; int[] xx1;
                string barcode = string.Empty;
                useawayfork = Handtask._forkNo.ToString();
                char[] cp = new char[1] { ',' };
                if (Handtask._correlTaskForks.Length > 0)
                {
                    string[] cforks = Handtask._correlTaskForks.Split(cp);
                    xx = new int[cforks.Length];
                    xx1 = new int[cforks.Length];
                    relfid = new int[cforks.Length];
                    for (int i = 0; i < cforks.Length; i++)
                    {
                        if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 1)
                        {
                            string useawayfork1 = cforks[i];
                            xx[i] = x + (Convert.ToInt32(useawayfork1) - Handtask._forkNo);
                            xx1[i] = x1 + (Convert.ToInt32(useawayfork1) - Handtask._forkNo);
                            #region 堆垛机

                            if ((Handtask._deviceOrder == 4) || (Handtask._deviceOrder == 5))
                            {
                                rehidx = hidx + 1 + i;
                                rehmindx = ccf.GetMonitorIndex(rehidx, 4);
                                string bc = rehmindx.ToString();
                                int bcl = bc.Length;
                                for (int j = 0; j < (6 - bcl); j++)
                                {
                                    bc += j.ToString();
                                }
                                if (Handtask._deviceOrder == 4)//取货
                                {//z-x-y

                                    if (x == 1)
                                    {
                                        //xx[i] = 1;
                                    }
                                    else
                                    {
                                        dv = dbo.ExceSQL(string.Format("SELECT FID FROM ST_CELL WHERE (F_Z = {0}) AND (F_X = {1}) AND (F_Y = {2})", z, xx[i], y)).Tables[0].DefaultView;
                                        if (dv.Count == 0)
                                        {
                                            Errtext = "堆垛机取货坐标在数据库不存在！";
                                            return false;

                                        }
                                    }


                                    qcell = z.ToString() + "-" + xx[i].ToString() + "-" + y.ToString();//20101028
                                    dbo.ExceSQL("insert into T_Monitor_Task(F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex," +
                                        "F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_UseAwayFork,F_TxtParam) " +
                                        "values(" + routeIDsub + "," + rehidx + ",4," + rehmindx + "," + Handtask._deviceIndex
                                        + "," + Handtask._deviceOrder + "," + z + "," + xx[i] + "," + y + ",0,0,0,'" + useawayfork1 + "','" + bc + "')");

                                }
                                else if (Handtask._deviceOrder == 5)//送货
                                {//z1-x1-y1

                                    if (x1 == 1)
                                    {
                                        //20130710xx1[i] = 1;
                                    }
                                    else
                                    {
                                        dv = dbo.ExceSQL("SELECT FID FROM ST_CELL WHERE (F_Z = " + z1 + ") AND (F_X = " + xx1[i] + ") AND (F_Y = " + y1 + ")").Tables[0].DefaultView;
                                        if (dv.Count == 0)
                                        {
                                            Errtext = "堆垛机送货坐标在数据库不存在！";
                                            return false;

                                        }
                                    }


                                    scell = z1.ToString() + "-" + xx1[i].ToString() + "-" + y1.ToString();//20101028
                                    dbo.ExceSQL("insert into T_Monitor_Task(F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex," +
                                    "F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_UseAwayFork,F_TxtParam) " +
                                    "values(" + routeIDsub + "," + rehidx + ",4," + rehmindx + "," + Handtask._deviceIndex
                                    + "," + Handtask._deviceOrder + ",0,0,0," + z1 + "," + xx1[i] + "," + y1 + ",'" + useawayfork1 + "','" + bc + "')");

                                }

                                dbo.ExceSQL("insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME) values('" +
                                    bc + "'," + rehidx + ",4,-1,1," + Handtask._deviceIndex + ",'" + Handtask._deviceOrder + "','" + qcell + "'," + Handtask._deviceIndex + ",'" + scell + "','" + dtime + "')");

                                RecordMaxHandTaskFID(rehidx);
                                relfid[i] = rehidx;
                            }
                            #endregion
                        }
                        else if (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 2)
                        {
                            rehidx = hidx + 1 + i;
                            rehmindx = ccf.GetMonitorIndex(rehidx, 4);
                            string bc = rehmindx.ToString();
                            int bcl = bc.Length;
                            for (int j = 0; j < (6 - bcl); j++)
                            {
                                bc += j.ToString();
                            }
                            string useawayfork1 = (Handtask._forkNo + 1 + i).ToString();
                            Sql = "insert into T_Monitor_Task(F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex," +
                        "F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_UseAwayFork,F_TxtParam) " +
                        "values(" + routeIDsub + "," + rehidx + ",4," + rehmindx + "," + Handtask._deviceIndex
                        + "," + Handtask._deviceOrder + "," + z + "," + x + "," + y + "," + z1 + "," + x1 + "," + y1 + ",'" + useawayfork1 + "','" + bc + "')";
                            dbo.ExceSQL(Sql);
                            Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                                bc + "'," + rehidx + ",4,-1,1," + Handtask._deviceIndex + ",'" + Handtask._deviceOrder + "','" + z.ToString() + "-" + x.ToString() + "-" + y.ToString()
                                + "'," + Handtask._arrowLocation + ",'" + z1.ToString() + "-" + x1.ToString() + "-" + y1.ToString() + "','" + dtime + "'," + Handtask._forkNo + ")";
                            dbo.ExceSQL(Sql);
                            RecordMaxHandTaskFID(rehidx);
                            relfid[i] = rehidx;
                        }

                    }
                }
                if ((ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 13) || (ccf.GetDeviceKindIdx(Handtask._deviceIndex) == 31))
                {
                    barcode = Handtask._cellcodeBegin;
                }
                else
                {
                    barcode = hmindx.ToString();
                }

                int bcll = barcode.Length;
                for (int j = 0; j < (6 - bcll); j++)
                {
                    barcode += j.ToString();
                }

                Sql = "insert into T_Monitor_Task(F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex," +
                        "F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_UseAwayFork,F_TxtParam) " +
                        "values(" + routeIDsub + "," + hidx + ",4," + hmindx + "," + Handtask._deviceIndex
                        + "," + Handtask._deviceOrder + "," + z + "," + x + "," + y + "," + z1 + "," + x1 + "," + y1 + ",'" + useawayfork + "','" + barcode + "')";
                dbo.ExceSQL(Sql);
                Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                    barcode + "'," + hidx + ",4,-1,1," + Handtask._deviceIndex + ",'" + Handtask._deviceOrder + "','" + z.ToString() + "-" + x.ToString() + "-" + y.ToString()
                    + "'," + Handtask._arrowLocation + ",'" + z1.ToString() + "-" + x1.ToString() + "-" + y1.ToString() + "','" + dtime + "'," + Handtask._forkNo + ")";
                dbo.ExceSQL(Sql);
                RecordMaxHandTaskFID(hidx);
                if (relfid != null)
                {
                    dbo.ExecuteSql("update T_Manage_Task set F_RELATIVECONTORLID=" + hidx + " where F_ManageTaskKindIndex=4 and FID=" + hidx);
                    for (int i = 0; i < relfid.Length; i++)
                    {
                        dbo.ExecuteSql("update T_Manage_Task set F_RELATIVECONTORLID=" + hidx + " where F_ManageTaskKindIndex=4 and FID=" + relfid[i]);
                    }
                }

                Errtext = string.Empty;
                CDataChangeEventArgs cea = new CDataChangeEventArgs(null, null);
                OnDataChange("BuildHandTask", cea);
                return true;
            }
            catch (Exception ex)
            {
                Errtext = ex.StackTrace + ex.Message;
                return false;
            }
            finally
            {
                dv.Dispose();
            }
        }
        int GetManageHandIdx()
        {
            DataSet ds = new DataSet(); DataSet dss = new DataSet();
            try
            {
                int hidx = 0;
                ds = dbo.ExceSQL("SELECT F_ManageTaskKindIndex, max(FID) as mFID FROM T_Manage_Task Where F_ManageTaskKindIndex=4 group by F_ManageTaskKindIndex");
                if (ds.Tables[0].DefaultView.Count > 0)
                {
                    hidx = Convert.ToInt32(ds.Tables[0].DefaultView[0]["mFID"]) + 1;

                }
                else
                {
                    dss = dbo.ExceSQL("SELECT F_ManageTaskIndex FROM T_Base_Manage_Task_Index_Hand_Task");
                    if (dss.Tables[0].DefaultView.Count > 0)
                    {
                        if ((Convert.ToInt32(dss.Tables[0].DefaultView[0]["F_ManageTaskIndex"]) + 1) >= 29998)
                        {
                            hidx = 20001;
                        }
                        else
                        {
                            hidx = (Convert.ToInt32(dss.Tables[0].DefaultView[0]["F_ManageTaskIndex"]) + 1);
                        }
                    }
                    else
                    {
                        hidx = 20001;
                    }
                }
                RecordMaxHandTaskFID(hidx);
                return hidx;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                ds.Dispose();
                dss.Dispose();
            }
        }
        void RecordMaxHandTaskFID(int fid)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL("select F_ManageTaskIndex from T_Base_Manage_Task_Index_Hand_Task").Tables[0].DefaultView;

                if (dv.Count > 0)
                {
                    if (fid == 29998)
                    {
                        dbo.ExceSQL("UPDATE T_Base_Manage_Task_Index_Hand_Task SET F_ManageTaskIndex =20001");
                        return;
                    }
                    if (fid > Convert.ToInt32(dv[0]["F_ManageTaskIndex"]))
                    {
                        dbo.ExceSQL("UPDATE T_Base_Manage_Task_Index_Hand_Task SET F_ManageTaskIndex =" + fid);
                        return;
                    }
                }
                else
                {
                    dbo.ExceSQL("INSERT INTO T_Base_Manage_Task_Index_Hand_Task (F_ManageTaskIndex)VALUES (" + fid + ")");
                    return;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
    }
}