using HH.WCS.Hexafluo;
using HH.WCS.Hexafluo.util;
using HH.WCS.Hexafluo.wms;
using HH.WCS.SJML.Comm;
using HH.WCS.SJML.dispatch;
using HH.WCS.SJML.Dto;
using HH.WCS.SJML.Entitys;
using HH.WCS.SJML.InWork;
using HH.WCS.SJML.util;
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;

namespace HH.WCS.SJML.Bll
{
    public class InWorkAreaBll
    {
        public virtual OperateResult InWorkArea(List<InWorkAreaEntity> inWorkAreaEntitys)
        {
            var logPara = LogType.LogPara("入作业区");
            LogHelper.InDetail(logPara, "InWorkArea接口请求参数：" + JsonConvert.SerializeObject(inWorkAreaEntitys));
            OperateResult er = InWorkArea(inWorkAreaEntitys, logPara);
            var result = JsonConvert.SerializeObject(er);
            LogHelper.InDetail(logPara, "InWorkArea接口返回结果：" + result);
            return er;
        }

        public virtual OperateResult InWorkArea(List<InWorkAreaEntity> inWorkAreaEntitys, LogPara logPara)
        {
            var response = new OperateResult();
            if (inWorkAreaEntitys == null) return new OperateResult { Success = false, Msg = "参数不正确" };
            for (var i = 0; i < inWorkAreaEntitys.Count; i++)
            {
                var result = InWorkArea(inWorkAreaEntitys[i], logPara);

                if (result.BasisResponse.Success)
                {
                    response.Success = true;
                    response.okList.Add(result.TaskExecuteState.okTask);
                    //发送到AMS
                }
                else
                {
                    response.failList.Add(new TaskExecuteState().Error(i, result.BasisResponse.Msg).FailTask);
                    //入库转运锁定起点的，如果执行不成功则解锁

                    if (result.RollbackLocations.Count > 0)
                    {
                        var chi = new SqlHelper<object>().GetInstance();
                        var newDb = chi.CopyNew();
                        foreach (string sLocation in result.RollbackLocations)
                        {
                            newDb.BeginTran();
                            var I = newDb.Updateable<Location>().SetColumns(it => it.S_LOCK_STATE == "无").Where(x => x.S_LOC_CODE == sLocation).ExecuteCommand();
                            if (I == 0)
                            {
                                newDb.RollbackTran();
                            }
                            newDb.CommitTran();
                        }
                    }
                }
                response.Code = result.BasisResponse.Code;
                response.Msg = result.BasisResponse.Msg;
            }
            //var curResult = (response.failList.Any() ? response.Error(null, string.Empty, inWorkAreaEntitys) : response.Ok(null, inWorkAreaEntitys));
            //if (!curResult.Success)
            //{
            //    curResult.Code = response.Code;
            //}
            LogHelper.Info("入库", " response.errCode是" + JsonConvert.SerializeObject(response));
            return response;
        }
        public virtual ExecuteInWorkAreaPara InWorkArea(InWorkAreaEntity inWorkAreaEntity, LogPara logPara)
        {
            if (string.IsNullOrEmpty(inWorkAreaEntity.TaskOrderType)) inWorkAreaEntity.TaskOrderType = "自管";
            var executeInWorkAreaPara = new ExecuteInWorkAreaPara { InWorkAreaEntity = inWorkAreaEntity };
            try
            {
                if (!InWorkAreaVerifyPara(ref executeInWorkAreaPara, logPara).BasisResponse.Success) return executeInWorkAreaPara;
                if (!InWorkAreaHandlePara(ref executeInWorkAreaPara, logPara).BasisResponse.Success) return executeInWorkAreaPara;
                if (string.IsNullOrEmpty(inWorkAreaEntity.endBit))
                {
                    if (!InWorkAreaCalculatePath(ref executeInWorkAreaPara, logPara).BasisResponse.Success) return executeInWorkAreaPara;
                    if (!InWorkAreaInAss(ref executeInWorkAreaPara, logPara).BasisResponse.Success) return executeInWorkAreaPara;
                }
                InWorkAreaCreateTask(ref executeInWorkAreaPara, logPara);
                executeInWorkAreaPara = InWorkAreaProcedure(executeInWorkAreaPara, logPara);
            }
            catch (System.Exception ex)
            {
                executeInWorkAreaPara.BasisResponse = OperateResult.Error("ExecuteInWorkArea 方法异常：" + JsonConvert.SerializeObject(ex.Message));
                SqlSugarHelper.Db.RollbackTran();
            }
            return executeInWorkAreaPara;
        }
        public virtual ExecuteInWorkAreaPara InWorkAreaVerifyPara(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            if (executeInWorkAreaPara.InWorkAreaEntity.isTransport == null) executeInWorkAreaPara.InWorkAreaEntity.isTransport = "N";


            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            //物料编码_对象不为空时，必须存在物料编码
            if (executeInWorkAreaPara.InWorkAreaEntity.Data != null && executeInWorkAreaPara.InWorkAreaEntity.Data.Count() > 0)
                if (executeInWorkAreaPara.InWorkAreaEntity.Data.Any(entity => string.IsNullOrEmpty(entity.S_ITEM_CODE)))
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("物料编码为空" + JsonConvert.SerializeObject(executeInWorkAreaPara.InWorkAreaEntity.Data));
                    return executeInWorkAreaPara;
                }

