using HH.WCS.Mobox3.HD.dispatch;
using HH.WCS.Mobox3.HD.process;
using HH.WCS.Mobox3.HD.wms;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using HH.WCS.Mobox3.HD.util;
using System.Web.Http;
using static HH.WCS.Mobox3.HD.api.ApiModel;
using static HH.WCS.Mobox3.HD.api.OtherModel;
using static HH.WCS.Mobox3.HD.api.WmsController;
using static HH.WCS.Mobox3.HD.dispatch.ShopFloorControl;
using static System.Runtime.CompilerServices.RuntimeHelpers;
using static HH.WCS.Mobox3.HD.api.MoboxController;
using HH.WCS.Mobox3.HD.device;
using S7.Net;
using HH.WCS.Mobox3.HD.models;
using System.Linq;
using NLog.Fluent;
using System;
using SqlSugar;
using static HH.WCS.Mobox3.HD.core.Monitor;
using static HH.WCS.Mobox3.HD.api.DigitHelper;
using System.Web.SessionState;
using static HH.WCS.Mobox3.HD.util.ExpressionHelper;
using static HH.WCS.Mobox3.HD.wms.WMSHelper;

namespace HH.WCS.Mobox3.HD.api {
    /// <summary>
    /// mobox3调用，脚本中调用
    /// </summary>
    public class MoboxController : System.Web.Http.ApiController {
   
