using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using wcftest.orm;
using logtxtWrite;
using wcftest.wcfApi;
using wcftest.wcf;
using wcftest.EnumDefine;
using System.Data.Entity.Validation;
using wcftest.sapEntity;
using wcftest.sendToSap;
using Newtonsoft.Json;
using System.Diagnostics;
using wcftest.sql;
using System.Data.Entity.Migrations;
using System.Data.Entity;
using wcftest.BussinessExtension.Handle;
using wcftest.BussinessExtension;
using wcftest.EnumDefine.Position;
using wcftest.BussinessExtension.Common;
using wcftest.orm_test;
using wcftest.EnumDefine.Sys;
namespace wcftest
{
    //库存表 ExtendField03可用分拣-ContainerNo库存锁定-ExtendField02 出库数量
    public partial class Form1 : Form
    {
        #region 大叠盘机和小叠盘机满空托标记 [EditBy shaocx,2022-03-08]

        /// <summary>
        /// 大叠盘机满空托标记,true：已满，false：未满
        /// </summary>
        public static bool IsFull_BigFoldingPlate = false;
        /// <summary>
        /// 小叠盘机满空托标记,true：已满，false：未满
        /// </summary>
        public static bool IsFull_SmallFoldingPlate = false;

        #endregion
        /// <summary>
        /// wcf服务变量
        /// </summary>
        ServiceHost myWcf;
        /// <summary>
        /// 自动执行任务线程,任务确认线程,检测叠盘机入口是否空,出口是否满线程
        /// </summary>
        Thread autoTaskThreadForOutStoreArea,//自动入库线程
               autoTaskThreadForInStoreArea,//自动入库线程
               autoTaskThreadForMoveStoreArea,//自动入库线程
               writeOutTaskThread,//自动出库线程
               finishConfirmThread,//完成确认线程
               sendSpaThread,//发生SAP确认(24小时内)
               containerIsFullThread,//检测需入口要空托盘和出口空托盘满
               deviceInfos,//设备信息
               Colors,//状态指示灯
               writeTaskTread;//写入任务表线程
        /// <summary>设备运行时间
        /// 设备运行时间
        /// </summary>
        public static TimeSpan deviceRunTime;
        public static TimeSpan deviceRunTime_Srm1;
        public static TimeSpan deviceRunTime_Srm2;
        /// <summary>设备等待时间
        /// 设备等待时间
        /// </summary>
        public static TimeSpan deviceWaitTime;
        public static TimeSpan deviceWaitTime_Srm1;
        public static TimeSpan deviceWaitTime_Srm2;
        /// <summary>设备报警时间
        /// 设备报警时间
        /// </summary>
        public static TimeSpan deviceAlarmTime;
        public static TimeSpan deviceAlarmTime_Srm1;
        public static TimeSpan deviceAlarmTime_Srm2;
        /// <summary>设备使用率
        /// 设备使用率
        /// </summary>
        public static TimeSpan deviceUsageRate;
        /// <summary>设备运行计时器
        /// 设备运行计时器
        /// </summary>
        Stopwatch deviceSw = new Stopwatch();
        Stopwatch deviceSw_Srm1 = new Stopwatch();
        Stopwatch deviceSw_Srm2 = new Stopwatch();
        /// <summary>上一次设备运行状态
        /// 上一次设备运行状态
        /// </summary>
        public string lastStatus = "等待";
        public string lastStatus_Srm1 = "等待";
        public string lastStatus_Srm2 = "等待";
        /// <summary>上一次小时数--每隔一小时保存一次设备状态时间
        /// 上一次小时数--每隔一小时保存一次设备状态时间
        /// </summary>
        int lastHour = 0;
        public static string lastPlateCode = "0";
        public static string lastPosition = "0";
        /// <summary>wcf服务
        /// wcf服务
        /// </summary>
        public static wcfApi.ControlCenterWcfServiceClient wcsApi = new wcfApi.ControlCenterWcfServiceClient();
        // 获取 设备信息
        ControlCenterWcfServiceClient device = new ControlCenterWcfServiceClient();
        /// <summary>线程锁防止并发
        /// //线程锁防止并发
        /// </summary>
        public static Mutex single = new Mutex();
        /// <summary>是否是虚拟仿真模式
        /// 是否是虚拟仿真模式
        /// </summary>
        //bool IsVirtualMode = true;
        public static bool IsVirtualMode = ConfigHelper.GetConfigBool("IsVirtualMode");//修改为配置文件 【EditBy shaocx,2022-01-27】
        bool allowGetDeviceInfo = true;//允许获取设备开关
        bool opentask = true;//打开线程
        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            //检测是否已经开启
            #region 只允许单启动和绑定电脑
            Process current = Process.GetCurrentProcess();
            Process[] processes = Process.GetProcessesByName(current.ProcessName);
            foreach (Process process in processes)
            {
                if (process.Id != current.Id)
                {
                    if (process.MainModule.FileName == current.MainModule.FileName)
                    {
                        MessageBox.Show("不允许重复开启！");
                        Environment.Exit(0);
                        return;
                    }
                }
            }
            //string computerName = Environment.GetEnvironmentVariable("ComputerName");//获取电脑用户名
            //if (computerName != "DESKTOP-0IQRMAE" && computerName != "XMZ2" && computerName != "XMZ1")
            //{
            //    MessageBox.Show("非法主机！");
            //    Environment.Exit(0);
            //}
            #endregion

            Control.CheckForIllegalCrossThreadCalls = false;
            myWcf = new ServiceHost(typeof(wcftest.wcf.apitest));
            myWcf.Open();//开启wcf服务
            if (opentask == true)
            {
                //自动入库执行任务线程
                autoTaskThreadForOutStoreArea = new Thread(autoSendTaskForOutStoreArea);
                autoTaskThreadForOutStoreArea.Start();
                autoTaskThreadForInStoreArea = new Thread(autoSendTaskForInStoreArea);
                autoTaskThreadForInStoreArea.Start();
                autoTaskThreadForMoveStoreArea = new Thread(autoSendTaskForMoveStoreArea);
                autoTaskThreadForMoveStoreArea.Start();
                //写出库任务线程
                writeOutTaskThread = new Thread(writeOutTask);
                writeOutTaskThread.Start();
                //写入库任务
                writeTaskTread = new Thread(writeInTask);
                writeTaskTread.Start();
                //确认任务
                finishConfirmThread = new Thread(finishConfirm);
                finishConfirmThread.Start();
                //检测需入口要空托盘和出口空托盘满
                containerIsFullThread = new Thread(containerIsFull);
                containerIsFullThread.Start();

                //读取SAP发送数据
                sendSpaThread = new Thread(sendSapInfo);
                sendSpaThread.Start();
                Colors = new Thread(changeColor);
                Colors.Start();
            }
            // 获取设备信息
            deviceInfoInit();
            if (IsVirtualMode)
            {
                this.BackColor = Color.Pink;
                label11.Text = "虚拟模式,不可用于生产！";

            }

            new Thread(DeleteData).Start();//定时清理日志

            new Thread(DeleteData_Base_ProductPosition).Start();//定时清理暂存区

            new Thread(AutoMoveForArea1).Start();//闲时移库-库区1

            new Thread(AutoMoveForArea2).Start();//闲时移库-库区2

            new Thread(doNoBillForAddOutInStockTask).Start();//处理 新增无单入库的入库记录

        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            try
            {
                //时间计算，这块去掉 【Editby shaocx,2024-12-30】
                /*
                using (dbModel mod = new dbModel())
                {
                    DateTime todayTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd"));//今天凌晨时间
                    deviceGeneralInfo todayDeviceInfo = mod.deviceGeneralInfo.FirstOrDefault(x => x.createTime > todayTime);
                    todayDeviceInfo.deviceWaitTime = deviceWaitTime.Hours * 60M + deviceWaitTime.Minutes;
                    todayDeviceInfo.deviceRunTime = deviceRunTime.Hours * 60M + deviceRunTime.Minutes;
                    todayDeviceInfo.deviceAlarmTime = deviceAlarmTime.Hours * 60M + deviceAlarmTime.Minutes;
                    mod.SaveChanges();
                    // if (myWcf != null) myWcf.Close();//关闭wcf服务线程
                    // Environment.Exit(0);//退出本进程所有线程
                }
                //*/
            }
            catch (Exception ex)
            {

            }
            // if (myWcf != null) myWcf.Close();//关闭wcf服务线程
            Environment.Exit(0);//退出本进程所有线程
        }

        #region 处理【“未下发”，“下发中”的任务】