            //任务号_当任务号不为空时，系统判断任务号是否重复
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
            {
                var taskNo = executeInWorkAreaPara.InWorkAreaEntity.taskNo;

                if (SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => e.S_TASK_NO == taskNo).ToList().Count() > 0)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("任务号" + executeInWorkAreaPara.InWorkAreaEntity.taskNo + "重复！");
                    return executeInWorkAreaPara;
                }
            }
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.startBit))
            {
                executeInWorkAreaPara.BasisResponse = OperateResult.Error("参数中缺少起始位置！" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                return executeInWorkAreaPara;
            }
            else
            {
                var startBit = executeInWorkAreaPara.InWorkAreaEntity.startBit?.Trim();
                //获取起点货位实体数据
                executeInWorkAreaPara.StartLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();
                if (executeInWorkAreaPara.StartLocationExt == null)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始位置未找到对应数据！(货位表)" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    return executeInWorkAreaPara;
                }
                if (executeInWorkAreaPara.StartLocationExt?.C_ENABLE != "Y")
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始位置未处于启用状态(货位表)" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    return executeInWorkAreaPara;
                }
                //缓存起始库区实体
                var StartArea = executeInWorkAreaPara.StartLocationExt.S_AREA_CODE;
                executeInWorkAreaPara.StartStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == StartArea)?.First();
                if (executeInWorkAreaPara.StartStockAreaEntity == null)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始位置未找到对应的库区！" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    return executeInWorkAreaPara;
                }

                // 检查货位状态  是转运且管控数量时使用
                if (executeInWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY.Equals("Y"))
                {
                    executeInWorkAreaPara.InWorkAreaEntity.isTransport = "Y";
                    if (!executeInWorkAreaPara.StartLocationExt.S_LOCK_STATE.Equals("无"))
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始货位状态为" + executeInWorkAreaPara.StartLocationExt.S_LOCK_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    if (executeInWorkAreaPara.StartLocationExt.N_CURRENT_NUM == 0)
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始货位存储数量为" + executeInWorkAreaPara.StartLocationExt.N_CURRENT_NUM + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }

                    //锁定起点货位
                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Updateable<Location>().SetColumns(it => it.S_LOCK_STATE == "出库锁").Where(x => x.S_LOC_CODE == startBit && x.S_LOCK_STATE == "无").ExecuteCommand();
                        if (I == 0)
                        {
                            throw new System.Exception("锁定起点货位失败!");
                        }
                        else
                        {
                            executeInWorkAreaPara.RollbackLocations.Add(executeInWorkAreaPara.InWorkAreaEntity.startBit);
                        }
                        newDb.CommitTran();
                    }
                    catch (System.Exception ex)
                    {
                        newDb.RollbackTran();
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                        return executeInWorkAreaPara;
                    }
                }
                //检查起点货位是否为报废状态 
                executeInWorkAreaPara.InWorkAreaEntity.startArea = executeInWorkAreaPara.StartStockAreaEntity.S_AREA_CODE;
                executeInWorkAreaPara.InWorkAreaEntity.startStock = executeInWorkAreaPara.StartStockAreaEntity.S_WH_CODE;
            }
            //当指定目的位置后 参数验证
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.endBit))
            {
                var EndBit = executeInWorkAreaPara.InWorkAreaEntity.endBit?.Trim();
                //获取目的货位实体数据
                executeInWorkAreaPara.EndLocationEntity = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == EndBit)?.First();
                if (executeInWorkAreaPara.EndLocationEntity == null)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前目的位置未找到对应数据！(货位表)" + executeInWorkAreaPara.InWorkAreaEntity.endBit);
                    return executeInWorkAreaPara;
                }
                if (executeInWorkAreaPara.EndLocationEntity?.C_ENABLE != "Y")
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前目的位置未处于启用状态(货位表)" + executeInWorkAreaPara.InWorkAreaEntity.endBit);
                    return executeInWorkAreaPara;
                }
                //缓存目的库区实体
                var EndArea = executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE;
                executeInWorkAreaPara.EndStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == EndArea)?.First();
                if (executeInWorkAreaPara.EndStockAreaEntity == null)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前目的位置未找到对应的库区！" + executeInWorkAreaPara.InWorkAreaEntity.endBit);
                    return executeInWorkAreaPara;
                }

                // 检查货位状态  是转运且管控数量时使用
                if (executeInWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY.Equals("Y"))
                {
                    if (!executeInWorkAreaPara.EndLocationEntity.S_LOCK_STATE.Equals("无"))
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前目的货位状态为" + executeInWorkAreaPara.EndLocationEntity.S_LOCK_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    if (executeInWorkAreaPara.EndLocationEntity.N_CURRENT_NUM > 0)
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前起始货位存储数量为" + executeInWorkAreaPara.EndLocationEntity.N_CURRENT_NUM + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }

                    //锁定目的货位
                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Updateable<Location>().SetColumns(it => it.S_LOCK_STATE == "入库锁").Where(x => x.S_LOC_CODE == EndBit && x.S_LOCK_STATE == "无").ExecuteCommand();
                        if (I == 0)
                        {
                            throw new System.Exception("锁定目的货位失败!");
                        }
                        else
                        {
                            executeInWorkAreaPara.RollbackLocations.Add(executeInWorkAreaPara.InWorkAreaEntity.endBit);
                        }
                        newDb.CommitTran();
                    }
                    catch (System.Exception ex)
                    {
                        newDb.RollbackTran();
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                        return executeInWorkAreaPara;
                    }
                }
                //检查起点货位是否为报废状态 
                executeInWorkAreaPara.InWorkAreaEntity.endArea = executeInWorkAreaPara.EndStockAreaEntity.S_AREA_CODE;
                executeInWorkAreaPara.InWorkAreaEntity.endStock = executeInWorkAreaPara.EndStockAreaEntity.S_WH_CODE;
            }
            return executeInWorkAreaPara;
        }

        public virtual ExecuteInWorkAreaPara InWorkAreaHandlePara(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            //任务号 考虑是否重复？
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
            {
                executeInWorkAreaPara.InWorkAreaEntity.taskNo = BLLCreator.Create<IdGuid>().TaskNo("RK");
                if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("生成任务号失败");
                    return executeInWorkAreaPara;
                }
            }
            //托盘码
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.trayCode))
            {
                //转运并且不传托盘号，默认从货位中获取
                if (executeInWorkAreaPara.InWorkAreaEntity.isTransport == "Y")
                {
                    var startBit = executeInWorkAreaPara.InWorkAreaEntity.startBit;
                    var lstObj = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_LOC_CODE == startBit).ToList();
                    if (lstObj.Count() > 0)
                    {
                        //去除已经在任务中的托盘
                        var strTray = string.Join("','", lstObj.Select(o => o.S_CNTR_CODE).ToList());
                        List<string> state = new List<string> { "完成", "取消" };
                        var lstTasks = SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => strTray.Contains(e.S_CNTRS) && !(state.Contains(e.S_B_STATE))).ToList();

                        var lstInTaskTray = lstTasks.Select(o => o.S_CNTRS).ToList();
                        lstObj.RemoveAll(o => lstInTaskTray.Contains(o.S_CNTR_CODE));

                        if (lstObj.Count > 0)
                        {
                            executeInWorkAreaPara.InWorkAreaEntity.trayCode = lstObj[0].S_CNTR_CODE;

                            //根据托盘号查询托盘产品关联信息主表
                            var trayItemMst = SqlSugarHelper.Db.Queryable<CntrItemRel>().Where(e => e.S_CNTR_CODE == lstObj[0].S_CNTR_CODE).ToList();
                        }
                        else
                        {
                            executeInWorkAreaPara.BasisResponse = OperateResult.Error("该货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "中的托盘都已在任务中，不允许重复下达");
                        }
                    }
                    else
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("起点货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "没有绑定托盘");
                        return executeInWorkAreaPara;
                    }
                }
                else
                {
                    var startBit = executeInWorkAreaPara.InWorkAreaEntity.startBit;
                    var trayLocation = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_LOC_CODE == startBit)?.First();
                    if (trayLocation == null)
                    {
                        //生成虚拟托盘
                        var vgy = SnowflakeId.SowId();
                        for (int i = 0; i < 10; i++)
                        {
                            var lObj = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == vgy.ToString()).ToList();
                            if (lObj.Count() == 0)
                            {
                                break;
                            }
                            else
                            {
                                vgy = SnowflakeId.SowId();
                            }
                        }
                        if (executeInWorkAreaPara.InWorkAreaEntity.TrayType == "KJZ")
                        {

                            executeInWorkAreaPara.InWorkAreaEntity.trayCode = "KJZ" + vgy;
                        }
                        else
                        {
                            executeInWorkAreaPara.InWorkAreaEntity.trayCode = "XN" + vgy;
                        }
                    }
                    else
                    {
                        executeInWorkAreaPara.InWorkAreaEntity.trayCode = trayLocation.S_CNTR_CODE;
                    }
                }
            }
            else
            {
                //验证托盘是否合法 ---排除库中托盘及正在执行的任务中的托盘
                var trayCode = executeInWorkAreaPara.InWorkAreaEntity.trayCode;
                var TrayLoca = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == trayCode).ToList();

                List<string> state = new List<string> { "完成", "取消" };
                var WmTask = SqlSugarHelper.Db.Queryable<WMSTask>().Where(e => e.S_CNTRS == trayCode && !(state.Contains(e.S_B_STATE))).ToList();
                LogHelper.Info("入库", "入库校验托盘是否在执行的任务中 查询的结果：" + JsonConvert.SerializeObject(WmTask));
                if (TrayLoca.Count() > 0 && executeInWorkAreaPara.InWorkAreaEntity.isTransport != "Y")
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("该托盘" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "已在库区中，不允许重复下达");
                    executeInWorkAreaPara.BasisResponse.Code = "100";//标识托盘已存在库中
                    return executeInWorkAreaPara;
                }
                if (WmTask.Count() > 0)
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("托盘" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "该负载已存在运输");
                    executeInWorkAreaPara.BasisResponse.Code = "100";//标识托盘已存在库中
                    return executeInWorkAreaPara;
                }
            }
            //处理物料编码
            if (executeInWorkAreaPara.InWorkAreaEntity.Data != null)
            {
                //foreach (var itemData in executeInWorkAreaPara.InWorkAreaEntity.Data)
                //{
                //    //查询物料维护表数据--查询该物料是否合法

                //    var item = SqlSugarHelper.Db.Queryable<TN_MaterialEntitys>().Where(e => e.S_ITEM_CODE == itemData.S_ITEM_CODE).ToList();
                //    if (item != null)
                //    {
                //    }
                //    else
                //    {
                //        executeInWorkAreaPara.BasisResponse = OperateResult.Error("物料" + itemData.S_ITEM_CODE + "在物料维护表中没有维护");
                //        return executeInWorkAreaPara;
                //    }
                //}
            }

            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.endBit))
            {
                var endBit = executeInWorkAreaPara.InWorkAreaEntity.endBit?.Trim();
                executeInWorkAreaPara.EndLocationEntity = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == endBit)?.First();
                if (executeInWorkAreaPara.EndLocationEntity != null)
                {
                    var EndArea = executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE;
                    executeInWorkAreaPara.EndStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == EndArea)?.First();
                    if (executeInWorkAreaPara.EndStockAreaEntity == null)
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("结束位置：" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "，库区：" + executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE + "未找到库区信息！");
                        return executeInWorkAreaPara;
                    }
                }
                else
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error("结束位置：" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "未找到货位信息！");
                    return executeInWorkAreaPara;
                }
                // 检查货位状态  管控数量时使用
                if (executeInWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY.Equals("Y"))
                {

                    if (!executeInWorkAreaPara.EndLocationEntity.S_LOCK_STATE.Equals("无"))
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前终点货位状态为" + executeInWorkAreaPara.EndLocationEntity.S_LOCK_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    if (executeInWorkAreaPara.EndLocationEntity.N_CURRENT_NUM > 0)
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("当前终点货位存储数量为" + executeInWorkAreaPara.EndLocationEntity.N_CURRENT_NUM + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    //锁定终点货位
                    try
                    {
                        newDb.BeginTran();
                        var I = newDb.Updateable<Location>().SetColumns(it => it.S_LOCK_STATE == "入库锁").Where(x => x.S_LOC_CODE == endBit && x.S_LOCK_STATE == "无").ExecuteCommand();
                        if (I == 0)
                        {
                            throw new System.Exception("锁定起点货位失败!");
                        }
                        else
                        {
                            executeInWorkAreaPara.RollbackLocations.Add(executeInWorkAreaPara.InWorkAreaEntity.endBit);
                        }
                        newDb.CommitTran();
                    }
                    catch (System.Exception ex)
                    {
                        newDb.RollbackTran();
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                        return executeInWorkAreaPara;
                    }
                }
            }
            return executeInWorkAreaPara;
        }

        public virtual ExecuteInWorkAreaPara InWorkAreaCalculatePath(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            //获取作业区列表
            //这里在判断是否需要作业区流程
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.endArea))
            {
                var S_WH_CODE = executeInWorkAreaPara.StartStockAreaEntity.S_WH_CODE;
                var S_AREA_CODE = executeInWorkAreaPara.StartStockAreaEntity.S_AREA_CODE;
                if (executeInWorkAreaPara.EndStockAreaEntity?.S_AREA_TYPE == "立库")
                {
                    var Subs = Expressionable.Create<TN_SubsidiaryEntitys>();
                    Subs.And(it => it.S_WH_CODE == S_WH_CODE);
                    Subs.And(it => it.S_AREA_CODE == S_AREA_CODE);
                    var Subsidiary = SqlSugarHelper.Db.Queryable<TN_SubsidiaryEntitys>().Where(Subs.ToExpression()).ToList();
                    if (Subsidiary.Any())
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("辅助表未查询到对应库区的数据！库区:" + S_AREA_CODE);
                        throw new Exception("辅助表未查询到对应库区的数据！库区:" + S_AREA_CODE);
                    }
                    else
                    {
                        if (Subsidiary.FindAll(e => e.S_YN_JOBPATH == "Y").Count() == 0)
                        {
                            //不需要的话就直接返回
                            TN_WorkFlowEntitys Flow = new TN_WorkFlowEntitys();
                            Flow.S_StartArea = executeInWorkAreaPara.StartStockAreaEntity?.S_AREA_CODE;
                            Flow.S_EndArea = executeInWorkAreaPara.EndStockAreaEntity?.S_AREA_CODE;
                            if (string.IsNullOrEmpty(Flow.S_EndArea))
                            {
                                executeInWorkAreaPara.BasisResponse = OperateResult.Error("未启用作业路径,并且未下达终点库区参数 库区:" + S_AREA_CODE);
                                throw new Exception("未启用作业路径,并且未下达终点库区参数！库区:" + S_AREA_CODE);
                            }
                            executeInWorkAreaPara.WorkAreaProEntitys.Add(Flow);
                            return executeInWorkAreaPara;
                        }
                    }
                }
                else
                {
                    //不需要的话就直接返回
                    TN_WorkFlowEntitys Flow = new TN_WorkFlowEntitys();
                    Flow.S_StartArea = executeInWorkAreaPara.StartStockAreaEntity?.S_AREA_CODE;
                    Flow.S_EndArea = executeInWorkAreaPara.EndStockAreaEntity?.S_AREA_CODE;
                    if (string.IsNullOrEmpty(Flow.S_EndArea))
                    {
                        executeInWorkAreaPara.BasisResponse = OperateResult.Error("未启用作业路径,并且未下达终点库区参数 库区:" + S_AREA_CODE);
                        throw new Exception("未启用作业路径,并且未下达终点库区参数！库区:" + S_AREA_CODE);
                    }
                    executeInWorkAreaPara.WorkAreaProEntitys.Add(Flow);
                    return executeInWorkAreaPara;
                }
            }
            var workAreaProList = GetInWorkPosition(executeInWorkAreaPara);
            if (workAreaProList.Any())
            {
                executeInWorkAreaPara.WorkAreaProEntitys = workAreaProList;
            }
            else
            {
                executeInWorkAreaPara.BasisResponse = OperateResult.Error("未找到该起点库区到终点库区的作业流转流程！");
                throw new Exception("未找到该起点库区到终点库区的作业流转流程！");
            }
            return executeInWorkAreaPara;
        }


        public virtual ExecuteInWorkAreaPara InWorkAreaInAss(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            List<string> Roadway = new List<string>();
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.S_Roadway))
            {
                Roadway.Add(executeInWorkAreaPara.InWorkAreaEntity.S_Roadway);
            }
            var logicAreaCode = string.Empty;
            logicAreaCode = executeInWorkAreaPara.InWorkAreaEntity.locationGear;
            var aEntity = new InAssignEntity()
            {
                objectType = InAssignEntity.ObjectType.托盘,
                S_TASK_NO = executeInWorkAreaPara.InWorkAreaEntity.taskNo,
                objectCode = executeInWorkAreaPara.InWorkAreaEntity.trayCode,
                itemCode = (executeInWorkAreaPara.InWorkAreaEntity.Data != null &&
                 executeInWorkAreaPara.InWorkAreaEntity.Data.Count > 0)
                    ? executeInWorkAreaPara.InWorkAreaEntity.Data[0].S_ITEM_CODE
                    : "",
                lstAreaPrior = executeInWorkAreaPara.WorkAreaProEntitys.Select(p => new areaPriorClass { areaCode = p.S_EndArea, Prior = p.S_Priority, S_FlowNo = p.S_FlowNo }).ToList(),
                projectCode = executeInWorkAreaPara.InWorkAreaEntity.projectCode,
                logicAreaCode = logicAreaCode,
                stockCode = executeInWorkAreaPara.InWorkAreaEntity.startStock,
                S_Roadway = Roadway,
                // callSys = executeInWorkAreaPara.InWorkAreaEntity.sysName,
                needCalLock = true
            };

            //根据库区获取货位
            InAssignResultEntity resultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(aEntity);
            if (resultEntity.Success)
            {
                executeInWorkAreaPara.TransportEntity.CN_S_QTY_INDEX = resultEntity.index;
                //增加到回滚记录里面
                if ((resultEntity.areaType == Constants.Area_Struc_PingStock || resultEntity.areaType == Constants.Area_Struc_LiStock) && resultEntity.isControlQty == "Y")
                {
                    executeInWorkAreaPara.RollbackLocations.Add(resultEntity.locationCode);
                }

                var loca = Expressionable.Create<Location>();
                loca.And(it => it.S_LOC_CODE == resultEntity.locationCode);
                executeInWorkAreaPara.EndLocationEntity = SqlSugarHelper.Db.Queryable<Location>().Where(loca.ToExpression())?.First();
                if (executeInWorkAreaPara.EndLocationEntity != null)
                {
                    var Areacode = executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE;
                    var area = Expressionable.Create<TN_AreaEntitys>();
                    area.And(it => it.S_AREA_CODE == Areacode);
                    executeInWorkAreaPara.EndStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(area.ToExpression())?.First();
                }
            }
            else
            {
                executeInWorkAreaPara.BasisResponse = OperateResult.Error("在" + string.Join(",", executeInWorkAreaPara.WorkAreaProEntitys.Select(o => o.S_EndArea).ToList()) + "库区中未找到合适的入库货位,详细原因：" + resultEntity.Msg);
            }

            return executeInWorkAreaPara;
        }


        /// <summary>
        /// 获取作业区流程列表
        /// </summary>
        /// <param name="executeInWorkAreaPara"></param>
        /// <returns></returns>
        public List<TN_WorkFlowEntitys> GetInWorkPosition(ExecuteInWorkAreaPara executeInWorkAreaPara)
        {
            //根据起始库区计算作业区
            var startArea = executeInWorkAreaPara.InWorkAreaEntity.startArea;
            var endArea = executeInWorkAreaPara.InWorkAreaEntity.endArea;
            var exp = Expressionable.Create<TN_WorkFlowEntitys>();
            exp.AndIF(!string.IsNullOrEmpty(startArea), it => it.S_StartArea == startArea);
            exp.AndIF(!string.IsNullOrEmpty(endArea), it => it.S_EndArea == endArea);
            exp.And(it => it.S_IS_IN_OUT == "入库");
            var workAreaProList = SqlSugarHelper.Db.Queryable<TN_WorkFlowEntitys>().Where(exp.ToExpression()).ToList();
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.TaskFlow))
            {
                workAreaProList = workAreaProList.FindAll(e => e.S_FlowNo == executeInWorkAreaPara.InWorkAreaEntity.TaskFlow).ToList();
            }
            return workAreaProList;
        }

        public virtual ExecuteInWorkAreaPara InWorkAreaCreateTask(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            executeInWorkAreaPara.TransportEntity.CN_S_TASK_NO = executeInWorkAreaPara.InWorkAreaEntity.taskNo;
            executeInWorkAreaPara.TransportEntity.CN_S_CIR_OBJ = "托盘";
            executeInWorkAreaPara.TransportEntity.CN_S_CIR_OBJ_CODE = executeInWorkAreaPara.InWorkAreaEntity.trayCode;
            executeInWorkAreaPara.TransportEntity.CN_S_START_BIT = executeInWorkAreaPara.InWorkAreaEntity.startBit;
            executeInWorkAreaPara.TransportEntity.CN_S_STATE = "未执行";
            executeInWorkAreaPara.TransportEntity.CN_N_PRIORITY = executeInWorkAreaPara.InWorkAreaEntity.priority;
            executeInWorkAreaPara.TransportEntity.CN_T_CREATE = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");//DateTime.Now.ToString();
            executeInWorkAreaPara.TransportEntity.CN_T_MODIFY = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");//DateTime.Now.ToString();
            executeInWorkAreaPara.TransportEntity.CN_S_REMARK = executeInWorkAreaPara.InWorkAreaEntity.remark;
            executeInWorkAreaPara.TransportEntity.CN_S_START_AREA = executeInWorkAreaPara.InWorkAreaEntity.startArea;
            executeInWorkAreaPara.TransportEntity.CN_S_STOCK_CODE = executeInWorkAreaPara.InWorkAreaEntity.startStock;
            executeInWorkAreaPara.TransportEntity.CN_S_TASK_TYPE = executeInWorkAreaPara.InWorkAreaEntity.isTransport == "Y" ? "转运" : "入库";
            executeInWorkAreaPara.TransportEntity.CN_S_END_BIT = executeInWorkAreaPara.EndLocationEntity.S_LOC_CODE;
            executeInWorkAreaPara.TransportEntity.CN_S_END_AREA = executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE;
            executeInWorkAreaPara.TransportEntity.CN_C_END_IS_CONTROL_QTY = executeInWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY;
            return executeInWorkAreaPara;
        }


        public virtual ExecuteInWorkAreaPara InWorkAreaProcedure(ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            InWorkAreaProcedureFunc(executeInWorkAreaPara, logPara);
            //判断空托 满托
            if (executeInWorkAreaPara.WorkSubsidiary?.S_YN_JOBPATH == "Y")
            {
                if (executeInWorkAreaPara.WorkAreaProEntity?.S_Subtask != "Y")
                {
                    if (executeInWorkAreaPara.WorkAreaProEntity?.S_TransAgv == "Y")
                    {
                        //通知小车
                        //var ta = TaskProcess.SendTask(executeInWorkAreaPara.TaskEntity);
                        //LogHelper.InDetail(logPara, "通知小车是否成功:" + ta);
                        //LogHelper.InDetail(logPara, "通知小车");
                        //if (!ta)
                        //{
                        //    throw new Exception("通知小车失败");
                        //}
                        //else
                        //{
                        //    SqlSugarHelper.Db.CommitTran();
                        //}
                        SqlSugarHelper.Db.CommitTran();
                    }
                    if (executeInWorkAreaPara.WorkAreaProEntity.S_TransWcs == "Y")
                    {

                        //通知立库
                        var ta = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(executeInWorkAreaPara.TaskEntity, executeInWorkAreaPara.InWorkAreaEntity.Data?.FirstOrDefault());
                        LogHelper.InDetail(logPara, "通知立库是否成功:" + JsonConvert.SerializeObject(ta));
                        LogHelper.InDetail(logPara, "通知立库");
                        if (!ta.Success)
                        {
                            throw new Exception("通知立库失败");
                        }
                        else
                        {
                            SqlSugarHelper.Db.CommitTran();
                        }
                    }
                }
            }
            else
            {
                if (executeInWorkAreaPara.InWorkAreaEntity?.S_Subtask != "Y")
                {
                    if (executeInWorkAreaPara.InWorkAreaEntity?.S_TransAgv == "Y")
                    {
                        //通知小车
                        //var ta = TaskProcess.SendTask(executeInWorkAreaPara.TaskEntity);
                        //LogHelper.InDetail(logPara, "通知小车是否成功:" + ta);
                        //LogHelper.InDetail(logPara, "通知小车");
                        //if (!ta)
                        //{
                        //    throw new Exception("通知小车失败");
                        //}
                        //else
                        //{
                        //    SqlSugarHelper.Db.CommitTran();
                        //}
                        SqlSugarHelper.Db.CommitTran();
                    }
                    if (executeInWorkAreaPara.InWorkAreaEntity?.S_TransWcs == "Y")
                    {
                        //通知立库
                        var ta = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(executeInWorkAreaPara.TaskEntity, executeInWorkAreaPara.InWorkAreaEntity.Data?.FirstOrDefault());
                        LogHelper.InDetail(logPara, "通知立库是否成功:" + JsonConvert.SerializeObject(ta));
                        LogHelper.InDetail(logPara, "通知立库");
                        if (!ta.Success)
                        {
                            throw new Exception("通知立库失败");
                        }
                        else
                        {
                            SqlSugarHelper.Db.CommitTran();
                        }
                    }
                }
            }
            executeInWorkAreaPara.TaskExecuteState = new TaskExecuteState().Ok(new OkTask()
            {
                index = executeInWorkAreaPara.index,
                taskNo = executeInWorkAreaPara.TransportEntity.CN_S_TASK_NO,
                startStock = executeInWorkAreaPara.TransportEntity.CN_S_STOCK_CODE,
                startArea = executeInWorkAreaPara.TransportEntity.CN_S_START_AREA,
                startBit = executeInWorkAreaPara.TransportEntity.CN_S_START_BIT,
                endStock = executeInWorkAreaPara.TransportEntity.CN_S_STOCK_CODE,
                endArea = executeInWorkAreaPara.TransportEntity.CN_S_END_AREA,
                endBit = executeInWorkAreaPara.TransportEntity.CN_S_END_BIT,
                priority = executeInWorkAreaPara.TransportEntity.CN_N_PRIORITY,
                trayCode = executeInWorkAreaPara.TransportEntity.CN_S_CIR_OBJ_CODE,
                startAreaClass = executeInWorkAreaPara.TransportEntity.CN_S_START_AREA_TYPE,
                endAreaClass = executeInWorkAreaPara.TransportEntity.CN_S_END_AREA_TYPE
            });
            SqlSugarHelper.Db.CommitTran();
            return executeInWorkAreaPara;
        }

        public virtual void InWorkAreaProcedureFunc(ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            //这里获取辅助表对应的  接驳位- -准备点 
            //这里判断库区是否可用 并且哪些巷道可用 且必须库区类型是立库
            var Subs = Expressionable.Create<TN_SubsidiaryEntitys>();
            var transport = executeInWorkAreaPara.TransportEntity;
            executeInWorkAreaPara.WorkAreaProEntity = executeInWorkAreaPara.WorkAreaProEntitys.Find(e => e.S_StartArea == transport.CN_S_START_AREA && e.S_EndArea == transport.CN_S_END_AREA);
            Subs.And(it => it.S_WH_CODE == executeInWorkAreaPara.EndLocationEntity.S_WH_CODE);
            Subs.And(it => it.S_AREA_CODE == executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE);
            Subs.And(it => it.N_ROADWAY == executeInWorkAreaPara.EndLocationEntity.N_ROADWAY);
            Subs.And(it => it.S_IS_IN_OUT == "入库");
            var Subsidiary = SqlSugarHelper.Db.Queryable<TN_SubsidiaryEntitys>().Where(Subs.ToExpression()).ToList();
            var S_Jb_Bit = "";
            if (Subsidiary.Count() == 0 && executeInWorkAreaPara.InWorkAreaEntity.NoAssist != "Y")
            {
                executeInWorkAreaPara.BasisResponse = OperateResult.Error($"辅助表未查询到对应的库区数据 请核实 仓库:{executeInWorkAreaPara.EndLocationEntity.S_WH_CODE} 库区:{executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE} 巷道:{executeInWorkAreaPara.EndLocationEntity.N_ROADWAY} 流程去向:入库  ,请确定立库是否报警");
                throw new Exception($"辅助表未查询到对应的库区数据 请核实 仓库:{executeInWorkAreaPara.EndLocationEntity.S_WH_CODE} 库区:{executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE} 巷道:{executeInWorkAreaPara.EndLocationEntity.N_ROADWAY} 流程去向:入库, 请确定立库是否报警");
            }
            var Subsidia = Subsidiary.FirstOrDefault();
            if (Subsidia.S_AREA_TYPE == Constants.Area_Struc_LiStock && Subsidia.S_YN_JOBPATH != "Y")
            {
                S_Jb_Bit = Subsidia.S_CONNECTION;
            }
            else
            {
                if (!string.IsNullOrEmpty(executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo))
                {
                    var ttr = Subsidiary.Find(e => e.S_FlowNo == executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo);
                    if (ttr != null)
                    {
                        var Location = ttr.S_CONNECTION.Split(',').ToList();
                        var IsJb = SqlSugarHelper.Db.Queryable<TN_IsopenBitEntitys>().Where(e => e.S_IsOpen == "N" && Location.Contains(e.S_JbBit)).ToList();
                        if (IsJb.Count() > 0)
                        {
                            var A = 0;
                            var lo = new List<string>();
                            foreach (var item in Location)
                            {
                                if (executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE == "LC11M")
                                {
                                    if (executeInWorkAreaPara.EndLocationEntity.N_ROADWAY == 1)
                                    {
                                        var Jbw1 = IsJb.Find(e => e.S_JbBit == "TMRKHCW-01");
                                        if (Jbw1 != null)
                                        {
                                            if (item == "TMRKJBW-02" || item == "TMRKJBW-03")
                                            {
                                                continue;
                                            }
                                        }
                                    }
                                    if (executeInWorkAreaPara.EndLocationEntity.N_ROADWAY == 4)
                                    {
                                        var Jbw3 = IsJb.Find(e => e.S_JbBit == "TMRKHCW-02");
                                        if (Jbw3 != null)
                                        {
                                            if (item == "TMRKJBW-05" || item == "TMRKJBW-06")
                                            {
                                                continue;
                                            }
                                        }
                                    }
                                }
                                if (IsJb.FindAll(e => e.S_JbBit == item).ToList().Count() == 0)
                                {
                                    A++;
                                    lo.Add(item);
                                }
                            }
                            if (Location.Count() == A)
                            {
                                S_Jb_Bit = ttr.S_CONNECTION;
                            }
                            else
                            {
                                S_Jb_Bit = String.Join(",", lo);
                            }
                        }
                        else
                        {
                            S_Jb_Bit = ttr.S_CONNECTION;
                        }

                    }
                    else
                    {
                        S_Jb_Bit = "";
                    }
                }
                else
                {
                    S_Jb_Bit = "";
                }
                //S_Jb_Bit = Subsidia.S_CONNECTION;
                // S_Jb_Bit = executeInWorkAreaPara?.WorkAreaProEntity?.S_Jb_Bit;
                if (string.IsNullOrEmpty(S_Jb_Bit) && executeInWorkAreaPara.InWorkAreaEntity.NoAssist != "Y")
                {
                    executeInWorkAreaPara.BasisResponse = OperateResult.Error($"未筛选出对应的作业流程接驳位,请查询核对{executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo} 仓库:{executeInWorkAreaPara.EndLocationEntity.S_WH_CODE} 库区:{executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE} 巷道:{executeInWorkAreaPara.EndLocationEntity.N_ROADWAY} 流程去向:入库 流程编码为{executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo} ,请确定立库是否报警");
                    throw new Exception($"未筛选出对应的作业流程接驳位,请查询核对{executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo} 仓库:{executeInWorkAreaPara.EndLocationEntity.S_WH_CODE} 库区:{executeInWorkAreaPara.EndLocationEntity.S_AREA_CODE} 巷道:{executeInWorkAreaPara.EndLocationEntity.N_ROADWAY} 流程去向:入库 流程编码为{executeInWorkAreaPara?.WorkAreaProEntity?.S_FlowNo} , 请确定立库是否报警");
                }
            }
            executeInWorkAreaPara.WorkSubsidiary = Subsidia;

            if (executeInWorkAreaPara.InWorkAreaEntity.Data != null)
            {
                if (executeInWorkAreaPara.InWorkAreaEntity.Data.Count > 0)
                {
                    //删除托盘产品关联
                    LogHelper.Info("入库", "删除容器产品关联" + JsonConvert.SerializeObject(executeInWorkAreaPara.InWorkAreaEntity.Data));
                    var tray = executeInWorkAreaPara.InWorkAreaEntity.trayCode;
                    SqlSugarHelper.Db.BeginTran();
                    var I = SqlSugarHelper.Db.Deleteable<CntrItemRel>().Where(e => e.S_CNTR_CODE == tray).ExecuteCommand();
                    foreach (var item in executeInWorkAreaPara.InWorkAreaEntity.Data)
                    {
                        var trayItemMstGuid = Guid.NewGuid().ToString();
                        //添加托盘物料关联表
                        CntrItemRel rel = new CntrItemRel();
                        rel.S_ITEM_CODE = item.S_ITEM_CODE;
                        rel.S_ITEM_NAME = item.S_ITEM_NAME;
                        rel.S_CNTR_CODE = tray;
                        rel.S_BATCH_NO = item.S_BATCH_NO;
                        rel.TurnCardNum = item.TurnCardNum;
                        rel.Level = item.Level;
                        rel.itemModel = item.itemModel;
                        rel.expireTime = executeInWorkAreaPara.InWorkAreaEntity.expireTime;
                        rel.takeEffectTime = executeInWorkAreaPara.InWorkAreaEntity.takeEffectTime;
                        rel.F_QTY = Convert.ToDecimal(executeInWorkAreaPara.InWorkAreaEntity.CURRENT_AMOUNT);
                        rel.S_ITEM_STATE = executeInWorkAreaPara.InWorkAreaEntity.CHECK_INFO;
                        rel.productionDate = executeInWorkAreaPara.InWorkAreaEntity.PRODUCE_TIME;
                        rel.S_ITEM_SPEC = item.S_ITEM_SPEC;
                        rel.F_SUM_QTY = item.F_SUM_QTY;
                        rel.F_AVG_QTY = item.F_AVG_QTY;
                        rel.S_SUPPLIER_N0 = item.S_SUPPLIER_N0;
                        rel.S_SUPPLIER = item.S_SUPPLIER;
                        rel.applyProdSpecList = item.applyProdSpecList;
                        rel.T_INSTOCK = DateTime.Now;
                        var A = SqlSugarHelper.Db.Insertable(rel).ExecuteCommand();
                        if (A == 0)
                        {
                            SqlSugarHelper.Db.RollbackTran();
                            executeInWorkAreaPara.BasisResponse = OperateResult.Error("物料表添加失败");
                            throw new Exception("物料表添加失败");
                        }
                    }
                }
            }

            string objectTask = null;
            if (Subsidia?.S_YN_JOBPATH == "Y")
            {
                if (executeInWorkAreaPara.WorkAreaProEntity.S_Subtask != "Y")
                {
                    if (executeInWorkAreaPara.WorkAreaProEntity.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;
                    }
                    if (executeInWorkAreaPara.WorkAreaProEntity.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                    }
                }
            }
            else
            {
                if (executeInWorkAreaPara.InWorkAreaEntity.S_Subtask != "Y")
                {
                    if (executeInWorkAreaPara.InWorkAreaEntity.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;
                    }
                    if (executeInWorkAreaPara.InWorkAreaEntity.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                    }
                }
            }

            //创建任务
            LogHelper.Info("入库", "创建任务开始");
            WMSTask Task = new WMSTask();
            Task.S_TASK_NO = transport.CN_S_TASK_NO;
            Task.S_START_LAREA = transport.CN_S_START_AREA;
            Task.S_END_LAREA = transport.CN_S_END_AREA;
            Task.S_START_LOC = transport.CN_S_START_BIT;
            Task.S_END_LOC = transport.CN_S_END_BIT;
            Task.S_B_STATE = "未执行";
            Task.S_TYPE = "入库";
            Task.S_CNTRS = transport.CN_S_CIR_OBJ_CODE;
            Task.N_CNTR_COUNT = 1;
            Task.N_PRIORITY = transport.CN_N_PRIORITY;
            Task.S_NOTE = objectTask ?? "自管任务";
            Task.S_READ_LOCK = "N";
            Task.S_Subtask = executeInWorkAreaPara.WorkAreaProEntity.S_Subtask;
            Task.S_FlowNo = executeInWorkAreaPara.WorkAreaProEntity.S_FlowNo;
            Task.S_SRC_SYS = executeInWorkAreaPara.InWorkAreaEntity.TaskOrderType;
            Task.S_Jb_Bit = S_Jb_Bit;
            Task.S_Zb_Bit = executeInWorkAreaPara.WorkAreaProEntity.S_Zb_Bit;
            Task.S_TOOLS_TPYE = executeInWorkAreaPara.InWorkAreaEntity.TrayType ?? executeInWorkAreaPara.InWorkAreaEntity.locationGear;
            Task.S_UpstreamNo = executeInWorkAreaPara.InWorkAreaEntity.mesTaskNo;
            Task.S_InTaskType = executeInWorkAreaPara.InWorkAreaEntity.flag;
            Task.S_SRC_NO = transport.CN_S_TASK_NO;
            Task.S_Main_task = "主任务";
            var C = SqlSugarHelper.Db.Insertable(Task).ExecuteCommand();
            LogHelper.Info("入库", "   创建任务结束");
            if (C == 0)
            {
                SqlSugarHelper.Db.RollbackTran();
                executeInWorkAreaPara.BasisResponse = OperateResult.Error("任务表添加失败");
                throw new Exception("任务表添加失败");
            }
            executeInWorkAreaPara.TaskEntity = Task;

        }
    }
}