        /// <summary>
        /// 1.发货确认接口（PDA）
        /// </summary>
        /// <returns></returns>
        public SimpleResult sendOver(TrayInfo trayInfo)
        {
            LogHelper.Info("发货确认接口-sendOver Request：" + JsonConvert.SerializeObject(trayInfo), "Mobox");
            var result = new SimpleResult();
            var wmsTask = WMSHelper.GetWmsTaskByCntr(trayInfo.trayCode);
            if (wmsTask != null) 
            {
                result.resultCode = 1;
                result.resultMsg = "托盘存在未完成任务，不能确认发货";
                return result;
            }
            var locCntrRel = ContainerHelper.getLocCntr(trayInfo.trayCode);
            if (locCntrRel == null) 
            {
                var cntrItemRels = ItemHelper.GetCntrItemByCntrCode(trayInfo.trayCode);
                if (cntrItemRels != null && cntrItemRels.Count > 0)
                {
                    // 发货信息记录
                    ReleaseRecord releaseRecord = new ReleaseRecord()
                    {
                        S_CNTR_CODE = cntrItemRels[0].S_CNTR_CODE,
                        S_WORK_NO = cntrItemRels[0].S_WORK_NO,
                        S_PARTDRAW_NO = cntrItemRels[0].S_PARTDRAW_NO,
                        S_ITEM_TYPE = cntrItemRels[0].S_ITEM_TYPE,
                        F_QTY = cntrItemRels[0].F_QTY,
                        F_WEIGHT = cntrItemRels[0].F_WEIGHT,
                        T_RELEASE_DATE = DateTime.Now,
                    };
                    WMSHelper.addReleaseRecord(releaseRecord);
                    ContainerHelper.deleteCntrItem(trayInfo.trayCode);
                }

                // 通知车间控制器
                LogHelper.Info("容器物料解绑通知车间控制器", "Mobox");
                UnBindInfo unBindInfo = new UnBindInfo()
                {
                    trayCode = trayInfo.trayCode,
                };
                ShopFloorControl.trayMaterialUnBind(unBindInfo);
            }
            LogHelper.Info("发货确认接口-sendOver response：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 2.空托盘入库（PDA）
        /// </summary>
        /// <returns></returns>
        public SimpleResult emptyTrayInStock(EmptyTrayInStockInfo model)
        {
            LogHelper.Info("空托盘入库_emptyTrayInStock Request：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            var startLoc = LocationHelper.GetLoc(model.startLocCode);
            Location endLoc = null;
            var locMouldCntr = WMSHelper.getLocMouldCntr(model.trayCode);
            if (locMouldCntr != null)
            {
                if (model.endLocCode != null && locMouldCntr.S_LOC_CODE != model.endLocCode)
                {
                    result.resultCode = 1;
                    result.resultMsg = "模具托盘存在货位容器绑定关系，绑定货位：" + locMouldCntr.S_LOC_CODE;
                    return result;
                }
                endLoc = LocationHelper.GetLoc(locMouldCntr.S_LOC_CODE);
            }
            else {
                locMouldCntr = new LocMouldCntr() { S_LOC_CODE = model.endLocCode, S_CNTR_CODE = model.trayCode };
                WMSHelper.addLocMouldCntr(locMouldCntr);
            }

            if (model.endLocCode != null)
            {
                endLoc = LocationHelper.GetLoc(model.endLocCode);
            }

            if (endLoc != null && startLoc != null)
            {
                // 清理原托盘的物料信息
                ContainerHelper.deleteCntrItem(model.trayCode);

                // 2、创建空盘入库作业任务
                WMSTask wmsTask = new WMSTask()
                {
                    S_CNTR_CODE = model.trayCode,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = startLoc.S_CODE,
                    S_START_AREA = startLoc.S_AREA_CODE,
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "空托盘入库",
                    S_OP_DEF_NAME = "空托盘入库（模具）",
                    N_PRIORITY = 1,
                    T_START_TIME = DateTime.Now,
                };
                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    // 3、创建一段任务
                    WCSTask wcsTask = new WCSTask
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = wmsTask.S_TYPE + "-1",
                        S_START_LOC = wmsTask.S_START_LOC,
                        S_START_AREA = wmsTask.S_START_AREA,
                        S_END_LOC = wmsTask.S_END_LOC,
                        S_END_AREA = wmsTask.S_END_AREA,
                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                        N_CNTR_COUNT = 1,
                        S_SCHEDULE_TYPE = "HL",
                        S_OP_CODE = wmsTask.S_CODE,
                        N_PRIORITY = wmsTask.N_PRIORITY,
                        T_START_TIME = DateTime.Now,
                    };
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        // 对开始货位、接驳货位、终点货位进行加锁
                        LocationHelper.LockLoc(startLoc.S_CODE, 2);
                        LocationHelper.LockLoc(endLoc.S_CODE, 1);

                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);
                    }
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "起点货位或终点货位不存在";
                return result;
            }

            LogHelper.Info("空托盘入库_emptyTrayInStock response：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

      
        /// <summary>
        /// 3.成品发货
        /// 批量创建作业
        /// </summary>
        /// <returns></returns>
        public SimpleResult finisheProductShipment(FinisheProductInfos model)
        {
            LogHelper.Info("成品发货_finisheProductShipment Request：" + JsonConvert.SerializeObject(model), "Mobox");
            var result = new SimpleResult();
            var list = model.finisheProductList;

            // 库区对应的发货区
            Dictionary<string, string> areaToShippingArea = new Dictionary<string, string>();
            
            foreach (var item in Settings.dispatchAreaInfos)
            {
                areaToShippingArea.Add(item.relateArea, item.areaCode);
            }

            List<WMSTask> wmsTaskList = new List<WMSTask>();
            foreach (var item in list)
            {
                // 1.查询容器物料以及货位
                LocCntrRel locCntr = ContainerHelper.getLocCntr(item.trayCode);
                if (locCntr == null)
                {
                    result.resultCode = 1;
                    result.resultMsg = "容器编码：" + item.trayCode + " 的货位容器不存在";
                    return result;
                }

                var existWmsTask = WMSHelper.GetWmsTaskByCntr(item.trayCode);
                if (existWmsTask != null)
                {
                    result.resultCode = 1;
                    result.resultMsg = "相关容器存在未完成任务";
                    return result;
                }

                Location startLoc = LocationHelper.GetLoc(locCntr.S_LOC_CODE);
                var endAreaCode = areaToShippingArea[startLoc.S_AREA_CODE];
                Location endLoc = WMSHelper.GetDeliverEndLocation(endAreaCode);

                // 创建成品出库作业任务
                if (endLoc != null)
                {
                    WMSTask wmsTask = new WMSTask()
                    {
                        S_CNTR_CODE = item.trayCode,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_TYPE = "成品出库",
                        /*S_OP_DEF_CODE = model.workNo,*/
                        S_OP_DEF_NAME = "成品出库",
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask)) 
                    {
                        LocationHelper.LockLoc(wmsTask.S_START_LOC, 2);
                        LocationHelper.LockLoc(wmsTask.S_END_LOC, 1);
                    }
                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "终点货位未获取到,容器编号："+ item.trayCode;
                    return result;
                }
            }
            LogHelper.Info("成品发货_finisheProductShipment response：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 3.1成品发货
        /// 批量创建作业
        /// </summary>
        /// <returns></returns>
        public SimpleResult finisheProductShipment1(FinisheProductInfo model)
        {
            LogHelper.Info("成品发货_finisheProductShipment Request：" + JsonConvert.SerializeObject(model), "Mobox");
            var result = new SimpleResult();

            var existWmsTask = WMSHelper.GetWmsTaskByCntr(model.trayCode);
            if (existWmsTask != null)
            {
                result.resultCode = 1;
                result.resultMsg = "相关容器存在未完成任务";
                return result;
            }
            Location startLoc = null;
            Location firstTaskEnd = null;
            ItemStartLoc itemStartLoc = WMSHelper.GetStartLocation(model.itemCode,null ,model.workNo);
            if (itemStartLoc.type != 0)
            {
                startLoc = itemStartLoc.loc;
                firstTaskEnd = itemStartLoc.connectloc;
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "库区没有该物料";
                return result;
            }

            if (startLoc == null)
            {
                result.resultCode = 1;
                result.resultMsg = "库区没有该物料";
                return result;
            }

            Location endLoc = LocationHelper.GetLoc(model.endLocCode);
            if (endLoc == null) {
                result.resultCode = 1;
                result.resultMsg = "终点货位不存在，请检查终点货位编码是否正常";
                return result;
            }

            // 2、创建出库作业任务
            string cntrCode = null;
            LocCntrRel locCntrRel = ContainerHelper.getLocCntrByLoc(startLoc.S_CODE);
            if (locCntrRel != null)
            {
                cntrCode = locCntrRel.S_CNTR_CODE;
            }

            if (firstTaskEnd != null)
            {
              var wmsTask = new WMSTask()
                {
                    S_CNTR_CODE = cntrCode,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = startLoc.S_CODE,
                    S_START_AREA = startLoc.S_AREA_CODE,
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "成品出库",
                    S_OP_DEF_NAME = "出库搬运任务",
                    N_PRIORITY = 1,
                    T_START_TIME = DateTime.Now
                };

                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    // 物料不可取货位,需先进行移库
                    if (itemStartLoc.type == 2)
                    {
                        bool shiftResult = ApiHelper.shiftStock(itemStartLoc.outLoc, wmsTask.S_CODE);
                        if (!shiftResult)
                        {
                            wmsTask.N_B_STATE = 3;
                            WMSHelper.UpdateTaskState(wmsTask);
                           
                            result.resultCode = 1;
                            result.resultMsg = "取货阻塞且巷道两边货物已满，无法取货";
                            return result;
                        }
                    }

                    // 查询立体库库区
                    string S_SCHEDULE_TYPE = null;
                    List<string> areaCodes = Settings.getStoreAreaCodes(2, 1);
                    if (areaCodes.Contains(startLoc.S_AREA_CODE))
                    {
                        S_SCHEDULE_TYPE = "RB";
                        /*string firstEndLoc = WCSHelper.GetLinePlcInfoByDesc(firstTaskEnd.S_CODE).localtion;
                        firstTaskEnd = LocationHelper.GetLoc(firstEndLoc);*/
                    }

                    var wcsTask = new WCSTask
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = wmsTask.S_TYPE + "-1",
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = firstTaskEnd.S_CODE,
                        S_END_AREA = firstTaskEnd.S_AREA_CODE,
                        S_CNTR_CODE = cntrCode,
                        S_SCHEDULE_TYPE = S_SCHEDULE_TYPE,
                        S_OP_CODE = wmsTask.S_CODE,
                        S_EQ_NO = ApiHelper.getEqNo(startLoc.S_AREA_CODE, startLoc.N_ROADWAY),
                        N_PRIORITY = 1,
                        T_START_TIME = DateTime.Now
                    };

                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        // 开始货位、终点货位进行加锁
                        LocationHelper.LockLoc(startLoc.S_CODE, 2);
                        LocationHelper.LockLoc(firstTaskEnd.S_CODE, 1);
                        LocationHelper.LockLoc(endLoc.S_CODE, 1);
                        // 更新作业任务状态
                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);
                    }
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "输送线故障或已上锁，请查看";
                return result;
            }
            LogHelper.Info("成品发货_finisheProductShipment response：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 4.空盘垛入库（PDA）
        /// </summary>
        /// <returns></returns>
        public SimpleResult emptyTrayStackInStock(EmptyTrayStackInStockInfo model)
        {
            LogHelper.Info("空盘垛入库_emptyTrayStackInStock 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            var result = new SimpleResult();

            var startLoc = LocationHelper.GetLoc(model.startLocCode);
            if (startLoc == null) {
                result.resultCode = 1;
                result.resultMsg = "开始货位不存在";
                return result;
            }

            var existWmsTask = WMSHelper.GetWmsTaskByCntr(model.trayCode);
            if (existWmsTask != null)
            {
                result.resultCode = 1;
                result.resultMsg = "托盘任务已生成，请勿重复下发";
                return result;
            }

            model.trayCode.IndexOf("");

            Location endLoc = null;
            Location connectLoc = null;
            var connectLocs = LocationHelper.GetConnectLocation(model.endAreaCode, 1 ,1 ,1,startLoc.S_AREA_CODE);
            foreach (var item in connectLocs)
            {
                var conLoc = LocationHelper.GetLoc(item);
                endLoc = WMSHelper.GetEndLocation(model.endAreaCode, null , conLoc.N_ROADWAY, conLoc.N_ROW);
                if (endLoc != null)
                {
                    connectLoc = conLoc;
                    endLoc.S_CODE = "虚拟货位";
                    break;
                }
            }

            if (endLoc != null && connectLoc != null) 
            {
                // 清理原托盘的物料信息
                ContainerHelper.deleteCntrItem(model.trayCode);
                ContainerHelper.addCntr(model.trayCode,model.trayNum);

                // 2、创建空盘垛入库作业任务
                WMSTask wmsTask = new WMSTask()
                {
                    S_CNTR_CODE = model.trayCode,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = startLoc.S_CODE,
                    S_START_AREA = startLoc.S_AREA_CODE,
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "空盘垛入库",
                    S_OP_DEF_NAME = "空盘垛入库",
                    N_PRIORITY = 1,
                    T_START_TIME = DateTime.Now,
                };
                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    // 3、创建一段任务
                    WCSTask wcsTask = new WCSTask
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = wmsTask.S_TYPE + "-1",
                        S_START_LOC = wmsTask.S_START_LOC,
                        S_START_AREA = wmsTask.S_START_AREA,
                        S_END_LOC = connectLoc.S_CODE,
                        S_END_AREA = connectLoc.S_AREA_CODE,
                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                        N_CNTR_COUNT = 1,
                        S_SCHEDULE_TYPE = "LD",
                        S_OP_CODE = wmsTask.S_CODE,
                        N_PRIORITY = wmsTask.N_PRIORITY,
                        T_START_TIME = DateTime.Now,
                    };
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        // 对开始货位、接驳货位、终点货位进行加锁
                        LocationHelper.LockLoc(startLoc.S_CODE, 2);
                        LocationHelper.LockLoc(connectLoc.S_CODE, 1);

                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);
                    }
                }
            }
            else {
                result.resultCode = 1;
                result.resultMsg = "未获取到终点货位或接驳货位";
            }
            LogHelper.Info("空盘垛入库_emptyTrayStackInStock 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 5.根据工作号，查询X5系统钢卷信息
        /// </summary>
        /// <returns></returns>
        public ResponseResult findX5SteelCoilInfo(SteelCoilModel model)
        {
            LogHelper.Info("查询X5系统钢卷信息-sendOver Request：" + JsonConvert.SerializeObject(model), "Mobox");
            ResponseResult responseResult = new ResponseResult()
            {
                success = true,
            };
            try
            {
                // 调用X5系统查询
                var db = new SqlHelper<object>().GetOracleInstance(Settings.X5SqlServer);
                List<SteelCoilInfo> steelCoilInfos = db.Queryable<SteelCoilInfo>().Where(a => a.PROJECT_CODE == model.workNo && a.CL_PH == model.texture).ToList();
                responseResult.result = steelCoilInfos;
            }
            catch (Exception ex) {
                LogHelper.Info("调用X5系统错误，错误原因：" + ex.Message, "Mobox");
            }
           
            LogHelper.Info("查询X5系统钢卷信息-sendOver response：" + JsonConvert.SerializeObject(responseResult), "Mobox");
            return responseResult;
        }

        /// <summary>
        /// 6.堆垛机告警复位
        /// 1.满入和放货阻塞报警
        /// 2.空取和取货阻塞报警
        /// </summary>
        /// <param name="taskCode"></param>
        /// <returns></returns>
        public SimpleResult alarmReset(string taskCode) {
            SimpleResult result = new SimpleResult();
            WMSTask wmsTask = WMSHelper.GetWmsTask(taskCode);
            List<WCSTask>  wcsTaskList = WCSHelper.GetTaskListBySrcNo(wmsTask.S_CODE);
            foreach (var item in wcsTaskList)
            {
                if (item.S_SCHEDULE_TYPE.Equals("RB")) {
                    // 1.下发复位指令
                    foreach (var it in Settings.devicePlcInfos)
                    {
                        if(it.deviceNo.Equals(item.S_EQ_NO))
                        {
                            S7Helper.WriteInt(it.deviceName, 550, 4, 13);
                        }
                    }
                }
                // 2.取消任务，解绑和解锁，并删除容器相关数据
                LocationHelper.UnBindingLoc(item.S_CODE, new List<string>() { item.S_CNTR_CODE });
                LocationHelper.UnLockLoc(item.S_START_LOC);
                LocationHelper.UnLockLoc(item.S_END_LOC);
                WCSHelper.Fail(item);
            }
            // 恢复起点物料信息
            LocationHelper.BindingLoc(wmsTask.S_START_LOC, new List<string>() { wmsTask.S_CNTR_CODE });
            LocationHelper.UnLockLoc(wmsTask.S_END_LOC);
            wmsTask.N_B_STATE = 3;
            WMSHelper.UpdateTaskState(wmsTask);
            return result;
        }

        /// <summary>
        /// 7.模具初始化
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult initMouldInfo(mouldModel model)
        {
            LogHelper.Info("模具初始化-initMouldInfo 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            Location loc = LocationHelper.GetLoc(model.locCode);
            if (loc == null)
            {
                result.resultCode = 1;
                result.resultMsg = "货位不存在";
                return result;
            }
            else {
                 var mould = MouldHelper.GetMouldCntrByLoc(model.locCode);
                if (mould != null) {
                    result.resultCode = 1;
                    result.resultMsg = "该货位已绑定其他模具";
                    return result;
                }
            }

            model.ableFlag = "否";
            ApiHelper.initMould(model);
            LogHelper.Info("模具初始化-initMouldInfo 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 9、钢卷入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult steelCoilIntoStorage(SteelCoilInStockInfo model)
        {
            LogHelper.Info("钢卷来料入库-steelCoilIntoStorage 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            var result = ApiHelper.steelCoilIntoStorage(model);
            LogHelper.Info("钢卷来料入库-steelCoilIntoStorage 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 10.任务取消
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult cancelTask(MoboxTaskBase model) 
        {
            LogHelper.Info("取消任务-CancelTask 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            WCSTask wcsTask = WCSHelper.GetTask(model.taskNo);
            if (wcsTask != null && wcsTask.N_B_STATE <= 3) {

                if (wcsTask.N_B_STATE != 0) 
                {
                    // 堆垛机任务
                    if (wcsTask.S_SCHEDULE_TYPE == "RB")
                    {
                        short[] resSignal = S7Helper.ReadInt(wcsTask.S_EQ_NO, 551, 0, 8);
                        if (resSignal != null)
                        {
                            ResSignalInfo resSignalInfo = new ResSignalInfo()
                            {
                                HandShake = resSignal[0],
                                SRM_Num = resSignal[1],
                                Auto = resSignal[2],
                                Alarm_Code = resSignal[3],
                                State = resSignal[4],
                                TaskStatus1 = resSignal[5],
                                Loaded1 = resSignal[6],
                                Busines1 = resSignal[7]
                            };

                            if (resSignalInfo.Auto == 1)
                            {
                                if (resSignalInfo.Alarm_Code == 1)
                                {
                                    result.resultCode = 1;
                                    result.resultMsg = "堆垛机正常作业中，无法取消";
                                    return result;
                                }
                                else
                                {
                                    LogHelper.Info("人工取消堆垛机任务", "Mobox");
                                    S7Helper.WriteInt(wcsTask.S_EQ_NO, 550, 4, 12);  // 任务删除
                                    clearingDDJData(wcsTask.S_EQ_NO); // 清除堆垛机数据
                                }
                            }
                        }
                    }
                }

                WCSHelper.Fail(wcsTask);
                LocationHelper.UnLockLoc(wcsTask.S_START_LOC);
                LocationHelper.UnLockLoc(wcsTask.S_END_LOC);
                LocationHelper.UnBindingLoc(wcsTask.S_END_LOC, new List<string>() { wcsTask.S_CNTR_CODE });

                WMSTask wmsTask = WMSHelper.GetWmsTask(wcsTask.S_OP_CODE);
                if (wmsTask.S_OP_DEF_NAME == "模具入库（初始化）") {
                    var mouldCntr = MouldHelper.GetMouldCntrByCntr(wmsTask.S_CNTR_CODE);
                    MouldHelper.deleteMould(mouldCntr.S_MOULD_NO);
                }

                wmsTask.N_B_STATE = 3;
                wmsTask.S_B_STATE = "取消";
                wmsTask.T_END_TIME = DateTime.Now;
                WMSHelper.UpdateTask(wmsTask);
            }
            LogHelper.Info("取消任务-CancelTask 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 11.强制完成
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult forceFinishTask(MoboxTaskBase model)
        {
            LogHelper.Info("强制完成任务-forceFinishTask 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            var wcsTask = WCSHelper.GetTask(model.taskNo);
            if (wcsTask != null)
            {
                wcsTask.N_B_STATE = 3;
                WCSHelper.UpdateStatus(wcsTask, "强制完成");

                LocationHelper.UnLockLoc(wcsTask.S_START_LOC);
                LocationHelper.UnLockLoc(wcsTask.S_END_LOC);
                LocationHelper.UnBindingLoc(wcsTask.S_START_LOC, new List<string>() { wcsTask.S_CNTR_CODE });
                LocationHelper.BindingLoc(wcsTask.S_END_LOC, new List<string>() { wcsTask.S_CNTR_CODE });

                WMSTask wmsTask = WMSHelper.GetWmsTask(wcsTask.S_OP_CODE);
                if (wmsTask != null && wmsTask.S_END_LOC.Equals(wcsTask.S_END_LOC)) {
                    wmsTask.N_B_STATE = 2;  
                    wmsTask.T_END_TIME = DateTime.Now;
                    WMSHelper.UpdateTaskState(wmsTask);
                }

                if (wcsTask.S_SCHEDULE_TYPE == "HL") 
                {
                    // HL状态回报车间
                    HLStatusInfo hLStatusInfo = new HLStatusInfo()
                    {
                        orderId = wmsTask.S_CODE,
                        status = "2",
                        agvId = wcsTask.S_EQ_NO,
                        reason = "强制完成"
                    };
                    ShopFloorControl.updateStatus(hLStatusInfo);
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "任务不存在";
            }
            LogHelper.Info("强制完成任务-forceFinishTask 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 12.、立库汇总数据（半成品/成品）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult summaryLTKData(AreaBase model)
        {
            /*LogHelper.Info("立库汇总数据（半成品/成品）-summaryLTKData 入参：" + JsonConvert.SerializeObject(model), "Mobox");*/
            SimpleResult result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            DateTime date = DateTime.Parse(model.dataDate).Date;

            // 出库数量
            int outNum = db.Queryable<StockRecord>().Where(a => a.S_AREA_CODE == model.areaCode && a.S_ACT_TYPE == "出库").Where("(CONVERT(date, T_OUT_TIME) = @date or CONVERT(date, T_IN_TIME) = @date)", new { date }).Count();
            // 入库数量
            int inNum = db.Queryable<StockRecord>().Where(a => a.S_AREA_CODE == model.areaCode && a.S_ACT_TYPE == "入库").Where("(CONVERT(date, T_OUT_TIME) = @date or CONVERT(date, T_IN_TIME) = @date)", new { date }).Count();
            // 剩余空货位数量
            int emptyNum = db.Queryable<Location>().Where(a => a.S_AREA_CODE == model.areaCode && a.N_CURRENT_NUM == 0).Count();
            // 库存超3月数量
            int threeMonthsNum = db.Queryable<Location>()
            .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
            .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
            .Where((l, lc, ci) => l.S_AREA_CODE == model.areaCode && l.N_CURRENT_NUM > 0 && (ci.S_ITEM_TYPE == "成品" || ci.S_ITEM_TYPE == "半成品"))
            .Where("DATEDIFF(day, l.T_FULL_TIME, GETDATE()) > 90").Count();
            // 库存超6月数量
            int sixMonthsNum = db.Queryable<Location>()
            .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
            .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
            .Where((l, lc, ci) => l.S_AREA_CODE == model.areaCode && l.N_CURRENT_NUM > 0 && (ci.S_ITEM_TYPE == "成品" || ci.S_ITEM_TYPE == "半成品"))
            .Where("DATEDIFF(day, l.T_FULL_TIME, GETDATE()) > 180").Count();
            // 空托盘数量
            int emptyTrayNum = db.Queryable<Location>()
              .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
              .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
              .LeftJoin<Container>((l, lc, ci, c) => lc.S_CNTR_CODE == c.S_CODE)
              .Where((l, lc, ci, c) => l.S_AREA_CODE == model.areaCode && l.N_CURRENT_NUM > 0 && lc.S_CNTR_CODE != null && ci.S_ITEM_TYPE == null)
              .Sum((l, lc, ci, c) => c.N_DETAIL_COUNT);

            LTKSummaryData summaryData = new LTKSummaryData() { 
                outNum = outNum,
                inNum = inNum,
                emptyNum = emptyNum,
                threeMonthsNum = threeMonthsNum,
                sixMonthsNum = sixMonthsNum,
                emptyTrayNum = emptyTrayNum,
            };
            result.result = summaryData;
           /* LogHelper.Info("立库汇总数据（半成品/成品）-summaryLTKData 出参：" + JsonConvert.SerializeObject(result), "Mobox");*/
            return result;
        }

        /// <summary>
        /// 13.根据库区、排查询立库半成品、成品、空托盘数量
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult queryLTKItemNum(AreaBase model)
        {
           /* LogHelper.Info("立库半成品、成品、空托盘数量-getLTKItemNum 入参：" + JsonConvert.SerializeObject(model), "Mobox");*/
            SimpleResult result = new SimpleResult();
            List<LTKStatisticsData> list = new List<LTKStatisticsData>();

            var db = new SqlHelper<object>().GetInstance();

            var rowList = db.Queryable<Location>().Where(a => a.S_AREA_CODE == model.areaCode).GroupBy(a => a.N_ROW).OrderBy(a => a.N_ROW).Select(a => a.N_ROW).ToList();
            foreach (var row in rowList)
            {
                int semiFinishedNum = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
                .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
                .Where((l, lc, ci) => l.S_AREA_CODE == model.areaCode && l.N_ROW == row && l.N_CURRENT_NUM > 0 && ci.S_ITEM_TYPE == "半成品").Count();

                int finishedNum = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
                .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
                .Where((l, lc, ci) => l.S_AREA_CODE == model.areaCode && l.N_ROW == row && l.N_CURRENT_NUM > 0 && ci.S_ITEM_TYPE == "成品").Count();

                int emptyTrayNum = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((l, lc) => l.S_CODE == lc.S_LOC_CODE)
                .LeftJoin<CntrItemRel>((l, lc, ci) => lc.S_CNTR_CODE == ci.S_CNTR_CODE)
                .Where((l, lc, ci) => l.S_AREA_CODE == model.areaCode && l.N_ROW == row && l.N_CURRENT_NUM > 0 && lc.S_CNTR_CODE != null && ci.S_ITEM_TYPE == null).Count();
                LTKStatisticsData statisticsData = new LTKStatisticsData()
                {
                    row = row,
                    semiFinishedNum = semiFinishedNum,
                    finishedNum = finishedNum,
                    emptyTrayNum = emptyTrayNum
                };
                list.Add(statisticsData);
            }
            
            result.result = list;
           /* LogHelper.Info("立库半成品、成品、空托盘数量-getLTKItemNum 出参：" + JsonConvert.SerializeObject(result), "Mobox");*/
            return result;
        }

        /// <summary>
        /// 13.根据库区、排统计空 、满货位数量
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult statisticsLocNum(AreaBase model)
        {
           /* LogHelper.Info("根据库区、排统计空 、满货位数量-statisticsLocNum 入参：" + JsonConvert.SerializeObject(model), "Mobox");*/
            SimpleResult result = new SimpleResult();
            List<LocStatisticsData> list = new List<LocStatisticsData>();
            var db = new SqlHelper<object>().GetInstance();
            
            var rowList = db.Queryable<Location>().Where(a => a.S_AREA_CODE == model.areaCode).GroupBy(a => a.N_ROW).OrderBy(a => a.N_ROW).Select(a => a.N_ROW).ToList();
            foreach (var row in rowList)
            {
                int fullNum = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == model.areaCode && a.N_ROW == row).Count();
                int emptydNum = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == 0 && a.S_AREA_CODE == model.areaCode && a.N_ROW == row).Count();

                LocStatisticsData locStatisticsData = new LocStatisticsData()
                {
                    row = row,
                    fullNum = fullNum,
                    emptydNum = emptydNum,
                };
                list.Add(locStatisticsData);
            }
           
            result.result = list;
          /*  LogHelper.Info("根据库区、排统计空 、满货位数量-statisticsLocNum 出参：" + JsonConvert.SerializeObject(result), "Mobox");*/
            return result;
        }

        /// <summary>
        /// 14.PDA呼叫空托（模具）
        /// </summary>
        /// <returns></returns>
        public SimpleResult callEmptyTray(MouldDispatchModel model)
        {
            LogHelper.Info("PDA呼叫空托（模具）-callEmptyTray 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            // 大模具库区
            List<string> mouldAreaCodes = Settings.getStoreAreaCodes(1, 3);
            LogHelper.Info("模具库区编码："+ JsonConvert.SerializeObject(mouldAreaCodes), "Mobox");

            // 查询空托盘(未绑定模具)货位
            var emptyTrayLoc = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((a, b) => a.S_CODE == b.S_LOC_CODE)
                .Where((a, b) => mouldAreaCodes.Contains(a.S_AREA_CODE) && a.N_CURRENT_NUM == 1 && b.S_CNTR_CODE != null && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y" && b.S_CNTR_CODE == model.trayCode)
                .Select((a, b) => new { a, b.S_CNTR_CODE })
                .First();

            Location endLoc = LocationHelper.GetLoc(model.locCode);
            if (emptyTrayLoc != null && endLoc != null )
            {
                // 2、创建空盘出库作业任务
                WMSTask wmsTask = new WMSTask()
                {
                    S_CNTR_CODE = emptyTrayLoc.S_CNTR_CODE,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = emptyTrayLoc.a.S_CODE,
                    S_START_AREA = emptyTrayLoc.a.S_AREA_CODE,
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "空托出库",
                    S_OP_DEF_NAME = "呼叫空托（模具）",
                    T_START_TIME = DateTime.Now,
                };
                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    // 3、创建一段任务
                    WCSTask wcsTask = new WCSTask
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = wmsTask.S_TYPE + "-1",
                        S_START_LOC = wmsTask.S_START_LOC,
                        S_START_AREA = wmsTask.S_START_AREA,
                        S_END_LOC = wmsTask.S_END_LOC,
                        S_END_AREA = wmsTask.S_END_AREA,
                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                        N_CNTR_COUNT = 1,
                        S_SCHEDULE_TYPE = "HL",
                        S_OP_CODE = wmsTask.S_CODE,
                        N_PRIORITY = wmsTask.N_PRIORITY,
                        T_START_TIME = DateTime.Now,
                    };
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        // 对开始货位、终点货位进行加锁
                        LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                        LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);
                    }
                }
            }
            else 
            {
                result.resultCode = 1;
                result.resultMsg = "未查询到空托盘或终点货位不存在";
            }

            LogHelper.Info("PDA呼叫空托（模具）-callEmptyTray 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 15.PDA模具入库(初始化)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public SimpleResult mouldIntoStock(mouldModel model)
        {
            LogHelper.Info("PDA模具入库-mouldIntoStock 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();

            var mouldCntr1 = MouldHelper.GetMouldCntrByCntr(model.trayCode);
            var mouldCntr2 = MouldHelper.GetMouldCntr(model.mouldNo);

            if (mouldCntr1 != null && mouldCntr1.S_MOULD_NO != model.mouldNo) {
                result.resultCode = 1;
                result.resultMsg = "托盘已绑定其他模具，无法初始化入库";
                return result;
            }
            
            if (mouldCntr2 != null && mouldCntr2.S_CNTR_CODE != model.trayCode)
            {
                result.resultCode = 1;
                result.resultMsg = "模具已绑定其他托盘，无法初始化入库";
                return result;
            }

            // 查询空托盘是否绑定货位
            var locMouldCntr = db.Queryable<LocMouldCntr>()
                .Where(a => a.S_CNTR_CODE == model.trayCode)
                .OrderByDescending(a => a.T_CREATE)
                .First();

            if (locMouldCntr == null) {
                locMouldCntr = new LocMouldCntr();
                locMouldCntr.S_CNTR_CODE = model.trayCode;
                locMouldCntr.S_LOC_CODE = model.locCode;
                db.Insertable(locMouldCntr).ExecuteCommand();
            }

            Location trayLoc = LocationHelper.GetLoc(locMouldCntr.S_LOC_CODE);
            Location fromLoc = LocationHelper.GetLoc(model.fromLocCode);
            if (trayLoc != null && fromLoc != null && fromLoc.N_LOCK_STATE == 0)
            {
                model.locCode = trayLoc.S_CODE;
                model.ableFlag = "是";
                ApiHelper.initMould(model);

                // 2、创建模具出库作业任务
                WMSTask wmsTask = new WMSTask()
                {
                    S_CNTR_CODE = model.trayCode,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = fromLoc.S_CODE,
                    S_START_AREA = fromLoc.S_AREA_CODE,
                    S_END_LOC = trayLoc.S_CODE,
                    S_END_AREA = trayLoc.S_AREA_CODE,
                    S_TYPE = "模具入库",
                    S_OP_DEF_NAME = "模具入库（初始化）",
                    T_START_TIME = DateTime.Now,
                };
                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    // 3、创建一段任务
                    WCSTask wcsTask = new WCSTask
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = wmsTask.S_TYPE + "-1",
                        S_START_LOC = wmsTask.S_START_LOC,
                        S_START_AREA = wmsTask.S_START_AREA,
                        S_END_LOC = wmsTask.S_END_LOC,
                        S_END_AREA = wmsTask.S_END_AREA,
                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                        N_CNTR_COUNT = 1,
                        S_SCHEDULE_TYPE = "HL",
                        S_OP_CODE = wmsTask.S_CODE,
                        N_PRIORITY = wmsTask.N_PRIORITY,
                        T_START_TIME = DateTime.Now,
                    };
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        // 对开始货位、终点货位进行加锁
                        LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                        LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);
                    }
                }
            }

            LogHelper.Info("PDA模具入库-mouldIntoStock 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 16.查询成品、半成品、空托盘的出入库汇总数据
        /// </summary>
        /// <returns></returns>
        public SimpleResult queryOutInStockSummary(StockRecordModel model) {
           /* LogHelper.Info("16.查询成品、半成品、空托盘的出入库汇总数据-queryOutInStockSummary 入参：" + JsonConvert.SerializeObject(model), "Mobox");*/
            SimpleResult result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            DateTime date = DateTime.Parse(model.dataDate).Date;
            var finishNum = db.Queryable<StockRecord>().Where(a => a.S_AREA_CODE == model.areaCode && a.S_ACT_TYPE == model.actType && a.S_ITEM_TYPE == "成品").Where("(CONVERT(date, T_OUT_TIME) = @date or CONVERT(date, T_IN_TIME) = @date)", new { date }).Count();
            var unfinishNum = db.Queryable<StockRecord>().Where(a => a.S_AREA_CODE == model.areaCode && a.S_ACT_TYPE == model.actType && a.S_ITEM_TYPE == "半成品").Where("(CONVERT(date, T_OUT_TIME) = @date or CONVERT(date, T_IN_TIME) = @date)", new { date }).Count();
            var emptyTrayNum = db.Queryable<StockRecord>().Where(a => a.S_AREA_CODE == model.areaCode && a.S_ACT_TYPE == model.actType && a.S_ITEM_TYPE == "空托盘").Where("(CONVERT(date, T_OUT_TIME) = @date or CONVERT(date, T_IN_TIME) = @date)", new { date }).Count();
            StockRecordSummaryData outStockDatas = new StockRecordSummaryData() { 
                finishNum = finishNum,
                unFinishNum = unfinishNum, 
                emptyTrayNum = emptyTrayNum,
            };
            result.result = outStockDatas;
           /* LogHelper.Info("16.查询成品、半成品、空托盘的出入库汇总数据-queryOutInStockSummary 出参：" + JsonConvert.SerializeObject(result), "Mobox");*/
            return result;
        }

        /// <summary>
        /// 17.模具出库检修
        /// </summary>
        /// <returns></returns>
        public SimpleResult callMouldOutStock(CallMouldModel model)
        {
            LogHelper.Info("17.PDA叫模具出库到指定位置-callMouldOutStock 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            MouldCntr mouldCntr = MouldHelper.GetMouldCntr(model.mouldNo);
            if (mouldCntr != null)
            {
                Location startLoc = LocationHelper.GetLoc(mouldCntr.S_LOC_CODE);
                Location endLoc = LocationHelper.GetLoc(model.endLocCode);

                if (startLoc != null && startLoc.N_LOCK_STATE == 0 && endLoc != null)
                {
                    // 1、创建模具出库作业任务
                    WMSTask wmsTask = new WMSTask()
                    {
                        S_CNTR_CODE = mouldCntr.S_CNTR_CODE,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_TYPE = "模具出库",
                        S_OP_DEF_NAME = "模具出库检修",
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask))
                    {
                        // 2、创建一段任务
                        WCSTask wcsTask = new WCSTask
                        {
                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = wmsTask.S_TYPE,
                            S_START_LOC = wmsTask.S_START_LOC,
                            S_START_AREA = wmsTask.S_START_AREA,
                            S_END_LOC = wmsTask.S_END_LOC,
                            S_END_AREA = wmsTask.S_END_AREA,
                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                            N_CNTR_COUNT = 1,
                            S_SCHEDULE_TYPE = "HL",
                            S_OP_CODE = wmsTask.S_CODE,
                            N_PRIORITY = wmsTask.N_PRIORITY,
                            T_START_TIME = DateTime.Now,
                        };
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            // 对开始货位、终点货位进行加锁
                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                            wmsTask.N_B_STATE = 1;
                            WMSHelper.UpdateTaskState(wmsTask);
                        }
                    }
                }
            }
            else 
            {
                result.resultCode = 1;
                result.resultMsg = "模具不存在";
            }
            LogHelper.Info("17.PDA叫模具出库到指定位置-callMouldOutStock 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 17.模具出库(初始化)
        /// </summary>
        /// <returns></returns>
        public SimpleResult callMouldOutStockInitial(CallMouldModel model)
        {
            LogHelper.Info("17.PDA叫模具出库到指定位置-callMouldOutStock 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            MouldCntr mouldCntr = MouldHelper.GetMouldCntr(model.mouldNo);
            if (mouldCntr != null)
            {
                Location startLoc = LocationHelper.GetLoc(mouldCntr.S_LOC_CODE);
                Location endLoc = LocationHelper.GetLoc(model.endLocCode);

                if (startLoc != null && startLoc.N_LOCK_STATE == 0 && endLoc != null)
                {
                    // 1、创建模具出库作业任务
                    WMSTask wmsTask = new WMSTask()
                    {
                        S_CNTR_CODE = mouldCntr.S_CNTR_CODE,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_TYPE = "模具出库",
                        S_OP_DEF_NAME = "模具出库(初始化)",
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask))
                    {
                        // 2、创建一段任务
                        WCSTask wcsTask = new WCSTask
                        {
                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = wmsTask.S_TYPE,
                            S_START_LOC = wmsTask.S_START_LOC,
                            S_START_AREA = wmsTask.S_START_AREA,
                            S_END_LOC = wmsTask.S_END_LOC,
                            S_END_AREA = wmsTask.S_END_AREA,
                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                            N_CNTR_COUNT = 1,
                            S_SCHEDULE_TYPE = "HL",
                            S_OP_CODE = wmsTask.S_CODE,
                            N_PRIORITY = wmsTask.N_PRIORITY,
                            T_START_TIME = DateTime.Now,
                        };
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            // 对开始货位、终点货位进行加锁
                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                            wmsTask.N_B_STATE = 1;
                            WMSHelper.UpdateTaskState(wmsTask);
                        }
                    }
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "模具不存在";
            }
            LogHelper.Info("17.PDA叫模具出库到指定位置-callMouldOutStock 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 18.解绑模具信息，变成空托
        /// </summary>
        /// <returns></returns>
        public SimpleResult unBindMould(mouldBase model)
        {
            LogHelper.Info("18.解绑模具信息，变成空托-unBindMould 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            MouldCntr mouldCntr = MouldHelper.GetMouldCntr(model.mouldNo);
            if (mouldCntr != null) {
                MouldHelper.deleteMould(model.mouldNo);
            }
            LogHelper.Info("18.解绑模具信息，变成空托-unBindMould 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 19.查询钢卷库存信息
        /// </summary>
        /// <returns></returns>
        public SimpleResult querySteelCoilStockInfo(SteelCoilPage model)
        {
            LogHelper.Info("19.查询钢卷库存信息-querySteelCoilStockInfo 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            PageInfo page = new PageInfo();
            var db = new SqlHelper<object>().GetInstance();
            int totalCount = 0;
            var areaCodes = Settings.getStoreAreaCodes(1, 2);

            var cntrItems = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((a, b) => a.S_CODE == b.S_LOC_CODE)
                .LeftJoin<CntrItemRel>((a, b, c) => b.S_CNTR_CODE == c.S_CNTR_CODE)
                .Where((a, b, c) => a.N_CURRENT_NUM > 0 && c.S_ITEM_TYPE == "钢卷" && areaCodes.Contains(a.S_AREA_CODE))
                .Select((a, b, c) => c)
                .ToPageList(model.pageNum, model.pageSize, ref totalCount);
            
            page.totalCount = totalCount;
            page.pageNum = model.pageNum;
            page.pageSize = model.pageSize;
            page.data = cntrItems;
            result.result = page;
            LogHelper.Info("19.查询钢卷库存信息-querySteelCoilStockInfo 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 20.更新钢卷在库信息
        /// </summary>
        /// <returns></returns>
        public SimpleResult updateSteelCoilStockInfo()
        {
            LogHelper.Info("20.更新钢卷在库信息-updateSteelCoilStockInfo 入参：null" , "Mobox");
            SimpleResult result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            var areaCodes = Settings.getStoreAreaCodes(1, 2);
            var cntrs = db.Queryable<Location>()
                .LeftJoin<LocCntrRel>((a, b) => a.S_CODE == b.S_LOC_CODE)
                .LeftJoin<CntrItemRel>((a, b, c) => b.S_CNTR_CODE == c.S_CNTR_CODE)
                .Where((a, b, c) => a.N_CURRENT_NUM > 0 && c.S_ITEM_NAME == "钢卷" && areaCodes.Contains(a.S_AREA_CODE))
                .Select((a, b, c) => c.S_CNTR_CODE).ToList();
            LogHelper.Info("容器数量："+ cntrs.Count, "Mobox");
            db.Updateable<CntrItemRel>().SetColumns(a => new CntrItemRel() { ISFIND = 1 } ).Where( a => cntrs.Contains(a.S_CNTR_CODE)).ExecuteCommand();
            
            LogHelper.Info("20.更新钢卷在库信息-updateSteelCoilStockInfo 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        /// <summary>
        /// 21.模具检修回库
        /// </summary>
        /// <returns></returns>
        public SimpleResult ReturnMouldOutStock(ReturnMouldModel model)
        {
            LogHelper.Info("21.模具检修回库-ReturnMouldOutStock 入参：" + JsonConvert.SerializeObject(model), "Mobox");
            SimpleResult result = new SimpleResult();
            MouldCntr mouldCntr = MouldHelper.GetMouldCntr(model.mouldNo);
            if (mouldCntr != null)
            {
                Location startLoc = LocationHelper.GetLoc(model.startLocCode);
                Location endLoc = LocationHelper.GetLoc(mouldCntr.S_LOC_CODE);

                if (startLoc != null && startLoc.N_LOCK_STATE == 0 && endLoc != null)
                {
                    // 更新模具数量
                    ApiHelper.updateMouldNum(mouldCntr.S_MOULD_NO,model.aMouldNum,model.bMouldNum,model.cMouldNum);

                    // 1、创建模具回库作业任务
                    WMSTask wmsTask = new WMSTask()
                    {
                        S_CNTR_CODE = mouldCntr.S_CNTR_CODE,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_TYPE = "模具入库",
                        S_OP_DEF_NAME = "模具(检修)回库",
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask))
                    {
                        // 2、创建一段任务
                        WCSTask wcsTask = new WCSTask
                        {
                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = wmsTask.S_TYPE,
                            S_START_LOC = wmsTask.S_START_LOC,
                            S_START_AREA = wmsTask.S_START_AREA,
                            S_END_LOC = wmsTask.S_END_LOC,
                            S_END_AREA = wmsTask.S_END_AREA,
                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                            N_CNTR_COUNT = 1,
                            S_SCHEDULE_TYPE = "HL",
                            S_OP_CODE = wmsTask.S_CODE,
                            N_PRIORITY = wmsTask.N_PRIORITY,
                            T_START_TIME = DateTime.Now,
                        };
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            // 对开始货位、终点货位进行加锁
                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                            wmsTask.N_B_STATE = 1;
                            WMSHelper.UpdateTaskState(wmsTask);
                        }
                    }
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "模具不存在";
            }
            LogHelper.Info("21.模具检修回库-ReturnMouldOutStock 出参：" + JsonConvert.SerializeObject(result), "Mobox");
            return result;
        }

        public class SteelCoilPage
        {
            public int pageNum { get; set; }  // 当前页
            public int pageSize { get; set; }  // 每页数量
        }

        public class CallMouldModel {
            public string mouldNo { get; set; } // 模具序号 (车:模具序号)
            public string endLocCode { get; set; } // 终点货位编码
        }

        public class ReturnMouldModel
        {
            public string mouldNo { get; set; } // 模具序号 (车:模具序号)
            public string startLocCode { get; set; } // 终点货位编码
            public int aMouldNum { get; set; } // 主片模具数量
            public int bMouldNum { get; set; } // 项片模具数量
            public int cMouldNum { get; set; } // 主片冲头数量
        }

        public class StockRecordSummaryData
        {
            public int finishNum { get; set; } 
            public int unFinishNum { get; set; } 
            public int emptyTrayNum { get; set; } 
        }

        public class StockRecordModel {
            public string areaCode { get; set; } // 库区编码
            public string actType { get; set; } // 行为类型 入库、出库
            public string dataDate { get; set; } // 数据日期 YYYY-MM-DD
        }

        public class MouldDispatchModel
        {
            public string locCode { get; set; } // 模具配送位
            public string trayCode { get; set; } // 托盘号
        }

        public class LocStatisticsData {
            public int row { get; set; } // 排号
            public int fullNum { get; set; } // 满货位数量
            public int emptydNum { get; set; } // 空货位数量
        }

        public class LTKStatisticsData
        {
            public int row { get; set; } // 排号
            public int semiFinishedNum { get; set; } // 半成品数量
            public int finishedNum { get; set; } // 成品数量
            public int emptyTrayNum { get; set; } // 空托盘数量
        }

        public class LTKSummaryData {
            public int outNum { get; set; } // 出库数量
            public int inNum { get; set; } // 入库数量
            public int emptyNum { get; set; } // 剩余空货位数量
            public int threeMonthsNum { get; set; } // 库存超3月数量
            public int sixMonthsNum { get; set; } // 库存超6月数量
            public int emptyTrayNum { get; set; } // 空托盘数量
        }

        public class AreaBase {
            public string areaCode { get; set; } // 库区编码
            public string dataDate { get; set; } // 数据日期
        }

        /// <summary>
        /// mobox 取消任务、标记完成任务
        /// </summary>
        public class MoboxTaskBase
        {
            public string taskNo { get; set; }
        }

        public class mouldBase {
            public string mouldNo { get; set; } // 模具序号 (车:模具序号)
        }

        public class mouldModel 
        {
            public string itemCode { get; set; } // 物料编号（车:模具编号）
           /* public string S_MOULD_NAME { get; set; } // 模具名称*/
            public string mouldNo { get; set; } // 模具序号 (车:模具序号)
            public string mouldType { get; set; } // 模具类型  主片模具 、项片模具
            public string trayCode { get; set; } // 容器编码
            public string locCode { get; set; } // 货位编码
            public string ableFlag { get; set; } // 是否可用
            public int aMouldNum { get; set; } // 主片模具数量
            public int bMouldNum { get; set; } // 项片模具数量
            public int cMouldNum { get; set; } // 主片冲头数量
            public string fromLocCode { get; set; } // 货位编码
        }

        public class SteelCoilModel
        {
            public string workNo { get; set; } // 工作号
            public string texture { get; set; } // 物料编码
        }

        [SugarTable("IPlatform_sys_test.WMS_X5V")]
        public class SteelCoilInfo
        {
            public string PROJECT_CODE { get; set; } // 工作号
            public string GZH { get; set; } // 物料编码
            public string CL_GG { get; set; } // 规格
            public string CL_PH { get; set; } // 材质
            public string QC { get; set; } // 钢卷描述
        }

        public class FinisheProductInfos { 
            public List<FinisheProductInfo> finisheProductList { get; set; }
        }

        public class FinisheProductInfo
        {
            public string workNo { get; set; } // 工作号
            public string trayCode { get; set; } // 托盘号
            public string itemCode { get; set; } // 物料编码 
            public string endLocCode { get; set; } // 终点货位
        }

        public class EmptyTrayInStockInfo {
            public string startLocCode { get; set; } // 起点货位
            public string trayCode { get; set; } //托盘编号
            public string endLocCode { get; set; } // 终点货位
        }

        public class EmptyTrayStackInStockInfo
        {
            public string trayCode { get; set; } // 容器编码
            public int trayNum { get; set; } = 1; // 托盘数量
            public string startLocCode { get; set; } // 起点货位
            public string endAreaCode { get; set; } // 终点库区
        }
    }
}