        /// <summary> 处理【“未下发”，“下发中”的任务】,出库区域专用
        /// 处理【“未下发”，“下发中”的任务】,出库区域专用
        /// </summary>
        private void autoSendTaskForOutStoreArea()
        {
            while (true)
            {
                Thread.Sleep(2000);
                try
                {
                    //读取任务列表Task_Queue
                    using (dbModel mod = new dbModel())
                    {

                        //出库区任务类型
                        var q_TaskType_常规出库 = ((int)TaskTypeEnum.常规出库).ToString();
                        var q_TaskType_出库叠盘 = ((int)TaskTypeEnum.出库叠盘).ToString();
                        var q_TaskType_余料回库 = ((int)TaskTypeEnum.余料回库).ToString();
                        var q_TaskType_满空托回库 = ((int)TaskTypeEnum.满空托回库).ToString();

                        //判断是否有闲时移库任务在执行 [EditBy shaocx,2022-09-22]
                        var isExistRuningTask = FreeTimeMoveLocationTaskHandler.IsExistRuningTask(mod);
                        if (isExistRuningTask)
                        {
                            var q_TaskType_move = ((int)TaskTypeEnum.移库).ToString();

                            this.lbl_Msg_autoSendTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前存在闲时移库任务在执行中，不允许下发其他任务，只允许下发移库任务！";
                            //更新所有 未下发的任务,除了移库任务
                            List<Task_Queue> updateList = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发")
                        && (
                         x.TaskType == q_TaskType_常规出库 || x.TaskType == q_TaskType_出库叠盘 ||
                         x.TaskType == q_TaskType_余料回库 || x.TaskType == q_TaskType_满空托回库
                        )).ToList();
                            if (updateList != null && updateList.Count > 0)
                            {
                                foreach (var item in updateList)
                                {
                                    item.Remark = "当前存在闲时移库任务在执行中,暂停下发该任务";
                                }
                                mod.SaveChanges();
                            }

                            continue;
                        }

                        //1、优先下发 回库任务 [EditBy shaocx,2022-07-26]
                        var q_TaskType1 = ((int)TaskTypeEnum.余料回库).ToString();
                        var q_TaskType2 = ((int)TaskTypeEnum.满空托回库).ToString();
                        var q_TaskType3 = ((int)TaskTypeEnum.出库叠盘).ToString();

                        List<Task_Queue> taskDispost1 = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发" || x.TaskStatus == "下发中")
                            && (x.TaskType == q_TaskType1 || x.TaskType == q_TaskType2 || x.TaskType == q_TaskType3)
                            ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).ToList();
                        if (taskDispost1 != null && taskDispost1.Count > 0)
                        {
                            common_autoSendTask(taskDispost1, mod, false);
                        }

                        //2、其次做 常规出库任务
                        var q_TaskType4 = ((int)TaskTypeEnum.常规出库).ToString();
                        taskDispost1 = new List<Task_Queue>();
                        taskDispost1 = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发" || x.TaskStatus == "下发中")
                            && (x.TaskType == q_TaskType4) && x.DoCount == 1   // 1号堆垛机
                            ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).ToList();
                        if (taskDispost1 != null && taskDispost1.Count > 0)
                        {
                            var isPass = validate常规出库(mod, 1);
                            if (isPass)
                            {
                                common_autoSendTask(taskDispost1, mod, true);
                            }
                        }
                        taskDispost1 = new List<Task_Queue>();
                        taskDispost1 = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发" || x.TaskStatus == "下发中")
                           && (x.TaskType == q_TaskType4) && x.DoCount == 2 //2号堆垛机
                           ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).ToList();
                        if (taskDispost1 != null && taskDispost1.Count > 0)
                        {
                            var isPass = validate常规出库(mod, 2);
                            if (isPass)
                            {
                                common_autoSendTask(taskDispost1, mod, true);
                            }
                        }
                        //this.lbl_Msg_autoSendTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "执行完毕一轮";
                    }
                }
                catch (Exception ex)
                {
                    this.lbl_Msg_autoSendTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常:" + ex.Message;
                    Log4NetHelper.WriteErrorLog(LogType.AutoSendTaskForOutStoreArea, "异常:" + ex.Message, ex);
                }
            }
        }

        /// <summary> 处理【“未下发”，“下发中”的任务】,入库区域专用
        /// 处理【“未下发”，“下发中”的任务】,入库区域专用
        /// </summary>
        private void autoSendTaskForInStoreArea()
        {
            while (true)
            {
                Thread.Sleep(2000);
                try
                {
                    //读取任务列表Task_Queue
                    using (dbModel mod = new dbModel())
                    {
                        //入库区任务类型
                        var q_TaskType_入库拆盘 = ((int)TaskTypeEnum.入库拆盘).ToString();
                        var q_TaskType_常规入库 = ((int)TaskTypeEnum.常规入库).ToString();
                        var q_TaskType_组盘出库 = ((int)TaskTypeEnum.组盘出库).ToString();
                        var q_TaskType_空托出库 = ((int)TaskTypeEnum.空托出库).ToString();

                        //判断是否有闲时移库任务在执行 [EditBy shaocx,2022-09-22]
                        var isExistRuningTask = FreeTimeMoveLocationTaskHandler.IsExistRuningTask(mod);
                        if (isExistRuningTask)
                        {
                            var q_TaskType_move = ((int)TaskTypeEnum.移库).ToString();

                            this.lbl_Msg_autoSendTaskForInStoreArea.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前存在闲时移库任务在执行中，不允许下发其他任务，只允许下发移库任务！";
                            //更新所有 未下发的任务,除了移库任务
                            List<Task_Queue> updateList = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发")
                        && (
                         x.TaskType == q_TaskType_入库拆盘 || x.TaskType == q_TaskType_常规入库 ||
                         x.TaskType == q_TaskType_组盘出库 || x.TaskType == q_TaskType_空托出库
                        )).ToList();
                            if (updateList != null && updateList.Count > 0)
                            {
                                foreach (var item in updateList)
                                {
                                    item.Remark = "当前存在闲时移库任务在执行中,暂停下发该任务";
                                }
                                mod.SaveChanges();
                            }

                            continue;
                        }

                        //3、最后做别的任务
                        List<Task_Queue> taskDispost2 = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发" || x.TaskStatus == "下发中")
                          && (
                             x.TaskType == q_TaskType_入库拆盘 || x.TaskType == q_TaskType_常规入库 ||
                         x.TaskType == q_TaskType_组盘出库 || x.TaskType == q_TaskType_空托出库
                          )
                          ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).ToList();

                        if (taskDispost2.Count < 1) continue;
                        common_autoSendTask(taskDispost2, mod, false);

                        this.lbl_Msg_autoSendTaskForInStoreArea.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "执行完毕一轮";
                    }
                }
                catch (Exception ex)
                {
                    this.lbl_Msg_autoSendTaskForInStoreArea.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常:" + ex.Message;
                    Log4NetHelper.WriteErrorLog(LogType.AutoSendTaskForInStoreArea, "异常:" + ex.Message, ex);
                }
            }
        }

        /// <summary> 处理【“未下发”，“下发中”的任务】,移库区域专用
        /// 处理【“未下发”，“下发中”的任务】,移库区域专用
        /// </summary>
        private void autoSendTaskForMoveStoreArea()
        {
            while (true)
            {
                Thread.Sleep(2000);
                try
                {
                    //throw new Exception("报错了");//测试
                    //读取任务列表Task_Queue
                    using (dbModel mod = new dbModel())
                    {
                        var q_TaskType_move = ((int)TaskTypeEnum.移库).ToString();


                        List<Task_Queue> taskDispost_move = mod.Task_Queue.Where(x => (x.TaskStatus == "未下发" || x.TaskStatus == "下发中")
                     && (x.TaskType == q_TaskType_move)
                     ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).ToList();
                        if (taskDispost_move.Count < 1) continue;
                        common_autoSendTask(taskDispost_move, mod, false);
                    }
                    this.lbl_Msg_autoSendTaskForMoveStoreArea.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "执行完毕一轮";
                }
                catch (Exception ex)
                {
                    this.lbl_Msg_autoSendTaskForMoveStoreArea.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常:" + ex.Message;
                    Log4NetHelper.WriteErrorLog(LogType.AutoSendTaskForMoveStoreArea, "异常:" + ex.Message, ex);
                }
            }
        }

        /// <summary> 处理【“未下发”，“下发中”的任务】
        /// 处理【“未下发”，“下发中”的任务】
        /// </summary>
        private void common_autoSendTask(List<Task_Queue> taskDispost, dbModel mod, bool is常规出库)
        {
            try
            {
                int handlerNum = 0;
                foreach (var item in taskDispost)
                {
                    handlerNum++;
                    if (is常规出库 && handlerNum > 2)
                    {
                        this.lbl_Msg_autoSendTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " ,常规出库,本次循环处理的的任务超过2条，先暂停下发常规出库任务";
                        break;//如果是常规出库，并且下发给wcs任务失败，就跳出循环。要求是必须出库任务按照时间来出库，不能跳任务 【EditBy shaocx,2022-07-28】
                    }

                    int taskId = item.Task_Id;

                    taskId = ExtendHelper.ConvertPlcNO(item.Task_Id);//修复 【EditBy shaocx,2022-04-18】

                    string sourcePlce = item.FromPositionName;
                    string toPlace = item.ToPositionName;
                    int TaskType = Convert.ToInt32(item.TaskType);
                    int containerType = Convert.ToInt32(item.PlateType);
                    int storageno = Convert.ToInt32(item.DoCount);//DoCount字段当库区用 后期更改
                    int height = 0;// direction字段当高度用 后期更改
                    string containerName = item.PlateCode;
                    //发送wcs 任务  SendTask(taskId,sourcePlce,toPlace,taskType,containerType,storageno,height)  设备报警失败返回0,1任务完成,2外形检测不通过

                    #region 增加校验 【Editby shaocx,2024-09-10】
                    //不能加这个验证，他入库是根据 后面的高度检测来的 【Editby shaocx,2024-09-11】
                    /*
                    if (item.TaskType == ((int)TaskTypeEnum.常规入库).ToString())
                    {
                        if (storageno == 0)
                        {
                            Log4NetHelper.WriteErrorLog(LogType.IssueTask, "自动发送任务，传递参数,PLC任务号:" + taskId + ",sourcePlce:" + sourcePlce + ",toPlace:" + toPlace
                    + ",TaskType:" + TaskType + ",containerType:" + containerType + ",storageno:" + storageno
                    + ",height:" + height + ",containerName:" + containerName);
                            throw new Exception("常规入库,storageno=0");
                        }
                    }
                    //*/
                    #endregion


                    bool result;

                    wcftest.wcfApi.FunModel fm = null;
                    //模拟
                    if (IsVirtualMode)
                    {
                        result = true;//模拟环境下，改为true 【EditBy shaocx,2022-06-20】
                        VirtualModeHelper.ThrowExceptionWhenVirtualMode(IsVirtualMode);
                        fm = new FunModel()
                        {
                            result = true,
                        };
                    }

                    else
                    {
                        //调用新的接口，返回wcs返回的错误消息
                        //result = wcsApi.SendTask(taskId, sourcePlce, toPlace, TaskType, containerType, storageno, height, containerName);
                        fm = wcsApi.SendTaskWithMsg(taskId, sourcePlce, toPlace, TaskType, containerType, storageno, height, containerName, item.Task_Id);
                        result = fm.result;

                        //logtxt.txtWrite("类名：Form1/函数名：autoSendTask自动发送任务，传递参数,PLC任务号:" + taskId + ",sourcePlce:" + sourcePlce + ",toPlace:" + toPlace
                        //    + ",TaskType:" + TaskType + ",containerType:" + containerType + ",storageno:" + storageno
                        //    + ",height:" + height + ",containerName:" + containerName,
                        // 2);

                        Log4NetHelper.WriteInfoLog(LogType.IssueTask, "自动发送任务，传递参数,PLC任务号:" + taskId + ",sourcePlce:" + sourcePlce + ",toPlace:" + toPlace
                       + ",TaskType:" + TaskType + ",containerType:" + containerType + ",storageno:" + storageno
                       + ",height:" + height + ",containerName:" + containerName);

                    }




                    if (result == true)
                    {
                        item.TaskStatus = "已下发";
                        item.PlcTaskNo = taskId;//保存下PLC的任务号 [EditBy shaocx,2022-04-18]
                        item.ExpandFields = taskId.ToString();//同时用这个字段保存下PLC的任务号 [EditBy shaocx,2022-04-18]
                        item.Remark = "";
                        mod.SaveChanges();

                        //设置优先级 【EditBy shaocx,2022-07-06】
                        if (item.OrderNumber != null && Convert.ToInt32(item.OrderNumber) > 0)
                        {//只有当大于0的时候，才会主动触发优先级
                            WcsWcfApiHelper.SetMainTaskPriority(wcsApi, taskId.ToString(), item.OrderNumber, item.Task_Id);
                        }
                    }
                    else
                    {//下发失败
                        Log4NetHelper.WriteInfoLog(LogType.IssueTask, "下发任务，WCS返回false,Task_Id:" + item.Task_Id + ",PLC任务号:" + taskId + ",IsVirtualMode:" + IsVirtualMode);
                        //logtxt.txtWrite("类名：Form1/函数名：autoSendTask自动发送任务，返回false,Task_Id:" + item.Task_Id + ",PLC任务号:" + taskId + ",IsVirtualMode:" + IsVirtualMode,
                        //2);
                        item.PlcTaskNo = taskId;//保存下PLC的任务号 [EditBy shaocx,2022-04-18]
                        item.ExpandFields = taskId.ToString();//同时用这个字段保存下PLC的任务号 [EditBy shaocx,2022-04-18]
                        item.Remark = fm.errMsg;
                        mod.SaveChanges();

                        if (is常规出库)
                        {
                            break;//如果是常规出库，并且下发给wcs任务失败，就跳出循环。要求是必须出库任务按照时间来出库，不能跳任务 【EditBy shaocx,2022-07-28】
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //logtxt.txtWrite("类名：Form1/函数名：autoSendTask自动发送任务/ " + ex.Message + "出错行号" + (string)ex.StackTrace + ",异常:" + JsonConvert.SerializeObject(ex),
                //    2);
                Log4NetHelper.WriteErrorLog(LogType.IssueTask, "异常:" + ex.Message, ex);
                throw ex;
            }
        }

        /// <summary>
        /// 验证常规出库任务 【Editby shaocx,2024】
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="doCount"></param>
        /// <returns></returns>
        private bool validate常规出库(dbModel mod, int doCount)
        {
            var q_TaskType4 = ((int)TaskTypeEnum.常规出库).ToString();
            var ooListNum = mod.Task_Queue.Where(x => (x.TaskStatus == "已下发")
                && (x.TaskType == q_TaskType4) && x.DoCount == doCount  // 某号堆垛机
                ).OrderByDescending(x => x.OrderNumber).ThenBy(x => x.CreateDate).Count();
            if (ooListNum > 2)
            {
                this.lbl_Msg_autoSendTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " " + doCount.ToString() + "号堆垛机,常规出库,已下发的任务超过2条，先暂停下发常规出库任务";
                return false;
            }
            return true;
        }

        #endregion



        /// <summary> 处理“待下架”的表单，创建出库任务
        /// 处理“待下架”的表单，创建出库任务
        /// </summary>
        private void writeOutTask()
        {
            //ExtendField02 出库数量  ContainerNo=1 锁定(正在出库)  ExtendField03=1允许分拣 Remark 移动类型
            while (true)
            {
                Thread.Sleep(3000);
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        //判断是否有闲时移库任务在执行 [EditBy shaocx,2022-09-22]
                        var isExistRuningTask = FreeTimeMoveLocationTaskHandler.IsExistRuningTask(mod);
                        if (isExistRuningTask)
                        {
                            this.lbl_Msg_writeOutTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前存在闲时移库任务在执行中，不允许下发其他任务，只允许下发移库任务！";
                            continue;//继续下一个循环
                        }
                        int alack = 0;//缺货条数
                        //查找出库单
                        var queryStatus = Sale_Order_StatusEnum.待下架.ToString();
                        //按照任务优先级的降序排序 【Editby shaocx,2024-02-27】
                        List<Sale_Order> saleOrderList = mod.Sale_Order.Where(x => x.StatusText == queryStatus).OrderByDescending(x => x.PriorityNo).ToList();
                        //List<Sale_Order> saleOrderList = mod.Sale_Order.Where(x => x.StatusText == "待下架").OrderByDescending(x => x.PriorityNo).ToList();

                        if (saleOrderList.Count > 0)
                        {   //出库单里的明细
                            //一次获取所有库存
                            Thread.Sleep(3000);//增加延迟 防止主表信息写进去，明细还没写进去

                            #region 事务处理 【EditBy shaocx,2022-10-16】
                            using (var trans = mod.Database.BeginTransaction())
                            {
                                try
                                {
                                    string last_toplace = "";//记录本次循环上一个的目标点 【EditBy shaocx,2022-10-15】
                                    foreach (var sale in saleOrderList)
                                    {
                                        #region 单个循环处理

                                        List<Sale_OrderList> saleList = mod.Sale_OrderList.Where(x => x.Order_Id == sale.Order_Id && x.ExtendField03 == "待下架" && x.QuantityOrder > 0).ToList();
                                        if (saleList.Count < 1)
                                        {
                                            //sale.StatusText = "查找明细出错";
                                            sale.StatusText = Sale_Order_StatusEnum.错误.ToString();
                                            sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.错误);
                                            sale.Remark = "查找明细出错,没有找到出库明细";
                                            mod.SaveChanges();
                                            continue;
                                        }


                                        List<vvBase_ProductPosition> stockALL = mod.vvBase_ProductPosition.Where(x => x.ProductStorage > 0).ToList();//将读取库存信息放到循环里面
                                        List<vvBase_ProductPosition> stockALL_No收货暂存区 = stockALL.Where(x => x.PositionName != SysGlole.PositionName_SHZCQ).ToList();//非收货暂存区的库存列表

                                        //验证指定库位号出库
                                        var errMsg = "";
                                        var validateResult = BussinessExtension.BussinessExtension.ValidateSale_OrderForPointPositionName(mod, stockALL_No收货暂存区, sale, saleList, ref errMsg);
                                        if (validateResult == false)
                                        {
                                            //sale.StatusText = errMsg;
                                            sale.StatusText = Sale_Order_StatusEnum.错误.ToString();
                                            sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.错误);
                                            sale.Remark = errMsg;
                                            mod.SaveChanges();
                                            continue;
                                        }

                                        Sale_Order_History sale_Order_History = null;
                                        lackOrder lackTop = new lackOrder();//缺货表
                                        List<lackOrderList> lacks = new List<lackOrderList>();
                                        //if (sale.OrderType == "SAP生产订单")
                                        if (sale.OrderType == SysGlole.SAP_ORDER_TEXT)
                                        {
                                            #region 获取缺料主表数据
                                            try
                                            {
                                                int outNumber = sale.OutNumber == null ? 0 : Convert.ToInt32(sale.OutNumber);
                                                int materialCount = sale.MaterialCount == null ? 0 : Convert.ToInt32(sale.MaterialCount);
                                                if (outNumber <= 0)
                                                {
                                                    this.lbl_Msg_writeOutTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now)
                                                        + "SAP生产订单！";
                                                    continue;
                                                }

                                                int finishQty = sale.Client_Id == null ? 0 : Convert.ToInt32(sale.Client_Id);
                                                string trackNum = sale.TrackingNumber == null ? "" : sale.TrackingNumber;
                                                lackTop.workCode = sale.OrderCode;//生产单号
                                                lackTop.trackCode = trackNum;
                                                lackTop.totalCount = sale.MaterialCount == null ? 0 : (int)sale.MaterialCount;
                                                lackTop.counting = outNumber;//本次出库套数
                                                lackTop.finishCount = finishQty;//完成

                                                //增加出库套数记录表 [EditBy shaocx,2022-10-16]
                                                sale_Order_History = Sale_Order_HistoryHandler.AddSale_Order_History(sale, mod, "", "");
                                                mod.SaveChanges();//保存数据，让对象Sale_Order_History的ID有值 【EditBy shaocx,2022-10-16】
                                            }
                                            catch (Exception ex)
                                            {
                                                textBox6.Text = "缺料主表 数据转换失败\r\n" + textBox6.Text;
                                                logtxt.txtWrite("类名：Form1/函数名：writeOutTask锁定库位失败/库位号: " + ex.ToString(), 2);
                                            }
                                            #endregion


                                        }
                                        else//手动出库,311和暂存区发料是跟设备没关系的
                                        {
                                            string moveType = saleList[0].ExtendField01 == null ? "" : saleList[0].ExtendField01;
                                            string moveTypeSap = ConvertMoveType(moveType);
                                            if (moveType == "暂存区发料到生产订单261")
                                            {
                                                List<GIMaterialEntity> resultSap = new List<GIMaterialEntity>();//出库实体集合
                                                // List<Base_ProductPosition> modifyStatus = new List<Base_ProductPosition>();//扣减暂存区集合
                                                #region 暂存区发料到生产订单261
                                                foreach (var item in saleList)
                                                {
                                                    GIMaterialEntity newSap = new GIMaterialEntity();
                                                    string trackNumber = item.TrackingNumber == null ? "" : item.TrackingNumber;
                                                    string materailCode = item.ProductCode.Trim();//产品编号
                                                    newSap.WorkOrder = item.StoreOrderId + "#0#0";//生产订单  
                                                    //如果库存数据没有跟踪号261不加E特殊类型符号
                                                    if (string.IsNullOrEmpty(trackNumber))
                                                    {
                                                        newSap.MoveType = moveTypeSap;//移动类型
                                                    }
                                                    else
                                                    {
                                                        newSap.MoveType = moveTypeSap + "E";//移动类型
                                                    }

                                                    //如果填了销售订单
                                                    if (!string.IsNullOrEmpty(item.PackageName))
                                                    {
                                                        newSap.SalesOrder = item.PackageName;//销售订单
                                                        newSap.SalesOrderItem = item.NumberOfGiftBags;//销售项号
                                                    }
                                                    newSap.Plant = "3TG1";//工厂
                                                    newSap.MaterialCode = materailCode;//产品编号
                                                    newSap.StorageLocation = "G021";//库区
                                                    newSap.Quantity = (decimal)item.QuantityOrder;//出库数量
                                                    resultSap.Add(newSap);

                                                }
                                                if (resultSap.Count > 0)
                                                {
                                                    //apitest wcfapi = new apitest();
                                                    string moveInfo = JsonConvert.SerializeObject(resultSap); //json序列化
                                                    //向SAP发送出库确认
                                                    returnInfo result = JsonConvert.DeserializeObject<returnInfo>(SAPHelper.StockOutConfirm(null, moveInfo));
                                                    if (result.result)//如果sap返回true 表示接受成功
                                                    {
                                                        //sale.StatusText = "已分配";
                                                        sale.StatusText = Sale_Order_StatusEnum.已分配.ToString();
                                                        sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.已分配);
                                                        #region 扣减暂存区数量
                                                        foreach (var item in saleList)//扣减暂存区数量
                                                        {
                                                            string trackNumber = item.TrackingNumber == null ? "" : item.TrackingNumber;
                                                            string materailCode = item.ProductCode.Trim();//产品编号
                                                            List<Base_ProductPosition> zcq_ProductPosition = mod.Base_ProductPosition.Where(x =>
                                                                x.PositionName == SysGlole.PositionName_SHZCQ  //增加收货暂存区的筛选 【Editby shaocx,2022-03-08】
                                                               && x.ExtendField04 == trackNumber && x.ProductCode == materailCode && x.ProductStorage > 0).OrderBy(x => x.ProductStorage).ToList();
                                                            bool subOK = false;//记录扣减是否完成
                                                            decimal outQuantity = 0M;// 库存相加临时变量
                                                            foreach (var itemSub in zcq_ProductPosition)
                                                            {
                                                                //把等于的数据优先处理
                                                                if (itemSub.ProductStorage == item.QuantityOrder)
                                                                {
                                                                    mod.Base_ProductPosition.Remove(itemSub);
                                                                    //增加出入库记录 【EditBy shaocx,2022-03-07】
                                                                    OutInStockTaskHandler.AddOutInStockTask22(sale.Creator, mod, OutInStockTaskName.清库任务, itemSub.ProductStorage, itemSub, "自动下发出库任务,手动出库,库存数等于要出库的数,清空库存", sale.OrderCode);
                                                                    subOK = true;
                                                                    break;
                                                                }

                                                            }
                                                            if (!subOK)
                                                            {
                                                                #region 没有等于的累加扣减
                                                                foreach (var itemSub in zcq_ProductPosition)
                                                                {
                                                                    outQuantity += (decimal)itemSub.ProductStorage;//先加后判断
                                                                    if (item.QuantityOrder > outQuantity)//累加库存数量小于出库数量 前库存数据都删除
                                                                    {

                                                                        mod.Base_ProductPosition.Remove(itemSub);
                                                                        //增加出入库记录 【EditBy shaocx,2022-03-07】
                                                                        OutInStockTaskHandler.AddOutInStockTask22(sale.Creator, mod, OutInStockTaskName.清库任务, itemSub.ProductStorage, itemSub, "自动下发出库任务,手动出库,1累加库存数量小于出库数量 前库存数据都删除,清空库存", sale.OrderCode);
                                                                    }
                                                                    else
                                                                    {
                                                                        if (item.QuantityOrder == outQuantity)
                                                                        {
                                                                            mod.Base_ProductPosition.Remove(itemSub);
                                                                            //增加出入库记录 【EditBy shaocx,2022-03-07】
                                                                            OutInStockTaskHandler.AddOutInStockTask22(sale.Creator, mod, OutInStockTaskName.清库任务, itemSub.ProductStorage, itemSub, "自动下发出库任务,手动出库,2累加库存数量小于出库数量 前库存数据都删除,清空库存", sale.OrderCode);
                                                                        }
                                                                        else//如果累计综合不等于那就是大于出库数量,这时不能删除这个库存,而是把超出的数量保存到最后一条数据里
                                                                        {
                                                                            //itemSub.ProductStorage = outQuantity - item.QuantityOrder; //原来的代码
                                                                            decimal? finallyQty = outQuantity - item.QuantityOrder;
                                                                            decimal? changeQty = itemSub.ProductStorage - finallyQty;
                                                                            itemSub.ProductStorage = finallyQty; //原来的代码
                                                                            //增加出入库记录 【EditBy shaocx,2022-03-07】
                                                                            OutInStockTaskHandler.AddOutInStockTask22(sale.Creator, mod, OutInStockTaskName.出库任务, changeQty, itemSub, "自动下发出库任务,手动出库,2累加库存数量小于出库数量 前库存数据都删除,清空库存", sale.OrderCode);
                                                                        }
                                                                        break;
                                                                    }
                                                                }
                                                                #endregion


                                                            }
                                                            mod.SaveChanges();
                                                        }
                                                        #endregion

                                                    }

                                                }
                                                #endregion
                                                continue;
                                            }
                                        }
                                        #region 出库任务
                                        if (saleList.Count > 0)
                                        {
                                            string isEnableSrmOne = "3";//一号堆垛机是否能用
                                            string isEnableSrmTwo = "3";//二号堆垛机是否能用
                                            //  #region  读取堆垛机是否禁用
                                            List<Base_Equipment> srmIsOk = mod.Base_Equipment.Where(x => x.DeviceType == "堆垛机").ToList();
                                            #region 判断堆垛机是否禁用 来设置库区
                                            if (srmIsOk != null)
                                            {
                                                #region 查询堆垛机是否可用
                                                foreach (var item in srmIsOk)
                                                {
                                                    if (item.DeviceCode == "1")
                                                    {
                                                        if (item.Enable == 1)
                                                        {
                                                            isEnableSrmOne = "1";
                                                        }
                                                    }
                                                    if (item.DeviceCode == "2")
                                                    {
                                                        if (item.Enable == 1)
                                                        {
                                                            isEnableSrmTwo = "2";
                                                        }
                                                    }
                                                }
                                                #endregion


                                            }
                                            else
                                            {
                                                logtxt.txtWrite("类名：Form1/函数名：writeOutTask出库写入任务异常/堆垛机全部被禁用 ", 2);
                                                // return "";
                                            }
                                            #endregion
                                            int outTaskSaleNum = 0;//记录出库子表中有几个已分配出库,然后做比对后改出库主表状态
                                            List<Task_Queue> taskList = new List<Task_Queue>();
                                            foreach (var item in saleList)
                                            {
                                                #region 计算库存
                                                decimal outQty = 0M;//需要出货的数量临时变量
                                                decimal exitQty = item.QuantityOrder == null ? 0M : (decimal)item.QuantityOrder;
                                                if (exitQty == 0)
                                                {
                                                    continue;
                                                }
                                                List<vvBase_ProductPosition> products = new List<vvBase_ProductPosition>();//当前库存
                                                #region 寻找库存
                                                //按跟踪号查找   ContainerNo = "1";//库位锁定
                                                if (item.TrackingNumber != null)
                                                {
                                                    products = stockALL_No收货暂存区.Where(x => x.ExtendField04 == item.TrackingNumber && x.ContainerNo != "1"
                                                    && x.ProductCode == item.ProductCode && x.IsLocked == (int)IsLockedEnum.未锁定 && x.PositionName != "收货暂存区"
                                                    && (x.AreaCode == isEnableSrmOne || x.AreaCode == isEnableSrmTwo))
                                                        //排序改为 限用日期 升序排序  【Editby shaocx,2024-06-22】
                                                        //.OrderBy(x => x.InStorageDate).ToList();
                                                    .OrderBy(x => x.LimitDate).ToList();
                                                }
                                                //2021-6-19 修改为 picklist 有跟踪号的只能找跟踪号的,没跟踪号只能找没跟踪号
                                                else
                                                {
                                                    int prodectId = Convert.ToInt32(item.Product_Id);

                                                    products = stockALL_No收货暂存区.Where(x => x.Product_Id == prodectId && x.PositionName != "收货暂存区"
                                                        && (x.ExtendField04 == "" || x.ExtendField04 == null) && x.ContainerNo != "1" && x.IsLocked == (int)IsLockedEnum.未锁定 &&
                                                        (x.AreaCode == isEnableSrmOne || x.AreaCode == isEnableSrmTwo))
                                                        //排序改为 限用日期 升序排序  【Editby shaocx,2024-06-22】
                                                        //.OrderBy(x => x.InStorageDate).ToList();
                                                        .OrderBy(x => x.LimitDate).ToList();

                                                }
                                                #region 增加指定库位号的过滤 【EditBy shaocx,2022-06-15】
                                                //增加指定库位号的过滤 【EditBy shaocx,2022-06-15】
                                                if (!string.IsNullOrEmpty(sale.AuditRemark))
                                                {
                                                    products = products.Where(x => x.PositionName == sale.AuditRemark).ToList();
                                                }
                                                #endregion

                                                if (products.Count < 1)
                                                {
                                                    alack++;
                                                    item.ExtendField03 = "缺货中";
                                                    //if (sale.OrderType == "SAP生产订单" && lackTop != null)
                                                    if (sale.OrderType == SysGlole.SAP_ORDER_TEXT && lackTop != null)
                                                    {
                                                        #region 写入缺料报表

                                                        #region 寻找暂存区数量
                                                        List<vvBase_ProductPosition> stroe = new List<vvBase_ProductPosition>();
                                                        string trankNum = item.TrackingNumber;
                                                        string materalNo = item.ProductCode;
                                                        decimal tempoaray = 0M;//暂存区数量
                                                        if (item.TrackingNumber != null)
                                                        {
                                                            stroe = stockALL.Where(x => x.ExtendField04 == trankNum && x.ProductCode == materalNo
                                                                && x.PositionName == "收货暂存区").ToList();
                                                        }
                                                        else
                                                        {
                                                            stroe = stockALL.Where(x => (x.ExtendField04 == null || x.ExtendField04 == "")
                                                                && x.ProductCode == materalNo && x.PositionName == "收货暂存区").ToList();
                                                        }
                                                        if (stroe != null)
                                                        {
                                                            tempoaray = (decimal)stroe.Sum(x => x.ProductStorage);
                                                        }
                                                        #endregion
                                                        lackOrderList lackList = new lackOrderList();
                                                        // lackList.lackId = lackTop.lackId;//主表ID
                                                        lackList.saleCode = item.SaleCode;//销售单号
                                                        lackList.saleCodeItem = item.ExtendField06;//销售项号
                                                        lackList.materailCode = item.ProductCode;//物料编号
                                                        lackList.materailName = item.ProductName;//物料名称
                                                        lackList.lackQuantity = (decimal)item.QuantityOrder;//缺料数量
                                                        lackList.temporaryQuantity = tempoaray;//暂存区数量
                                                        lackList.storageQuantity = outQty;//库存数量
                                                        lackList.storageUnit = item.SmallUnit;//库存单位
                                                        lacks.Add(lackList);

                                                        //新增 出库订单分批出库历史记录明细表 【EditBy shaocx,2022-10-16】
                                                        Sale_Order_HistoryHandler.AddSale_Order_History_ItemsForLack(sale, item, sale_Order_History, lackList, mod, "缺料", "");
                                                        #endregion
                                                    }

                                                    continue;//如果都找不到 ,标记此条未缺货中
                                                }
                                                #endregion

                                                //按出库数量计算 需要多少个相关库位  validQuantity  quantityOrder
                                                #region 一个库位刚好等于出库数量的
                                                //for (int i = 0; i < products.Count; i++)//如果库存数量刚好等于要出货的数量 直接出,不然下个循环 库存依次相加当大于等于出库量 出库之和
                                                //{
                                                //    if (item.QuantityOrder == (decimal)products[i].ProductStorage)
                                                //    {
                                                //        address.Add(products[i]);
                                                //        item.ExtendField03 = "已分配";
                                                //        break;
                                                //    }

                                                //}
                                                #endregion
                                                List<vvBase_ProductPosition> curStoreList = new List<vvBase_ProductPosition>();//记录找到的出库对象集合,准备要出库的
                                                #region 计算总共需要的库存数
                                                for (int j = 0; j < products.Count; j++)
                                                {
                                                    outQty += (decimal)products[j].ProductStorage;
                                                    curStoreList.Add(products[j]);
                                                    if (outQty >= item.QuantityOrder)
                                                    {
                                                        break;//什么时候大于了就退出
                                                    }
                                                }
                                                #endregion
                                                #region 缺料出货

                                                if (outQty < item.QuantityOrder)
                                                {//缺货，如果发现库存数量要小于需求数量，就认为缺货
                                                    if (outQty > 0)
                                                    {
                                                        item.ExtendField03 = "部分缺货";
                                                    }
                                                    else
                                                    {
                                                        item.ExtendField03 = "缺货中";
                                                    }

                                                    //if (sale.OrderType == "SAP生产订单" && lackTop != null)
                                                    if (sale.OrderType == SysGlole.SAP_ORDER_TEXT && lackTop != null)
                                                    {
                                                        #region 写入缺料报表
                                                        List<vvBase_ProductPosition> lack = new List<vvBase_ProductPosition>();
                                                        string trankNum = item.TrackingNumber;
                                                        string materalNo = item.ProductCode;
                                                        decimal tempoaray = 0M;//库存数量

                                                        #region 寻找暂存区数量
                                                        if (item.TrackingNumber != null)
                                                        {
                                                            lack = stockALL.Where(x => x.ExtendField04 == trankNum && x.ProductCode == materalNo && x.PositionName == "收货暂存区").ToList();
                                                        }
                                                        else
                                                        {
                                                            lack = stockALL.Where(x => (x.ExtendField04 == null || x.ExtendField04 == "") && x.ProductCode == materalNo && x.PositionName == "收货暂存区").ToList();
                                                        }

                                                        tempoaray = lack == null ? 0M : (decimal)lack.Sum(x => x.ProductStorage);

                                                        #endregion
                                                        lackOrderList lackList = new lackOrderList();
                                                        // lackList.lackId = lackTop.lackId;//主表ID
                                                        lackList.saleCode = item.SaleCode == null ? "" : item.SaleCode;//销售单号
                                                        lackList.saleCodeItem = item.ExtendField06 == null ? "" : item.ExtendField06;//销售项号
                                                        lackList.materailCode = item.ProductCode;//物料编号
                                                        lackList.materailName = item.ProductName == null ? "" : item.ProductName;//物料名称
                                                        lackList.lackQuantity = (decimal)item.QuantityOrder - outQty;     //缺料数量
                                                        lackList.temporaryQuantity = tempoaray;//暂存区数量
                                                        lackList.storageQuantity = 0M;//库存数量
                                                        lackList.storageUnit = item.SmallUnit == null ? "" : item.SmallUnit;//库存单位
                                                        lacks.Add(lackList);

                                                        //新增 出库订单分批出库历史记录明细表 【EditBy shaocx,2022-10-16】
                                                        Sale_Order_HistoryHandler.AddSale_Order_History_ItemsForLack(sale, item, sale_Order_History, lackList, mod, "缺料", "");
                                                        #endregion
                                                    }
                                                    // continue;//如果数量小于出库数量的 也标记缺货中  客户要新建单子,出库数量不能大于库存量
                                                }

                                                else
                                                {//不缺货
                                                    item.ExtendField03 = "已分配";
                                                    //新增 出库订单分批出库历史记录明细表 【EditBy shaocx,2022-10-16】
                                                    Sale_Order_HistoryHandler.AddSale_Order_History_ItemsForNoLack(sale, item, sale_Order_History, mod, "不缺料", "");
                                                }

                                                #endregion

                                                #region 写入任务表

                                                for (int k = 0; k < curStoreList.Count; k++)
                                                {

                                                    // 出口
                                                    //大 空托盘满 回库 1017
                                                    //小 空托盘满 回库 1018
                                                    //整托出库口  1001
                                                    //分拣不助力  1003
                                                    //分拣助力      1008
                                                    string toPlace = "";//目标地址临时变量
                                                    #region 计算目标地址
                                                    if (sale.OrderExit != null)//如果指定出口就去一号口
                                                    {
                                                        #region 指定出库口的情况
                                                        if (sale.OrderExit == 1)
                                                        {//指定去1号口
                                                            toPlace = "1001";
                                                        }
                                                        else
                                                        {
                                                            if (sale.OrderExit == 2)
                                                            {//指定去2号口
                                                                toPlace = "1003";
                                                            }
                                                            else
                                                            {//指定去3号口
                                                                toPlace = "1008";
                                                            }
                                                        }
                                                        #endregion
                                                    }
                                                    else
                                                    {
                                                        #region 不指定出库口的情况
                                                        string positionName = curStoreList[k].PositionName;
                                                        List<Base_ProductPosition> checkExit = mod.Base_ProductPosition.Where(x => x.PositionName == positionName).ToList();
                                                        if (checkExit.Count > 1)//大于1说明是一个托盘里有两种物料 必须去分拣区
                                                        {
                                                            if (curStoreList[k].IsBoosterArm == 1)//如果需要助力臂
                                                            {
                                                                toPlace = "1008";
                                                            }
                                                            else
                                                            {
                                                                //toPlace = "1003";
                                                                //按照规则选择出库口 【Editby shaocx,2022-06-09】
                                                                toPlace = BussinessExtension.BussinessExtension.GetOut(mod, last_toplace);
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if (checkExit[0].ProductStorage > item.QuantityOrder)//如果库存数量大于出库数量 说明还需要回去要去分拣区
                                                            {
                                                                if (curStoreList[k].IsBoosterArm == 1)//如果需要助力臂
                                                                {
                                                                    toPlace = "1008";
                                                                }
                                                                else
                                                                {
                                                                    //toPlace = "1003";
                                                                    //按照规则选择出库口 【Editby shaocx,2022-06-09】
                                                                    toPlace = BussinessExtension.BussinessExtension.GetOut(mod, last_toplace);
                                                                }
                                                            }
                                                            else
                                                            {
                                                                if (curStoreList[k].IsBoosterArm == 1)//如果需要助力臂
                                                                {
                                                                    toPlace = "1008";
                                                                }
                                                                else
                                                                {
                                                                    toPlace = "1001";//如果等于出库数量就去1号口
                                                                }

                                                            }
                                                        }
                                                        #endregion
                                                    }
                                                    #endregion
                                                    last_toplace = toPlace;//记录本次循环上一个的目标点 【EditBy shaocx,2022-10-15】
                                                    string sourcePlace = curStoreList[k].PositionName.Split('-')[1] + "-" + curStoreList[k].PositionName.Split('-')[2] + "-" + curStoreList[k].PositionName.Split('-')[3];//源地址转换
                                                    int areaCode = Convert.ToInt32(curStoreList[k].PositionName.Split('-')[0]);
                                                    Task_Queue addTask = new Task_Queue();
                                                    addTask.BillCode = sale.OrderCode;//来源单号
                                                    addTask.TaskType = ((int)TaskTypeEnum.常规出库).ToString();
                                                    addTask.PlateType = curStoreList[k].PlateType;//器具种类-大托盘小托盘
                                                    addTask.PlateCode = curStoreList[k].PlateCode;//母托盘编号
                                                    addTask.Bill_Id = (int)sale.Order_Id;// 单据id
                                                    addTask.OrderNumber = sale.PriorityNo;//任务执行优先级
                                                    addTask.TaskStatus = "未下发";//任务状态
                                                    addTask.FromPositionName = sourcePlace;//起始地址
                                                    addTask.ToPositionName = toPlace;//目标地址

                                                    addTask.DoCount = areaCode;//库区
                                                    addTask.Direction = areaCode == 1 ? "2" : "4";//出库不需要托盘高度

                                                    addTask.CreateDate = DateTime.Now;
                                                    addTask.Creator = sale.Creator;
                                                    addTask.UserProduct_Id = 1007;//账套id 老谢bug  
                                                    addTask.IsDoing = (int)item.OrderList_Id;//记录出库明细表ID,出库确认用(只有出库用)
                                                    taskList.Add(addTask);//添加到集合 循环外合并相同起始位任务

                                                    Base_ProductPosition exitProduct = mod.Base_ProductPosition.Find(curStoreList[k].ProductPosition_Id);
                                                    #region 写入出库数量
                                                    if (toPlace == "1003" || toPlace == "1008" || toPlace == "1001")
                                                    {
                                                        if ((k + 1) == curStoreList.Count)
                                                        {
                                                            //如有是最后一个托盘  且去分拣区的 出库数量有可能大于出库数量
                                                            //托盘库存数量加上要出库数量 减去所有出库托盘上的数量 等于 本托盘上的要出库的数量
                                                            //显示在分拣上页面上告诉操作人员拿走多少物料
                                                            if ((decimal)curStoreList[k].ProductStorage > exitQty)
                                                            {
                                                                // item.QuantityOrder 出库数量
                                                                exitProduct.ExtendField02 = exitQty.ToString();
                                                                exitProduct.Remark = item.ExtendField01;//移动类型
                                                            }
                                                            else
                                                            {
                                                                exitProduct.ExtendField02 = curStoreList[k].ProductStorage.ToString();
                                                                exitQty -= (decimal)curStoreList[k].ProductStorage;
                                                                exitProduct.Remark = item.ExtendField01;//移动类型
                                                            }


                                                        }
                                                        else
                                                        {
                                                            //如果不是最后一个托盘 肯定托盘里有多种物料 那么出库数量就是托盘里物料的数量
                                                            exitProduct.ExtendField02 = ((decimal)curStoreList[k].ProductStorage).ToString();
                                                            //增加下面一行代码，解决 显示要分拣数量老是是托盘库存的问题 【EditBy shaocx,2022-06-08】
                                                            exitQty -= (decimal)curStoreList[k].ProductStorage;
                                                        }
                                                        exitProduct.ContainerNo = "1";//库位锁定
                                                        //增加物料锁定和解锁的时间和备注记录  [EditBy shaocx,2023-07-26]
                                                        exitProduct.DoContainerNoTime = DateTime.Now;
                                                        exitProduct.OpRemark = "处理待下架的表单，创建出库任务，锁定物料";
                                                    }
                                                    #endregion

                                                    // mod.SaveChanges();
                                                }
                                                #endregion

                                                item.ValidQuantity -= (decimal)item.QuantityOrder;//修改未出数量
                                                item.QuantityOrder = 0;       //本次出库数量归零
                                                //  mod.SaveChanges();
                                                #endregion
                                            }
                                            var mergeTask = taskList.GroupBy(x => x.FromPositionName);//起始位相同的任务合并
                                            foreach (var merge in mergeTask)
                                            {
                                                mod.Task_Queue.Add(merge.ToList()[0]);
                                                string positionName = merge.ToList()[0].DoCount + "-" + merge.ToList()[0].FromPositionName;
                                                Base_Position BasePosition = mod.Base_Position.FirstOrDefault(x => x.PositionName == positionName);
                                                if (BasePosition != null)
                                                {
                                                    BasePosition.IsLocked = 1;
                                                    BasePosition.Remark = "订单出库-找到库存时，库位锁定！";
                                                }
                                                else
                                                {
                                                    logtxt.txtWrite("类名：Form1/函数名：writeOutTask锁定库位失败/库位号: " + positionName, 2);
                                                }
                                            }
                                            #region 更改主表状态
                                            if (outTaskSaleNum == saleList.Count)
                                            {
                                                int num = sale.OutNumber == null ? 0 : Convert.ToInt32(sale.OutNumber);
                                                sale.Client_Id = sale.Client_Id == null ? 0 : sale.Client_Id;
                                                sale.Client_Id += num;
                                                //sale.StatusText = "已分配";
                                                sale.StatusText = Sale_Order_StatusEnum.已分配.ToString();
                                                sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.已分配);
                                                //sale.StatusID = 7;
                                                sale.OutNumber = 0;
                                                //sale.ExtendField03 = (byte)7;
                                            }
                                            if (outTaskSaleNum == 0)
                                            {
                                                int num = sale.OutNumber == null ? 0 : Convert.ToInt32(sale.OutNumber);
                                                sale.Client_Id = sale.Client_Id == null ? 0 : sale.Client_Id;
                                                sale.Client_Id += num;
                                                //sale.StatusText = "部分分配";
                                                sale.StatusText = Sale_Order_StatusEnum.部分分配.ToString();
                                                sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.部分分配);
                                                //sale.StatusID = 1;
                                                sale.OutNumber = 0;
                                                // sale.ExtendField03 = (byte)5; outNumber
                                            }
                                            if (alack > 0)
                                            {
                                                //sale.StatusText = "缺货中";
                                                sale.StatusText = Sale_Order_StatusEnum.缺货中.ToString();
                                                sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.缺货中);
                                                //sale.StatusID = 1;
                                                sale.OutNumber = 0;
                                            }

                                            #endregion
                                            int ressuleMost = mod.SaveChanges();//多次保存
                                            for (int i = 0; i < 10; i++)
                                            {
                                                if (ressuleMost == 0)
                                                {
                                                    ressuleMost = mod.SaveChanges();
                                                }
                                                else { break; }
                                            }
                                            #region 如果缺料明细数量大于0,就写入缺料报表
                                            if (lacks.Count > 0)
                                            {
                                                try
                                                {
                                                    mod.lackOrder.Add(lackTop);//加入主表
                                                    int result = mod.SaveChanges();
                                                    if (result == 1)
                                                    {
                                                        foreach (var LackItem in lacks)
                                                        {
                                                            LackItem.lackId = lackTop.lackId;
                                                            mod.lackOrderList.Add(LackItem);
                                                        }

                                                    }
                                                    int lackNum = mod.SaveChanges();

                                                }
                                                catch (Exception ex)
                                                {
                                                    logtxt.txtWrite("类名：Form1/函数名：writeOutTask写入缺料报表异常/ " + ex.Message + "出错行号" + (string)ex.StackTrace, 2);

                                                }

                                            }
                                            #endregion
                                        }
                                        #endregion

                                        #endregion
                                    }

                                    trans.Commit();//提交事务
                                }
                                catch (Exception)
                                {
                                    trans.Rollback();//回滚事务
                                    throw;
                                }
                            }
                            #endregion


                        }
                        this.lbl_Msg_writeOutTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " 正常循环一次！";
                    }
                }
                catch (Exception ex)
                {
                    //logtxt.txtWrite("类名：Form1/函数名：writeOutTask出库写入任务异常/ " + ex.Message + "出错行号" + (string)ex.StackTrace, 2);
                    Log4NetHelper.WriteErrorLog(LogType.WriteOutTask, "出库写入任务异常:" + ex.Message, ex);
                    this.lbl_Msg_writeOutTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " 异常！:" + ex.Message;
                }
            }

        }


        /// <summary> 码盘上架写入任务列表
        /// 码盘上架写入任务列表
        /// </summary>
        private void writeInTask()
        {
            var _taskType = TaskTypeEnum.常规入库;
            while (true)
            {
                Thread.Sleep(5000);//原先2秒，现在增加到5秒一次 [EditBy shaocx,2022-05-06]
                this.lbl_Msg_writeInTask.Text = "";
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        //判断是否有闲时移库任务在执行 [EditBy shaocx,2022-09-22]
                        var isExistRuningTask = FreeTimeMoveLocationTaskHandler.IsExistRuningTask(mod);
                        if (isExistRuningTask)
                        {
                            this.lbl_Msg_writeInTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前存在闲时移库任务在执行中，不允许下发其他任务，只允许下发移库任务！";
                            continue;
                        }
                        Purchase_Shelve shelveTask = mod.Purchase_Shelve.FirstOrDefault(x => x.OnShelveStatus == "待上架");
                        if (shelveTask != null)
                        {
                            string PlateCode = shelveTask.PlateCode;//母托盘编号
                            if (lastPlateCode == PlateCode)//并发物理防御 (码盘上架产生两条入库任务 怀疑是EF没保存成功导致)
                            {
                                shelveTask.OnShelveStatus = "上架完成_同一托盘号连续上架";
                                mod.SaveChanges();
                                continue;
                            }
                            //增加判断是否上一个任务就是这个托盘号的入库 [EditBy shaocx,2022-05-06]
                            var q_taskType = ((int)_taskType).ToString();
                            var db_Exist = mod.Task_Queue.Where(x => x.PlateCode == PlateCode && x.TaskType == q_taskType && x.BillCode == shelveTask.ShelveCode).FirstOrDefault();
                            if (db_Exist != null)
                            {
                                this.lbl_Msg_writeInTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now)
                                    + "，任务表Task_Queue已经存在同托盘号，同单据编号，同任务类型的任务，不允许再重复建Task_Queue任务，托盘号:"
                                    + PlateCode + ",单据编号:" + shelveTask.ShelveCode + ",任务类型是" + _taskType.ToString();
                                continue;
                            }

                            Base_Plate ContinerType = mod.Base_Plate.FirstOrDefault(x => x.PlateCode == PlateCode);
                            string containerType = "";//托盘类型
                            #region 通过托盘号分辨托盘类型
                            if (ContinerType == null)
                            {
                                shelveTask.OnShelveStatus = "无此托盘号";
                                mod.SaveChanges();
                                continue;
                            }
                            else
                            {
                                if (ContinerType.PlateType == "smallContiner")
                                {
                                    containerType = "1";
                                }
                                else
                                {
                                    containerType = "2";
                                }
                            }
                            #endregion

                            shelveTask.OnShelveStatus = "上架中";
                            shelveTask.ModifyDate = DateTime.Now;//增加修改时间 [EditBy shaocx,2022-05-06]
                            shelveTask.Modifier = "WCS";

                            //int shelveId = (int)shelveTask.Shelve_Id;//出库主表ID
                            string sourcePlace = containerType == "1" ? "1021" : "1026";//输送线编号 小的是1021,大的是1026
                            #region 写入任务表
                            Task_Queue addTask = new Task_Queue();
                            addTask.BillCode = shelveTask.ShelveCode;//来源单号
                            addTask.TaskType = ((int)_taskType).ToString();
                            addTask.PlateType = containerType;//器具种类-大托盘小托盘
                            addTask.PlateCode = PlateCode;//母托盘编号
                            addTask.Bill_Id = shelveTask.Shelve_Id;// 单据id
                            addTask.OrderNumber = 0;//任务执行优先级
                            addTask.TaskStatus = "下发中";//任务状态
                            addTask.FromPositionName = sourcePlace;//起始地址
                            addTask.ToPositionName = "";//目标地址给空返回测量高度后重新写入
                            addTask.Direction = "";//托盘高度给空返回测量高度后重新写入
                            addTask.DoCount = 0;//库区给空返回测量高度后重新写入
                            addTask.CreateDate = DateTime.Now;
                            addTask.Creator = shelveTask.Creator;
                            addTask.UserProduct_Id = 1007;//账套id 老谢bug  
                            mod.Task_Queue.Add(addTask);

                            //数据库保存
                            int i = mod.SaveChanges();
                            if (i <= 1)
                            {
                                logtxt.txtWrite("类名：Form1/函数名：writeTask码盘上架保存修改状态失败,会产生并发 ", 1);
                                this.lbl_Msg_writeInTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now)
                                 + "，数据库保存[失败！！！]，托盘号:"
                                 + PlateCode + ",单据编号:" + shelveTask.ShelveCode + ",任务类型是" + _taskType.ToString();
                            }
                            else
                            {
                                this.lbl_Msg_writeInTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now)
                                + "，数据库保存[成功]，托盘号:"
                                + PlateCode + ",单据编号:" + shelveTask.ShelveCode + ",任务类型是" + _taskType.ToString();
                                lastPlateCode = PlateCode;//记录本次托盘号,下一次比对 防止并发
                            }
                            #endregion

                        }
                    }
                }
                catch (Exception ex)
                {
                    //logtxt.txtWrite("类名：Form1/函数名：writeTask码盘上架写入任务异常/ " + ex.Message + "出错行号" + (string)ex.StackTrace + ",异常堆栈:" + JsonConvert.SerializeObject(ex), 2);
                    Log4NetHelper.WriteErrorLog(LogType.WriteInTask, "入库写入任务异常:" + ex.Message, ex);
                    this.lbl_Msg_writeInTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now)
                               + "，出现异常:" + ex.Message;
                }
            }
        }
        /// <summary> 检测入口拆盘机是否空,出口叠盘机是否满
        /// 检测入口拆盘机是否空,出口叠盘机是否满
        /// </summary>
        private void containerIsFull()
        {

            //GetCheckIsNeedOrSendContainer()
            //            入口,
            //小  库里出来到 1020
            //大 库里出来到  1025
            //上架小 1021
            //上架大 1026
            //出口
            //大 空托盘满 回库 1017
            //小 空托盘满 回库 1018
            //整托出库口  1001
            //分拣不助力  1003
            //分拣助力    1008
            while (true)
            {
                wcftest.wcfApi.BackData resultDate = new BackData();
                resultDate = GetBackDataFromWCS();

                Thread.Sleep(2000);
                try
                {
                    bool isInMoreHighPosition = false;
                    if (resultDate == null)
                    {
                        this.tb_Msg_containerIsFull.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "调用wcs设备状态信息返回resultDate为NULL";
                        continue;
                    }
                    this.tb_Msg_containerIsFull.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "调用wcs设备状态信息返回resultDate.Type:" + resultDate.Type
                        + ",resultDate.DevId:" + resultDate.DevId + ",(resultDate.DevId 4是大盘拆盘机，5是小盘拆盘机，6是大盘叠盘机，7是小盘叠盘机)"
                        + "(resultDate.Type 0不需要操作,1是入口需要空托盘,2是出库空托盘满了要回库 ),resultDate.Id:" + resultDate.Id;
                    if (resultDate.Type == 1 || resultDate.Type == 2)//等于0不需要操作,1是入口需要空托盘,2是出库空托盘满了要回库
                    {
                        using (dbModel mod = new dbModel())
                        {
                            //判断是否有闲时移库任务在执行 [EditBy shaocx,2022-09-22]
                            var isExistRuningTask = FreeTimeMoveLocationTaskHandler.IsExistRuningTask(mod);
                            if (isExistRuningTask)
                            {
                                this.tb_Msg_containerIsFull.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前存在闲时移库任务在执行中，不允许下发其他任务，只允许下发移库任务！";
                                continue;
                            }

                            //读取数据库的叠盘机和拆盘机信号, 任务没前信号会一直给所以要做比对
                            ContainerIsFullOrEmpty lastTaskSql = mod.ContainerIsFullOrEmpty.Find(1);//1就是第一条数据

                            string sourcePlace = "";//输送线编号
                            int containerTypeId = 0;
                            string toPlace = "";
                            int areaNo = 0;
                            #region 空托盘满入库
                            var findEmptyReason = "";
                            if (resultDate.Type == 2)//等于2是空托盘满入库
                            {
                                #region 使用事务 [EditBy shaocx,2022-09-22]

                                using (var trans = mod.Database.BeginTransaction())
                                {
                                    try
                                    {
                                        #region 处理 空托盘满入库
                                        if (resultDate.DevId == (int)DeviceId.大盘叠盘机)
                                        {
                                            IsFull_BigFoldingPlate = true;
                                            if (lastTaskSql.DieBig == resultDate.Id)
                                            {
                                                this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + "大叠盘任务id重复：" + resultDate.Id;
                                                logtxt.txtWrite("类名：Form1/函数名：callContainer  大叠盘任务id重复：" + resultDate.Id, 2);
                                                continue;
                                            }
                                            lastTaskSql.DieBig = resultDate.Id;
                                            sourcePlace = "1017";
                                            containerTypeId = 2;

                                            toPlace = FindEmptyLocationHandler.findStorage(mod, "", true, ref isInMoreHighPosition, ref findEmptyReason, 2, 2, 4, 0);//分配大库位
                                            areaNo = 2;//大库区
                                        }
                                        else
                                        {
                                            IsFull_SmallFoldingPlate = true;
                                            if (lastTaskSql.DieSmall == resultDate.Id)
                                            {
                                                logtxt.txtWrite("类名：Form1/函数名：callContainer  小叠盘任务id重复：" + resultDate.Id, 2);
                                                this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + "小叠盘任务id重复：" + resultDate.Id;
                                                continue;
                                            }
                                            lastTaskSql.DieSmall = resultDate.Id;
                                            sourcePlace = "1018";
                                            containerTypeId = 1;

                                            toPlace = FindEmptyLocationHandler.findStorage(mod, "", true, ref isInMoreHighPosition, ref findEmptyReason, 1, 1, 2, 0);//分配小库位
                                            // toPlace=mod
                                            areaNo = 1;//小库区
                                        }
                                        // (任务id-起始位-目标位-托盘类型(大小)-任务类型)
                                        if (toPlace == "")
                                        {
                                            //listInfo.Items.Add("满托回库,库位已满" );
                                            //listInfo.Refresh();
                                            //logtxt.txtWrite("类名：taskApi，函数名：callContainer 库位满了" + containerTypeId.ToString(), 0);
                                            //不做日记  一但库位满会产生大量垃圾日志
                                            this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + " 获取托盘满回库的库位toPlace为空,原因:" + findEmptyReason;
                                            continue;
                                        }

                                        var isExistNoFinishedTaskFor满空托回库 = BussinessExtension.BussinessExtension.IsExistNoFinishedTaskFor满空托回库(mod, sourcePlace);
                                        if (isExistNoFinishedTaskFor满空托回库)
                                        {
                                            this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + " 已经存在未结束的满空托回库的任务，来源位:" + sourcePlace;
                                            continue;
                                        }

                                        Task_Queue CallContainerTaks = new Task_Queue();
                                        CallContainerTaks.TaskType = ((int)TaskTypeEnum.满空托回库).ToString();//任务类型
                                        CallContainerTaks.OrderNumber = 0;//任务权重
                                        CallContainerTaks.TaskStatus = "未下发";//任务状态
                                        CallContainerTaks.PlateType = containerTypeId == 1 ? ((int)Sys_containerType.小托盘).ToString() : ((int)Sys_containerType.大托盘).ToString();//托盘类型
                                        CallContainerTaks.FromPositionName = sourcePlace;
                                        CallContainerTaks.ToPositionName = toPlace;
                                        CallContainerTaks.CreateDate = DateTime.Now;
                                        CallContainerTaks.Creator = "系统";
                                        CallContainerTaks.DoCount = areaNo;//库区
                                        CallContainerTaks.UserProduct_Id = 1007;//账套id 老谢bug  

                                        //更新数量为0 【EditBy shaocx,2022-03-12】
                                        Base_EquipmentHandler.FoldingPlateMachine_UpdateCurQuantityZero(mod, Convert.ToInt32(CallContainerTaks.PlateType));

                                        //垃圾值都赋值0 转到autoTask()里有说明
                                        string height = "";
                                        if (areaNo == 1)
                                        {
                                            height = "2";
                                        }
                                        else
                                        {
                                            height = "4";
                                        }
                                        CallContainerTaks.Direction = height;//托盘高度
                                        mod.Task_Queue.Add(CallContainerTaks);//满空托回库任务

                                        int num = mod.SaveChanges();

                                        if (num > 0)
                                        {
                                            trans.Commit();
                                        }
                                        else
                                        {
                                            throw new Exception("寻找满空托回库，保存数据失败");
                                        }

                                        #endregion
                                    }
                                    catch (Exception)
                                    {
                                        trans.Rollback();
                                        throw;
                                    }
                                }

                                #endregion

                            }
                            #endregion

                            #region 需要空托盘
                            else//等于1是需要空托盘
                            {
                                #region 使用事务 [EditBy shaocx,2022-09-22]

                                using (var trans = mod.Database.BeginTransaction())
                                {
                                    try
                                    {
                                        if (resultDate.DevId == (int)DeviceId.大盘拆盘机)
                                        {
                                            if (lastTaskSql.ChaiBig == resultDate.Id)
                                            {
                                                logtxt.txtWrite("类名：Form1/函数名：callContainer  大拆盘机任务id重复：" + resultDate.Id, 2);
                                                this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + "大拆盘机任务id重复：" + resultDate.Id;
                                                continue;
                                            }
                                            lastTaskSql.ChaiBig = resultDate.Id;
                                            areaNo = 2;//库区
                                            toPlace = "1025";//入口大拆盘机输送线地址
                                            containerTypeId = 2;//2是大托盘
                                        }
                                        else
                                        {
                                            if (lastTaskSql.ChaiSmall == resultDate.Id)
                                            {
                                                logtxt.txtWrite("类名：Form1/函数名：callContainer  小拆盘机任务id重复：" + resultDate.Id, 2);
                                                this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + "小拆盘机任务id重复：" + resultDate.Id;
                                                continue;
                                            }
                                            lastTaskSql.ChaiSmall = resultDate.Id;
                                            areaNo = 1;//小库区
                                            toPlace = "1020";//入口小拆盘机输送线地址
                                            containerTypeId = 1;//1是小托盘
                                        }
                                        // (任务id-起始位-目标位-托盘类型(大小)-任务类型)
                                        sourcePlace = findEmptyContainer(mod, areaNo.ToString());//找库存空托盘 1号库区放小托盘,2号库区放大托盘 
                                        if (sourcePlace == "")
                                        {
                                            logtxt.txtWrite("类名：Form1/函数名：containerIsFull找不到库位", 2);
                                            this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + "找不到库位";
                                            continue;
                                        }
                                        sourcePlace = sourcePlace.Split('-')[1] + "-" + sourcePlace.Split('-')[2] + "-" + sourcePlace.Split('-')[3];

                                        var isExistNoFinishedTaskFor空托出库 = BussinessExtension.BussinessExtension.IsExistNoFinishedTaskFor空托出库(mod, toPlace);
                                        if (isExistNoFinishedTaskFor空托出库)
                                        {
                                            this.tb_Msg_containerIsFull.Text += " \r\n  ,【报警】" + " 已经存在未结束的空托出库的任务，目标位:" + toPlace;
                                            continue;
                                        }

                                        Task_Queue outEmptyContainer = new Task_Queue();
                                        outEmptyContainer.TaskType = ((int)TaskTypeEnum.空托出库).ToString();//任务类型
                                        outEmptyContainer.OrderNumber = 0;//任务权重
                                        outEmptyContainer.TaskStatus = "未下发";//任务状态
                                        outEmptyContainer.PlateType = containerTypeId == 1 ? ((int)Sys_containerType.小托盘).ToString() : ((int)Sys_containerType.大托盘).ToString();//托盘类型
                                        outEmptyContainer.FromPositionName = sourcePlace;
                                        outEmptyContainer.ToPositionName = toPlace;
                                        outEmptyContainer.CreateDate = DateTime.Now;
                                        outEmptyContainer.Creator = "系统";
                                        outEmptyContainer.DoCount = areaNo;//库区
                                        outEmptyContainer.UserProduct_Id = 1007;//账套id 老谢bug垃圾值必须给
                                        //垃圾值都赋值0 这是WCS协议
                                        string height = "";
                                        if (areaNo == 1)
                                        {
                                            height = "2";
                                        }
                                        else
                                        {
                                            height = "4";
                                        }
                                        outEmptyContainer.Direction = height;//托盘高度
                                        mod.Task_Queue.Add(outEmptyContainer);
                                        int num = mod.SaveChanges();

                                        if (num > 0)
                                        {
                                            trans.Commit();
                                        }
                                        else
                                        {
                                            throw new Exception("寻找库里空托盘，保存数据失败");
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        trans.Rollback();
                                        throw;
                                    }
                                }

                                #endregion

                                logtxt.txtWrite("类名：from1 ，函数名：callContainer  拆盘任务发送成功 containerType：" + containerTypeId.ToString(), 0);
                                this.tb_Msg_containerIsFull.Text += " \r\n  ,【成功】" + "拆盘任务发送成功 containerType：" + containerTypeId.ToString();
                            }
                            #endregion
                        }
                    }
                }
                catch (Exception ex)
                {
                    //logtxt.txtWrite("类名：Form1/函数名：callContainer  空托盘出库或满托回库异常" + ex.Message + "出错行号" + (string)ex.StackTrace, 2);
                    Log4NetHelper.WriteErrorLog(LogType.ContainerIsFull, "异常:" + ex.Message, ex);
                    this.lbl_Msg_containerIsFull.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常：" + ex.Message;
                }
            }
        }

        #region 任务完成处理线程
        /// <summary>任务完成
        /// 任务完成
        /// </summary>
        private void finishConfirm()
        {

            while (true)
            {
                Thread.Sleep(2000);
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        List<Task_Queue> confirmList = mod.Task_Queue.Where(x => x.TaskStatus == "已下发").ToList();
                        if (confirmList != null && confirmList.Count > 0)
                        {
                            try
                            {
                                finishConfirmHandler(mod, confirmList);//有错误就抛出异常
                            }
                            catch (Exception)
                            {
                                throw;
                            }
                        }
                        else
                        {
                            this.lbl_Msg_FinishConfirm.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "没有要处理的任务...";
                        }
                    }
                }
                catch (Exception ex)
                {
                    logtxt.txtWrite("类名：Form1/函数名：finishConfirm  处理任务完成产生异常" + "出错行号" + ex.StackTrace.ToString(), 2);
                    this.lbl_Msg_FinishConfirm.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "出现异常:" + ex.Message;
                }
            }

        }

        /// <summary>
        /// 任务完成处理类
        /// </summary>
        /// <param name="mod"></param>
        private void finishConfirmHandler(dbModel mod, List<Task_Queue> confirmList)
        {
            foreach (var item in confirmList)
            {
                //使用事务
                using (DbContextTransaction tran = mod.Database.BeginTransaction())
                {
                    try
                    {
                        single_finishConfirmHandler(mod, item);
                        tran.Commit();
                        this.lbl_Msg_FinishConfirm.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "事务提交,处理正常...，PLC任务号：" + item.PlcTaskNo + ",任务号:" + item.Task_Id + ",任务类型:" + item.TaskType;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        this.lbl_Msg_FinishConfirm.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "事务回滚:" + ex.Message + ",处理失败...，PLC任务号：" + item.PlcTaskNo + ",任务号:" + item.Task_Id + ",任务类型:" + item.TaskType;
                        logtxt.txtWrite("类名：Form1/函数名：finishConfirmHandler  处理任务完成产生异常" + "出错行号" + ex.StackTrace.ToString() + ",异常堆栈:" + JsonConvert.SerializeObject(ex), 2);
                    }
                }
            }
        }

        /// <summary>
        /// 任务完成处理类【单个】
        /// </summary>
        /// <param name="mod"></param>
        private void single_finishConfirmHandler(dbModel mod, Task_Queue item)
        {
            try
            {
                //注释以下内容!!!!! 【EditBy shaocx,2022-05-27】
                /*
                //检测任务有没有产生异常 异常超过3此 改为异常状态下次不执行
                if (item.ModifyID > 3)
                {
                    item.TaskStatus = "任务异常";
                    mod.SaveChanges();
                    continue;
                }
                //*/
                // 任务执行中,
                //任务完成,
                //尺寸超高
                int result = 0;
                #region 跟WCS获取任务执行情况
                if (IsVirtualMode)
                {
                    result = 1;//模拟环境下，改为 1（任务完成） 【EditBy shaocx,2022-06-20】
                    VirtualModeHelper.ThrowExceptionWhenVirtualMode(IsVirtualMode);
                }

                else
                {
                    try
                    {
                        //修复 【EditBy shaocx,2022-04-18】
                        int plcTaskNo = 0;
                        if (item.PlcTaskNo != null && Convert.ToInt32(item.PlcTaskNo) > 0)
                        {
                            plcTaskNo = Convert.ToInt32(item.PlcTaskNo);
                        }
                        else
                        {
                            //感觉这里有问题。
                            //plcTaskNo = ExtendHelper.ConvertPlcNO(item.Task_Id);
                            //抛异常 【Editby shaocx,2023-03-18】
                            throw new Exception("任务表的PlcTaskNo值不符合！任务号:" + item.Task_Id);
                        }
                        //result = wcsApi.GetTaskIsFinishOrCheckOk(item.Task_Id);
                        int wmsTaskId = item.Task_Id;//使用最新参数，任务表的ID查询wcs任务  【EditBy shaocx,2022-09-28】
                        //int wmsTaskId = 0;//暂时写先死为0，先跑一段时间，等之前任务都清理了，再改回 【EditBy shaocx,2022-09-22】
                        result = wcsApi.GetTaskIsFinishOrCheckOk(plcTaskNo, wmsTaskId);//访问WCS的任务状态
                        logtxt.txtWrite("类名：Form1/函数名：finishConfirm  查询任务完成wcsApi.GetTaskIsFinishOrCheckOk,任务ID:"
                            + item.Task_Id + ",PLC任务号:" + plcTaskNo + ",返回结果:" + result, 2);
                    }
                    catch (Exception ex)
                    {
                        logtxt.txtWrite("类名：Form1/函数名：finishConfirm  查询任务完成产生异常" + ex.Message + "出错行号" + (string)ex.StackTrace, 2);
                        throw ex;//抛出异常 【EditBy shaocx,2022-05-28】
                    }
                }
                #endregion
                if (result == (int)taskInfo.任务执行中)
                {
                }
                else if (result == (int)taskInfo.任务完成)
                {

                    #region 常规入库确认
                    if (item.TaskType == ((int)TaskTypeEnum.常规入库).ToString())
                    {
                        writeProductPositionFor常规入库(mod, item, (item.Bill_Id == null ? 0 : Convert.ToInt32(item.Bill_Id)), item.ToPositionName, (int)item.DoCount, item.PlateType);
                        item.TaskStatus = "完成";

                    }
                    #endregion
                    #region 满空托回库任务确认
                    if (item.TaskType == ((int)TaskTypeEnum.满空托回库).ToString())
                    {
                        Base_ProductPosition EmptyContainer = new Base_ProductPosition();
                        EmptyContainer.ProductStorage = item.PlateType == "1" ? 10 : 8;//当前数量
                        EmptyContainer.PlateType = item.PlateType;//托盘类型
                        EmptyContainer.AreaCode = item.DoCount.ToString();//库区
                        EmptyContainer.ExtendField01 = ((int)ContainerOrProduct.空托盘).ToString();//标志为空托盘,

                        //////////////以下为不为空字段
                        EmptyContainer.ClassName = TaskTypeEnum.满空托回库.ToString();
                        EmptyContainer.StorageName = "立体库";

                        EmptyContainer.PositionName = item.DoCount.ToString() + "-" + item.ToPositionName;//库位地址
                        var msg = "";
                        var isRight = ExtendHelper.ValidateIsRightForPositionName(EmptyContainer.PositionName, ref msg);
                        if (!isRight)
                        {
                            throw new Exception("满空托回库(任务确认):" + msg);
                        }

                        EmptyContainer.ProductCode = "0";//物料编号
                        EmptyContainer.ProductName = "0";//物料名称
                        EmptyContainer.InStorageDate = DateTime.Now;
                        /////------以下为垃圾字段
                        EmptyContainer.MainID = 0;
                        EmptyContainer.DetailID = 0;
                        EmptyContainer.Storage_Id = 87;
                        EmptyContainer.Product_Id = 50126;
                        EmptyContainer.ProductModel = "0";
                        EmptyContainer.ConsignorCode = "GX30";
                        EmptyContainer.ConsignorName = "广州西门子";
                        EmptyContainer.Consignor_Id = 30;
                        EmptyContainer.UserProduct_Id = 1007;
                        EmptyContainer.ExtendField02 = ((int)usable.不可用).ToString();//出库数量给默认值
                        ///////////////////
                        mod.Base_ProductPosition.Add(EmptyContainer);
                        //空托处理，不需要记录出入库记录 【EditBy shaocx,2022-03-07】
                        item.TaskStatus = "完成";
                        Base_Position position = mod.Base_Position.Where(x => x.AreaCode == item.DoCount.ToString() && x.PositionName == item.DoCount.ToString() + "-" + item.ToPositionName).FirstOrDefault();
                        //position.IsFreeze = 1;//标志有货
                        position.IsFreeze = (int)IsFreezeEnum.有货;
                        position.Remark = "满空托回库任务确认-解锁库位！";
                        position.IsLocked = 0;//解除货位锁定
                        //position.PositionType = 6;//货位类型 常规库位,暂存区,空托盘
                        position.PositionType = (int)PositionType.空托盘; //使用枚举 【EditBy shaocx,2022-03-06】

                        logtxt.txtWrite("类名：Form1/函数名：finishConfirm满托回库完成 托盘类型" + item.PlateType, 0);
                    }
                    #endregion
                    #region 入库拆盘任务确认
                    if (item.TaskType == ((int)TaskTypeEnum.入库拆盘).ToString())
                    {
                        item.TaskStatus = "完成";

                    }
                    #endregion

                    #region 空托出库
                    if (item.TaskType == ((int)TaskTypeEnum.空托出库).ToString())
                    {
                        item.TaskStatus = "完成";
                        List<Base_ProductPosition> emptyContainer = mod.Base_ProductPosition.Where(x => x.AreaCode == item.DoCount.ToString() &&
                              x.PositionName == (item.DoCount.ToString() + "-" + item.FromPositionName)).ToList();
                        foreach (var clearPosition in emptyContainer)
                        {
                            mod.Base_ProductPosition.Remove(clearPosition);//空托出库完成删了这条记录
                            //空托出库不需要记录出入库记录
                        }

                        Base_Position emptyPosition = mod.Base_Position.Where(x => x.AreaCode == item.DoCount.ToString() &&
                            x.PositionName == item.DoCount.ToString() + "-" + item.FromPositionName).FirstOrDefault();
                        //出库完了释放库位
                        //emptyPosition.IsFreeze = 0;//标志无货
                        emptyPosition.IsFreeze = (int)IsFreezeEnum.无货;//标志无货
                        emptyPosition.IsLocked = 0;//标志未锁定、
                        emptyPosition.Remark = "空托出库任务确认-解锁库位！";
                    }
                    #endregion

                    #region 常规出库
                    if (item.TaskType == ((int)TaskTypeEnum.常规出库).ToString())
                    {
                        item.TaskStatus = "完成";
                        string PositionName = (item.DoCount + "-" + item.FromPositionName);

                        List<Base_ProductPosition> sortingMake = mod.Base_ProductPosition.Where(x => x.PositionName == PositionName).ToList();
                        if (sortingMake.Count > 0)
                        {
                            foreach (var SortingItem in sortingMake)
                            {
                                SortingItem.ExtendField03 = "1";//可用分拣
                            }
                        }
                        //修改

                        #region 修改出库单状态
                        if (item.ToPositionName == "1001" || item.ToPositionName == "1003" || item.ToPositionName == "1008")
                        {
                            Sale_Order sale = mod.Sale_Order.Find(item.Bill_Id);
                            if (sale != null)
                            {   //出库单里的明细
                                List<Sale_OrderList> saleList = mod.Sale_OrderList.Where(x => x.Order_Id == sale.Order_Id).ToList();
                                int OrderIsFinish = 0;
                                #region 检查出库单关联的出库任务是否全部完成,
                                foreach (var exitConfirm in saleList)
                                {
                                    List<Task_Queue> exitTaskList = mod.Task_Queue.Where(x => x.IsDoing == exitConfirm.OrderList_Id).ToList();
                                    int OrderListIsFinish = 0;
                                    for (int i = 0; i < exitTaskList.Count; i++)
                                    {
                                        if (exitTaskList[i].TaskStatus != "完成")
                                        {
                                            OrderListIsFinish++;
                                        }
                                    }
                                    if (OrderListIsFinish == exitTaskList.Count)
                                    {
                                        OrderIsFinish++;
                                        exitConfirm.ExtendField03 = "完成";
                                    }
                                    if (OrderListIsFinish > 0 && OrderListIsFinish < exitTaskList.Count)
                                    {
                                        exitConfirm.ExtendField03 = "部分完成";
                                    }
                                }

                                if (OrderIsFinish == saleList.Count)
                                {
                                    //sale.StatusID = 4;
                                    //sale.StatusText = "完成";
                                    sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.完成);
                                    sale.StatusText = Sale_Order_StatusEnum.完成.ToString();
                                }
                                if (OrderIsFinish > 0 && OrderIsFinish == saleList.Count)
                                {
                                    //sale.StatusID = 6;
                                    //sale.StatusText = "部分完成";
                                    sale.StatusID = Convert.ToByte(Sale_Order_StatusEnum.部分完成);
                                    sale.StatusText = Sale_Order_StatusEnum.部分完成.ToString();
                                }
                                #endregion

                            }

                        }
                        #endregion


                    }
                    #endregion

                    #region 出库叠盘
                    if (item.TaskType == ((int)TaskTypeEnum.出库叠盘).ToString())
                    {
                        item.TaskStatus = "完成";
                        //Base_ProductPosition emptyContainer = mod.Base_ProductPosition.Where(x => x.AreaCode == item.DoCount.ToString() &&
                        //    x.PositionName == item.FromPositionName).FirstOrDefault();
                        //mod.Base_ProductPosition.Remove(emptyContainer);//空托出库完成删了这条记录
                        Task_Queue backTask = mod.Task_Queue.Where(x => x.PlateCode == item.PlateCode && x.TaskType == "4").OrderByDescending(x => x.CreateDate).FirstOrDefault();
                        Base_Position emptyPosition = mod.Base_Position.Where(x => x.AreaCode == item.DoCount.ToString() &&
                            x.PositionName == item.DoCount.ToString() + "-" + backTask.FromPositionName).FirstOrDefault();
                        //出库完了释放库位
                        //emptyPosition.IsFreeze = 0;//标志无货
                        emptyPosition.IsFreeze = (int)IsFreezeEnum.无货;//标志无货
                        emptyPosition.IsLocked = 0;//标志未锁定
                        emptyPosition.Remark = "出库叠盘任务确认-解锁库位！";
                    }
                    #endregion

                    #region 余料回库
                    if (item.TaskType == ((int)TaskTypeEnum.余料回库).ToString())
                    {

                        item.TaskStatus = "完成";
                        if (item.CreateID == null)
                        {//表示是 真正的余料回库
                            #region 余料回库
                            List<Base_ProductPosition> returnProductPosition = mod.Base_ProductPosition.Where(x => x.AreaCode == item.DoCount.ToString() &&
                            x.PositionName == item.DoCount.ToString() + "-" + item.ToPositionName).ToList();
                            //ContainerNo=0 库存解锁,任务合并的时候这个字段设置为1
                            if (returnProductPosition.Count > 0)
                            {
                                foreach (var returnItem in returnProductPosition)
                                {//
                                    returnItem.ContainerNo = "0";//是否锁定
                                    //增加物料锁定和解锁的时间和备注记录  [EditBy shaocx,2023-07-26]
                                    returnItem.DoContainerNoTime = DateTime.Now;
                                    returnItem.OpRemark = "任务完成线程处理之余料回库，解绑物料锁定";
                                    returnItem.ExtendField03 = "0";//不可分拣
                                    returnItem.ExtendField02 = "0";//分拣数量

                                }
                            }

                            Base_Position emptyPosition = mod.Base_Position.FirstOrDefault(x => x.AreaCode == item.DoCount.ToString() &&
                                x.PositionName == item.DoCount.ToString() + "-" + item.ToPositionName);
                            //余料回库了释放库位
                            //emptyPosition.IsFreeze = 1;//标志有货
                            emptyPosition.IsFreeze = (int)IsFreezeEnum.有货;//标志有货
                            emptyPosition.IsLocked = 0;//标志未锁定
                            emptyPosition.Remark = "余料回库任务确认-解锁库位！";
                            #endregion

                        }
                        else
                        {//表示是 空托盘入库，是从出库口1001人工入库的！
                            Base_ProductPosition addPPForEmptyContainer = new Base_ProductPosition();
                            addPPForEmptyContainer.ProductStorage = item.PlateType == "1" ? 10 : 8;//当前数量
                            addPPForEmptyContainer.PlateType = item.PlateType;//托盘类型
                            addPPForEmptyContainer.AreaCode = item.DoCount.ToString();//库区
                            addPPForEmptyContainer.ExtendField01 = ((int)ContainerOrProduct.空托盘).ToString();//标志为空托盘,

                            //////////////以下为不为空字段
                            addPPForEmptyContainer.ClassName = TaskTypeEnum.满空托回库.ToString();
                            addPPForEmptyContainer.StorageName = "立体库";

                            addPPForEmptyContainer.PositionName = item.DoCount.ToString() + "-" + item.ToPositionName;//库位地址
                            var msg = "";
                            var isRight = ExtendHelper.ValidateIsRightForPositionName(addPPForEmptyContainer.PositionName, ref msg);
                            if (!isRight)
                            {
                                throw new Exception("满空托回库:" + msg);
                            }

                            addPPForEmptyContainer.ProductCode = "0";//物料编号
                            addPPForEmptyContainer.ProductName = "0";//物料名称
                            addPPForEmptyContainer.InStorageDate = DateTime.Now;
                            /////------以下为垃圾字段
                            addPPForEmptyContainer.MainID = 0;
                            addPPForEmptyContainer.DetailID = 0;
                            addPPForEmptyContainer.Storage_Id = 87;
                            addPPForEmptyContainer.Product_Id = 50126;
                            addPPForEmptyContainer.ProductModel = "0";
                            addPPForEmptyContainer.ConsignorCode = "GX30";
                            addPPForEmptyContainer.ConsignorName = "广州西门子";
                            addPPForEmptyContainer.Consignor_Id = 30;
                            addPPForEmptyContainer.UserProduct_Id = 1007;
                            addPPForEmptyContainer.ExtendField02 = ((int)usable.不可用).ToString();//出库数量给默认值
                            ///////////////////
                            mod.Base_ProductPosition.Add(addPPForEmptyContainer);
                            //余料回库，因为之前在分拣确认时，就已经记录了出入库记录，因此这里就不需要记录出入库记录了 【EditBy shaocx,2022-03-07】
                            item.TaskStatus = "完成";
                            Base_Position position = mod.Base_Position.Where(x => x.AreaCode == item.DoCount.ToString() && x.PositionName == item.DoCount.ToString() + "-" + item.ToPositionName).FirstOrDefault();
                            //position.IsFreeze = 1;//标志有货
                            position.IsFreeze = (int)IsFreezeEnum.有货;//标志有货
                            position.IsLocked = 0;//解除货位锁定
                            position.Remark = "满空托回库确认-解锁库位！";
                            //position.PositionType = 6;//货位类型 常规库位,暂存区,空托盘
                            position.PositionType = (int)PositionType.空托盘; //使用枚举 【EditBy shaocx,2022-03-06】

                            logtxt.txtWrite("类名：Form1/函数名：finishConfirm满托回库完成 托盘类型" + item.PlateType, 0);
                        }

                    }
                    #endregion

                    #region 组盘出库
                    if (item.TaskType == ((int)TaskTypeEnum.组盘出库).ToString())
                    {//拼盘出库
                        item.TaskStatus = "完成";
                        Base_Position Positions = mod.Base_Position.FirstOrDefault(x => x.PositionName == item.DoCount + "-" + item.FromPositionName);
                        if (Positions != null)
                        {
                            Positions.IsLocked = 0;
                            Positions.Remark = "组盘出库任务确认-解锁库位！";
                            //Positions.IsFreeze = 0;
                            Positions.IsFreeze = (int)IsFreezeEnum.无货;
                            Positions.PositionType = 0;
                        }
                    }
                    #endregion
                    #region 移库
                    if (item.TaskType == ((int)TaskTypeEnum.移库).ToString())
                    {

                        string toPositionName = item.DoCount + "-" + item.ToPositionName;
                        string fromPositionName = item.DoCount + "-" + item.FromPositionName;
                        List<Base_ProductPosition> movePosition = mod.Base_ProductPosition.Where(x => x.PositionName == fromPositionName).ToList();
                        Base_Position fromPosition = mod.Base_Position.FirstOrDefault(x => x.PositionName == fromPositionName);
                        Base_Position toPosition = mod.Base_Position.FirstOrDefault(x => x.PositionName == toPositionName);
                        if (movePosition.Count > 0 && fromPosition != null && toPosition != null)
                        {//转移库存
                            foreach (var itemMoveStock in movePosition)
                            {
                                //增加出入库记录 【EditBy shaocx,2022-10-18】，注意要放到最前面才可以
                                OutInStockTaskHandler.AddOutInStockTask22("系统", mod, OutInStockTaskName.移库任务, -itemMoveStock.ProductStorage, itemMoveStock, "移库任务-移出", itemMoveStock.PositionName);
                                OutInStockTaskHandler.AddOutInStockTask22("系统", mod, OutInStockTaskName.移库任务, itemMoveStock.ProductStorage, itemMoveStock, "移库任务-移入", toPositionName);

                                itemMoveStock.PositionName = toPositionName;

                            }
                            //fromPosition.IsFreeze = 0;//是否有货
                            fromPosition.IsFreeze = (int)IsFreezeEnum.无货;//是否有货
                            fromPosition.IsLocked = 0;//是否锁定 PositionType
                            fromPosition.Remark = "移库任务确认-解锁库位！";
                            fromPosition.PositionType = 0;//货位类型 1是货物  6 是空托盘
                            //toPosition.PositionType = 1;//货位类型 1是货物  6 是空托盘
                            toPosition.PositionType = (int)PositionType.常规货位; //使用枚举 【EditBy shaocx,2022-03-06】
                            //toPosition.IsFreeze = 1;
                            toPosition.IsFreeze = (int)IsFreezeEnum.有货;
                            toPosition.IsLocked = 0;
                            toPosition.Remark = "移库任务确认-解锁库位！";
                            toPosition.PositionLength = fromPosition.PositionLength;//托盘空间占用比
                            fromPosition.PositionLength = 0;
                            fromPosition.IsLocked = 0;

                            //获取闲时移库的明细数据，判断其转移类型 【EditBy shaocx,2022-09-26】
                            var freeTimeMoveLocationTaskDetail = mod.Wms_FreeTimeMoveLocationTaskDetails.Where(x => x.Task_Id == item.Task_Id).FirstOrDefault();
                            if (freeTimeMoveLocationTaskDetail != null)
                            {
                                if (freeTimeMoveLocationTaskDetail.MoveRemark == (AutoMoveLocationReasonEnum.高库位去合适库位).ToString())
                                {
                                    foreach (var itemMoveStock in movePosition)
                                    {
                                        itemMoveStock.IsInMoreHighPosition = 0;//配置为 适配库位 
                                    }
                                }
                            }

                            int resule = mod.SaveChanges();
                            if (resule < 1)//保存失败再保存一次
                            {
                                resule = mod.SaveChanges();
                                if (resule < 1)
                                {
                                    item.TaskStatus = "确认异常";
                                }
                                else
                                {
                                    item.TaskStatus = "完成";

                                }
                            }
                            else
                            {
                                item.TaskStatus = "完成";
                            }

                        }
                        else
                        {
                            item.TaskStatus = "确认异常";
                        }



                    }
                    #endregion
                }
                else if (result == (int)taskInfo.尺寸超高)
                {//BillCode
                    #region MyRegion
                    FindEmptyLocationHandler.changPlateCode();
                    logtxt.txtWrite("类名：Form1/函数名：finishConfirm 确认任务尺寸超高/ 任务id" + item.Task_Id + "wcf返回值" + result, 2);
                    mod.Task_Queue.Remove(item);
                    int shelveId = item.Bill_Id == null ? 0 : Convert.ToInt32(item.Bill_Id);//码盘上架ID
                    Purchase_Shelve shelve = mod.Purchase_Shelve.Find(shelveId);
                    // List<Purchase_ShelveList> shelveList = mod.Purchase_ShelveList.Where(x => x.Shelve_Id == shelveId).ToList();
                    if (shelve != null)
                    {
                        shelve.OnShelveStatus = "尺寸异常";
                    }
                    mod.SaveChanges();
                    #endregion
                }
                else if (result == (int)taskInfo.找不到库位)
                {//BillCode
                    #region MyRegion  找库位失败已经 任务状态和上架状态已经处理完了
                    FindEmptyLocationHandler.changPlateCode();//上一个托盘号
                    logtxt.txtWrite("类名：Form1/函数名：finishConfirm 确认任务找不到库位/ 任务id" + item.Task_Id + "wcf返回值" + result, 2);
                    // mod.Task_Queue.Remove(item);
                    //int shelveId = Convert.ToInt32(item.Bill_Id);//码盘上架ID
                    //Purchase_Shelve shelve = mod.Purchase_Shelve.Find(shelveId);
                    //if (shelve != null)
                    //{
                    //    shelve.OnShelveStatus = "找不到库位";
                    //}
                    //mod.SaveChanges();
                    #endregion
                }
            }
            catch (Exception ex)
            {//ModifyID
                logtxt.txtWrite("类名：Form1/函数名：finishConfirm  查询任务完成产生异常" + ex.Message + "出错行号" + (string)ex.StackTrace, 2);
                throw;//抛出异常
            }
            mod.SaveChanges();
        }

        #endregion

        #region 定时删除数据

        /// <summary>
        /// 定时删除数据
        /// </summary>
        public void DeleteData()
        {
            while (true)
            {
                try
                {
                    int days = 180;
                    LogTextHelper.BatchDeleteLog(@"d:\\Log4Net_siemensSapService", days);//增加 Log4Net_siemensSapService 文件夹 [EditBy shaocx,2022-10-12]
                    LogTextHelper.BatchDeleteLog(@"d:\\Log4Net", days);//增加Log4Net文件夹 [EditBy shaocx,2022-09-22]
                    LogTextHelper.BatchDeleteLog(@"d:\\log_MySAP", 30);
                    LogTextHelper.BatchDeleteLog(@"d:\\log_ShuYing", 30);
                    LogTextHelper.BatchDeleteLog(@"c:\\Siemens\\SAP_LOG", 30);

                    //增加 WCS日志的删除  [EditBy shaocx,2022-10-22]
                    LogTextHelper.BatchDeleteLog(@"c:\\CCSLog", 30);
                    LogTextHelper.BatchDeleteLog(@"c:\\DevLog", 30);
                    LogTextHelper.BatchDeleteLog(@"c:\\WCSLog", 30);


                    this.lbl_DeleteData.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "清理成功...";
                }
                catch (Exception ex)
                {
                    //SystemWarningMsg._lbl_Alert_DeleteData = "出现异常:" + ex.Message;
                    // Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "定时删除数据 出现异常", ex);
                    this.lbl_DeleteData.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "清理异常..." + ex.Message;
                }
                finally
                {
                    Thread.Sleep(8 * 60 * 60 * 1000);//每天8小时一次 
                }
            }
        }

        /// <summary>
        /// 定时删除 收货暂存区 无效 数据
        /// </summary>
        public void DeleteData_Base_ProductPosition()
        {
            while (true)
            {
                try
                {
                    if (DateTime.Now.Hour == 4 || DateTime.Now.Hour == 6)
                    //if (true)//暂时 测试
                    {
                        //定时删除6个月之前的
                        using (dbModel emd = new dbModel())
                        {
                            var qureyTime = DateTime.Now.AddMonths(-6);
                            var removeList = emd.Base_ProductPosition.Where(x => x.PositionName == SysGlole.PositionName_SHZCQ
                                 && x.InStorageDate <= qureyTime).Take(1000).ToList();
                            if (removeList != null && removeList.Count > 0)
                            {
                                emd.Base_ProductPosition.RemoveRange(removeList);
                                emd.SaveChanges();
                            }
                        }

                        this.lbl_Msg_DeleteData_Base_ProductPosition.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "清理成功...";
                    }
                }
                catch (Exception ex)
                {
                    //SystemWarningMsg._lbl_Alert_DeleteData = "出现异常:" + ex.Message;
                    // Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "定时删除数据 出现异常", ex);
                    this.lbl_Msg_DeleteData_Base_ProductPosition.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "清理异常..." + ex.Message;
                }
                finally
                {
                    Thread.Sleep(20 * 60 * 1000);//每天20分钟一次 
                    //Thread.Sleep(3 * 1000);//每天3分钟一次 //暂时 测试
                }
            }
        }

        #endregion

        #region 闲时移库

        /// <summary>
        /// 闲时移库-库区1
        /// </summary>
        public void AutoMoveForArea1()
        {
            var areaCode = "1";
            while (true)
            {
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        var task = AutoMoveLocationHandler.GetCurExcuteFreeTimeMoveLocationTask(mod);
                        if (task != null)
                        {
                            bool validateResult = AutoMoveLocationHandler.IsNeedCreateNewMoveTask(mod, areaCode);
                            if (validateResult == false)
                            {
                                this.lbl_Msg_AutoMoveForArea1.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前库区还有未结束的移库任务，不允许创建新的移库任务..";
                                continue;
                            }
                            var result = AutoMoveLocationHandler.DoForHighLocation(mod, areaCode, task);
                            if (result == false)
                            {
                                AutoMoveLocationHandler.DoForAutoBalance(mod, areaCode, task);
                            }
                            this.lbl_Msg_AutoMoveForArea1.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "一次闲时移库循环结束..";
                        }
                        else
                        {
                            this.lbl_Msg_AutoMoveForArea1.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前无要执行的闲时移库";
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.lbl_Msg_AutoMoveForArea1.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常..." + ex.Message;
                    Log4NetHelper.WriteErrorLog(LogType.FreeTimeMoveLocation, "库区1闲时移库异常:" + ex.Message, ex);
                }
                finally
                {
                    Thread.Sleep(10 * 1000);//每10秒一次 
                }
            }
        }

        /// <summary>
        /// 闲时移库-库区2
        /// </summary>
        public void AutoMoveForArea2()
        {
            var areaCode = "2";
            while (true)
            {
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        var task = AutoMoveLocationHandler.GetCurExcuteFreeTimeMoveLocationTask(mod);
                        if (task != null)
                        {
                            bool validateResult = AutoMoveLocationHandler.IsNeedCreateNewMoveTask(mod, areaCode);
                            if (validateResult == false)
                            {
                                this.lbl_Msg_AutoMoveForArea1.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前库区还有未结束的移库任务，不允许创建新的移库任务..";
                                continue;
                            }
                            var result = AutoMoveLocationHandler.DoForHighLocation(mod, areaCode, task);
                            if (result == false)
                            {
                                AutoMoveLocationHandler.DoForAutoBalance(mod, areaCode, task);
                            }
                            this.lbl_Msg_AutoMoveForArea2.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "一次闲时移库循环结束..";
                        }
                        else
                        {
                            this.lbl_Msg_AutoMoveForArea2.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "当前无要执行的闲时移库";
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.lbl_Msg_AutoMoveForArea2.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "异常..." + ex.Message;
                    Log4NetHelper.WriteErrorLog(LogType.FreeTimeMoveLocation, "库区2闲时移库异常:" + ex.Message, ex);
                }
                finally
                {
                    Thread.Sleep(10 * 1000);//每10秒一次 
                }
            }
        }

        #endregion

        #region 处理 新增无单入库的入库记录
        private void doNoBillForAddOutInStockTask()
        {
            while (true)
            {
                Thread.Sleep(3000);
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        var queryClassName = "无单入库扫描";
                        List<Base_ProductPosition> ppList = mod.Base_ProductPosition.Where(x => x.PositionName == SysGlole.PositionName_SHZCQ
                            && x.ClassName == queryClassName
                            && (x.isHasInRecordForNoBill == null || x.isHasInRecordForNoBill == 0)
                            ).ToList();
                        if (ppList != null && ppList.Count > 0)
                        {
                            foreach (var item in ppList)
                            {
                                //增加出入库记录 【EditBy shaocx,2022-10-18】
                                OutInStockTaskHandler.AddOutInStockTask22(item.Creator, mod, OutInStockTaskName.收货任务, item.ProductStorage, item, "无单收货-收货,收货暂存区,增加库存", item.PoCode);
                                item.isHasInRecordForNoBill = 1;
                                mod.SaveChanges();
                            }
                        }
                        this.lbl_Msg_doNoBillForAddOutInStockTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " 正常循环一次！";
                    }
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(LogType.DoNoBillForAddOutInStockTask, "处理 新增无单入库的入库记录 异常:" + ex.Message, ex);
                    this.lbl_Msg_doNoBillForAddOutInStockTask.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + " 异常！:" + ex.Message;
                }
            }

        }
        #endregion

        /// <summary> 循环给SAP发生数据确认
        /// 循环给SAP发生数据确认
        /// </summary>
        private void sendSapInfo()
        {
            while (true)
            {
                Thread.Sleep(2000);
                // DateTime yesterdayTime = DateTime.Now.AddDays(-1.0);//注意：这里只查1天前的数据？
                try
                {
                    using (dbModel mod = new dbModel())
                    {
                        //改为查询所有
                        //List<SapSendInfo> sapInfoList = mod.SapSendInfo.Where(x => x.isFinish == 0 && x.creatTime > yesterdayTime).ToList();
                        List<SapSendInfo> sapInfoList = mod.SapSendInfo.Where(x => x.isFinish == 0).ToList();
                        if (sapInfoList.Count > 0)
                        {
                            apitest wcfapi = new apitest();

                            foreach (var item in sapInfoList)
                            {
                                //判断如果重发了5次之后，就不允许再发了 【EditBy shaocx,2022-09-23】
                                if (item.sendCount > 5)
                                {
                                    item.isFinish = 1;
                                    item.Remark = "重发次数超过5次，自动标记完成";
                                    mod.SaveChanges();
                                    continue;
                                }

                                //向sap发送出库任务
                                //if (item.moveType == 1)
                                if (item.moveType == (int)MoveTypeForSapSend.出库)
                                {
                                    string result = SAPHelper.StockOutConfirm(item, item.SendSapData);//发送出库确认
                                    resultInfo resultData = JsonConvert.DeserializeObject<resultInfo>(result);
                                    if (resultData.result)//成功标记完成
                                    {
                                        item.voucherCode = item.RetMsg = resultData.msg;
                                        item.isFinish = 1;
                                    }
                                    else
                                    {
                                        if (resultData.msg == "失败")
                                        {
                                            item.isFinish = 1;
                                            item.voucherCode = item.RetMsg = resultData.msg;

                                        }
                                        else
                                        {
                                            item.sendCount = item.sendCount + 1;//增加次数

                                        }

                                    }



                                }
                                //向sap发送移库任务
                                //else if (item.moveType == 2)
                                else if (item.moveType == (int)MoveTypeForSapSend.移库)
                                {

                                    string result = SAPHelper.moveStockConfirm(item, item.SendSapData);//发送移库确认
                                    resultInfo resultData = JsonConvert.DeserializeObject<resultInfo>(result);
                                    if (resultData.result)//成功标记完成
                                    {
                                        item.voucherCode = item.RetMsg = resultData.msg;
                                        item.isFinish = 1;
                                    }
                                    else
                                    {
                                        if (resultData.msg == "失败")
                                        {
                                            item.isFinish = 1;
                                            item.voucherCode = item.RetMsg = resultData.msg;
                                        }
                                        else
                                        {
                                            item.sendCount = item.sendCount + 1;//增加次数
                                        }

                                    }


                                }
                                int isSendSueeccd = mod.SaveChanges();
                                if (isSendSueeccd == 0)
                                {
                                    logtxt.txtWrite("SAP发送成功保存失败 ID:" + item.id, 2);
                                    this.lbl_sendSapInfo.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "保存数据失败:" + item.id;
                                }
                                else
                                {
                                    this.lbl_sendSapInfo.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "SAP发送成功:" + item.id;
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.lbl_sendSapInfo.Text = DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "SAP发送异常:" + ex.Message;
                    logtxt.txtWrite("SAP发送成功保存失败 " + ex.StackTrace.ToString(), 2);
                }

            }
        }
        #region 辅助
        /// <summary>返回设备名称和报警信息
        /// 返回设备名称和报警信息
        /// </summary>
        /// <param name="deviceType"></param>
        /// <param name="alarmNumber"></param>
        /// <param name="deviceNumber"></param>
        /// <returns></returns>
        public string[] alarmName(int deviceType, int alarmNumber, int deviceNumber)
        {
            string[] name = { "", "" };
            try
            {
                name[0] = Enum.GetName(typeof(DeviceId), deviceNumber);
                switch (deviceType)
                {
                    case 0:

                        name[1] = Enum.GetName(typeof(ESrmAlarm), alarmNumber);
                        break;
                    case 1:

                        name[1] = Enum.GetName(typeof(EConveyorAlarm), alarmNumber);
                        break;
                    case 2:

                        name[1] = Enum.GetName(typeof(ERgvAlarm), alarmNumber);
                        break;
                    case 3:

                        name[1] = Enum.GetName(typeof(EChaiDeiAlerm), alarmNumber);
                        break;
                    default:
                        name[0] = "设备号错误";
                        name[1] = "设备号错误";
                        break;
                }
            }
            catch (Exception)
            {
                name[0] = "转换失败";
                name[1] = "转换失败";
            }
            return name;


        }
        /// <summary>把前端移动类型描述转换成sap格式
        /// 把前端移动类型描述转换成sap格式
        /// </summary>
        /// <param name="stringMove">移动类型描述</param>
        /// <returns>返回SAP格式</returns>
        public string ConvertMoveType(string stringMove)
        {
            switch (stringMove.Trim())
            {
                case "发料到成本中心201": return "201";
                case "发料到生产订单261": return "261";
                case "发料到销售订单231": return "231";
                case "暂存区发料到生产订单261": return "261";
                case "311立库到平库": return "311";
                default: return "";

            }
        }
        /// <summary>运行状态指示灯
        /// 运行状态指示灯
        /// </summary>
        public void changeColor()
        {
            bool isChange = true;
            while (true)
            {
                textBox7.Text = lastPlateCode;
                Thread.Sleep(1000);
                if (isChange)
                {
                    label11.BackColor = Color.Yellow;

                }
                else
                {
                    label11.BackColor = Color.Pink;
                }
                isChange = !isChange;
            }


        }

        /// <summary>找库里的空托盘
        /// 找库里的空托盘
        /// </summary>
        /// <param name="areaNo">库区</param>
        /// <returns>找到的库位</returns>
        private string findEmptyContainer(dbModel mod, string areaNo)
        {
            string sourcePlace = "";
            if (single.WaitOne())//增加线程锁防止并发
            {
                try
                {

                    //vvBase_ProductPosition 库存和库位视图表
                    //ExtendField01 有货是0 空托盘是1
                    //ExtendField02 不可用是0 可用是1

                    vvBase_ProductPosition emptyContainer = mod.vvBase_ProductPosition.Where(x => x.ExtendField01 == ((int)ContainerOrProduct.空托盘).ToString() &&
                      x.AreaCode == areaNo && x.IsLocked == (int)IsLockedEnum.未锁定).FirstOrDefault();
                    // Base_ProductPosition emptyContainer = mod.Base_ProductPosition.Where(x => x.ExtendField01 == ((int)ContainerOrProduct.空托盘)
                    //.ToString() && x.ExtendField02 == ((int)usable.可用).ToString() && x.AreaCode == areaNo).FirstOrDefault();

                    if (emptyContainer != null)
                    {
                        //找到库位地址准备锁定
                        Base_Position lockPosition = mod.Base_Position.Where(x => x.AreaCode == areaNo && x.PositionName == emptyContainer.PositionName).FirstOrDefault();

                        sourcePlace = emptyContainer.PositionName;
                        lockPosition.IsLocked = (int)IsLockedEnum.锁定;
                        int i = mod.SaveChanges();
                        if (i == 0)
                        {
                            throw new Exception("找到库里的空托盘，但是锁定库位数据失败！" + lockPosition.PositionName + "，库区:" + lockPosition.AreaCode);
                        }
                    }
                }
                catch (Exception ex)
                {
                    logtxt.txtWrite("类名：Form1/函数名：findEmptyContainer/寻找库里空托盘 产生异常 库区=" + areaNo.ToString() + "-出错信息" + ex.Message + "-出错行号" + (string)ex.StackTrace, 2);
                    throw ex;
                }
                finally { single.ReleaseMutex(); }//一轮结束
            }
            return sourcePlace;

        }
        /// <summary>  写入库存
        /// 写入库存,保存不成功抛出异常
        /// </summary>
        /// <param name="billId">上架ID</param>
        /// <param name="toPlace">目的地址</param>
        /// <param name="areaCode">库区</param>
        private void writeProductPositionFor常规入库(dbModel mod, Task_Queue task, int ShelveId, string toPlace, int areaCode, string continerType)
        {
            if (single.WaitOne())//增加线程锁防止并发
            {
                try
                {
                    var _PositionName = areaCode.ToString() + "-" + toPlace;
                    var msg = "";
                    var isRight = ExtendHelper.ValidateIsRightForPositionName(_PositionName, ref msg);
                    if (!isRight)
                    {
                        throw new Exception("常规入库:" + msg);
                    }
                    Purchase_Shelve shelve = mod.Purchase_Shelve.Where(x => x.Shelve_Id == ShelveId).FirstOrDefault();
                    if (shelve != null)
                    {
                        List<Purchase_ShelveList> shelvelist = mod.Purchase_ShelveList.Where(x => x.Shelve_Id == ShelveId).ToList();
                        if (shelvelist.Count > 0)
                        {
                            if (shelve.ShelveType == ShelveTypeEnum.拼盘上架.ToString())
                            {
                                ExtendHelper.RemoveProductPositionForPinPan(mod, shelve.PlateCode, shelve.Creator);
                            }

                            foreach (var item in shelvelist)
                            {
                                //OutInStockTask _outInStockTask = new OutInStockTask();
                                //_outInStockTask.taskName = "入库任务";
                                //_outInStockTask.orderCode = shelve.ShelveCode;
                                //_outInStockTask.trackNumber = item.TrackingNumber;
                                //_outInStockTask.materialNumber = item.ProductCode;
                                //_outInStockTask.materialName = item.ProductName;//物料名称
                                //_outInStockTask.unit = item.SmallUnit;//库存单位
                                //_outInStockTask.quantity = (Decimal)item.Quantity;
                                //_outInStockTask.creatDate = DateTime.Now;
                                ////增加字段 【EditBy shaocx,2022-03-06】
                                //_outInStockTask.PositionName = _PositionName;
                                //decimal cghw_ProductStorage = 0;
                                //decimal zcq__ProductStorage = 0;
                                //BussinessExtension.BussinessExtension.GetCurrentProductStorage(mod, _outInStockTask.materialNumber, out cghw_ProductStorage, out zcq__ProductStorage);
                                //_outInStockTask.CGHW_ProductStorage = cghw_ProductStorage;
                                //_outInStockTask.ZCG_ProductStorage = zcq__ProductStorage;

                                //mod.OutInStockTask.Add(_outInStockTask);//增加入库记录
                                OutInStockTaskHandler.AddOutInStockTask(shelve.PlateCode, mod, OutInStockTaskName.入库任务, shelve.ShelveCode, item.TrackingNumber, item.ProductCode,
                                    item.ProductName, item.SmallUnit, (Decimal)item.Quantity, _PositionName, "入库任务完成", task.Creator);

                                Base_ProductPosition addPP = new Base_ProductPosition();

                                //注意：这里处理支持二维码的方式 【Editby shaocx,2023-11-5】
                                var isQrCode = false;
                                if (!string.IsNullOrEmpty(item.ExtendField06) && item.ExtendField06.Length > 15)
                                {
                                    isQrCode = true;
                                    addPP.qrCode_guid = item.ExtendField06;
                                }
                                addPP.BarCode = addPP.ExtendField06 = item.ExtendField06;
                                addPP.IsQrCode = isQrCode;

                                addPP.BillCode = ShelveId.ToString();//码盘单号
                                addPP.OrignStorage = (Decimal)item.Quantity; //原始数量
                                addPP.ProductStorage = (Decimal)item.Quantity;//当前数量
                                addPP.IsBoosterArm = item.IsBoosterArm == null ? (byte)0 : (byte)item.IsBoosterArm;// 是否需要助力;
                                addPP.PlateCode = shelve.PlateCode;//母托盘号
                                addPP.PlateType = continerType;//托盘类型
                                addPP.AreaCode = areaCode.ToString();//库区
                                addPP.ExtendField01 = ((int)ContainerOrProduct.货物).ToString();//标志为货物,
                                addPP.ExtendField02 = "0";//预出库数量,给个默认值
                                addPP.SmallUnit = item.SmallUnit;//库存单位

                                ////////以下数据空不可为空 库存视图关系字段
                                addPP.ClassName = TaskTypeEnum.常规入库.ToString();
                                addPP.StorageName = "立体库";
                                //ProductPosition.PositionName = areaCode.ToString() + "-" + toPlace;//库位地址
                                addPP.PositionName = _PositionName;//库位地址

                                //ProductCode 字段是必需的。
                                //ProductName 字段是必需的。
                                if (string.IsNullOrEmpty(item.ProductCode))
                                {
                                    addPP.ProductCode = "虚拟物料编号";
                                }
                                else
                                {
                                    addPP.ProductCode = item.ProductCode;//物料编号
                                }
                                if (string.IsNullOrEmpty(item.ProductName))
                                {
                                    addPP.ProductName = "虚拟物料名称";//物料名称
                                }
                                else
                                {
                                    addPP.ProductName = item.ProductName;//物料名称
                                }



                                //productPosition.InStorageDate = DateTime.Now;//入库时间
                                addPP.InStorageDate = ExtendHelper.GetInStorageDate(shelve, item);//入库时间

                                addPP.UserProduct_Id = 1007;
                                if (item.Product_Id != null)
                                {
                                    addPP.Product_Id = (int)item.Product_Id;//产品ID
                                }
                                else
                                {
                                    addPP.Product_Id = 0;
                                }

                                addPP.PoCode = item.PoCode;//采购单号
                                addPP.ItemNumber = item.ExtendField09;//采购项号
                                addPP.ExtendField04 = item.TrackingNumber;//跟踪号
                                addPP.SaleCode = item.SaleCode == null ? "" : item.SaleCode;// 销售单号
                                addPP.ExtendField08 = item.ExtendField08 == null ? "" : item.ExtendField08;// 销售项号
                                addPP.LimitDate = item.LimitDate;//限用日期
                                addPP.ContainerNo = "0";//
                                //增加物料锁定和解锁的时间和备注记录  [EditBy shaocx,2023-07-26]
                                addPP.DoContainerNoTime = DateTime.Now;
                                addPP.OpRemark = "常规入库操作，初始化库存，解绑物料锁定";
                                ////----------以下垃圾值
                                addPP.MainID = 0;
                                addPP.DetailID = 0;
                                addPP.Storage_Id = 87;
                                addPP.ProductModel = "0";
                                addPP.ConsignorCode = "GX30";
                                addPP.ConsignorName = "广州西门子";
                                addPP.Consignor_Id = 30;

                                //记录 物料高度和逻辑高度 【EditBy shaocx,2022-08-25】
                                addPP.LogicHeight = task.LogicHeight;
                                addPP.PhysicsHeight = task.PhysicsHeight;

                                //记录 是否入的是匹配自己高度的更高库位，这些库位需要移库的 【EditBy shaocx,2022-09-19】
                                addPP.IsInMoreHighPosition = task.IsInMoreHighPosition;

                                mod.Base_ProductPosition.Add(addPP);
                                //上面已有增加入库记录的方法了 【EditBy shaocx,2022-03-07】

                                //有个问题：入库任务完成，收货暂存区的物料不删除吗？？【EditBy shaocx,2024-09-08】
                                var find_PositionName = SysGlole.PositionName_SHZCQ;
                                var shzcObj = mod.Base_ProductPosition.Where(x => x.ExtendField06 == addPP.ExtendField06 && x.PositionName == find_PositionName).FirstOrDefault();
                                if (shzcObj != null)
                                {
                                    mod.Base_ProductPosition.Remove(shzcObj);
                                }
                            }
                            shelve.OnShelveStatus = "上架完成";
                            Base_Position position = mod.Base_Position.Where(x => x.AreaCode == areaCode.ToString() && x.PositionName == areaCode + "-" + toPlace).FirstOrDefault();
                            //position.IsFreeze = 1;//标志有货
                            position.IsFreeze = (int)IsFreezeEnum.有货;//标志有货
                            position.IsLocked = 0;//解除货位锁定
                            position.Remark = "常规入库任务确认-解锁库位！";
                            //position.PositionType = 1;//常规货位
                            position.PositionType = (int)PositionType.常规货位; //使用枚举 【EditBy shaocx,2022-03-06】
                            position.PositionLength = Convert.ToDecimal(shelve.Provider_Id);//库位白百分比




                            int changeCount = mod.SaveChanges();
                            if (changeCount <= 0)
                            {//保存失败
                                logtxt.txtWrite("类名：form1/函数名：writeProductPosition/保存数据失败 码盘上架单号=" + ShelveId.ToString(), 2);
                                throw new Exception("写入库存,保存数据失败");
                            }

                        }

                        else
                        {
                            logtxt.txtWrite("类名：form1/函数名：writeProductPosition/码盘单号无效 码盘上架单号=" + ShelveId.ToString(), 2);

                        }

                    }
                    else
                    {
                        logtxt.txtWrite("类名：form1/函数名：writeProductPosition/码盘单号无效 码盘上架单号=" + ShelveId.ToString(), 2);

                    }

                }
                catch (Exception ex)
                {
                    logtxt.txtWrite("类名：Form1/函数名：writeProductPosition/写入库存产生异常 码盘上架单号=" + ShelveId.ToString()
                        + "-出错信息" + ex.Message + "-出错行号" + (string)ex.StackTrace
                         + ",我记录的异常堆栈:" + JsonConvert.SerializeObject(ex)
                        , 2);
                    throw;
                }
                finally { single.ReleaseMutex(); }//一轮结束
            }
        }





        /// <summary> 托盘高度转换
        /// 托盘高度转换
        /// </summary>
        /// <param name="shelveid">码盘主表ID</param>
        /// <param name="height">选择的高度</param>
        /// <param name="ContainerType">托盘类型</param>
        /// <param name="areaCode">库区</param>
        /// <returns></returns>
        //private int getHeight(int shelveid, string height, int ContainerType, out int areaCode)
        //{// getHeight(shelveId, shelveTask.ProviderShortName, containerType, out areaCode)
        //    int result = 0;

        //    try
        //    {

        //        #region 大托盘
        //        if (ContainerType == 2)
        //        {
        //            if (height == "600以下")
        //            {
        //                result = 1;
        //            }
        //            else if (height == "600-750")
        //            {
        //                result = 2;
        //            }
        //            else if (height == "750-1150")
        //            {
        //                result = 3;
        //            }
        //            else if (height == "1150-1350")
        //            {
        //                result = 4;
        //            }
        //            areaCode = 2;
        //            return result;
        //        }
        //        #endregion
        //        #region 小托盘
        //        else
        //        {

        //            if (height == "1350-1850")
        //            {
        //                areaCode = 1;
        //                return 2;
        //            }
        //            using (dbModel mod = new dbModel())
        //            {
        //                //找到物料编号 用来分别哪个哪个巷道物料多
        //                Purchase_ShelveList shelveList = mod.Purchase_ShelveList.Where(x => x.Shelve_Id == shelveid).FirstOrDefault();
        //                if (shelveList == null)
        //                {
        //                    areaCode = 0;
        //                    return 0;
        //                }
        //                string productNo = shelveList.ProductCode;
        //                //分析哪个巷道物料多
        //                var productOne = mod.Base_ProductPosition.Where(x => x.AreaCode == "1" && x.ProductCode == productNo).ToList();//.Sum(x => x.ProductStorage);
        //                var productTwo = mod.Base_ProductPosition.Where(x => x.AreaCode == "2" && x.ProductCode == productNo).ToList();// Sum(x => x.ProductStorage);
        //                #region 判断各巷道数量
        //                if (productOne.Count == 0)
        //                {
        //                    areaCode = 1;
        //                    if (height == "600" || height == "600-750" || height == "750-975")
        //                    {
        //                        result = 1;
        //                    }
        //                    else
        //                    {
        //                        result = 2;
        //                    }

        //                    return result;
        //                }
        //                else
        //                {
        //                    if (productTwo.Count == 0)
        //                    {
        //                        areaCode = 2;
        //                        if (height == "600")
        //                        {
        //                            result = 1;
        //                        }
        //                        else if (height == "600-750")
        //                        {
        //                            result = 2;
        //                        }
        //                        else if (height == "750-975" || height == "975-1150")
        //                        {
        //                            result = 3;
        //                        }
        //                        else
        //                        {
        //                            result = 4;
        //                        }
        //                        return result;
        //                    }
        //                    else
        //                    {
        //                        decimal oneQty = (decimal)productOne.Sum(x => x.ProductStorage);
        //                        decimal twoQty = (decimal)productTwo.Sum(x => x.ProductStorage);
        //                        #region 根据数量判断
        //                        if (oneQty <= twoQty)
        //                        {
        //                            areaCode = 1;
        //                            if (height == "600" || height == "600-750" || height == "750-975")
        //                            {
        //                                result = 1;
        //                            }
        //                            else
        //                            {
        //                                result = 2;
        //                            }

        //                            return result;
        //                        }
        //                        else
        //                        {
        //                            areaCode = 2;
        //                            if (height == "600")
        //                            {
        //                                result = 1;
        //                            }
        //                            else if (height == "600-750")
        //                            {
        //                                result = 2;
        //                            }
        //                            else if (height == "750-975" || height == "975-1150")
        //                            {
        //                                result = 3;
        //                            }
        //                            else
        //                            {
        //                                result = 4;
        //                            }
        //                            return result;
        //                        }
        //                        #endregion

        //                    }
        //                #endregion

        //                }

        //            }


        //        }
        //        #endregion


        //    }
        //    catch (Exception)
        //    {
        //        areaCode = 0;
        //        return 0;
        //    }

        //    #region old
        //    //if (height == "975以下" || height == "600以下")
        //    //{
        //    //    result = 1;
        //    //}
        //    //else if (height == "975-1850" || height == "600-750")
        //    //{
        //    //    result = 2;
        //    //}
        //    //else if (height == "750-1150")
        //    //{
        //    //    result = 3;
        //    //}
        //    //else if (height == "1150-1350")
        //    //{
        //    //    result = 4;
        //    //}
        //    #endregion
        //}
        #endregion
        #region 测试代码

        #region 模拟wcf
        private static BackData GetCheckIsNeedOrSendContainer()
        {
            wcftest.wcfApi.BackData resultDate = new BackData();
            resultDate.Type = 0;
            resultDate.DevId = 0;

            return resultDate;
        }
        #endregion
        /// <summary>//入库尺寸检测正常后找库位
        /// 接口测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            apitest wcfapi = new apitest();
            int taskID = Convert.ToInt32(textBox5.Text);
            int continerType = comboBox2.SelectedIndex + 1;
            int height = comboBox1.SelectedIndex + 1;
            //string result = wcfapi.getToPlace(taskID, continerType, height);
            //listInfo.Items.Add("收到的目标位置是: " + result);
            //listInfo.Refresh();
        }

        int aaa = 0;//临时用



        #endregion
        /// <summary> 撤销SAP
        /// 撤销
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_Click(object sender, EventArgs e)
        {
            //apitest wcfapi = new apitest();
            //string result = wcfapi.reverser(textBox2.Text.Trim());

        }

        /// <summary> 大屏展示信息
        /// 大屏展示信息
        /// </summary>
        public void deviceInfo()
        {
            while (true)
            {
                Thread.Sleep(3000);
                try
                {
                    string srm1Msg = "";
                    string rgv1Msg = "";
                    string srm2Msg = "";
                    string rgv2Msg = "";
                    string contMsg = "";

                    string[] containers = new string[19];
                    deviceSw.Start();// 设备运行计算器开始记时
                    deviceSw_Srm1.Start();// 设备运行计算器开始记时
                    deviceSw_Srm2.Start();// 设备运行计算器开始记时
                    #region 获取设备信息

                    if (allowGetDeviceInfo == true)
                    {
                        var srm1Info = device.GetStackInfo("Srm1", out srm1Msg);
                        var srm2Info = device.GetStackInfo("Srm2", out srm2Msg);
                        var rgv1Info = device.GetRGVInfo("Rgv1", out rgv1Msg);
                        var rgv2Info = device.GetRGVInfo("Rgv2", out rgv2Msg);
                        var contInfo = device.GetConveyorInfo("Line1021", out contMsg);
                        if (srm1Info != null && srm2Info != null && rgv1Info != null && rgv2Info != null)
                        {
                            //RGV1赋值
                            deviceListInfo.rgv1.goods = rgv1Info.Loaded; //bool是否有货
                            deviceListInfo.rgv1.position = rgv1Info.RgvPosition;//位置
                            deviceListInfo.rgv1.status = rgv1Info.State;//状态
                            deviceListInfo.rgv1.isAlarm = rgv1Info.Alarm == "正常" ? false : true;//状态
                            totalInfo.list22[0] = rgv1Info.State;//状态
                            //RGV2赋值
                            deviceListInfo.rgv2.goods = rgv2Info.Loaded; //bool是否有货
                            deviceListInfo.rgv2.position = rgv2Info.RgvPosition;//位置
                            deviceListInfo.rgv2.status = rgv2Info.State;//状态
                            deviceListInfo.rgv2.isAlarm = rgv2Info.Alarm == "正常" ? false : true;//状态
                            totalInfo.list22[1] = rgv2Info.State;//状态
                            //堆垛机1赋值
                            deviceListInfo.srm1.goods = srm1Info.LiftFull; //bool是否有货
                            deviceListInfo.srm1.position = Convert.ToInt32(srm1Info.PosXmm);//位置
                            deviceListInfo.srm1.status = srm1Info.State;//状态
                            deviceListInfo.srm1.isAlarm = srm1Info.Alarm;//是否报警

                            totalInfo.list22[2] = srm1Info.State;//状态

                            //堆垛机2赋值
                            deviceListInfo.srm2.goods = srm2Info.LiftFull; //bool是否有货
                            deviceListInfo.srm2.position = Convert.ToInt32(srm2Info.PosXmm);//位置
                            deviceListInfo.srm2.status = srm2Info.State;//状态
                            deviceListInfo.srm2.isAlarm = srm2Info.Alarm;//是否报警

                            totalInfo.list22[3] = srm2Info.State;//状态
                        }
                    }
                    //*/
                    #endregion

                    DateTime today = DateTime.Now;
                    int year = today.Year;
                    int month = today.Month + 1;
                    if (month > 12)
                    {
                        month = 1;
                        year++;
                    }
                    DateTime outtime = new DateTime(year, month, today.Day);//提前一月的时间
                    DateTime todayTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd"));//今天凌晨时间
                    using (dbModel mod = new dbModel())
                    {
                        #region 获取入库任务数量,出库任务数量,已使用的库存数两,过期数量小于一个月的数量
                        //获取今天入库任务数量
                        List<Task_Queue> enterTaskCount = mod.Task_Queue.Where(x => x.CreateDate > todayTime && x.TaskType == "1").ToList();
                        //获取出库任务数量
                        List<Task_Queue> outTaskCount = mod.Task_Queue.Where(x => x.CreateDate > todayTime && x.TaskType == "4").ToList();
                        //获取当前已使用的库位数量
                        List<Base_Position> stockUsingCount = mod.Base_Position.Where(x => x.IsFreeze == 1 || x.IsLocked == 1).ToList();
                        //获取过期时间小于一个月的库存数据
                        List<Base_ProductPosition> outTimeStockCount = mod.Base_ProductPosition.Where(x => x.ClassName == "常规入库" && x.LimitDate < outtime).ToList();
                        if (enterTaskCount != null)
                        {
                            totalInfo.list11[0] = enterTaskCount.Count;
                        }
                        if (outTaskCount != null)
                        {
                            totalInfo.list11[1] = outTaskCount.Count;
                        }


                        totalInfo.list11[2] = 1152;
                        totalInfo.list11[3] = 1152 - stockUsingCount.Count();

                        if (lastHour != today.Hour)
                        {
                            //每隔一小时保存一次设备状态时间
                            lastHour = today.Hour;
                            deviceGeneralInfo todayDeviceInfo = new deviceGeneralInfo();
                            todayDeviceInfo = mod.deviceGeneralInfo.FirstOrDefault(x => x.createTime > todayTime);
                            if (todayDeviceInfo == null)
                            {
                                todayDeviceInfo = new deviceGeneralInfo();
                                todayDeviceInfo.createTime = DateTime.Now;
                                mod.deviceGeneralInfo.Add(todayDeviceInfo);
                                //计时复位
                                deviceSw.Reset();
                                deviceAlarmTime = deviceSw.Elapsed;
                                deviceRunTime = deviceSw.Elapsed;
                                deviceWaitTime = deviceSw.Elapsed;

                            }
                            else
                            {

                                todayDeviceInfo.deviceRunTime = deviceRunTime.TotalMinutes > 0 ? Convert.ToDecimal(deviceRunTime.TotalMinutes) : 0M;
                                todayDeviceInfo.deviceAlarmTime = deviceAlarmTime.TotalMinutes > 0 ? Convert.ToDecimal(deviceAlarmTime.TotalMinutes) : 0M;
                                //重新计算设备等待时间 【Editby shaocx,2024-12-30】
                                DeviceGeneralInfoHelper.CommonCalcWaitTime(ref todayDeviceInfo);

                                todayDeviceInfo.taskEnterCount = enterTaskCount.Count;//入库任务数
                                todayDeviceInfo.taskOutCount = outTaskCount.Count;//出库任务数
                                //更改数量 【Editby shaocx,2024-11-22】
                                decimal cout = stockUsingCount.Count / 1152M * 100;
                                todayDeviceInfo.stockProportion = Convert.ToInt32(cout);//已使用的库位
                                todayDeviceInfo.outDate = outTimeStockCount.Count;//过期时间小于一个月的库存数据
                            }

                            DeviceGeneralInfoHelper.HandlerDeviceGeneralInfoForDetail(1, enterTaskCount, outTaskCount, stockUsingCount, outTimeStockCount,
                                mod, lastHour, todayTime,
                                deviceSw_Srm1, deviceRunTime_Srm1, deviceAlarmTime_Srm1, deviceWaitTime_Srm1
                                );
                            DeviceGeneralInfoHelper.HandlerDeviceGeneralInfoForDetail(2, enterTaskCount, outTaskCount, stockUsingCount, outTimeStockCount,
                             mod, lastHour, todayTime,
                             deviceSw_Srm2, deviceRunTime_Srm2, deviceAlarmTime_Srm2, deviceWaitTime_Srm2
                             );

                            int chang = mod.SaveChanges();
                        }

                        #endregion
                    }
                    #region 统计设备运行效率
                    if (deviceListInfo.srm1.isAlarm == true || deviceListInfo.srm2.isAlarm == true || deviceListInfo.rgv1.isAlarm == true || deviceListInfo.rgv2.isAlarm == true)
                    {
                        if (lastStatus != "报警")
                        {
                            setDeviceStatusTime(lastStatus, "报警");
                        }

                    }
                    else
                    {
                        if (deviceListInfo.srm1.status == "空闲" && deviceListInfo.srm2.status == "空闲" && deviceListInfo.rgv1.status == "空闲" && deviceListInfo.rgv2.status == "空闲")
                        {
                            if (lastStatus != "等待")
                            {
                                setDeviceStatusTime(lastStatus, "等待");
                            }
                        }
                        else
                        {
                            if (lastStatus != "运行")
                            {
                                setDeviceStatusTime(lastStatus, "运行");
                            }
                        }
                    }
                    #endregion

                    #region 统计设备运行效率（详细） 【Editby shaocx,2025-09-19】
                    //1号堆垛机
                    if (deviceListInfo.srm1.isAlarm == true)
                    {
                        if (lastStatus_Srm1 != "报警")
                        {
                            setDeviceStatusTimeForDetail(1, lastStatus_Srm1, "报警");
                        }
                    }
                    else
                    {
                        if (deviceListInfo.srm1.status == "空闲")
                        {
                            if (lastStatus_Srm1 != "等待")
                            {
                                setDeviceStatusTimeForDetail(1, lastStatus_Srm1, "等待");
                            }
                        }
                        else
                        {
                            if (lastStatus_Srm1 != "运行")
                            {
                                setDeviceStatusTimeForDetail(1, lastStatus_Srm1, "运行");
                            }
                        }
                    }
                    //2号堆垛机
                    if (deviceListInfo.srm2.isAlarm == true)
                    {
                        if (lastStatus_Srm2 != "报警")
                        {
                            setDeviceStatusTimeForDetail(2, lastStatus_Srm2, "报警");
                        }

                    }
                    else
                    {
                        if (deviceListInfo.srm2.status == "空闲")
                        {
                            if (lastStatus_Srm2 != "等待")
                            {
                                setDeviceStatusTimeForDetail(2, lastStatus_Srm2, "等待");
                            }
                        }
                        else
                        {
                            if (lastStatus_Srm2 != "运行")
                            {
                                setDeviceStatusTimeForDetail(2, lastStatus_Srm2, "运行");
                            }
                        }
                    }
                    #endregion

                }
                catch (Exception ex)
                {
                    textBox6.Text = "获取设备信息请检查第 " + ex.StackTrace + "行\r\n" + textBox6.Text;
                }

            }


        }
        /// <summary>设备状态变化的时候 保存状态时间
        /// 设备状态变化的时候 保存状态时间
        /// </summary>
        /// <param name="status"></param>
        private void setDeviceStatusTime(string lastStatuss, string nowStatus)
        {
            try
            {
                switch (lastStatuss)
                {
                    case "等待":
                        deviceWaitTime += deviceSw.Elapsed;
                        deviceSw.Restart();

                        lastStatus = nowStatus;
                        break;
                    case "运行":
                        deviceRunTime += deviceSw.Elapsed;
                        deviceSw.Restart();

                        lastStatus = nowStatus;
                        break;
                    case "报警":
                        deviceAlarmTime += deviceSw.Elapsed;
                        deviceSw.Restart();

                        lastStatus = nowStatus;
                        break;
                }
            }
            catch (Exception)
            {

            }
        }
        /// <summary>设备状态变化的时候 保存状态时间（明细）
        /// 设备状态变化的时候 保存状态时间
        /// </summary>
        /// <param name="status"></param>
        private void setDeviceStatusTimeForDetail(int srmNo, string lastStatuss, string nowStatus)
        {
            try
            {
                switch (lastStatuss)
                {
                    case "等待":
                        if (srmNo == 1)
                        {
                            deviceWaitTime_Srm1 += deviceSw_Srm1.Elapsed;
                        }
                        else
                        {
                            deviceWaitTime_Srm2 += deviceSw_Srm2.Elapsed;
                        }
                        break;
                    case "运行":
                        if (srmNo == 1)
                        {
                            deviceRunTime_Srm1 += deviceSw_Srm1.Elapsed;
                        }
                        else
                        {
                            deviceRunTime_Srm2 += deviceSw_Srm2.Elapsed;
                        }
                        break;
                    case "报警":
                        if (srmNo == 1)
                        {
                            deviceAlarmTime_Srm1 += deviceSw_Srm1.Elapsed;
                        }
                        else
                        {
                            deviceAlarmTime_Srm2 += deviceSw_Srm2.Elapsed;
                        }
                        break;
                }

                if (srmNo == 1)
                {
                    deviceSw_Srm1.Restart();

                    lastStatus_Srm1 = nowStatus;
                }
                else
                {
                    deviceSw_Srm2.Restart();

                    lastStatus_Srm2 = nowStatus;
                }
            }
            catch (Exception)
            {

            }
        }
        /// <summary>大屏信息初始化
        /// 大屏信息初始化
        /// </summary>
        public void deviceInfoInit()
        {
            try
            {
                DateTime todayTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd"));//今天凌晨时间
                DateTime today = DateTime.Now;
                lastHour = today.Hour;
                using (dbModel mod = new dbModel())
                {
                    deviceGeneralInfo todayDeviceInfo = mod.deviceGeneralInfo.FirstOrDefault(x => x.createTime > todayTime);
                    if (todayDeviceInfo != null)
                    {
                        TimeSpan alarmTime = new TimeSpan(Convert.ToInt32(Math.Floor((decimal)todayDeviceInfo.deviceAlarmTime / 60M)), Convert.ToInt32((decimal)todayDeviceInfo.deviceAlarmTime % 60), 0);
                        deviceAlarmTime = alarmTime;
                        TimeSpan runTime = new TimeSpan(Convert.ToInt32(Math.Floor((decimal)todayDeviceInfo.deviceRunTime / 60M)), Convert.ToInt32((decimal)todayDeviceInfo.deviceRunTime % 60), 0);
                        deviceRunTime = runTime;
                        TimeSpan waitTime = new TimeSpan(Convert.ToInt32(Math.Floor((decimal)todayDeviceInfo.deviceWaitTime / 60M)), Convert.ToInt32((decimal)todayDeviceInfo.deviceWaitTime % 60), 0);
                        deviceWaitTime = waitTime;

                    }
                    else
                    {
                        deviceGeneralInfo creatTodayDeviceInfo = new deviceGeneralInfo();
                        //设备报警时间
                        creatTodayDeviceInfo.deviceAlarmTime = Convert.ToDecimal(deviceAlarmTime.Hours * 60M) + deviceAlarmTime.Minutes;//单位分钟
                        //设备运行时间
                        creatTodayDeviceInfo.deviceRunTime = Convert.ToDecimal(deviceRunTime.Hours * 60M) + deviceRunTime.Minutes;//单位分钟
                        //设备等待时间
                        //creatTodayDeviceInfo.deviceWaitTime = Convert.ToDecimal(deviceWaitTime.Hours * 60M) + deviceWaitTime.Minutes;//单位分钟
                        //重新计算设备等待时间 【Editby shaocx,2024-12-30】
                        DeviceGeneralInfoHelper.CommonCalcWaitTime(ref creatTodayDeviceInfo);

                        creatTodayDeviceInfo.createTime = DateTime.Now;
                        mod.deviceGeneralInfo.Add(creatTodayDeviceInfo);
                        mod.SaveChanges();
                        //计时复位

                    }

                }

                DeviceGeneralInfoHelper.deviceInfoInitForDetails(1, todayTime, lastHour, deviceAlarmTime_Srm1, deviceRunTime_Srm1, deviceWaitTime_Srm1);
                DeviceGeneralInfoHelper.deviceInfoInitForDetails(2, todayTime, lastHour, deviceAlarmTime_Srm2, deviceRunTime_Srm2, deviceWaitTime_Srm2);

                deviceInfos = new Thread(deviceInfo);
                deviceInfos.Start();
            }
            catch (Exception ex)
            {
            }

        }

        #region 无用
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                int orderid = 0;
                bool io = Int32.TryParse(textBox1.Text.Trim(), out orderid);
                if (io)
                {
                    using (dbModel mod = new dbModel())
                    {
                        Sale_Order order = mod.Sale_Order.FirstOrDefault(x => x.Order_Id == orderid);
                        List<Sale_OrderList> orderList = mod.Sale_OrderList.Where(x => x.Order_Id == orderid).ToList();
                    }
                }

            }
            catch (Exception)
            {

            }
        }
        /// <summary>获取PO 反推跟踪号
        /// 获取PO
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button6_Click_2(object sender, EventArgs e)
        {//getPoList
            try
            {
                using (dbModel mod = new dbModel())
                {
                    string[] aax = { "8660-3005972284-002000", "11222-3005972207-001000", "11223-4507863055-00030", "11217-4507863055-00040", "11216-4507863055-00050" };
                    string lastTracknum = "";
                    for (int i = 0; i < aax.Length; i++)
                    {
                        string[] stringinfo = aax[i].Split('-');
                        string trackingNum = stringinfo[0];
                        string saleOrder = stringinfo[1];
                        string saleItemNumber = stringinfo[2];
                        #region 反推picklist 里的跟踪号

                        if (saleOrder != "" && lastTracknum != trackingNum)
                        {
                            if (trackingNum != "")
                            {
                                //明细加跟踪号
                                List<Sale_OrderList> sendPicklistTrackNumber = mod.Sale_OrderList.Where(x => x.SaleCode == saleOrder && x.ExtendField06 == saleItemNumber && x.TrackingNumber == "").ToList();
                                lastTracknum = trackingNum;
                                if (sendPicklistTrackNumber.Count > 0)
                                {
                                    var orderTrack = sendPicklistTrackNumber.GroupBy(x => x.Order_Id);
                                    var orders = mod.Sale_Order.ToList();//一次读取不然出库单多的时候会卡死 2021-8-16 修改
                                    if (orderTrack != null)
                                    {
                                        foreach (var itemOrder in orderTrack)
                                        {
                                            long orderId = itemOrder.ToList()[0].Order_Id;
                                            Sale_Order addTrack = orders.FirstOrDefault(x => x.Order_Id == orderId);
                                            //if (addTrack != null && addTrack.OrderType == "SAP生产订单" && addTrack.StatusText == "新建")
                                            //if (addTrack != null && addTrack.OrderType == SysGlole.SAP_ORDER_TEXT && addTrack.StatusText == "新建")
                                            if (addTrack != null && addTrack.OrderType == SysGlole.SAP_ORDER_TEXT && addTrack.StatusText == Sale_Order_StatusEnum.新建.ToString())
                                            {
                                                addTrack.TrackingNumber = trackingNum;
                                                foreach (var itemList in itemOrder)
                                                {
                                                    itemList.TrackingNumber = trackingNum;
                                                }
                                            }
                                        }
                                    }
                                }

                                int results = mod.SaveChanges();
                                for (int h = 0; h < 10; h++)
                                {
                                    if (results < 1)
                                    {
                                        results = mod.SaveChanges();
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }

                            }


                        }
                        #endregion


                    }

                }
            }
            catch (Exception)
            {

            }
        }
        private void button1_Click_2(object sender, EventArgs e)
        {
            try
            {
                using (dbModel mod = new dbModel())
                {
                    List<vvBase_ProductPosition> sunStock = mod.vvBase_ProductPosition.Where(x => x.ClassName == "常规入库" && x.ProductStorage > 0).ToList();
                    List<vvBase_ProductPosition> yanzheng = sunStock.Where(x => x.ProductCode == "A7EQD-5141153925").ToList();
                    foreach (var item in yanzheng)
                    {
                        item.ExtendField04 = "";
                        List<vvBase_ProductPosition> yanzheng1 = sunStock.Where(x => x.ProductCode == "A7EQD-5141153925" && x.ContainerNo != "1").ToList();
                    }
                    int isod = mod.SaveChanges();
                    List<vvBase_ProductPosition> yanzheng2 = sunStock.Where(x => x.ProductCode == "A7EQD-5141153925" && x.ContainerNo != "1").ToList();
                }
            }
            catch (Exception ex)
            {
            }
        }
        /// <summary>无用
        /// 无用
        /// </summary>
        /// <param name="info"></param>
        public void trackNum(string info)
        {
            string[] infos = info.Split('-');
            string saleOrder = infos[0];
            string saleItemNumber = infos[1];
            string trackingNum = infos[2];
            using (dbModel mod = new dbModel())
            {
                if (saleOrder != "")
                {
                    if (trackingNum != "")
                    {
                        List<Sale_OrderList> sendPicklistTrackNumber = mod.Sale_OrderList.Where(x => x.SaleCode == saleOrder && x.ExtendField06 == saleItemNumber).ToList();
                        if (sendPicklistTrackNumber.Count > 0)
                        {
                            foreach (var itemSendTrackNumber in sendPicklistTrackNumber)
                            {
                                itemSendTrackNumber.TrackingNumber = trackingNum;
                            }
                        }
                        var orderTrack = sendPicklistTrackNumber.GroupBy(x => x.Order_Id);
                        if (orderTrack != null)
                        {
                            foreach (var item in orderTrack)
                            {
                                long orderId = item.ToList()[0].Order_Id;
                                Sale_Order addTrack = mod.Sale_Order.Find(orderId);
                                if (addTrack != null)
                                {
                                    addTrack.TrackingNumber = trackingNum;
                                }
                            }
                        }
                        int result = mod.SaveChanges();
                        MessageBox.Show("保存成功: " + result);
                    }


                }
            }

        }
        #endregion

        private void button3_Click(object sender, EventArgs e)
        {
            lastPlateCode = "0";
        }


        private void button5_Click(object sender, EventArgs e)
        {
            TestForm frm = new TestForm();
            frm.ShowDialog();
        }

        #region 公共方法

        /// <summary>
        /// 通过WCS获取当前的设备数据
        /// </summary>
        /// <returns></returns>
        private static BackData GetBackDataFromWCS()
        {
            wcftest.wcfApi.BackData resultDate = new BackData();
            try
            {
                if (IsVirtualMode)
                {
                    resultDate = GetCheckIsNeedOrSendContainer();
                    VirtualModeHelper.ThrowExceptionWhenVirtualMode(IsVirtualMode);
                }
                else
                {
                    try
                    {
                        //检测是否需要空托盘
                        resultDate = wcsApi.GetCheckIsNeedOrSendContainer();
                    }
                    catch (Exception ex)
                    {
                        logtxt.txtWrite("类名：Form1/函数名：检测是否需要空托盘" + ex.Message + "出错行号" + (string)ex.StackTrace, 2);
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
            return resultDate;
        }



        #endregion

        private void lbl_Msg_containerIsFull_Click(object sender, EventArgs e)
        {

        }

    }
    public class resultInfo
    {
        public bool result { get; set; }
        public string msg { get; set; }

    }
}