using HanHe.Message;
using HH.WCS.Hexafluo.dispatch;
using HH.WCS.Hexafluo.util;
using HH.WCS.Hexafluo.wms;
using HH.WCS.SJML.api;
using HH.WCS.SJML.Bll;
using HH.WCS.SJML.Comm;
using HH.WCS.SJML.dispatch;
using HH.WCS.SJML.Dto;
using HH.WCS.SJML.Entitys;
using HH.WCS.SJML.util;
using HH.WCS.SJML.wms;
using HH.WCS.ZCQTJ.dispatch;
using HH.WCS.ZCQTJ.Dto;
using HH.WCS.ZCQTJ.Entitys;
using HH.WCS.ZCQTJ.util;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Web.Http;
using static HH.WCS.SJML.api.ApiModel;

namespace HH.WCS.Hexafluo.api
{
    /// <summary>
    /// 第三方调用的接口
    /// </summary>
    [RoutePrefix("api")]
    public class WmsController : System.Web.Http.ApiController
    {

        [HttpPost]
        [Route("NoticeComplete")]
        public SimpleResult NoticeComplete()
        {
            LogHelper.Debug("ResetDevice Request");
            return ApiHelper.NoticeComplete();

        }
        #region 中策钱塘江
        #region 完工回报
        /// <summary>
        /// 完工回报
        /// </summary>
        /// <param name="jsonData"></param>
        [HttpPost]
        [Route("OperateTask")]
        public OperateResult OperateTask(dynamic jsonData)
        {
            var logPara = LogType.LogPara("完工回报");
            LogHelper.TaskDetail(logPara, " Mobox完工回报参数：" + jsonData.ToString());
            try
            {
                AgvTaskState Supplier = JsonConvert.DeserializeObject<AgvTaskState>(jsonData.ToString());
                var task = TaskHelper.GetTask(Supplier.No);
                var SataeLis = SataeList[Supplier.State];
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                if (task.S_NOTE.Equals("立库任务") && task.S_TYPE == "入库" && Supplier.State == 7)
                {
                    var task2 = newDb.Queryable<WMSTask>().Where(a => a.S_TASK_NO.Trim() == task.S_SRC_NO + "_1").First();
                    if (task2 != null)
                    {
                        if (!task2.S_B_STATE.Trim().Equals("完成") && !task2.S_B_STATE.Trim().Equals("取消"))
                        {
                            throw new Exception("先把小车任务完成了,才能取消立库任务！");
                        }
                    }
                }
                if (task.S_NOTE.Equals("立库任务") && Supplier.State == 22)
                {
                    var re = BLLCreator.CreateSingleton<WcsTask>().WcsCancellTask(task);
                    LogHelper.TaskDetail(logPara, $"立库任务取消通知{JsonConvert.SerializeObject(task)} 是否成功:{JsonConvert.SerializeObject(re)}");
                    if (!re.Success)
                    {
                        throw new Exception(re.Msg);
                    }
                }
                if (task.S_NOTE.Equals("agv任务") && task.S_TYPE == "入库")
                {
                    if (Supplier.State == 2 || Supplier.State == 22)
                    {
                        var tac = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "5")?.First();
                        LogHelper.TaskDetail(logPara, $"强制完成 查询agv任务 是否上报过5 {JsonConvert.SerializeObject(tac)}");
                        if (tac == null)
                        {
                            throw new Exception(" 没有卸货完成,只能取消");
                        }
                    }
                }
                var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(Supplier.No, SataeLis, logPara, task);
                if (task.S_NOTE.Equals("agv任务") && (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "完成") && Supplier.State == 22 && ta.Success)
                {
                    NDCHelper.Cancel(task.S_TASK_NO);//取消agv任务
                    LogHelper.TaskDetail(logPara, "通知agv取消任务--强制完成");
                    if (task.S_TYPE == "出库")
                    {
                        var tac = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "4")?.First();
                        LogHelper.TaskDetail(logPara, $"强制完成 查询agv任务 是否上报过4 {JsonConvert.SerializeObject(tac)}");
                        if (tac == null)
                        {
                            AloneWcsTaskUnbingEntitys aloneWcsTask = new AloneWcsTaskUnbingEntitys()
                            {
                                S_TASK_NO = Supplier.No,
                                JbLocation = task.S_START_LOC,
                                IsRead = "N"
                            };
                            var I = newDb.Insertable(aloneWcsTask).ExecuteCommand();
                            if (I == 0)
                            {
                                LogHelper.TaskDetail(logPara, "添加点对点接驳位释放表数据失败");
                            }
                            LogHelper.TaskDetail(logPara, "添加点对点接驳位释放表数据");
                        }
                    }
                }
                if (task.S_NOTE.Equals("agv任务") && Supplier.State == 7 && ta.Success && task.S_TYPE == "入库")
                {
                    if (task.S_TASK_NO.IndexOf('_') > 0)
                    {
                        AgvStateWcsIn(task, logPara);
                        //var tac =newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "1103")?.First();
                        //if (tac != null)
                        //{
                        //    LogHelper.TaskDetail(logPara, "完工回报 调用安全请求取消：");
                        //    var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 7, task.S_EQ_NO);
                        //}
                    }
                }
                else if (task.S_NOTE.Equals("agv任务") && Supplier.State == 22 && ta.Success && task.S_TYPE == "入库")
                {
                    if (task.S_TASK_NO.IndexOf('_') > 0)
                    {
                        AgvStateWcsIn(task, logPara);
                        //var tac =newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "1103")?.First();
                        //if (tac != null)
                        //{
                        //    LogHelper.TaskDetail(logPara, "完工回报 调用安全请求取消：");
                        //    var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 7, task.S_EQ_NO);
                        //}
                    }
                }
                else if (task.S_NOTE.Equals("agv任务") && Supplier.State == 7 && ta.Success && task.S_TYPE == "出库")
                {
                    if (task.S_TASK_NO.IndexOf('_') > 0)
                    {
                        var tac = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "1101")?.First();
                        if (tac != null)
                        {
                            LogHelper.TaskDetail(logPara, "完工回报 调用安全请求取消：");
                            var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 7, task.S_EQ_NO);
                        }
                    }
                }
                else if (task.S_NOTE.Equals("agv任务") && Supplier.State == 22 && ta.Success && task.S_TYPE == "出库")
                {
                    if (task.S_TASK_NO.IndexOf('_') > 0)
                    {
                        var tac = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "1101")?.First();
                        if (tac != null)
                        {
                            var taf = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO && a.S_ACTION_CODE == "1102")?.First();
                            if (tac != null)
                            {
                                LogHelper.TaskDetail(logPara, "完工回报 调用安全请求取消：");
                                var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 7, task.S_EQ_NO);
                            }
                        }
                    }
                    NDCHelper.Cancel(task.S_TASK_NO);//取消agv任务
                    LogHelper.TaskDetail(logPara, "完工回报 调用小车取消任务接口：");
                }
                LogHelper.TaskDetail(logPara, "完工回报返回：" + JsonConvert.SerializeObject(ta));
                return ta;
            }
            catch (Exception ex)
            {
                LogHelper.TaskDetail(logPara, "完工回报报错：" + JsonConvert.SerializeObject(ex));
                CwLine("完工回报报错：" + JsonConvert.SerializeObject(ex));
                return OperateResult.Error(JsonConvert.SerializeObject(ex));
            }
        }
        /// <summary>
        /// agv 入库取消是否调立库取消接口
        /// </summary>
        /// <returns></returns>
        public void AgvStateWcsIn(WMSTask task, SJML.util.LogPara logParas)
        {
            try
            {
                //任务是agv任务 且是入库任务 如果有1104 则 把1104之前的信号都排除 
                //然后再排除后的参数里查询1101后有没有1102 如果有则不调wcs 安全交互取消 如果没有 则取消
                //货位取的是任务的接驳位 ,如果没有1104信号则看是否有1103信号 如果有则发送wcs取消 货位则是发的agv任务的终点
                var tacList = SqlSugarHelper.Db.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == task.S_TASK_NO).ToList();
                var ActList = tacList.OrderBy(e => e.T_CREATE).ToList();
                var ggf = tacList.Find(e => e.S_ACTION_CODE == "1104");
                if (ggf != null)
                {
                    ActList.RemoveAll(e => e.T_CREATE < ggf.T_CREATE);
                    //查询1104后 查1101后有没有1102
                    if (ActList.Find(e => e.S_ACTION_CODE == "1101") != null)
                    {
                        if (ActList.Find(e => e.S_ACTION_CODE == "1102") == null)
                        {
                            LogHelper.TaskDetail(logParas, "完工回报 调用安全请求取消：");
                            var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 8, task.S_EQ_NO);
                        }
                    }
                }
                else
                {
                    if (ActList.Find(e => e.S_ACTION_CODE == "1103") != null)
                    {
                        LogHelper.TaskDetail(logParas, "完工回报 调用安全请求取消：");
                        var Wcs = BLLCreator.CreateSingleton<WcsTask>().WcsCallback(task, 7, task.S_EQ_NO);
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.TaskDetail(logParas, ex.Message);
            }
        }
        /// <summary>
        /// WCS 完工回报
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("WcsOperateTask")]
        public ReturnValue WcsOperateTask(dynamic jsonData)
        {
            var logPara = LogType.LogPara("完工回报");
            LogHelper.TaskDetail(logPara, "立库完工回报参数：" + jsonData.ToString());
            ReturnValue retu = new ReturnValue();
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            retu.requestPk = Supplier.requestPk;
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                TaskHelper.WcsAddActionRecord(Supplier.requestPk, Supplier.noticeType, "WCS", JsonConvert.SerializeObject(Supplier));
                var taskNo = "";
                string SataeLis = "";
                if (string.IsNullOrEmpty(Supplier.requestPk))
                {
                    throw new Exception("任务号为空");
                }
                else
                {
                    taskNo = Supplier.requestPk;
                }
                var transportTask = newDb.Queryable<WMSTask>().Where(e => e.S_TASK_NO == taskNo)?.First();

                if (transportTask == null)
                {
                    throw new Exception("未查询到对应的任务");
                }
                WcsRfidCheckoutEntitys RfidChek = new WcsRfidCheckoutEntitys();
                RfidChek.S_TASK_NO = Supplier.requestPk;
                RfidChek.S_NEWTRAY_CODE = Supplier.contNo;
                RfidChek.S_OLDTRAY_CODE = transportTask.S_CNTRS;
                RfidChek.S_JBWBIT = transportTask.S_START_LOC;
                RfidChek.S_TRAY_TYPE = transportTask.S_TOOLS_TPYE;
                if (Supplier.noticeType == "4")
                {
                    RfidChek.S_NOTE = Supplier.result;
                    //RFID异常
                    if (transportTask.S_TYPE == "入库")
                    {
                        if (Supplier.code == "0")
                        {
                            RfidChek.S_RESULT = "RFID符合";
                        }
                        else
                        {
                            RfidChek.S_RESULT = "RFID不符!!!!!!";
                        }
                        try
                        {
                            newDb.BeginTran();
                            var ggf = newDb.Insertable(RfidChek).ExecuteCommand();
                            if (ggf == 0)
                            {
                                throw new Exception("影响行数为0");
                            }
                            newDb.CommitTran();
                        }
                        catch (Exception ex)
                        {
                            newDb.RollbackTran();
                            LogHelper.TaskDetail(logPara, "添加RFID效验结果表 失败：" + ex.Message);
                        }
                    }

                    if (taskNo.IndexOf('_') > 0)
                    {
                        string topNo = taskNo.Substring(0, taskNo.IndexOf("_"));
                        if (transportTask.S_TYPE == "入库")
                        {
                            var tac = newDb.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == topNo + "_1" && a.S_ACTION_CODE == "1002")?.First();
                            if (tac == null)
                            {
                                retu.code = "0";
                                retu.msg = "成功/success";
                                LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                                return retu;
                            }
                            else
                            {
                                if (Supplier.code == "0")
                                {
                                    NDCHelper.ChangeParam(topNo + "_1", 60000, 18);
                                    retu.code = "0";
                                    retu.msg = "成功/success";
                                    LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                                    return retu;
                                }
                                if (Supplier.code == "1")
                                {
                                    var transport = newDb.Queryable<WMSTask>().Where(e => e.S_TASK_NO == taskNo)?.First();
                                    if (transport == null)
                                    {
                                        throw new Exception($"未查询到任务{taskNo} 数据");
                                    }
                                    TN_Loc_AbnormalEntitys ent = null;
                                    if (transportTask.S_TOOLS_TPYE == "KJZ")
                                    {
                                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == transportTask.S_START_LOC + "-" + transportTask.S_TOOLS_TPYE)?.First();
                                    }
                                    else
                                    {
                                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == transportTask.S_TOOLS_TPYE)?.First();
                                    }
                                    if (ent == null)
                                    {
                                        throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                                    }
                                    if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                                    {
                                        throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                                    }
                                    int[] parms = { LocationHelper.GetAgvSiteZc(transport.S_END_LOC), LocationHelper.GetAgvSiteZc(ent.S_S_LOC_CODE) };
                                    NDCHelper.ChangeParam(taskNo, parms[0], 1);
                                    NDCHelper.ChangeParam(taskNo, parms[1], 2);
                                    NDCHelper.ChangeParam(taskNo, 1002, 18);
                                    var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(topNo + "_2", "取消", logPara);
                                    LogHelper.TaskDetail(logPara, "完工回报返回：" + JsonConvert.SerializeObject(ta));
                                    try
                                    {
                                        newDb.BeginTran();
                                        var I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == topNo).ExecuteCommand();//主任务
                                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == topNo + "_2").ExecuteCommand();//第二个子任务
                                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == topNo + "_1").ExecuteCommand();//第一个子任务
                                        if (I == 0)
                                        {
                                            throw new Exception("更新任务状态失败");
                                        }
                                        newDb.CommitTran();
                                    }
                                    catch (Exception ex)
                                    {
                                        LogHelper.TaskDetail(logPara, JsonConvert.SerializeObject(ex));
                                        newDb.RollbackTran();
                                        retu.code = "0";
                                        retu.msg = "成功/success";
                                        LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                                        return retu;
                                    }

                                    retu.code = "0";
                                    retu.msg = "成功/success";
                                    LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                                    return retu;
                                }
                            }
                        }
                        else
                        {
                            throw new Exception("该信号与任务类型不符合");
                        }
                    }
                    else
                    {
                        throw new Exception("该任务不是两段式任务");
                    }
                    retu.code = "0";
                    retu.msg = "成功/success";
                    LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                    return retu;
                }
                else
                {
                    if (Supplier.noticeType == "1")
                    {
                        //RFID正常
                        if (transportTask.S_TYPE == "入库")
                        {
                            RfidChek.S_RESULT = "RFID符合";
                            try
                            {
                                newDb.BeginTran();
                                var ggf = newDb.Insertable(RfidChek).ExecuteCommand();
                                if (ggf == 0)
                                {
                                    throw new Exception("影响行数为0");
                                }
                                newDb.CommitTran();
                            }
                            catch (Exception ex)
                            {
                                newDb.RollbackTran();
                                LogHelper.TaskDetail(logPara, "添加RFID效验结果表 失败：" + ex.Message);
                            }
                        }

                        SataeLis = "执行中";

                    }
                    else if (Supplier.noticeType == "2")
                    {
                        SataeLis = "完成";
                        if (transportTask.S_B_STATE == "完成")
                        {
                            retu.code = "0";
                            retu.msg = "成功/success";
                            LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                            return retu;
                        }
                    }
                    else if (Supplier.noticeType == "3")
                    {
                        retu.code = "0";
                        retu.msg = "成功/success";
                        LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                        return retu;
                    }
                    else if (Supplier.noticeType == "5")
                    {
                        SataeLis = "取货完成";
                        try
                        {
                            newDb.BeginTran();
                            var I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { S_B_STATE = SataeLis }).Where(x => x.S_TASK_NO == taskNo).ExecuteCommand();
                            if (I == 0)
                            {
                                throw new Exception("更新任务状态失败");
                            }
                            newDb.CommitTran();
                            retu.code = "0";
                            retu.msg = "成功/success";
                            LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                            return retu;
                        }
                        catch (Exception ex)
                        {
                            LogHelper.TaskDetail(logPara, JsonConvert.SerializeObject(ex));
                            newDb.RollbackTran();
                            retu.code = "1";
                            retu.msg = "更新任务状态失败";
                            LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                            return retu;
                        }


                    }
                    else if (Supplier.noticeType == "7")
                    {
                        SataeLis = "取消";
                        if (transportTask.S_TYPE == "入库")
                        {
                            var tTask = newDb.Queryable<WMSTask>().Where(e => e.S_TASK_NO == transportTask.S_SRC_NO + "_1")?.First();
                            if (tTask != null)
                            {
                                if (!tTask.S_B_STATE.Trim().Equals("完成") && !tTask.S_B_STATE.Trim().Equals("取消"))
                                {
                                    throw new Exception("先把小车任务完成了,才能取消立库任务！");
                                }
                            }

                        }
                    }
                    var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(taskNo, SataeLis, logPara, transportTask);
                    LogHelper.TaskDetail(logPara, $"完工回报返回 {taskNo}：" + JsonConvert.SerializeObject(ta));
                    if (ta.Success)
                    {
                        retu.code = "0";
                        retu.msg = "成功/success";
                    }
                    else
                    {
                        throw new Exception(ta.Msg);
                    }
                }
                LogHelper.TaskDetail(logPara, $"接口返回 {taskNo}   {DateTime.Now}");
                return retu;
            }
            catch (Exception ex)
            {
                LogHelper.TaskDetail(logPara, "完工回报报错：" + JsonConvert.SerializeObject(ex));
                retu.code = "1";
                retu.msg = ex.Message;
                CwLine("完工回报报错：" + JsonConvert.SerializeObject(ex));
                return retu;
            }

        }
        public static Dictionary<int, string> SataeList = new Dictionary<int, string>()
        {
            {1,"执行中"},//开始执行
            {3 ,"开始取货"},//开始取货
            {4 ,"取货完成"},//取货完成
            {5 ,"开始卸货"},//开始卸货
            {6 ,"卸货完成"},//卸货完成
            {2 ,"完成"},//完成
            {7 ,"取消"},//取消
             {22 ,"完成"},//完成
        };
        #endregion

        #region MES任务取消接口

        /// <summary>
        /// MES任务取消接口
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("CancelWorkArea")]
        public OperateResult CancelWorkArea(dynamic jsonData)
        {
            LogHelper.Info("任务下发", "MES下发取消参数:" + JsonConvert.SerializeObject(jsonData));
            try
            {
                MesItemList sendTaskEntity = JsonConvert.DeserializeObject<MesItemList>(jsonData.ToString());
                var SataeLis = SataeList[7];
                var logPara = LogType.LogPara("完工回报");
                if (string.IsNullOrEmpty(sendTaskEntity.task_no))
                {
                    throw new Exception("任务号为空");
                }
                var tno = sendTaskEntity.task_no;
                var tasklist = new List<string> { tno, tno + "_1", tno + "_2" };
                var Wmtask = SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => tasklist.Contains(e.S_TASK_NO)).ToList();
                if (Wmtask.Count() == 0)
                {
                    throw new Exception("未查询到此任务");
                }
                var Z_task = Wmtask.Find(e => e.S_TASK_NO == tno);
                if (Z_task.S_TYPE != "入库")
                {
                    throw new Exception("只能取消入库任务");
                }
                if (Z_task.S_B_STATE == "未执行")
                {
                    var tas = Wmtask.Find(e => e.S_TASK_NO == tno);
                    return BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(tno, SataeLis, logPara, tas, "MES");
                }
                else
                {
                    //查询一段子任务的状态是什么状态
                    var task_1 = Wmtask.Find(e => e.S_TASK_NO == tno + "_1") ?? throw new Exception("未查询到对应的agv子任务");

                    if (task_1.S_B_STATE == "未执行" || task_1.S_B_STATE == "已推送" || task_1.S_B_STATE == "执行中")
                    {
                        return BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(task_1.S_TASK_NO, SataeLis, logPara, task_1, "MES");
                    }
                    else
                    {
                        throw new Exception("当前任务已经处于执行状态了,请勿取消");
                    }
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info("任务下发", "取消任务报错:" + ex.Message);
                return OperateResult.Error(ex.Message);
            }
        }

        #endregion
        #region ts切换路线
        /// <summary>
        /// ts切换路线
        /// </summary>
        /// <param name="ON">开关 Y打开  N关闭</param>
        /// <param name="DicName">参数0 字段</param>
        /// <returns></returns>
        [HttpGet]
        [Route("TsChangeRoute")]
        public OperateResult TsChangeRoute(string ON, string DicName)
        {
            var Result = OperateResult.Succeed();
            try
            {
                LogHelper.DanInfo("ts切换路线", $"入参:ON={ON} ");
                var dic = new Dictionary<string, string>();
                var dic1 = new Dictionary<string, string>();
                dic.Add("Pri", "0");
                dic.Add("No", "1");
                if (ON == "Y")
                {

                    dic1.Add($"{DicName}", "0");
                    var res = NDC.OrderAdd(82, dic, dic1);
                    if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                    {
                        Result = OperateResult.Succeed("发送成功");
                    }
                    else
                    {
                        Result = OperateResult.Error("发送失败");
                    }
                }
                else if (ON == "N")
                {
                    dic1.Add($"{DicName}", "1");
                    var res = NDC.OrderAdd(82, dic, dic1);
                    if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                    {
                        Result = OperateResult.Succeed("发送成功");
                    }
                    else
                    {
                        Result = OperateResult.Error("发送失败");
                    }
                }
                else
                {
                    Result = OperateResult.Error("无效信号");
                }
                return Result;
            }
            catch (Exception ex)
            {
                Result = OperateResult.Error("异常信息:" + ex.Message);
                LogHelper.DanInfo("ts切换路线", "异常信息:" + ex.Message);
                return Result;
            }
        }
        #endregion

        #region 供应商维护
        /// <summary>
        /// 供应商添加
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SJsupplierMainAdd")]
        public OperateResult SJsupplierMainAdd(dynamic jsonData)
        {
            LogHelper.Info("供应商维护", "添加入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_SupplierEntitys> Supplier = JsonConvert.DeserializeObject<List<TN_SupplierEntitys>>(jsonData.ToString());
                SupplierHelper supplier = new SupplierHelper();
                result = supplier.SJsupplierMainAdd(Supplier);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("供应商维护", "添加--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }


        /// <summary>
        /// 供应商删除
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SJsupplierMainDelete")]
        public OperateResult SJsupplierMainDelete(dynamic jsonData)
        {
            LogHelper.Info("供应商维护", "删除入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_SupplierEntitys> Supplier = JsonConvert.DeserializeObject<List<TN_SupplierEntitys>>(jsonData.ToString());
                SupplierHelper supplier = new SupplierHelper();
                result = supplier.SJsupplierMainDelete(Supplier);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("供应商维护", "删除--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        /// <summary>
        /// 供应商查询
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SJsupplierMainSelect")]
        public OperateResult SJsupplierMainSelect(dynamic jsonData)
        {
            LogHelper.Info("供应商维护", "查询入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                SupplierMainDto Supplier = JsonConvert.DeserializeObject<SupplierMainDto>(jsonData.ToString());
                SupplierHelper supplier = new SupplierHelper();
                result = supplier.SJsupplierMainSelect(Supplier);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("供应商维护", "查询--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        /// <summary>
        /// 供应商更新
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SJsupplierMainUpdate")]
        public OperateResult SJsupplierMainUpdate(dynamic jsonData)
        {
            LogHelper.Info("供应商维护", "更新入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_SupplierEntitys> Supplier = JsonConvert.DeserializeObject<List<TN_SupplierEntitys>>(jsonData.ToString());
                SupplierHelper supplier = new SupplierHelper();
                result = supplier.SJsupplierMainUpdate(Supplier);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("供应商维护", "更新--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }
        #endregion

        #region 物料维护

        /// <summary>
        /// 增
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SjMaterialMainAdd")]
        public OperateResult SjMaterialMainAdd(dynamic jsonData)
        {
            LogHelper.Info("物料维护", "添加入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_MaterialEntitys> mater = JsonConvert.DeserializeObject<List<TN_MaterialEntitys>>(jsonData.ToString());
                MaterialHelper supplier = new MaterialHelper();
                result = supplier.SjMaterialMainAdd(mater);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("物料维护", "添加--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        /// <summary>
        /// 删
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SjMaterialMainDelete")]
        public OperateResult SjMaterialMainDelete(dynamic jsonData)
        {
            LogHelper.Info("物料维护", "删除入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_MaterialEntitys> mater = JsonConvert.DeserializeObject<List<TN_MaterialEntitys>>(jsonData.ToString());
                MaterialHelper supplier = new MaterialHelper();
                result = supplier.SjMaterialMainDelete(mater);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("物料维护", "删除--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        /// <summary>
        /// 改
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SjMaterialMainUpdate")]
        public OperateResult SjMaterialMainUpdate(dynamic jsonData)
        {
            LogHelper.Info("物料维护", "更新入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                List<TN_MaterialEntitys> mater = JsonConvert.DeserializeObject<List<TN_MaterialEntitys>>(jsonData.ToString());
                MaterialHelper supplier = new MaterialHelper();
                result = supplier.SjMaterialMainUpdate(mater);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("物料维护", "更新--" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        /// <summary>
        /// 查
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SjMaterialMainSelect")]
        public OperateResult SjMaterialMainSelect(dynamic jsonData)
        {
            LogHelper.Info("物料维护", "查询入参--" + jsonData.ToString());
            try
            {
                OperateResult result = new OperateResult();
                MaterialMainDto Supplier = JsonConvert.DeserializeObject<MaterialMainDto>(jsonData.ToString());
                MaterialHelper supplier = new MaterialHelper();
                result = supplier.SjMaterialMainSelect(Supplier);
                return result;
            }
            catch (System.Exception ex)
            {
                LogHelper.Info("物料维护", "查询:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        #endregion

        #region 托盘解码

        /// <summary>
        /// 16进制 ASCII 码转换
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("HexToStr")]
        public string HexToStr(string hexString)
        {
            hexString = hexString.Replace(" ", "");
            if ((hexString.Length % 2) != 0)
                hexString += " ";
            byte[] returnBytes = new byte[hexString.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);

            return Encoding.ASCII.GetString(returnBytes);
        }
        #endregion

        #region 物料品质修改
        /// <summary>
        /// 物料品质修改
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SjUpdateItemState")]
        public OperateResult SjUpdateItemState(dynamic jsonData)
        {
            LogHelper.Info("物料品质修改", "入参--" + jsonData.ToString());
            try
            {

                OperateResult result = new OperateResult();
                UpdateItemStateDto Vendor = JsonConvert.DeserializeObject<UpdateItemStateDto>(jsonData.ToString());
                if (string.IsNullOrEmpty(Vendor.flot))
                {
                    result.Success = false;
                    result.Msg = "批次号为空!";
                    result.Code = "-1";
                    return result;
                }
                var ItemList = SqlSugarHelper.Db.Queryable<CntrItemRel>().Where(e => e.S_BATCH_NO == Vendor.flot).ToList();
                if (ItemList.Count() == 0)
                {
                    result.Success = false;
                    result.Msg = "未查询到该批次号的物料信息-1！";
                    result.Code = "-1";
                    return result;
                }
                CntrItemRelHelper CntrItem = new CntrItemRelHelper();
                result = CntrItem.SjUpdateItemState_CntrItemRelUpdate(Vendor);

                return result;
            }
            catch (Exception ex)
            {

                LogHelper.Info("物料品质修改", "报错:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }

        #endregion

        #region 入库
        /// <summary>
        /// 入库
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("InWorkArea")]
        public OperateResult InWorkArea(List<InWorkAreaEntity> InWorkArea)
        {
            try
            {
                OperateResult result = OperateResult.Succeed();
                LogHelper.Info("入库", "入参--" + JsonConvert.SerializeObject(InWorkArea));
                result = BLLCreator.CreateSingleton<InWorkAreaBll>().InWorkArea(InWorkArea);
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("入库", "报错:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }
        #endregion

        #region 出库
        /// <summary>
        /// 出库
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("OutWorkArea")]
        public OperateResult OutWorkArea(List<OutWorkAreaEntity> OutWorkArea)
        {
            try
            {
                OperateResult result = OperateResult.Succeed();
                LogHelper.Info("出库", "入参--" + JsonConvert.SerializeObject(OutWorkArea));
                result = BLLCreator.CreateSingleton<OutWorkAreaBll>().OutWorkArea(OutWorkArea);
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("出库", "报错:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }


        }
        #endregion

        #region 确定入库托盘信息
        /// <summary>
        /// 确定入库托盘信息
        /// </summary>
        /// <param name="Supplier"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcWcsInTrayAffirm")]
        public ReturnValue ZcWcsInTrayAffirm(WcsTaskState Supplier)
        {
            ReturnValue ret = new ReturnValue();
            LogHelper.DanInfo("确定入库托盘信息", "入参--" + JsonConvert.SerializeObject(Supplier));
            ret.requestPk = Supplier.requestPk;
            try
            {
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                //1检查参数
                if (string.IsNullOrEmpty(Supplier.curPos))
                {
                    throw new Exception("当前位置为空");
                }
                if (string.IsNullOrEmpty(Supplier.noticeType))
                {
                    throw new Exception("状态标识为空");
                }
                if (Supplier.noticeType != "1" && Supplier.noticeType != "4")
                {
                    throw new Exception("状态标识只能为 1或4");
                }
                List<string> state = new List<string>() { "卸货完成" };
                var taskhh = newDb.Queryable<WMSTask>().Where(a => state.Contains(a.S_B_STATE) && a.S_NOTE == "agv任务" && a.S_END_LOC == Supplier.curPos)?.First();
                if (taskhh == null)
                {
                    throw new Exception($"未找到任务终点为{Supplier.curPos} 并且任务状态为卸货完成的小车任务");
                }
                var TaskList = newDb.Queryable<WMSTask>().Where(e => e.S_SRC_NO == taskhh.S_SRC_NO).ToList();
                var TraySta = taskhh.S_TOOLS_TPYE;
                if (Supplier.TrayState == 2)
                {
                    TraySta = TraySta + "-BD";
                }
                else if (Supplier.TrayState == 3)
                {
                    TraySta = "KJZ";
                }
                if (Supplier.noticeType == "1")//正常托盘
                {
                    if (string.IsNullOrEmpty(Supplier.contNo))
                    {
                        throw new Exception("工装编号为空");
                    }
                    //获取物料信息,判断空满 
                    CntrItemRel rel = new CntrItemRel();
                    MesResponseResultTwo qe = BLLCreator.CreateSingleton<MesTask>().SelectItemList(Supplier.contNo, taskhh.S_SRC_NO);
                    if (qe == null || qe.data == null)
                    {
                        throw new Exception("调用MES接口获取托盘物料信息失败,未获取到数据");
                    }
                    else if (qe.data.currentAmount > 50)
                    {
                        var trayItemMstGuid = Guid.NewGuid().ToString();
                        //添加托盘物料关联表
                        rel.S_ITEM_CODE = qe.data?.prodNo;
                        rel.S_ITEM_NAME = qe.data?.prodName;
                        rel.S_CNTR_CODE = Supplier.contNo;
                        rel.TurnCardNum = qe.data?.turnoverNo;
                        rel.Level = qe.data?.prodName;
                        rel.itemModel = qe.data?.prodSpec;
                        rel.expireTime = qe.data.expiredTime;
                        rel.takeEffectTime = qe.data.shelfLifeTime;
                        rel.F_QTY = Convert.ToDecimal(qe.data.currentAmount);
                        rel.S_ITEM_STATE = qe.data?.prodSelfCheck;
                        rel.productionDate = qe.data.produceTime;
                        rel.S_ITEM_SPEC = qe.data?.prodSpec;
                        rel.applyProdSpecList = qe.data?.applyProdSpecList;
                        rel.T_INSTOCK = DateTime.Now;
                    }

                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Deleteable<CntrItemRel>().Where(e => e.S_CNTR_CODE == Supplier.contNo).ExecuteCommand();//先删
                        LogHelper.DanInfo("确定入库托盘信息", "有没有物料都先删一次-- 托盘:" + Supplier.contNo + " 影响行数:" + I);
                        if (!string.IsNullOrEmpty(rel.S_ITEM_CODE))
                        {
                            I = newDb.Insertable(rel).ExecuteCommand();// 后加
                            LogHelper.DanInfo("确定入库托盘信息", "添加物料--" + JsonConvert.SerializeObject(rel) + " 影响行数:" + I);
                        }

                        //修改任务号上的托盘

                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { S_CNTRS = Supplier.contNo, S_TOOLS_TPYE = TraySta }).Where(x => x.S_SRC_NO == taskhh.S_SRC_NO).ExecuteCommand();
                        LogHelper.DanInfo("确定入库托盘信息", "修改任务托盘码--S_CNTRS:" + Supplier.contNo + " 托盘类型:" + TraySta + "修改条件 S_SRC_NO:" + taskhh.S_SRC_NO + " 影响行数:" + I);
                        newDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        newDb.RollbackTran();
                        LogHelper.DanInfo("确定入库托盘信息", "更新任务托盘及添加物料信息报错--" + ex.Message);
                    }

                    var tac = SqlSugarHelper.Db.Queryable<WmsTaskAction>().Where(a => a.S_TASK_NO == taskhh.S_TASK_NO && a.S_ACTION_CODE == "1002")?.First();
                    if (tac == null)
                    {
                        ret.code = "0";
                        ret.msg = "成功/success";
                        return ret;
                    }
                    else
                    {
                        NDCHelper.ChangeParam(taskhh.S_TASK_NO, 60000, 18);
                        ret.code = "0";
                        ret.msg = "成功/success";
                        return ret;
                    }
                }
                else//异常托盘
                {
                    var LikuTask = TaskList.Find(e => e.S_NOTE == "立库任务");
                    //RFID异常
                    WcsRfidCheckoutEntitys RfidChek = new WcsRfidCheckoutEntitys();
                    RfidChek.S_TASK_NO = LikuTask.S_SRC_NO;
                    RfidChek.S_NEWTRAY_CODE = Supplier.contNo;
                    RfidChek.S_OLDTRAY_CODE = LikuTask.S_CNTRS;
                    RfidChek.S_JBWBIT = Supplier.curPos;
                    RfidChek.S_TRAY_TYPE = LikuTask.S_TOOLS_TPYE;
                    RfidChek.S_NOTE = Supplier.result;
                    RfidChek.S_RESULT = "RFID异常(无托盘码入库)!!!!!!";
                    try
                    {
                        newDb.BeginTran();
                        var ggf = newDb.Insertable(RfidChek).ExecuteCommand();
                        if (ggf == 0)
                        {
                            throw new Exception("影响行数为0");
                        }
                        newDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        newDb.RollbackTran();
                        LogHelper.DanInfo("确定入库托盘信息", "添加RFID效验结果表 失败：" + ex.Message);
                    }
                    TN_Loc_AbnormalEntitys ent = null;
                    if (TraySta == "KJZ")
                    {
                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == taskhh.S_END_LOC + "-" + TraySta)?.First();
                    }
                    else
                    {
                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == TraySta)?.First();
                    }
                    if (ent == null)
                    {
                        throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                    }
                    if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                    {
                        throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                    }
                    var logPara = LogType.LogPara("完工回报");
                    int[] parms = { LocationHelper.GetAgvSiteZc(taskhh.S_END_LOC), LocationHelper.GetAgvSiteZc(ent.S_S_LOC_CODE) };
                    NDCHelper.ChangeParam(taskhh.S_TASK_NO, parms[0], 1);
                    NDCHelper.ChangeParam(taskhh.S_TASK_NO, parms[1], 2);
                    NDCHelper.ChangeParam(taskhh.S_TASK_NO, 1002, 18);
                    var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(LikuTask.S_TASK_NO, "取消", logPara);
                    LogHelper.TaskDetail(logPara, "完工回报返回：" + JsonConvert.SerializeObject(ta));
                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == LikuTask.S_SRC_NO).ExecuteCommand();//主任务
                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == LikuTask.S_TASK_NO).ExecuteCommand();//第二个子任务
                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_TASK_NO == taskhh.S_TASK_NO).ExecuteCommand();//第一个子任务
                        if (I == 0)
                        {
                            throw new Exception("更新任务状态失败");
                        }
                        newDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        LogHelper.TaskDetail(logPara, JsonConvert.SerializeObject(ex));
                        newDb.RollbackTran();
                        ret.code = "0";
                        ret.msg = "成功/success";
                        return ret;
                    }
                }
                return ret;
            }
            catch (Exception ex)
            {
                LogHelper.DanInfo("确定入库托盘信息", "报错--" + ex.Message);
                return ret;
            }
        }

        /// <summary>
        /// wms-->wcs 获取托盘信息
        /// </summary>
        public OperateResult ZcInTrayAffirm(WMSTask task)
        {
            try
            {
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                var TaskList = newDb.Queryable<WMSTask>().Where(e => e.S_SRC_NO == task.S_SRC_NO).ToList();
                var TaskAgv = TaskList.Find(e => e.S_NOTE == "agv任务");
                var LikuTask = TaskList.Find(e => e.S_NOTE == "立库任务");
                var ZgTask = TaskList.Find(e => e.S_NOTE == "自管任务");
                var TraySta = task.S_TOOLS_TPYE;
                var Wcs = BLLCreator.Create<WcsTask>().WcsgetContNo(TaskAgv);
                if (Wcs.code == "0")
                {
                    //2调用mes接口获取物料
                    CntrItemRel rel = new CntrItemRel();

                    if (Wcs.contType == "2")
                    {
                        TraySta = TraySta + "-BD";
                    }
                    else if (Wcs.contType == "3")
                    {
                        TraySta = "KJZ";
                    }
                    if (!string.IsNullOrEmpty(Wcs.contNo))
                    {
                        MesResponseResultTwo qe = BLLCreator.CreateSingleton<MesTask>().SelectItemList(Wcs.contNo, LikuTask.S_TASK_NO);
                        bool ggf = false;
                        if ((TraySta == "15" && qe.data.currentAmount > 3) ||
                            ((TraySta == "25" || TraySta == "35" || TraySta == "45" || TraySta == "55") && qe.data.currentAmount > 5) ||
                            ((TraySta == "95" || TraySta == "85") && qe.data.currentAmount > 50) || (TraySta == "65" && qe.data.currentAmount > 2))
                        {
                            ggf = true;
                        }
                        if (qe != null && qe.data != null && ggf)
                        {
                            var trayItemMstGuid = Guid.NewGuid().ToString();
                            //添加托盘物料关联表
                            rel.S_ITEM_CODE = qe.data?.prodNo;
                            rel.S_ITEM_NAME = qe.data?.prodName;
                            rel.S_CNTR_CODE = Wcs.contNo;
                            rel.TurnCardNum = qe.data?.turnoverNo;
                            rel.Level = qe.data?.prodName;
                            rel.itemModel = qe.data?.prodSpec;
                            rel.expireTime = qe.data.expiredTime;
                            rel.takeEffectTime = qe.data.shelfLifeTime;
                            rel.F_QTY = Convert.ToDecimal(qe.data.currentAmount);
                            rel.S_ITEM_STATE = qe.data?.prodSelfCheck;
                            rel.productionDate = qe.data.produceTime;
                            rel.S_ITEM_SPEC = qe.data?.prodSpec;
                            rel.applyProdSpecList = qe.data?.applyProdSpecList;
                            rel.T_INSTOCK = DateTime.Now;
                        }
                        try
                        {
                            newDb.BeginTran();
                            var I = newDb.Deleteable<CntrItemRel>().Where(e => e.S_CNTR_CODE == Wcs.contNo).ExecuteCommand();//先删
                            LogHelper.DanInfo("确定入库托盘信息", "有没有物料都先删一次-- 托盘:" + Wcs.contNo + " 影响行数:" + I);
                            if (!string.IsNullOrEmpty(rel.S_ITEM_CODE))
                            {
                                I = newDb.Insertable(rel).ExecuteCommand();// 后加
                                LogHelper.DanInfo("确定入库托盘信息", "添加物料--" + JsonConvert.SerializeObject(rel) + " 影响行数:" + I);
                            }
                            //修改任务号上的托盘
                            var F = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { S_CNTRS = Wcs.contNo, S_TOOLS_TPYE = TraySta }).Where(x => x.S_ID == ZgTask.S_ID).ExecuteCommand();
                            LogHelper.DanInfo("确定入库托盘信息", "修改任务托盘码--S_CNTRS:" + Wcs.contNo + " 托盘类型:" + TraySta + "修改条件 S_SRC_NO:" + task.S_SRC_NO + " 影响行数:" + F);
                            F = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { S_CNTRS = Wcs.contNo, S_TOOLS_TPYE = TraySta }).Where(x => x.S_ID == LikuTask.S_ID).ExecuteCommand();
                            F = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { S_CNTRS = Wcs.contNo, S_TOOLS_TPYE = TraySta }).Where(x => x.S_ID == TaskAgv.S_ID).ExecuteCommand();
                            newDb.CommitTran();
                        }
                        catch (Exception ex)
                        {
                            newDb.RollbackTran();
                            LogHelper.DanInfo("确定入库托盘信息", "更新任务托盘及添加物料信息报错--" + ex.Message);
                            return OperateResult.Error();
                        }
                        return OperateResult.Succeed();

                    }
                    else
                    {

                        //RFID异常
                        WcsRfidCheckoutEntitys RfidChek = new WcsRfidCheckoutEntitys();
                        RfidChek.S_TASK_NO = LikuTask.S_SRC_NO;
                        RfidChek.S_NEWTRAY_CODE = Wcs.contNo;
                        RfidChek.S_OLDTRAY_CODE = LikuTask.S_CNTRS;
                        RfidChek.S_JBWBIT = task.S_Jb_Bit;
                        RfidChek.S_TRAY_TYPE = LikuTask.S_TOOLS_TPYE;
                        RfidChek.S_NOTE = Wcs.msg;
                        RfidChek.S_RESULT = "RFID异常(无托盘码入库)!!!!!!";
                        try
                        {
                            newDb.BeginTran();
                            var ggf = newDb.Insertable(RfidChek).ExecuteCommand();
                            if (ggf == 0)
                            {
                                throw new Exception("影响行数为0");
                            }
                            newDb.CommitTran();
                        }
                        catch (Exception ex)
                        {
                            newDb.RollbackTran();
                            LogHelper.DanInfo("确定入库托盘信息", "添加RFID效验结果表 失败：" + ex.Message);
                        }
                        TN_Loc_AbnormalEntitys ent = null;
                        if (TraySta == "KJZ")
                        {
                            ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == task.S_END_LOC + "-" + TraySta)?.First();
                        }
                        else
                        {
                            ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == TraySta)?.First();
                        }
                        if (ent == null)
                        {
                            throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                        }
                        if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                        {
                            throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                        }
                        var logPara = LogType.LogPara("完工回报");
                        int[] parms = { LocationHelper.GetAgvSiteZc(TaskAgv.S_END_LOC), LocationHelper.GetAgvSiteZc(ent.S_S_LOC_CODE) };
                        NDCHelper.ChangeParam(task.S_SRC_NO + "_1", parms[0], 1);
                        NDCHelper.ChangeParam(task.S_SRC_NO + "_1", parms[1], 2);
                        NDCHelper.ChangeParam(task.S_SRC_NO + "_1", 1002, 18);
                        var endloca = LocationHelper.LocationCodeJbw(ent.S_S_LOC_CODE);
                        var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(LikuTask.S_TASK_NO, "取消", logPara);
                        LogHelper.TaskDetail(logPara, "完工回报返回：" + JsonConvert.SerializeObject(ta));
                        try
                        {
                            newDb.BeginTran();
                            var I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_ID == ZgTask.S_ID).ExecuteCommand();//主任务
                            I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_ID == LikuTask.S_ID).ExecuteCommand();//第二个子任务
                            I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask()
                            {
                                mark = "Y",
                                S_START_LOC = TaskAgv.S_Jb_Bit,
                                S_START_LAREA = task.S_END_LAREA,
                                S_END_LOC = ent.S_S_LOC_CODE,
                                S_END_LAREA = endloca.S_AREA_CODE,
                                S_Subtask = "N"
                            }).Where(x => x.S_ID == TaskAgv.S_ID).ExecuteCommand();//第一个子任务
                            if (I == 0)
                            {
                                throw new Exception("更新任务状态失败");
                            }
                            newDb.CommitTran();
                        }
                        catch (Exception ex)
                        {
                            LogHelper.DanInfo("确定入库托盘信息", "修改任务RFID验证状态和改道:" + ex.Message);
                            newDb.RollbackTran();
                            return OperateResult.Error();
                        }
                        return OperateResult.Succeed();
                    }
                }
                else if (Wcs.code == "1")
                {
                    //RFID异常
                    WcsRfidCheckoutEntitys RfidChek = new WcsRfidCheckoutEntitys();
                    RfidChek.S_TASK_NO = LikuTask.S_SRC_NO;
                    RfidChek.S_NEWTRAY_CODE = Wcs.contNo;
                    RfidChek.S_OLDTRAY_CODE = LikuTask.S_CNTRS;
                    RfidChek.S_JBWBIT = task.S_Jb_Bit;
                    RfidChek.S_TRAY_TYPE = LikuTask.S_TOOLS_TPYE;
                    RfidChek.S_NOTE = Wcs.msg;
                    RfidChek.S_RESULT = "RFID异常(无托盘码入库)!!!!!!";
                    try
                    {
                        newDb.BeginTran();
                        var ggf = newDb.Insertable(RfidChek).ExecuteCommand();
                        if (ggf == 0)
                        {
                            throw new Exception("影响行数为0");
                        }
                        newDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        newDb.RollbackTran();
                        LogHelper.DanInfo("确定入库托盘信息", "添加RFID效验结果表 失败：" + ex.Message);
                    }
                    TN_Loc_AbnormalEntitys ent = null;
                    if (TraySta == "KJZ")
                    {
                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == task.S_END_LOC + "-" + TraySta)?.First();
                    }
                    else
                    {
                        ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == TraySta)?.First();
                    }
                    if (ent == null)
                    {
                        throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                    }
                    if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                    {
                        throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                    }
                    var logPara = LogType.LogPara("完工回报");
                    int[] parms = { LocationHelper.GetAgvSiteZc(TaskAgv.S_END_LOC), LocationHelper.GetAgvSiteZc(ent.S_S_LOC_CODE) };
                    NDCHelper.ChangeParam(task.S_SRC_NO + "_1", parms[0], 1);
                    NDCHelper.ChangeParam(task.S_SRC_NO + "_1", parms[1], 2);
                    NDCHelper.ChangeParam(task.S_SRC_NO + "_1", 1002, 18);
                    var endloca = LocationHelper.LocationCodeJbw(ent.S_S_LOC_CODE);
                    var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(LikuTask.S_TASK_NO, "取消", logPara);
                    LogHelper.TaskDetail(logPara, "完工回报返回：" + JsonConvert.SerializeObject(ta));
                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_ID == ZgTask.S_ID).ExecuteCommand();//主任务
                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask() { mark = "Y" }).Where(x => x.S_ID == LikuTask.S_ID).ExecuteCommand();//第二个子任务
                        I = newDb.Updateable<WMSTask>().SetColumns(it => new WMSTask()
                        {
                            mark = "Y",
                            S_START_LOC = TaskAgv.S_Jb_Bit,
                            S_START_LAREA = task.S_END_LAREA,
                            S_END_LOC = ent.S_S_LOC_CODE,
                            S_END_LAREA = endloca.S_AREA_CODE,
                            S_Subtask = "N"
                        }).Where(x => x.S_ID == TaskAgv.S_ID).ExecuteCommand();//第一个子任务
                        if (I == 0)
                        {
                            throw new Exception("更新任务状态失败");
                        }
                        newDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        LogHelper.DanInfo("确定入库托盘信息", "修改任务RFID验证状态和改道:" + ex.Message);
                        newDb.RollbackTran();
                        return OperateResult.Error();
                    }
                    return OperateResult.Succeed();
                }
                else
                {
                    LogHelper.DanInfo("确定入库托盘信息", "获取失败:" + Wcs.msg);
                    throw new Exception($"获取失败  {Wcs.msg}");
                }
            }
            catch (Exception ex)
            {
                LogHelper.DanInfo("确定入库托盘信息", "报错--" + JsonConvert.SerializeObject(ex));
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 更换终点--改道--入库
        /// <summary>
        /// 更换终点
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcInChangeBit")]
        public ReturnValue ZcInChangeBit(dynamic jsonData)
        {
            ReturnValue result = new ReturnValue();
            LogHelper.Info("更换终点", "入库改道--入参--" + jsonData.ToString());
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            result.requestPk = Supplier.requestPk;
            try
            {
                if (string.IsNullOrEmpty(Supplier.taskNo))
                {
                    throw new Exception("任务号为空");
                }
                var tra = BLLCreator.Create<ZCBLL>().GetDndLocation(Supplier);
                if (string.IsNullOrEmpty(tra?.S_LOC_CODE) || tra?.S_LOC_CODE == "101")
                {
                    throw new Exception("空货位不足!");
                }
                result.code = "0";
                result.msg = tra?.S_LOC_CODE;
                LogHelper.Info("更换终点", "返回--" + JsonConvert.SerializeObject(result));
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("更换终点", "报错:" + ex.Message + ex.StackTrace);
                result.code = "-1";
                result.msg = ex.Message;
                return result;
            }
        }
        #endregion

        #region 更换起点--改道--出库
        /// <summary>
        /// 更换终点
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcOutChangeBit")]
        public ReturnValue ZcOutChangeBit(dynamic jsonData)
        {
            ReturnValue result = new ReturnValue();
            LogHelper.Info("更换起点", "出库改道--入参--" + jsonData.ToString());
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            result.requestPk = Supplier.requestPk;
            try
            {
                if (string.IsNullOrEmpty(Supplier.taskNo))
                {
                    throw new Exception("任务号为空");
                }
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                var Task = Expressionable.Create<WMSTask>();
                Task.And(it => it.S_TASK_NO == Supplier.taskNo);
                var Tasks = newDb.Queryable<WMSTask>().Where(Task.ToExpression())?.First() ?? throw new Exception("未查询到该任务 任务号为:" + Supplier.taskNo);

                try
                {
                    newDb.BeginTran();
                    var C = newDb.Updateable<Location>().SetColumns(it => new Location
                    {
                        S_LOCK_STATE = "异常锁"
                    }).Where(x => x.S_LOC_CODE == Tasks.S_START_LOC).ExecuteCommand();
                    if (C == 0)
                    {
                        throw new Exception("起点 改异常锁失败");
                    }
                    newDb.CommitTran();
                }
                catch (Exception ex)
                {
                    newDb.RollbackTran();
                    LogHelper.Info("更换终点", "报错--" + ex.Message);
                }
                var logPara = LogType.LogPara("完工回报");
                var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(Supplier.taskNo, "取消", logPara);
                result.code = "0";
                result.msg = "任务取消成功";
                LogHelper.Info("更换起点", "返回--" + JsonConvert.SerializeObject(result));
                return result;
                //var tra = BLLCreator.Create<ZCBLL>().GetStaLocation(Supplier);
                //var logPara = LogType.LogPara("完工回报");
                //var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(Supplier.taskNo, "取消", logPara);
                //if (string.IsNullOrEmpty(tra?.S_LOC_CODE) || tra?.S_LOC_CODE == "102")
                //{
                //    var logPara = LogType.LogPara("完工回报");
                //    var ta = BLLCreator.CreateSingleton<StateTaskBLL>().ExecuteState(Supplier.taskNo, "取消", logPara);
                //    LogHelper.Info("更换起点", " 改道失败,异常任务 系统取消");
                //    throw new Exception("库存不足!");
                //}
                //else
                //{
                //    var Ta = SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => e.S_TASK_NO == Supplier.taskNo)?.First();
                //    var re1 = BLLCreator.CreateSingleton<WcsTask>().WcsCancellTask(Ta);
                //    var re = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(Ta);
                //    LogHelper.Info("更换终点", "重新下达任务给立库-- 返回:" + JsonConvert.SerializeObject(re));
                //}
                //result.code = "0";
                //result.msg = tra?.S_LOC_CODE;
                //LogHelper.Info("更换起点", "返回--" + JsonConvert.SerializeObject(result));
                //return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("更换终点", "报错:" + ex.Message + ex.StackTrace);
                result.code = "-1";
                result.msg = ex.Message;
                return result;
            }
        }
        #endregion
        #region 申请安全进入
        /// <summary>
        /// 申请安全进入
        /// </summary>
        /// <param name="State"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcSafetyRequest")]
        public ReturnValue ZcSafetyRequest(WcsTaskState State)
        {
            var logPara = LogType.LogPara("完工回报");
            LogHelper.TaskDetail(logPara, "立库安全请求参数：" + JsonConvert.SerializeObject(State));
            ReturnValue retu = new ReturnValue();
            retu.requestPk = State.requestPk;
            try
            {
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                if (State.isAllow == "1")
                {
                    var transportTask = newDb.Queryable<WMSTask>().Where(e => e.S_TASK_NO == State.requestPk)?.First();
                    if (transportTask == null)
                    {
                        throw new Exception("未查询到该任务");
                    }

                    if (transportTask.S_TYPE == "入库" && !string.IsNullOrEmpty(transportTask.mark))
                    {
                        if (State.clientType == "1")
                        {
                            NDCHelper.ChangeParam(State.requestPk, 1101, 18);
                        }
                    }
                    else if (transportTask.S_TYPE == "入库")
                    {
                        if (State.clientType == "1")
                        {
                            NDCHelper.ChangeParam(State.requestPk, 1103, 18);
                        }
                    }
                    else if (transportTask.S_TYPE == "出库")
                    {
                        if (State.clientType == "1")
                        {
                            NDCHelper.ChangeParam(State.requestPk, 1101, 18);
                        }
                    }
                }
                retu.code = "0";
                retu.msg = "成功/success";
                LogHelper.TaskDetail(logPara, $"接口返回 {State.requestPk}   {DateTime.Now}");
                return retu;
            }
            catch (Exception ex)
            {
                LogHelper.TaskDetail(logPara, "立库安全请求报错：" + JsonConvert.SerializeObject(ex));
                retu.code = "1";
                retu.msg = ex.Message;
                LogHelper.TaskDetail(logPara, $"接口返回 {State.requestPk}   {DateTime.Now}");
                return retu;
            }
        }
        #endregion
        #region MES下任务
        private static object locko2 = new object();
        /// <summary>
        /// 任务下发接口
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcInWorkArea")]
        public OperateResult ZcInWorkArea(dynamic jsonData)
        {
            LogHelper.Info("任务下发", "MES下发任务参数:" + JsonConvert.SerializeObject(jsonData));
            try
            {
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                MesTaskDto sendTaskEntity = JsonConvert.DeserializeObject<MesTaskDto>(jsonData.ToString());
                if (sendTaskEntity != null)
                {
                    LogHelper.Info("任务下发", "MES下发任务参数:" + JsonConvert.SerializeObject(sendTaskEntity));
                }
                else
                {
                    LogHelper.Info("任务下发", "MES下发任务参数为空");
                }
                if (string.IsNullOrEmpty(sendTaskEntity.BUSI_TYPE))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，缺少参数BUSI_TYPE。" + jsonData.ToString());
                    throw new Exception("缺少参数BUSI_TYPE");
                }
                if (sendTaskEntity.BUSI_TYPE == "3" && string.IsNullOrEmpty(sendTaskEntity.TOOLS_TPYE))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，缺少参数TOOLS_TPYE。" + jsonData.ToString());
                    throw new Exception("缺少参数TOOLS_TPYE");
                }
                if (sendTaskEntity.BUSI_TYPE == "1" || sendTaskEntity.BUSI_TYPE == "2")
                {
                    if (Util.ToDateTime(sendTaskEntity.SHELF_LIFE_TIME) == Util.ToDateTime(sendTaskEntity.EXPIRED_TIME))
                    {
                        throw new Exception("生效时间与失效时间不能一致!");
                    }
                }
                if (string.IsNullOrEmpty(sendTaskEntity.Location_From) && string.IsNullOrEmpty(sendTaskEntity.Location_To))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，起点和终点同时为空。" + jsonData.ToString());
                    throw new Exception("缺少起点Location_From或终点Location_To!");
                }
                if (!string.IsNullOrEmpty(sendTaskEntity.Location_From) && !string.IsNullOrEmpty(sendTaskEntity.Location_To))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，起点和终点同时有值。" + jsonData.ToString());
                    throw new Exception("起点Location_From或终点Location_To 不能同时有参!");
                }
                if (string.IsNullOrEmpty(sendTaskEntity.task_no) && string.IsNullOrEmpty(sendTaskEntity.Task_PDA))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，缺少参数task_no。" + jsonData.ToString());
                    throw new Exception("缺少参数task_no!");
                }
                if (sendTaskEntity.Task_PDA == "PDA")
                {
                    sendTaskEntity.task_no = BLLCreator.Create<IdGuid>().TaskNo("PDA");
                    if (sendTaskEntity.Location_From != null)
                    {
                        sendTaskEntity.Location_From = sendTaskEntity.Location_From.Trim();
                        var locationExt = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_From && e.S_LOCK_STATE == "无" && e.N_CURRENT_NUM > 0)?.First();
                        if (locationExt == null)
                        {
                            throw new Exception("您选择的起点货位已经存在别的任务");
                        }
                    }
                    if (sendTaskEntity.Location_To != null)
                    {
                        sendTaskEntity.Location_To = sendTaskEntity.Location_To.Trim();
                    }
                }
                if (sendTaskEntity.BUSI_TYPE == "7" && sendTaskEntity.TOOLS_TPYE == "15")
                {

                    var Kklock = newDb.Queryable<FunctionEntitys>().Where(e => e.Autoindex == "空托自动出库到接驳位")?.First();
                    if (Kklock != null && Kklock.TransportLock == "Y")
                    {
                        lock (locko2)
                        {
                            var locationExt = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_To)?.First();
                            if (locationExt?.C_ENABLE == "N")
                            {
                                LogHelper.Info("任务下发", "终点货位" + sendTaskEntity.Location_To + "  终点属于关闭状态");
                                throw new Exception("终点货位" + sendTaskEntity.Location_To + "  终点属于关闭状态");
                            }

                            var transportTask = newDb.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex == "点对点任务管控")?.First();
                            List<string> ListString = new List<string>();
                            if (transportTask != null)
                            {
                                ListString = JsonConvert.DeserializeObject<List<string>>(transportTask.TypeJson);
                            }
                            if (ListString.Contains(sendTaskEntity.Location_To))
                            {
                                List<string> state = new List<string> { "完成", "取消" };
                                var tasks = newDb.Queryable<WMSTask>().Where(e => e.S_END_LOC == sendTaskEntity.Location_To && !(state.Contains(e.S_B_STATE))).ToList();
                                if (tasks.Count > 0)
                                {
                                    LogHelper.Info("任务下发", "终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务 任务" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                    throw new Exception("终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务!" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                }
                            }
                            //先查 在添加
                            var transportTask1 = newDb.Queryable<MesKtTaskDto>().Where(e => e.NeedTrig == "Y" && e.Task_State == "接驳位至线边点对点" && e.Location_To == sendTaskEntity.Location_To).ToList();
                            //加入空托出库缓存表 然后后台循环去取
                            if (transportTask1.Count > 0)
                            {
                                LogHelper.Info("任务下发", "--任务已经存在于至缓存表:");
                                return OperateResult.Succeed("任务已经存在于至缓存表");
                            }
                            MesKtTaskDto Kt = new MesKtTaskDto()
                            {
                                task_no = sendTaskEntity.task_no,
                                Task_type = sendTaskEntity.Task_type,
                                //新增字段 Task_abnormal 任务异常字段 （如果mes传1过来 wms只接收不读取）
                                // Task_abnormal = receuveTask.Task_type,
                                TurnCardNum = sendTaskEntity.TurnCardNum,
                                PROD_NO = sendTaskEntity.PROD_NO,
                                PROD_TECH = sendTaskEntity.PROD_TECH,
                                PROD_SPEC = sendTaskEntity.PROD_SPEC,
                                PROD_BOM = sendTaskEntity.PROD_BOM,
                                PROD_Feature = sendTaskEntity.PROD_Feature,
                                TOOLS_NO = sendTaskEntity.TOOLS_NO,
                                ST_AMOUNT = sendTaskEntity.ST_AMOUNT,
                                CURRENT_AMOUNT = sendTaskEntity.CURRENT_AMOUNT,
                                Location_From = sendTaskEntity.Location_From,
                                Location_To = sendTaskEntity.Location_To,
                                PRODUCE_TIME = sendTaskEntity.PRODUCE_TIME,
                                SHELF_LIFE_TIME = sendTaskEntity.SHELF_LIFE_TIME,
                                EXPIRED_TIME = sendTaskEntity.EXPIRED_TIME,
                                SHELF_REP = sendTaskEntity.SHELF_REP,
                                EXPIRED_REP = sendTaskEntity.EXPIRED_REP,
                                CHECK_CODE = sendTaskEntity.CHECK_CODE,
                                CHECK_INFO = sendTaskEntity.CHECK_INFO,
                                Priority = sendTaskEntity.Priority,
                                Data_status = sendTaskEntity.Data_status,
                                NeedTrig = "Y",
                                CreateDate = DateTime.Now,
                                standardWeight = sendTaskEntity.standardWeight,
                                BUSI_TYPE = sendTaskEntity.BUSI_TYPE,
                                TOOLS_TPYE = sendTaskEntity.TOOLS_TPYE,
                                Givewayto = sendTaskEntity.Task_PDA,
                                applyProdSpecList = sendTaskEntity.applyProdSpecList,
                                Task_State = "接驳位至线边点对点",
                                frequency = 0
                            };
                            try
                            {
                                newDb.BeginTran();
                                var B = newDb.Insertable(Kt).ExecuteCommand();
                                if (B == 0)
                                {
                                    newDb.RollbackTran();
                                }
                                newDb.CommitTran();
                                LogHelper.Info("任务下发", "--任务已经添加至缓存表:" + JsonConvert.SerializeObject(B));

                                return OperateResult.Succeed("任务已经添加至缓存表");
                            }
                            catch (Exception ex)
                            {
                                newDb.RollbackTran();
                                LogHelper.Info("任务下发", "--发生了错误 错误为：" + ex.Message);
                                return OperateResult.Error(ex.Message);
                            }
                        }
                    }
                }
                else if (sendTaskEntity.BUSI_TYPE == "7" && sendTaskEntity.TOOLS_TPYE == "65")
                {
                    var transportTask1 = newDb.Queryable<MesKtTaskDto>().Where(e => e.NeedTrig == "Y" && e.Task_State == "胎圈空托出库缓存" && e.Location_To == sendTaskEntity.Location_To).ToList();
                    //加入空托出库缓存表 然后后台循环去取
                    if (transportTask1.Count > 0)
                    {
                        LogHelper.Info("任务下发", "--任务已经存在于至缓存表:");
                        return OperateResult.Succeed("任务已经存在于至缓存表");
                    }
                    MesKtTaskDto Kt = new MesKtTaskDto()
                    {
                        task_no = sendTaskEntity.task_no,
                        Task_type = sendTaskEntity.Task_type,
                        //新增字段 Task_abnormal 任务异常字段 （如果mes传1过来 wms只接收不读取）
                        // Task_abnormal = receuveTask.Task_type,
                        TurnCardNum = sendTaskEntity.TurnCardNum,
                        PROD_NO = sendTaskEntity.PROD_NO,
                        PROD_TECH = sendTaskEntity.PROD_TECH,
                        PROD_SPEC = sendTaskEntity.PROD_SPEC,
                        PROD_BOM = sendTaskEntity.PROD_BOM,
                        PROD_Feature = sendTaskEntity.PROD_Feature,
                        TOOLS_NO = sendTaskEntity.TOOLS_NO,
                        ST_AMOUNT = sendTaskEntity.ST_AMOUNT,
                        CURRENT_AMOUNT = sendTaskEntity.CURRENT_AMOUNT,
                        Location_From = sendTaskEntity.Location_From,
                        Location_To = sendTaskEntity.Location_To,
                        PRODUCE_TIME = sendTaskEntity.PRODUCE_TIME,
                        SHELF_LIFE_TIME = sendTaskEntity.SHELF_LIFE_TIME,
                        EXPIRED_TIME = sendTaskEntity.EXPIRED_TIME,
                        SHELF_REP = sendTaskEntity.SHELF_REP,
                        EXPIRED_REP = sendTaskEntity.EXPIRED_REP,
                        CHECK_CODE = sendTaskEntity.CHECK_CODE,
                        CHECK_INFO = sendTaskEntity.CHECK_INFO,
                        Priority = sendTaskEntity.Priority,
                        Data_status = sendTaskEntity.Data_status,
                        NeedTrig = "Y",
                        CreateDate = DateTime.Now,
                        standardWeight = sendTaskEntity.standardWeight,
                        BUSI_TYPE = sendTaskEntity.BUSI_TYPE,
                        TOOLS_TPYE = sendTaskEntity.TOOLS_TPYE,
                        Givewayto = sendTaskEntity.Task_PDA,
                        applyProdSpecList = sendTaskEntity.applyProdSpecList,
                        Task_State = "胎圈空托出库缓存",
                        frequency = 0
                    };
                    try
                    {
                        newDb.BeginTran();
                        var B = newDb.Insertable(Kt).ExecuteCommand();
                        if (B == 0)
                        {
                            newDb.RollbackTran();
                        }
                        newDb.CommitTran();
                        LogHelper.Info("任务下发", "--任务已经添加至缓存表:" + JsonConvert.SerializeObject(B));

                        return OperateResult.Succeed("任务已经添加至缓存表");
                    }
                    catch (Exception ex)
                    {
                        newDb.RollbackTran();
                        LogHelper.Info("任务下发", "--发生了错误 错误为：" + ex.Message);
                        return OperateResult.Error(ex.Message);
                    }
                }
                LogHelper.Info("任务下发", "ZCSendTask任务下发传递参数：" + jsonData.ToString());
                //调用ReceiveTask方法保存至中间库
                var result = ReceiveTask(sendTaskEntity);
                LogHelper.Info("任务下发", "任务下达接口,返回的参数" + JsonConvert.SerializeObject(result));
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("任务下发", "报错:" + ex.Message);
                CwLine($"MES任务下发 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }


        /// <summary>
        /// 任务下发接口--无托盘入库
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcWtInWorkArea")]
        public OperateResult ZcWtInWorkArea(dynamic jsonData)
        {
            LogHelper.Info("任务下发", "MES下发任务参数:" + JsonConvert.SerializeObject(jsonData));
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                MesTaskDto sendTaskEntity = JsonConvert.DeserializeObject<MesTaskDto>(jsonData.ToString());
                if (sendTaskEntity != null)
                {
                    LogHelper.Info("任务下发", "MES下发任务参数:" + JsonConvert.SerializeObject(sendTaskEntity));
                }
                else
                {
                    LogHelper.Info("任务下发", "MES下发任务参数为空");
                }
                if (string.IsNullOrEmpty(sendTaskEntity.BUSI_TYPE))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，缺少参数BUSI_TYPE。" + jsonData.ToString());
                    throw new Exception("缺少参数BUSI_TYPE");
                }

                if (string.IsNullOrEmpty(sendTaskEntity.Location_From) && string.IsNullOrEmpty(sendTaskEntity.Location_To))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，起点和终点同时为空。" + jsonData.ToString());
                    throw new Exception("缺少起点Location_From或终点Location_To!");
                }
                if (!string.IsNullOrEmpty(sendTaskEntity.Location_From) && !string.IsNullOrEmpty(sendTaskEntity.Location_To))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，起点和终点同时有值。" + jsonData.ToString());
                    throw new Exception("起点Location_From或终点Location_To 不能同时有参!");
                }
                if (string.IsNullOrEmpty(sendTaskEntity.task_no) && string.IsNullOrEmpty(sendTaskEntity.Task_PDA))
                {
                    LogHelper.Info("任务下发", "ZCSendTask任务下发失败，缺少参数task_no。" + jsonData.ToString());
                    throw new Exception("缺少参数task_no!");
                }
                sendTaskEntity.Task_PDA = "无托盘入库";
                LogHelper.Info("任务下发", "ZCSendTask任务下发传递参数：" + jsonData.ToString());

                if (sendTaskEntity.Task_type == "1")
                {
                    var locationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_From)?.First();
                    if (locationExt != null)
                    {
                        sendTaskEntity.TOOLS_TPYE = locationExt.S_MACH_TRAY_TYPE;
                    }
                    var tasks = newDb.Queryable<WMSTask>().Where(e => e.S_START_LOC == sendTaskEntity.Location_From && e.S_B_STATE == "未执行" && e.S_NOTE == "自管任务").ToList();
                    if (tasks.Count() > 0)
                    {
                        return OperateResult.Error("当前起点任务以下达,请勿重复下达任务");
                    }
                    List<string> state = new List<string> { "取货完成", "完成", "取消", "卸货完成" };
                    var tasks2 = newDb.Queryable<WMSTask>().Where(e => e.S_START_LOC == sendTaskEntity.Location_From && !(state.Contains(e.S_B_STATE)) && e.S_NOTE == "agv任务").ToList();
                    if (tasks2.Count() > 0)
                    {
                        return OperateResult.Error("当前起点任务以下达,请勿重复下达任务");
                    }
                }
                else
                {
                    var locationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_To)?.First();
                    if (locationExt != null)
                    {
                        sendTaskEntity.TOOLS_TPYE = locationExt.S_MACH_TRAY_TYPE;
                    }
                }
                if (!string.IsNullOrEmpty(sendTaskEntity.PROD_NO))
                {
                    sendTaskEntity.PROD_NO = "";
                }
                var result = BLLCreator.Create<ZCBLL>().SaveTask(sendTaskEntity);
                LogHelper.Info("任务下发", "任务下达接口,返回的参数" + JsonConvert.SerializeObject(result));
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("任务下发", "报错:" + ex.Message);
                CwLine($"MES任务下发 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }




        private OperateResult ReceiveTask(MesTaskDto receuveTask)
        {
            OperateResult ar = new OperateResult();
            var PRODUCE_TIME = receuveTask.PRODUCE_TIME.ToString();
            var SHELF_LIFE_TIME = receuveTask.SHELF_LIFE_TIME.ToString();
            var EXPIRED_TIME = receuveTask.EXPIRED_TIME.ToString();
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            if (receuveTask.Task_type == "1")
            {
                var tasks = newDb.Queryable<WMSTask>().Where(e => e.S_START_LOC == receuveTask.Location_From && e.S_B_STATE == "未执行" && e.S_NOTE == "自管任务").ToList();
                if (tasks.Count() > 0)
                {
                    return OperateResult.Error("当前起点任务以下达,请勿重复下达任务");
                }
                List<string> state = new List<string> { "取货完成", "完成", "取消", "卸货完成" };
                var tasks2 = newDb.Queryable<WMSTask>().Where(e => e.S_START_LOC == receuveTask.Location_From && !(state.Contains(e.S_B_STATE)) && e.S_NOTE == "agv任务").ToList();
                if (tasks2.Count() > 0)
                {
                    return OperateResult.Error("当前起点任务以下达,请勿重复下达任务");
                }
            }
            if (receuveTask.Task_type == "2" && !string.IsNullOrEmpty(receuveTask.TOOLS_NO))
            {
                return OperateResult.Error("出库任务禁止传工装编号");
            }
            if (receuveTask.BUSI_TYPE != "1")
            {
                if (PRODUCE_TIME == "0001/1/1 0:00:00")
                {
                    receuveTask.PRODUCE_TIME = DateTime.Now;
                }
                if (SHELF_LIFE_TIME == "0001/1/1 0:00:00")
                {
                    receuveTask.SHELF_LIFE_TIME = DateTime.Now;
                }
                if (EXPIRED_TIME == "0001/1/1 0:00:00")
                {
                    receuveTask.EXPIRED_TIME = DateTime.Now;
                }
            }
            else if (PRODUCE_TIME == "0001/1/1 0:00:00" || SHELF_LIFE_TIME == "0001/1/1 0:00:00" || EXPIRED_TIME == "0001/1/1 0:00:00")
            {
                ar.Msg = "生产时间、生效时间、失效时间 为空 任务号为：" + receuveTask.task_no;
                ar.Success = false;
                ar.Code = "-1";
                return ar;
            }
            if (receuveTask.BUSI_TYPE == "1" || receuveTask.BUSI_TYPE == "3" || receuveTask.BUSI_TYPE == "2" || receuveTask.BUSI_TYPE == "5" || receuveTask.BUSI_TYPE == "8")
            {
                if (string.IsNullOrEmpty(receuveTask.TOOLS_NO))
                {
                    //       Log.Info("工装编号为空", JsonConvert.SerializeObject(receuveTask));
                    ar.Msg = "工装编号为空 任务号为：" + receuveTask.task_no;
                    ar.Success = false;
                    ar.Code = "-1";
                    return ar;
                }
            }
            if (receuveTask.BUSI_TYPE == "1" || receuveTask.BUSI_TYPE == "4" || receuveTask.BUSI_TYPE == "2" || receuveTask.BUSI_TYPE == "6")
            {
                if (string.IsNullOrEmpty(receuveTask.PROD_NO))
                {
                    ar.Msg = "制品编号为空 任务号为：" + receuveTask.task_no;
                    ar.Success = false;
                    ar.Code = "-1";
                    return ar;
                }
            }
            if (receuveTask.BUSI_TYPE == "13" || receuveTask.BUSI_TYPE == "14")
            {
                receuveTask.TOOLS_TPYE = receuveTask.TOOLS_TPYE + "-BD";
            }

            if (string.IsNullOrEmpty(receuveTask.CHECK_INFO))
            {
                receuveTask.CHECK_INFO = "合格";
            }
            receuveTask.Task_PDA = "MES";
            if (!string.IsNullOrEmpty(receuveTask.Location_From))
            {

                var location = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == receuveTask.Location_From && e.S_LOCK_STATE == "无")?.First();
                if (location == null)
                {
                    ar.Msg = "起点货位当前不可用";
                    ar.Success = false;
                    ar.Code = "-1";
                    return ar;
                }
            }
            if (!string.IsNullOrEmpty(receuveTask.Location_To))
            {
                var location = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == receuveTask.Location_To && e.S_LOCK_STATE == "无")?.First();
                if (location == null)
                {
                    ar.Msg = "终点货位当前不可用";
                    ar.Success = false;
                    ar.Code = "-1";
                    return ar;
                }
                else if (receuveTask.BUSI_TYPE == "7")
                {
                    var transportTask1 = newDb.Queryable<MesKtTaskDto>().Where(e => e.NeedTrig == "Y" && e.Task_State == "智能空桶" && e.Location_To == receuveTask.Location_To).ToList();

                    List<string> state = new List<string> { "完成", "取消" };
                    var tasks = newDb.Queryable<WMSTask>().Where(e => e.S_END_LOC == receuveTask.Location_To && !(state.Contains(e.S_B_STATE))).ToList();
                    if ((transportTask1.Count() + location.N_CURRENT_NUM + tasks.Count()) >= location.N_CAPACITY)
                    {
                        ar.Msg = "任务达到最大可出库值";
                        ar.Success = false;
                        ar.Code = "-1";
                        return ar;
                    }
                }
            }
            if (receuveTask.BUSI_TYPE == "10")
            {
                receuveTask.PRODUCE_TIME = DateTime.Now;
                receuveTask.SHELF_LIFE_TIME = DateTime.Now;
                receuveTask.EXPIRED_TIME = DateTime.Now;
            }

            // 延长生产时间
            if (receuveTask.BUSI_TYPE != "11")
            {
                var Product = newDb.Queryable<TN_ProductdateEntitys>()?.First();

                if (Product?.CN_S_ADD_PRODUCT > 0)
                {
                    receuveTask.PRODUCE_TIME = receuveTask.PRODUCE_TIME.AddHours(Product.CN_S_ADD_PRODUCT);
                }
            }
            MesTaskDto req = new MesTaskDto()
            {
                task_no = receuveTask.task_no,
                Task_type = receuveTask.Task_type,
                //新增字段 Task_abnormal 任务异常字段 （如果mes传1过来 wms只接收不读取）
                // Task_abnormal = receuveTask.Task_type,
                TurnCardNum = receuveTask.TurnCardNum,
                PROD_NO = receuveTask.PROD_NO,
                PROD_TECH = receuveTask.PROD_TECH,
                PROD_SPEC = receuveTask.PROD_SPEC,
                PROD_BOM = receuveTask.PROD_BOM,
                PROD_Feature = receuveTask.PROD_Feature,
                TOOLS_NO = receuveTask.TOOLS_NO,
                ST_AMOUNT = receuveTask.ST_AMOUNT,
                CURRENT_AMOUNT = receuveTask.CURRENT_AMOUNT,
                Location_From = receuveTask.Location_From,
                Location_To = receuveTask.Location_To,
                PRODUCE_TIME = receuveTask.PRODUCE_TIME,
                SHELF_LIFE_TIME = receuveTask.SHELF_LIFE_TIME,
                EXPIRED_TIME = receuveTask.EXPIRED_TIME,
                SHELF_REP = receuveTask.SHELF_REP,
                EXPIRED_REP = receuveTask.EXPIRED_REP,
                CHECK_CODE = receuveTask.CHECK_CODE,
                CHECK_INFO = receuveTask.CHECK_INFO,
                Priority = receuveTask.Priority,
                Data_status = receuveTask.Data_status,
                NeedTrig = "Y",
                CreateDate = DateTime.Now,
                standardWeight = receuveTask.standardWeight,
                BUSI_TYPE = receuveTask.BUSI_TYPE,
                TOOLS_TPYE = receuveTask.TOOLS_TPYE,
                Givewayto = receuveTask.Task_PDA,
                applyProdSpecList = receuveTask.applyProdSpecList,
                frequency = 0
            };
            //特殊处理 要先判断这个任务能不能下
            if ((receuveTask.BUSI_TYPE == "3" || receuveTask.BUSI_TYPE == "7"))
            {
                MesKtTaskDto Kt = new MesKtTaskDto()
                {
                    task_no = receuveTask.task_no,
                    Task_type = receuveTask.Task_type,
                    //新增字段 Task_abnormal 任务异常字段 （如果mes传1过来 wms只接收不读取）
                    // Task_abnormal = receuveTask.Task_type,
                    TurnCardNum = receuveTask.TurnCardNum,
                    PROD_NO = receuveTask.PROD_NO,
                    PROD_TECH = receuveTask.PROD_TECH,
                    PROD_SPEC = receuveTask.PROD_SPEC,
                    PROD_BOM = receuveTask.PROD_BOM,
                    PROD_Feature = receuveTask.PROD_Feature,
                    TOOLS_NO = receuveTask.TOOLS_NO,
                    ST_AMOUNT = receuveTask.ST_AMOUNT,
                    CURRENT_AMOUNT = receuveTask.CURRENT_AMOUNT,
                    Location_From = receuveTask.Location_From,
                    Location_To = receuveTask.Location_To,
                    PRODUCE_TIME = receuveTask.PRODUCE_TIME,
                    SHELF_LIFE_TIME = receuveTask.SHELF_LIFE_TIME,
                    EXPIRED_TIME = receuveTask.EXPIRED_TIME,
                    SHELF_REP = receuveTask.SHELF_REP,
                    EXPIRED_REP = receuveTask.EXPIRED_REP,
                    CHECK_CODE = receuveTask.CHECK_CODE,
                    CHECK_INFO = receuveTask.CHECK_INFO,
                    Priority = receuveTask.Priority,
                    Data_status = receuveTask.Data_status,
                    NeedTrig = "Y",
                    CreateDate = DateTime.Now,
                    standardWeight = receuveTask.standardWeight,
                    BUSI_TYPE = receuveTask.BUSI_TYPE,
                    TOOLS_TPYE = receuveTask.TOOLS_TPYE,
                    Givewayto = receuveTask.Task_PDA,
                    applyProdSpecList = receuveTask.applyProdSpecList,
                    frequency = 0
                };
                var result = BLLCreator.CreateSingleton<ZCBLL>().BusTask(Kt);
                if (result.Success)
                {
                    return result;
                }
            }
            var c = BLLCreator.CreateSingleton<ZCBLL>().SaveTask(req);
            return c;
        }

        #endregion
        #region Wcs下任务
        /// <summary>
        /// WCS(立库)下任务
        /// </summary>
        [HttpPost]
        [Route("ZcWcsInWorkArea")]
        public ReturnValue ZcWcsInWorkArea(dynamic jsonData)
        {
            ReturnValue retu = new ReturnValue();
            var logPara = LogType.LogPara("立库任务下达");
            if (jsonData == null)
            {
                LogHelper.AreaTask(logPara, "立库任务下达：" + jsonData);
                retu.code = "1";
                retu.msg = "参数null值";
                CwLine("立库任务下达报错：" + "参数null值");
                return retu;
            }
            LogHelper.AreaTask(logPara, "立库任务下达：" + jsonData.ToString());
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            retu.requestPk = Supplier.requestPk;
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                if (string.IsNullOrEmpty(Supplier.noticeType))
                {
                    throw new Exception("通知类型为空");
                }
                if (string.IsNullOrEmpty(Supplier.curPos))
                {
                    throw new Exception("当前位置为空");
                }
                MesTaskDto task = new MesTaskDto();
                task.task_no = Supplier.requestPk;
                task.TOOLS_NO = Supplier.contNo;
                if (Supplier.noticeType == "5")
                {
                    task.Task_type = "2";
                    task.Location_To = Supplier.curPos;
                    //var trp = JsonHelper.GetValue("WcsKtType");
                    //var On_off = JsonConvert.DeserializeObject<List<JsonVale>>(trp);
                    //var tta = On_off
                    task.TOOLS_TPYE = "QB";
                }
                if (Supplier.noticeType == "7")
                {
                    task.Task_type = "1";
                    task.Location_From = Supplier.curPos;
                    task.BUSI_TYPE = "12";
                    task.TOOLS_NO = "";
                }
                if (Supplier.code == "1")
                {
                    task.Task_type = "2";
                    task.BUSI_TYPE = "0011";
                    task.Location_From = Supplier.curPos;
                    TN_Loc_AbnormalEntitys ent = (newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == Supplier.contNo)?.First()) ?? throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                    if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                    {
                        throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                    }
                    task.Location_To = ent.S_S_LOC_CODE;
                    task.Priority = 2;
                }
                else if (Supplier.noticeType == "0")
                {

                    try
                    {
                        TN_AsyncEntitys As = new TN_AsyncEntitys();
                        As.JsonValue = JsonConvert.SerializeObject(Supplier);
                        As.S_IsCall = "Y";
                        As.S_PortID = "2";
                        As.S_Note = "WCS异步下达满托入库";
                        newDb.BeginTran();
                        var B = newDb.Insertable(As).ExecuteCommand();
                        if (B == 0)
                        {
                            newDb.RollbackTran();
                        }
                        newDb.CommitTran();
                        LogHelper.AreaTask(logPara, $"添加异步接口缓存影响行数:{B}");
                        retu.code = "0";
                        retu.msg = "成功";
                        return retu;
                    }
                    catch (Exception ex)
                    {
                        LogHelper.AreaTask(logPara, $"异步接口缓存报错:{ex.Message}");
                        newDb.RollbackTran();
                        retu.code = "-1";
                        retu.msg = "添加异步缓存表报错";
                        return retu;
                    }
                    //if (string.IsNullOrEmpty(Supplier.contNo))
                    //{
                    //    throw new Exception("托盘条码为空");
                    //}
                    //task.Task_type = "1";
                    //task.Location_From = Supplier.curPos;
                    //MesResponseResultTwo qe = BLLCreator.CreateSingleton<MesTask>().SelectItemList(Supplier.contNo);
                    //if (qe == null || qe.data == null)
                    //{
                    //    throw new Exception("调用MES接口获取托盘物料信息失败,未获取到数据");
                    //}
                    //else if (qe.data.currentAmount > 50)
                    //{
                    //    task.PRODUCE_TIME = qe.data.produceTime;
                    //    task.SHELF_LIFE_TIME = qe.data.shelfLifeTime;
                    //    task.EXPIRED_TIME = qe.data.expiredTime;
                    //    task.CHECK_INFO = qe.data?.prodSelfCheck;
                    //    task.PROD_NO = qe.data?.prodNo;
                    //    task.PROD_SPEC = qe.data?.prodSpec;
                    //    task.TurnCardNum = qe.data?.turnoverNo;
                    //    task.PROD_BOM = qe.data?.prodName;
                    //    task.CURRENT_AMOUNT = qe.data.currentAmount;
                    //    task.applyProdSpecList = qe.data?.applyProdSpecList;
                    //}
                    //task.Givewayto = "WCS";
                }
                var re = BLLCreator.Create<ZCBLL>().ExecTransferTask(task);
                retu.code = re.Code ?? "0";
                if (retu.code == "0")
                {
                    retu.msg = "成功";
                }
                else
                {
                    retu.msg = "失败";
                }
                retu.msg = re.Msg;
                //if (re.Code == "100")//库中存在这个托盘,出到异常缓存位
                //{
                //    task.Task_type = "2";
                //    task.BUSI_TYPE = "0011";
                //    task.Location_From = Supplier.curPos;
                //    TN_Loc_AbnormalEntitys ent = SqlSugarHelper.Db.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == Supplier.contNo)?.First();
                //    if (ent == null)
                //    {
                //        ent = (SqlSugarHelper.Db.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE.Contains(Supplier.curPos))?.First()) ?? throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                //    }
                //    if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                //    {
                //        throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                //    }
                //    task.Location_To = ent.S_S_LOC_CODE;
                //    task.Priority = 2;
                //    var tta = BLLCreator.Create<ZCBLL>().ExecTransferTask(task);
                //    if (tta.Success)
                //    {
                //        retu.code = "100";
                //        retu.msg = "工装已存在库中,移送到异常缓存位";
                //    }
                //}
                if (Supplier.noticeType == "5" && re.Code == "101")//任务类型为5 且库存不足时出KJZ
                {
                    task.Task_type = "2";
                    task.BUSI_TYPE = "12";
                    var tta = BLLCreator.Create<ZCBLL>().ExecTransferTask(task);
                    if (tta.Success)
                    {
                        retu.code = "0";
                        retu.msg = "成功";
                    }
                    else
                    {
                        retu.code = "101";
                        retu.msg = "失败";
                        if (Supplier.noticeType == "5")
                        {

                            LogHelper.AreaTask(logPara, " 空托出库任务生成失败加入空托中间表 ：" + JsonConvert.SerializeObject(re));
                            var EmptyS = newDb.Queryable<TN_Empty_MiddleEntitys>().Where(e => e.isread == "N" && e.curPos == Supplier.curPos).OrderBy(st => st.reqTime)?.First();
                            if (EmptyS == null)
                            {
                                try
                                {
                                    TN_Empty_MiddleEntitys Empty = new TN_Empty_MiddleEntitys()
                                    {
                                        requestPk = Supplier.requestPk,
                                        contNo = Supplier.contNo,
                                        curPos = Supplier.curPos,
                                        isread = "N",
                                        reqTime = DateTime.Now
                                    };
                                    newDb.BeginTran();
                                    var B = newDb.Insertable(Empty).ExecuteCommand();
                                    if (B == 0)
                                    {
                                        newDb.RollbackTran();
                                    }
                                    newDb.CommitTran();
                                }
                                catch (Exception ex)
                                {
                                    newDb.RollbackTran();
                                    LogHelper.AreaTask(logPara, "立库任务添加中间表报错：" + JsonConvert.SerializeObject(ex));
                                    CwLine("立库任务下达报错：" + JsonConvert.SerializeObject(ex));
                                }
                            }
                        }
                    }
                }
                if (re.Success)
                {
                    retu.code = "0";
                    retu.msg = "成功";
                }
                else
                {
                    retu.code = re.Code ?? "1";
                }
                LogHelper.AreaTask(logPara, "立库任务下达 返回参数：" + JsonConvert.SerializeObject(retu));
                return retu;
            }
            catch (Exception ex)
            {
                LogHelper.AreaTask(logPara, "立库任务下达报错：" + JsonConvert.SerializeObject(ex));
                retu.code = "1";
                retu.msg = ex.Message;
                CwLine("立库任务下达报错：" + JsonConvert.SerializeObject(ex));
                return retu;
            }
        }

        [HttpPost]
        [Route("WcsMtInwork")]
        public OperateResult WcsMtInwork(string JsonValue)
        {
            try
            {
                WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(JsonValue);
                MesTaskDto task = new MesTaskDto();
                task.task_no = Supplier.requestPk;
                task.TOOLS_NO = Supplier.contNo;
                task.Task_type = "1";
                task.Location_From = Supplier.curPos;
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                MesResponseResultTwo qe = BLLCreator.CreateSingleton<MesTask>().SelectItemList(Supplier.contNo, task.task_no);
                if (qe == null || qe.data == null)
                {
                    throw new Exception("调用MES接口获取托盘物料信息失败,未获取到数据");
                }
                else if (qe.data.currentAmount > 50)
                {
                    task.PRODUCE_TIME = qe.data.produceTime;
                    task.SHELF_LIFE_TIME = qe.data.shelfLifeTime;
                    task.EXPIRED_TIME = qe.data.expiredTime;
                    task.CHECK_INFO = qe.data?.prodSelfCheck;
                    task.PROD_NO = qe.data?.prodNo;
                    task.PROD_SPEC = qe.data?.prodSpec;
                    task.TurnCardNum = qe.data?.turnoverNo;
                    task.PROD_BOM = qe.data?.prodName;
                    task.CURRENT_AMOUNT = qe.data.currentAmount;
                    task.applyProdSpecList = qe.data?.applyProdSpecList;
                }
                task.Givewayto = "WCS";
                var re = BLLCreator.Create<ZCBLL>().ExecTransferTask(task);
                LogHelper.Info("立库任务下达", "立库满托入库 异步缓存下任务(满托入库)：" + JsonConvert.SerializeObject(re));
                if (re.Success)
                {
                    return re;
                }
                else
                {
                    if (re.Code == "100")//库中存在这个托盘,出到异常缓存位
                    {
                        task.Task_type = "2";
                        task.BUSI_TYPE = "0011";
                        task.Location_From = Supplier.curPos;
                        TN_Loc_AbnormalEntitys ent = newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE == Supplier.contNo)?.First();
                        if (ent == null)
                        {
                            ent = (newDb.Queryable<TN_Loc_AbnormalEntitys>().Where(e => e.S_CNTR_CODE.Contains(Supplier.curPos))?.First()) ?? throw new Exception("未维护该工装类型的异常缓存位,请联系管理员");
                        }
                        if (string.IsNullOrEmpty(ent.S_S_LOC_CODE))
                        {
                            throw new Exception("维护的异常缓存位数据中缓存位货位码是空值");
                        }
                        task.Location_To = ent.S_S_LOC_CODE;
                        task.Priority = 2;
                        var tta = BLLCreator.Create<ZCBLL>().ExecTransferTask(task);
                        LogHelper.Info("立库任务下达", "立库满托入库 异步缓存下任务(移送异常缓存位)：" + JsonConvert.SerializeObject(tta));
                        return tta;
                    }
                    else
                    {
                        return re;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info("立库任务下达", "立库满托入库 异步缓存下任务 报错：" + JsonConvert.SerializeObject(ex));
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion
        #region MES物料查询
        /// <summary>
        /// MES物料查询
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("MesSecItem")]
        public OperateResult MesSecItem(dynamic jsonData)
        {
            LogHelper.Info("MES", $"MES物料查询 入参:{JsonConvert.SerializeObject(jsonData)}");
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                MesItemList sendTaskEntity = JsonConvert.DeserializeObject<MesItemList>(jsonData.ToString());
                var ca = Expressionable.Create<Location, LocCntrRel, CntrItemRel>();
                ca.AndIF(!string.IsNullOrEmpty(sendTaskEntity.Location_From), (o, p, t) => o.S_LOC_CODE == sendTaskEntity.Location_From);
                ca.AndIF(!string.IsNullOrEmpty(sendTaskEntity.TurnCardNum), (o, p, t) => t.TurnCardNum == sendTaskEntity.TurnCardNum);
                var lstCanOutL = newDb.Queryable<Location>().InnerJoin<LocCntrRel>((o, p) => o.S_LOC_CODE == p.S_LOC_CODE).InnerJoin<CntrItemRel>((o, p, t) => p.S_CNTR_CODE == t.S_CNTR_CODE).Where(ca.ToExpression()).Includes(e => e.LocCntrRel, p => p.CntrItemRel).ToList();
                LogHelper.Info("MES", $"MES物料查询 返参:{JsonConvert.SerializeObject(lstCanOutL.FirstOrDefault()?.LocCntrRel?.CntrItemRel)}");
                return OperateResult.Succeed("", lstCanOutL.FirstOrDefault()?.LocCntrRel?.CntrItemRel);
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", $"MES物料查询 报错:{ex.Message}");
                CwLine($"MES物料查询 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region MES物料查询
        /// <summary>
        /// MES物料查询
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("MesAreaSecItem")]
        public OperateResult MesAreaSecItem(dynamic jsonData)
        {
            LogHelper.Info("MES", $"MES物料查询 入参:{JsonConvert.SerializeObject(jsonData)}");
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                int totalCount = 0;
                var result = OperateResult.Succeed();
                MesItemList sendTaskEntity = JsonConvert.DeserializeObject<MesItemList>(jsonData.ToString());
                var ca = Expressionable.Create<Location, LocCntrRel, CntrItemRel>();
                ca.AndIF(!string.IsNullOrEmpty(sendTaskEntity.Location_From), (o, p, t) => o.S_AREA_CODE == sendTaskEntity.Location_From);
                ca.AndIF(!string.IsNullOrEmpty(sendTaskEntity.TurnCardNum), (o, p, t) => t.TurnCardNum == sendTaskEntity.TurnCardNum);
                var lstCanOutL = newDb.Queryable<Location>().InnerJoin<LocCntrRel>((o, p) => o.S_LOC_CODE == p.S_LOC_CODE).InnerJoin<CntrItemRel>((o, p, t) => p.S_CNTR_CODE == t.S_CNTR_CODE)
                    .Where(ca.ToExpression()).Includes(e => e.LocCntrRel, p => p.CntrItemRel).ToPageList(sendTaskEntity.pagenumber, sendTaskEntity.pageSize, ref totalCount);
                List<CntrItemRel> item = new List<CntrItemRel>();
                foreach (var itm in lstCanOutL)
                {
                    item.Add(itm?.LocCntrRel?.CntrItemRel);
                }
                // LogHelper.Info("MES", $"MES物料查询 返参:{JsonConvert.SerializeObject(item)}");
                result.Data = item;
                result.AffectedRows = totalCount;
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", $"MES物料查询 报错:{ex.Message}");
                CwLine($"MES物料查询 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region MES修改物料信息
        /// <summary>
        /// MES修改物料信息
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("MesUdeItem")]
        public OperateResult MesUdeItem(dynamic jsonData)
        {
            LogHelper.Info("MES", $"MES修改物料信息 入参:{JsonConvert.SerializeObject(jsonData)}");
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                MesItemList sendTaskEntity = JsonConvert.DeserializeObject<MesItemList>(jsonData.ToString());
                if (string.IsNullOrEmpty(sendTaskEntity.TurnCardNum))
                {
                    throw new Exception("周转卡号 不允许为空");
                }
                var Item = newDb.Queryable<CntrItemRel>().Where(e => e.TurnCardNum == sendTaskEntity.TurnCardNum)?.First();
                if (Item == null)
                {
                    throw new Exception("该周转卡号 未查询到指定物料信息");
                }
                newDb.BeginTran();
                var B = newDb.Updateable<CntrItemRel>()
                    .SetColumnsIF(!string.IsNullOrEmpty(sendTaskEntity.CHECK_INFO), it => it.S_ITEM_STATE == sendTaskEntity.CHECK_INFO)
                      .SetColumnsIF(!string.IsNullOrEmpty(sendTaskEntity.PROD_NO), it => it.S_ITEM_CODE == sendTaskEntity.PROD_NO)
                       .SetColumnsIF(sendTaskEntity.CURRENT_AMOUNT != 0, it => it.F_QTY == Convert.ToDecimal(sendTaskEntity.CURRENT_AMOUNT))
                        .SetColumns(it => it.expireTime == Item.expireTime.AddHours(sendTaskEntity.EXPIRED_REP))
                    .Where(x => x.TurnCardNum == sendTaskEntity.TurnCardNum).ExecuteCommand();
                if (B == 0)
                {
                    newDb.RollbackTran();
                    throw new Exception("更新物料信息失败");
                }
                newDb.CommitTran();
                LogHelper.Info("MES", $"MES修改物料信息 更新成功");
                return OperateResult.Succeed("更新成功");
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", $"MES修改物料信息 报错:{ex.Message}");
                newDb.RollbackTran();
                CwLine($"MES修改物料信息 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region MES物料绑定货位接口
        /// <summary>
        /// MES物料绑定货位接口
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("MesBindUnbind")]
        public OperateResult MesBindUnbind(dynamic jsonData)
        {
            LogHelper.Info("MES", $"MES绑定物料信息 入参:{JsonConvert.SerializeObject(jsonData)}");
            try
            {
                MesItemList sendTaskEntity = JsonConvert.DeserializeObject<MesItemList>(jsonData.ToString());
                if (sendTaskEntity.BUSI_TYPE != "100" && sendTaskEntity.BUSI_TYPE != "200")
                {
                    throw new Exception("操作类型不符合规定");
                }
                var re = BLLCreator.Create<ZCBLL>().TrayBindLocation(sendTaskEntity);
                return OperateResult.Succeed();
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", $"MES绑定物料信息 报错:{ex.Message}");
                CwLine($"MES绑定物料信息 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region MES点对点任务
        /// <summary>
        /// MES点对点任务
        /// </summary>
        /// <param name="sendTaskEntity"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SendTaskZCMes")]
        public OperateResult SendTaskZCMes(MesItemList sendTaskEntity)
        {
            LogHelper.Info("MES", $"MES点对点任务 入参:{JsonConvert.SerializeObject(sendTaskEntity)}");
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                Location locationExt = null;
                bool Isf = false;
                bool GGf = false;
                int hhr = 0;
                if (string.IsNullOrEmpty(sendTaskEntity.Location_From))
                {
                    throw new Exception("起始库位为空");
                }
                else
                {
                    List<string> TaskState = new List<string>() { "未执行", "已推送", "执行中", "取货完成", "开始取货" };
                    var Wmtask = newDb.Queryable<WMSTask>().Where(e => TaskState.Contains(e.S_B_STATE) && e.S_START_LOC == sendTaskEntity.Location_From).ToList();
                    if (Wmtask.Count() > 0)
                    {
                        throw new Exception("当前起点货位有任务在进行");
                    }
                }
                if (string.IsNullOrEmpty(sendTaskEntity.Location_To))
                {
                    throw new Exception("终点库位为空");
                }
                if (sendTaskEntity.Location_To.Contains("LC11_VIR01"))
                {
                    locationExt = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_From)?.First();
                    if (locationExt == null)
                    {
                        throw new Exception("非法起始库位");
                    }

                    var transportTask = newDb.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex == sendTaskEntity.Location_To)?.First();
                    List<string> ListString = new List<string>();
                    if (transportTask != null)
                    {
                        ListString = JsonConvert.DeserializeObject<List<string>>(transportTask.TypeJson);
                        if (ListString.Count() > 0)
                        {
                            //排除不可入货位
                            var locxt = newDb.Queryable<Location>().Where(e => ListString.Contains(e.S_LOC_CODE)).ToList();
                            var Nopa = locxt.FindAll(e => e.C_ENABLE == "N").ToList();
                            if (Nopa.Count > 0)
                            {
                                foreach (var item in Nopa)
                                {
                                    ListString.Remove(item.S_LOC_CODE);
                                }
                            }
                            if (ListString.Count == 0)
                            {
                                throw new Exception("能入的机台都关了,无机台可入");
                            }

                            var transport = newDb.Queryable<MesSendTaskEndEntitys>().Where(e => e.Autoindex == locationExt.S_MACH_TRAY_TYPE)?.First();
                            if (transport == null)
                            {
                                MesSendTaskEndEntitys aloneWcsTask = new MesSendTaskEndEntitys()
                                {
                                    Autoindex = locationExt.S_MACH_TRAY_TYPE,
                                    IsBalance = 0

                                };
                                try
                                {
                                    newDb.Insertable(aloneWcsTask).ExecuteCommand();
                                }
                                catch (Exception ex)
                                {

                                    throw;
                                }

                                sendTaskEntity.Location_To = ListString.First();
                            }
                            else
                            {
                                if (transport.IsBalance >= ListString.Count)
                                {
                                    sendTaskEntity.Location_To = ListString[0];
                                    GGf = true;
                                }
                                else
                                {
                                    sendTaskEntity.Location_To = ListString[transport.IsBalance];
                                }
                            }
                        }
                        hhr = ListString.Count();
                        Isf = true;

                    }
                }
                if (string.IsNullOrEmpty(sendTaskEntity.Location_To) || sendTaskEntity.Location_To == "LC11_VIR01")
                {
                    throw new Exception("终点库位为空或者非法");
                }
                if (string.IsNullOrEmpty(sendTaskEntity.TOOLS_NO))
                {
                    DateTimeOffset currentTime = DateTimeOffset.Now;
                    long unixTimestamp = currentTime.ToUnixTimeSeconds();
                    sendTaskEntity.TOOLS_NO = unixTimestamp.ToString();
                }
                List<OutWorkAreaEntity> outWorkAreas = new List<OutWorkAreaEntity>
                {
                    new OutWorkAreaEntity() {
                        taskNo=sendTaskEntity.task_no,
                        startBit = sendTaskEntity.Location_From,
                        endBit = sendTaskEntity.Location_To,
                        priority = sendTaskEntity.Priority,
                        trayCode= sendTaskEntity.TOOLS_NO,
                        TaskOrderType = "MES点对点",
                        NoAssist = "Y",
                        S_TransAgv = "Y"
                    }
                };
                var transportTask1 = newDb.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex == "点对点任务管控")?.First();
                List<string> ListString2 = new List<string>();
                if (transportTask1 != null)
                {
                    ListString2 = JsonConvert.DeserializeObject<List<string>>(transportTask1.TypeJson);
                }
                if (ListString2.Contains(sendTaskEntity.Location_To))
                {
                    List<string> state = new List<string> { "完成", "取消" };
                    var tasks = newDb.Queryable<WMSTask>().Where(e => e.S_END_LOC == sendTaskEntity.Location_To && !(state.Contains(e.S_B_STATE))).ToList();
                    if (tasks.Count > 0)
                    {
                        LogHelper.Info("任务下发", "终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务 任务" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                        throw new Exception("终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务!" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                    }
                }
                var StaLocation = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_From)?.First();
                var EndLocation = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == sendTaskEntity.Location_To)?.First();
                if (EndLocation == null && StaLocation == null)
                {
                    LogHelper.Info("MES", $"非法货位 起点: {sendTaskEntity.Location_From} 终点: {sendTaskEntity.Location_To}  请联系管理员查看是否维护过该货位信息");
                    throw new Exception("非法货位 起点: {sendTaskEntity.Location_From} 终点: {sendTaskEntity.Location_To}  请联系管理员查看是否维护过该货位信息");
                }
                else
                {
                    var exp = Expressionable.Create<TN_WorkFlowEntitys>();
                    exp.AndIF(!string.IsNullOrEmpty(StaLocation.S_AREA_CODE), it => it.S_StartArea == StaLocation.S_AREA_CODE);
                    exp.AndIF(!string.IsNullOrEmpty(EndLocation.S_AREA_CODE), it => it.S_EndArea == EndLocation.S_AREA_CODE);
                    exp.And(it => it.S_IS_IN_OUT == "点对点");
                    var workAreaProList = newDb.Queryable<TN_WorkFlowEntitys>().Where(exp.ToExpression()).ToList();
                    if (!workAreaProList.Any())
                    {
                        LogHelper.Info("MES", $"未配置点对点作业流程 起点库区{StaLocation.S_AREA_CODE}  终点库区{EndLocation.S_AREA_CODE}");
                        throw new Exception($"未配置点对点作业流程 起点库区{StaLocation.S_AREA_CODE}  终点库区{EndLocation.S_AREA_CODE}");
                    }
                }
                var result = BLLCreator.CreateSingleton<OutWorkAreaBll>().OutWorkArea(outWorkAreas);
                if (!result.Success)
                {
                    throw new Exception(result.Msg);
                }
                else
                {
                    if (Isf)
                    {
                        var transport = newDb.Queryable<MesSendTaskEndEntitys>().Where(e => e.Autoindex == locationExt.S_MACH_TRAY_TYPE)?.First();
                        if (transport != null)
                        {
                            var ffg = transport.IsBalance + 1;
                            if (ffg < hhr)
                            {
                                var I = newDb.Updateable<MesSendTaskEndEntitys>().SetColumns(it => new MesSendTaskEndEntitys() { IsBalance = ffg }).Where(x => x.Autoindex == locationExt.S_MACH_TRAY_TYPE).ExecuteCommand();
                            }
                            else if (GGf)
                            {
                                var I = newDb.Updateable<MesSendTaskEndEntitys>().SetColumns(it => new MesSendTaskEndEntitys() { IsBalance = 1 }).Where(x => x.Autoindex == locationExt.S_MACH_TRAY_TYPE).ExecuteCommand();
                            }
                            else
                            {
                                var I = newDb.Updateable<MesSendTaskEndEntitys>().SetColumns(it => new MesSendTaskEndEntitys() { IsBalance = 0 }).Where(x => x.Autoindex == locationExt.S_MACH_TRAY_TYPE).ExecuteCommand();
                            }
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", $"MES点对点任务 报错:{ex.Message}");
                CwLine($"MES点对点任务 报错:{ex.Message}");
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 清理数据
        [HttpGet]
        [Route("SelectLocation")]
        public OperateResult SelectLocation()
        {
            try
            {
                var lstCanOutL = SqlSugarHelper.Db.Queryable<Location>().InnerJoin<LocCntrRel>((o, p) => o.S_LOC_CODE == p.S_LOC_CODE).LeftJoin<CntrItemRel>((o, p, t) => p.S_CNTR_CODE == t.S_CNTR_CODE).Where((o, p, t) => o.N_CURRENT_NUM == 0).Includes(e => e.LocCntrRel).ToList();
                return OperateResult.Succeed("成功", JsonConvert.SerializeObject(lstCanOutL));
            }
            catch (Exception ex)
            {

                return OperateResult.Error(ex.Message);
            }
        }
        #endregion
        #region Wcs报警信息添加
        /// <summary>
        /// Wcs报警信息添加
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("WcsTaskProcessing")]
        public ReturnValue WcsTaskProcessing(dynamic jsonData)
        {
            LogHelper.Info(" Wcs报警信息", "入参：" + jsonData.ToString());
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            ReturnValue retu = new ReturnValue();
            retu.requestPk = Supplier.requestPk;
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                var Alone = newDb.Queryable<WcsAbnormityWarningEntitys>().Where(e => e.requestPk == Supplier.requestPk).ToList();
                if (Alone.Any())
                {
                    retu.code = "0";
                    retu.msg = "成功";
                    return retu;
                }
                try
                {
                    if (!string.IsNullOrEmpty(Supplier.taskNo))
                    {
                        TaskHelper.WcsAddActionRecord(Supplier.taskNo, Supplier.noticeType, "WCS", JsonConvert.SerializeObject(Supplier));
                    }
                    var ghh = $" 任务号:{Supplier.taskNo.Substring(Supplier.taskNo.Length - 4)} 库区:{Supplier.areaCode} 巷道:{Supplier.roadway} 故障内容:{Supplier.remarks}  时间:{DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")}";
                    BLLCreator.CreateSingleton<DingDingHelper>().button1_Click(ghh);
                    // BLLCreator.CreateSingleton<DingDingHelper>().button1_Click($"任务号:{Supplier.taskNo} 故障描述{Supplier.remarks} 库区{Supplier.areaCode} 巷道{Supplier.roadway}  时间 {DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")} ，请联系仓管解决。");
                    newDb.BeginTran();
                    WcsAbnormityWarningEntitys aloneWcsTask = new WcsAbnormityWarningEntitys()
                    {
                        requestPk = Supplier.requestPk,
                        taskNo = Supplier.taskNo,
                        errorDes = Supplier.errorDes,
                        errorNo = Supplier.errorNo,
                        remarks = Supplier.remarks,
                        areaCode = Supplier.areaCode,
                        roadway = Supplier.roadway,
                        reqTime = Supplier.reqTime
                    };
                    var I = newDb.Insertable(aloneWcsTask).ExecuteCommand();
                    if (I == 0)
                    {
                        throw new Exception("添加立库报警信息表失败");
                    }
                    newDb.CommitTran();
                    retu.code = "0";
                    retu.msg = "成功";
                    LogHelper.Info(" Wcs报警信息", "出参：" + JsonConvert.SerializeObject(retu));
                    return retu;
                }
                catch (Exception ex)
                {
                    newDb.RollbackTran();
                    retu.msg = ex.Message;
                    retu.code = "1";
                    LogHelper.Info(" Wcs报警信息", "报错：" + ex.Message);
                    return retu;
                }
            }
            catch (Exception ex)
            {
                retu.msg = ex.Message;
                retu.code = "1";
                LogHelper.Info(" Wcs报警信息", "报错：" + ex.Message);
                return retu;
            }
        }
        #endregion
        #region 巷道是否启用禁用
        /// <summary>
        /// 巷道是否启用禁用
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("WcsRoadwaystate")]
        public ReturnValue WcsRoadwaystate(dynamic jsonData)
        {
            LogHelper.Info("巷道用禁用", "入参：" + jsonData.ToString());
            ReturnValue retu = new ReturnValue();
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            retu.requestPk = Supplier.requestPk;
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                if (string.IsNullOrEmpty(Supplier.areaCode))
                {
                    throw new Exception("库区禁止为空");
                }
                if (Supplier.roadWay == 0)
                {
                    throw new Exception("没传巷道号");
                }
                if (string.IsNullOrEmpty(Supplier.status))
                {
                    throw new Exception("状态禁止为空");
                }
                if (Supplier.status != "0" && Supplier.status != "1")
                {
                    throw new Exception($"非法状态码 状态码为 {Supplier.status}");
                }
                var Subs = Expressionable.Create<TN_SubsidiaryEntitys>();

                Subs.And(it => it.S_AREA_CODE == Supplier.areaCode);
                Subs.And(it => it.N_ROADWAY == Supplier.roadWay);
                var Subsidiary = newDb.Queryable<TN_SubsidiaryEntitys>().Where(Subs.ToExpression()).ToList();
                LogHelper.Info("巷道用禁用", $" 辅助表数据{JsonConvert.SerializeObject(Subsidiary)}");
                if (Supplier.status == "0")
                {
                    if (Subsidiary.FindAll(e => e.N_Y_ROADWAY == "N").ToList().Count() == Subsidiary.Count())
                    {
                        LogHelper.Info("巷道用禁用", "当前所属巷道 都为禁止状态");
                        retu.code = "0";
                        retu.msg = "成功";
                        return retu;
                    }
                }
                else
                {
                    if (Subsidiary.FindAll(e => e.N_Y_ROADWAY == "Y").ToList().Count() == Subsidiary.Count())
                    {
                        LogHelper.Info("巷道用禁用", "当前所属巷道 都为启用状态");
                        retu.code = "0";
                        retu.msg = "成功";
                        return retu;
                    }
                }

                try
                {
                    var I = 0;
                    newDb.BeginTran();
                    if (Supplier.status == "0")
                    {
                        I = newDb.Updateable<TN_SubsidiaryEntitys>().SetColumns(it => new TN_SubsidiaryEntitys()
                        {
                            N_Y_ROADWAY = "N"
                        }).Where(x => x.S_AREA_CODE == Supplier.areaCode && x.N_ROADWAY == Supplier.roadWay).ExecuteCommand();
                        if (I == 0)
                        {
                            throw new Exception($"更新辅助表巷道状态为禁止 失败");
                        }
                        LogHelper.Info("巷道用禁用", " 更新为N");
                    }
                    else
                    {
                        I = newDb.Updateable<TN_SubsidiaryEntitys>().SetColumns(it => new TN_SubsidiaryEntitys()
                        {
                            N_Y_ROADWAY = "Y"
                        }).Where(x => x.S_AREA_CODE == Supplier.areaCode && x.N_ROADWAY == Supplier.roadWay).ExecuteCommand();
                        if (I == 0)
                        {
                            throw new Exception($"更新辅助表巷道状态为启动 失败");
                        }
                        LogHelper.Info("巷道用禁用", " 更新为Y");
                    }
                    newDb.CommitTran();
                    //if (Supplier.status == "0" && I > 0)
                    //{
                    //    //查询这个巷道里所有出库锁的货位
                    //    var Location = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_AREA_CODE == Supplier.areaCode && e.N_ROADWAY == Supplier.roadWay && e.S_LOCK_STATE == "出库锁").ToList();
                    //    if (Location.Count > 0)
                    //    {
                    //        var ListLoca = Location.Select(e => e.S_LOC_CODE).ToList();
                    //        //查这些货位的任务
                    //        var WmsTas = SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => ListLoca.Contains(e.S_START_LOC) && e.S_B_STATE == "未执行" && e.S_TYPE == "取消").ToList();
                    //        foreach (var item in WmsTas)
                    //        {
                    //            AgvTaskState state = new AgvTaskState();
                    //            state.No = item.S_TASK_NO;
                    //            state.State = 7;
                    //            BLLCreator.CreateSingleton<AgvController>().AGVCallbackState(state);
                    //        }
                    //    }
                    //} 
                    retu.code = "0";
                    retu.msg = "成功";
                    LogHelper.Info(" 巷道用禁用", "返回：" + JsonConvert.SerializeObject(retu));
                    return retu;
                }
                catch (Exception ex)
                {
                    newDb.RollbackTran();
                    retu.msg = ex.Message;
                    retu.code = "1";
                    LogHelper.Info(" 巷道用禁用", "报错：" + ex.Message);
                    return retu;
                }
            }
            catch (Exception ex)
            {
                retu.msg = ex.Message;
                retu.code = "1";
                newDb.RollbackTran();
                LogHelper.Info(" 巷道用禁用", "报错：" + ex.Message);
                return retu;
            }
        }
        #endregion

        #region 接驳位是否启用禁用
        /// <summary>
        /// 巷道是否启用禁用
        /// </summary>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("WcsJbBitstate")]
        public ReturnValue WcsJbBitstate(dynamic jsonData)
        {
            LogHelper.Info("接驳位用禁用", "入参：" + jsonData.ToString());
            ReturnValue retu = new ReturnValue();
            WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            retu.requestPk = Supplier.requestPk;
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                if (string.IsNullOrEmpty(Supplier.stnNo))
                {
                    throw new Exception("接驳位为空");
                }
                if (string.IsNullOrEmpty(Supplier.status))
                {
                    throw new Exception("状态禁止为空");
                }
                if (Supplier.status != "0" && Supplier.status != "1")
                {
                    throw new Exception($"非法状态码 状态码为 {Supplier.status}");
                }
                var Subs = Expressionable.Create<TN_IsopenBitEntitys>();

                Subs.And(it => it.S_JbBit == Supplier.stnNo);
                var Subsidiary = newDb.Queryable<TN_IsopenBitEntitys>().Where(Subs.ToExpression()).ToList();
                LogHelper.Info("接驳位用禁用", $" 表数据{JsonConvert.SerializeObject(Subsidiary)}");
                if (Supplier.status == "0")
                {
                    if (Subsidiary.FindAll(e => e.S_IsOpen == "N").ToList().Count() == Subsidiary.Count())
                    {
                        LogHelper.Info("接驳位用禁用", "当前所属接驳位 都为禁止状态");
                        retu.code = "0";
                        retu.msg = "成功";
                        LogHelper.Info("接驳位用禁用", $" 返回:{JsonConvert.SerializeObject(retu)}");
                        return retu;
                    }
                }
                else
                {
                    if (Subsidiary.FindAll(e => e.S_IsOpen == "Y").ToList().Count() == Subsidiary.Count())
                    {
                        LogHelper.Info("接驳位用禁用", "当前所属接驳位 都为启用状态");
                        retu.code = "0";
                        retu.msg = "成功";
                        LogHelper.Info("接驳位用禁用", $" 返回:{JsonConvert.SerializeObject(retu)}");
                        return retu;
                    }
                }
                try
                {
                    var I = 0;
                    newDb.BeginTran();
                    if (Supplier.status == "0")
                    {
                        I = newDb.Updateable<TN_IsopenBitEntitys>().SetColumns(it => new TN_IsopenBitEntitys()
                        {
                            S_IsOpen = "N"
                        }).Where(x => x.S_JbBit == Supplier.stnNo).ExecuteCommand();
                        if (I == 0)
                        {
                            throw new Exception($"更新接驳位状态为禁止 失败");
                        }
                        LogHelper.Info("接驳位用禁用", " 更新为N");
                    }
                    else
                    {
                        I = newDb.Updateable<TN_IsopenBitEntitys>().SetColumns(it => new TN_IsopenBitEntitys()
                        {
                            S_IsOpen = "Y"
                        }).Where(x => x.S_JbBit == Supplier.stnNo).ExecuteCommand();
                        if (I == 0)
                        {
                            throw new Exception($"更新接驳位状态为启动 失败");
                        }
                        LogHelper.Info("接驳位用禁用", " 更新为Y");
                    }
                    newDb.CommitTran();
                    retu.code = "0";
                    retu.msg = "成功";
                    LogHelper.Info("接驳位用禁用", $" 返回:{JsonConvert.SerializeObject(retu)}");
                    return retu;
                }
                catch (Exception ex)
                {
                    newDb.RollbackTran();
                    retu.msg = ex.Message;
                    retu.code = "1";
                    LogHelper.Info(" 接驳位用禁用", "报错：" + ex.Message);
                    return retu;
                }
            }
            catch (Exception ex)
            {
                retu.msg = ex.Message;
                retu.code = "1";
                newDb.RollbackTran();
                LogHelper.Info(" 接驳位用禁用", "报错：" + ex.Message);
                return retu;
            }
        }
        #endregion
        #region 点对点转运任务

        /// <summary>
        /// 点对点转运任务
        /// </summary>
        /// <param name="OutWorkArea"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ZcTransportTask")]
        public OperateResult ZcTransportTask(OutWorkAreaEntity OutWorkArea)
        {
            try
            {
                OperateResult result = OperateResult.Succeed();
                LogHelper.Info("转运", "入参--" + JsonConvert.SerializeObject(OutWorkArea));
                result = BLLCreator.CreateSingleton<TransportTaskBll>().TransportTask(OutWorkArea);
                return result;
            }
            catch (Exception ex)
            {
                LogHelper.Info("转运", "报错:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }
        #endregion
        #region MES 堆叠式修改货位容量
        /// <summary>
        /// MES 堆叠式修改货位容量
        /// </summary>
        /// <param name="receuveTask"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult ZcMesUpLocCurrent(MesLocCurrent receuveTask)
        {
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                LogHelper.Info("MES", "堆叠式修改货位容量:" + JsonConvert.SerializeObject(receuveTask));
                if (string.IsNullOrEmpty(receuveTask.Location_To))
                {
                    throw new Exception("货位为空");
                }
                var transJson = newDb.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex.Contains("堆叠-")).ToList();
                foreach (var item in transJson)
                {
                    List<string> ListString = new List<string>();
                    if (transJson != null)
                    {
                        ListString = JsonConvert.DeserializeObject<List<string>>(item.TypeJson);
                    }
                    if (ListString.Contains(receuveTask.Location_To))
                    {
                        string[] parts = item.TypeName.Split('-');
                        string resLoc = parts[1];
                        //先查
                        var endlication = newDb.Queryable<Location>().Where(e => e.S_LOC_CODE == resLoc)?.First();
                        if (endlication.N_CURRENT_NUM > 0)
                        {
                            try
                            {
                                newDb.BeginTran();
                                var I = newDb.Updateable<Location>().SetColumns(it => new Location()
                                {
                                    T_MODIFY = DateTime.Now,
                                    N_CURRENT_NUM = it.N_CURRENT_NUM - 1,
                                    T_FULL_TIME = DateTime.Now,
                                    S_LOCK_STATE = "无"
                                }).Where(x => x.S_LOC_CODE == endlication.S_LOC_CODE).ExecuteCommand();
                                if (I == 0)
                                {
                                    throw new Exception("修改失败");
                                }
                                newDb.CommitTran();
                                return OperateResult.Succeed();
                            }
                            catch (Exception ex)
                            {
                                LogHelper.Info("MES", "堆叠式修改货位容量 报错:" + ex.Message);
                                newDb.RollbackTran();
                                return OperateResult.Error(ex.Message);
                            }
                        }
                        else
                        {
                            throw new Exception("当前货位所对应的缓存点容量为0");
                        }
                    }
                    else
                    {

                    }
                }
                return OperateResult.Error($"失败--配置中未找到这个货位所属对应关系{receuveTask.Location_To}");
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES", "堆叠式修改货位容量 报错:" + ex.Message);
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion
        #region 上下架统计--Mobox大屏统计图
        /// <summary>
        /// Mobox大屏统计图
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("MoboxInOutStats")]
        public OperateResult MoboxInOutStats()
        {
            try
            {
                var time = DateTime.Now;
                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();

                var RkMt = new List<GroundingOffshelfEntitys>();
                var RkKt = new List<GroundingOffshelfEntitys>();
                var CkMt = new List<GroundingOffshelfEntitys>();
                var CkKt = new List<GroundingOffshelfEntitys>();
                var gghu = new List<GroundingOffshelfEntitysValue>();
                var hours = Enumerable.Range(0, 24).Select(h => new { Hour = h }).ToList();

                var queryableRight = newDb.Queryable<GroundingOffshelfEntitys>().Where(e => DateTime.Today <= e.T_CREATE && e.S_CNTR_CODE.Contains("TC1CM")).ToList();
                var Rk = queryableRight.FindAll(e => e.Type == "+").ToList();
                if (Rk.Any())
                {
                    RkMt = Rk.FindAll(e => !string.IsNullOrEmpty(e.S_ITEM_CODE)).ToList();
                    RkKt = Rk.FindAll(e => string.IsNullOrEmpty(e.S_ITEM_CODE)).ToList();
                }
                var Ck = queryableRight.FindAll(e => e.Type == "-").ToList();
                if (Ck.Any())
                {
                    CkMt = Ck.FindAll(e => !string.IsNullOrEmpty(e.S_ITEM_CODE)).ToList();
                    CkKt = Ck.FindAll(e => string.IsNullOrEmpty(e.S_ITEM_CODE)).ToList();
                }

                foreach (var item in hours)
                {
                    var iy1 = new GroundingOffshelfEntitysValue();
                    var iy2 = new GroundingOffshelfEntitysValue();
                    var iy3 = new GroundingOffshelfEntitysValue();
                    var iy4 = new GroundingOffshelfEntitysValue();
                    var ggh = RkMt.FindAll(e => e.T_CREATE.Hour == item.Hour).ToList();
                    iy1.N_HOUR = item.Hour;
                    iy1.S_TYPE = "入库";
                    iy1.S_TRAY_TYPE = "满托";
                    iy1.N_COUNT = ggh.Count();
                    gghu.Add(iy1);
                    var ggh2 = RkKt.FindAll(e => e.T_CREATE.Hour == item.Hour).ToList();
                    iy2.N_HOUR = item.Hour;
                    iy2.S_TYPE = "入库";
                    iy2.S_TRAY_TYPE = "空托";
                    iy2.N_COUNT = ggh2.Count();
                    gghu.Add(iy2);
                    var ggh3 = CkMt.FindAll(e => e.T_CREATE.Hour == item.Hour).ToList();
                    iy3.N_HOUR = item.Hour;
                    iy3.S_TYPE = "出库";
                    iy3.S_TRAY_TYPE = "满托";
                    iy3.N_COUNT = ggh3.Count();
                    gghu.Add(iy3);
                    var ggh4 = CkKt.FindAll(e => e.T_CREATE.Hour == item.Hour).ToList();
                    iy4.N_HOUR = item.Hour;
                    iy4.S_TYPE = "出库";
                    iy4.S_TRAY_TYPE = "空托";
                    iy4.N_COUNT = ggh4.Count();
                    gghu.Add(iy4);
                }
                return OperateResult.Succeed("", gghu);
            }
            catch (Exception ex)
            {

                return OperateResult.Error(ex.Message);
            }
        }
        #endregion
        #endregion
        [HttpGet]
        [Route("asss")]
        public OperateResult asss(int T)
        {
            // List<OperateResult> nn = new List<OperateResult>();
            //var ca = BLLCreator.Create<IdGuid>().TaskNo("CK");
            //LogHelper.Info("任务下发", "MES下发任务参数:");
            //return OperateResult.Succeed(ca.ToString());
            //   long iny = await SnowflakeId.GetSnowFlakeID();
            //WcsTaskState Supplier = JsonConvert.DeserializeObject<WcsTaskState>(jsonData.ToString());
            //var childA = SqlSugarHelper.Db.GetConnection("2");
            //var GGF = childA.Queryable<BDST_TO_AGV_STATUS>().OrderBy(st => st.VMI_TO_AGV_DATA, OrderByType.Desc)?.First();
            //nn.Add(OperateResult.Succeed("", GGF));
            //var GGF2 = childA.Queryable<DATA_TO_HMI>()?.First();
            //nn.Add(OperateResult.Succeed("", GGF2));
            //return nn;
            // BLLCreator.CreateSingleton<DingDingHelper>().button1_Click($"{Supplier.requestPk} {DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")}");
            // BLLCreator.CreateSingleton<DingDingHelper>().button1_Click($"{Supplier.requestPk}", Supplier.taskNo ?? "");

            //    var gg = BLLCreator.CreateSingleton<DingDingHelper>().SendTextMessageToUser("WMS通知:库存不足", "kks53nw");
            //BLLCreator.CreateSingleton<DingDingHelper>().button1_Click($"测试   {DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")} ");
            //  MonitorAgvDate.CheckCamera(T);
            return OperateResult.Succeed();
        }

        public void CwLine(string Text)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(Text);
            Console.ForegroundColor = ConsoleColor.White;
        }
    }
}