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.OutWork;
using HH.WCS.SJML.util;
using HH.WCS.ZCQTJ.Entitys;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;

namespace HH.WCS.SJML.Bll
{
    public class OutWorkAreaBll
    {
        public virtual OperateResult OutWorkArea(List<OutWorkAreaEntity> outWorkAreaList)
        {
            var logPara = LogType.LogPara("出作业区");
            LogHelper.OutDetail(logPara, "OutWorkArea接口请求参数：" + JsonConvert.SerializeObject(outWorkAreaList));
            OperateResult er = OutWorkArea(outWorkAreaList, logPara);

            //  var result = JsonConvert.SerializeObject(er);
            LogHelper.OutDetail(logPara, "OutWorkArea接口返回参数：" + JsonConvert.SerializeObject(er));
            return er;
        }


        public virtual OperateResult OutWorkArea(List<OutWorkAreaEntity> outWorkAreaList, LogPara logPara)
        {

            var response = new OperateResult();
            if (outWorkAreaList == null) return new OperateResult { Success = false, Msg = "参数不正确" };
            for (var i = 0; i < outWorkAreaList.Count; i++)
            {
                var result = OutWorkArea(outWorkAreaList[i], logPara);
                if (result.BasisResponse.Success)
                {
                    response.Success = true;
                    response.okList.Add(result.TaskExecuteState.okTask);
                    //发送到AMS
                    //SendToAms(response, logPara);
                }
                else
                {
                    response.failList.Add(new TaskExecuteState().Error(i, result.BasisResponse.Msg).FailTask);
                    if (result.RollLocations.Count > 0)
                    {
                        var chi = new SqlHelper<object>().GetInstance();
                        var newDb = chi.CopyNew();
                        foreach (string sLocation in result.RollLocations)
                        {
                            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;
            }
            LogHelper.OutDetail(logPara, "response结果：" + JsonConvert.SerializeObject(response));
            //var curResult = response.failList.Any() ? response.Error(null, string.Empty, outWorkAreaList) : response.Ok(null, outWorkAreaList);
            //if (!curResult.Success)
            //{
            //    curResult.Code = response.Code;
            //}
            // Log.Info("错误代码 response.errCode是", JsonConvert.SerializeObject(curResult));
            return response;
        }

        public virtual ExecuteOutWorkAreaPara OutWorkArea(OutWorkAreaEntity outWorkAreaEntity, LogPara logPara)
        {
            if (string.IsNullOrEmpty(outWorkAreaEntity.TaskOrderType)) outWorkAreaEntity.TaskOrderType = "自管";
            var executeOutWorkAreaPara = new ExecuteOutWorkAreaPara { OutWorkAreaEntity = outWorkAreaEntity };
            try
            {

                if (!OutWorkAreaVerifyPara(ref executeOutWorkAreaPara, logPara).BasisResponse.Success) return executeOutWorkAreaPara;
                LogHelper.OutDetail(logPara, "OutWorkAreaVerifyPara");
                if (!OutWorkAreaHandlePara(ref executeOutWorkAreaPara, logPara).BasisResponse.Success) return executeOutWorkAreaPara;
                LogHelper.OutDetail(logPara, "OutWorkAreaHandlePara");
                //算法计算货位
                if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.startBit))
                {
                    OutWorkAreaOutAss(ref executeOutWorkAreaPara, logPara);
                    LogHelper.OutDetail(logPara, "OutWorkAreaOutAss");
                    if (!executeOutWorkAreaPara.BasisResponse.Success) return executeOutWorkAreaPara;
                }

                if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.endBit))
                {
                    if (!InWorkAreaOutAss(ref executeOutWorkAreaPara, logPara).BasisResponse.Success) return executeOutWorkAreaPara;
                    LogHelper.OutDetail(logPara, "InWorkAreaOutAss");
                }

                if (!DoCreateTransportList(ref executeOutWorkAreaPara, logPara).BasisResponse.Success) return executeOutWorkAreaPara;
                LogHelper.OutDetail(logPara, "DoCreateTransportList");
                OutWorkAreaCreateTask(ref executeOutWorkAreaPara, logPara);
                LogHelper.OutDetail(logPara, "OutWorkAreaCreateTask");
                OutWorkAreaProcedure(ref executeOutWorkAreaPara, logPara);
                LogHelper.OutDetail(logPara, "OutWorkAreaProcedure");
                if (!string.IsNullOrEmpty(executeOutWorkAreaPara.objectTask))
                {
                    //下达任务给agv----双申位不用写
                    LogHelper.OutDetail(logPara, "执行的辅助表数据为:" + JsonConvert.SerializeObject(executeOutWorkAreaPara.WorkSubsidiary));
                    if (executeOutWorkAreaPara.WorkSubsidiary?.S_YN_JOBPATH == "Y")
                    {
                        LogHelper.OutDetail(logPara, "执行的作业路径为:" + JsonConvert.SerializeObject(executeOutWorkAreaPara.WorkAreaProEntity));
                        if (executeOutWorkAreaPara.WorkAreaProEntity?.S_Subtask != "Y")
                        {
                            if (executeOutWorkAreaPara.WorkAreaProEntity?.S_TransAgv == "Y")
                            {

                                //var ta = TaskProcess.SendTask(executeOutWorkAreaPara.TaskEntity);
                                //LogHelper.InDetail(logPara, "通知小车是否成功:" + ta);
                                //LogHelper.InDetail(logPara, "通知小车");
                                //if (!ta)
                                //{
                                //    throw new Exception("通知小车失败");
                                //}
                                //else
                                //{
                                //    SqlSugarHelper.Db.CommitTran();
                                //}
                                SqlSugarHelper.Db.CommitTran();
                            }
                            if (executeOutWorkAreaPara.WorkAreaProEntity?.S_TransWcs == "Y")
                            {
                                LogHelper.InDetail(logPara, "开始通知立库");
                                var ta = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(executeOutWorkAreaPara.TaskEntity);
                                LogHelper.InDetail(logPara, "通知立库是否成功:" + JsonConvert.SerializeObject(ta));
                                LogHelper.InDetail(logPara, "结束通知立库");
                                if (!ta.Success)
                                {
                                    throw new Exception("通知立库失败");
                                }
                                else
                                {
                                    SqlSugarHelper.Db.CommitTran();
                                }
                            }
                        }
                    }
                    else
                    {
                        if (executeOutWorkAreaPara.OutWorkAreaEntity.S_Subtask != "Y")
                        {
                            if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransAgv == "Y")
                            {
                                //LogHelper.OutDetail(logPara, "开始通知小车");
                                //var ta = TaskProcess.SendTask(executeOutWorkAreaPara.TaskEntity);
                                //LogHelper.OutDetail(logPara, "通知小车是否成功:" + ta);
                                //LogHelper.OutDetail(logPara, "结束通知小车");
                                //if (!ta)
                                //{
                                //    throw new Exception("通知小车失败");
                                //}
                                //else
                                //{
                                //    SqlSugarHelper.Db.CommitTran();
                                //}
                                SqlSugarHelper.Db.CommitTran();
                            }
                            if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransWcs == "Y")
                            {
                                LogHelper.OutDetail(logPara, "开始通知立库");
                                var ta = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(executeOutWorkAreaPara.TaskEntity);
                                LogHelper.OutDetail(logPara, "通知立库是否成功:" + JsonConvert.SerializeObject(ta));
                                LogHelper.OutDetail(logPara, "结束通知立库");
                                if (!ta.Success)
                                {
                                    throw new Exception("通知立库失败");
                                }
                                else
                                {
                                    SqlSugarHelper.Db.CommitTran();
                                }
                            }
                        }
                    }
                }
                SqlSugarHelper.Db.CommitTran();
            }
            catch (Exception ex)
            {
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error("OutWorkArea 方法异常：" + JsonConvert.SerializeObject(ex.Message));
                SqlSugarHelper.Db.RollbackTran();
            }
            return executeOutWorkAreaPara;
        }


        public virtual ExecuteOutWorkAreaPara OutWorkAreaVerifyPara(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            if (executeOutWorkAreaPara.OutWorkAreaEntity == null)
            {
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error("参数不合法,接收参数为null！");
                return executeOutWorkAreaPara;
            }
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            #region 检查起点位置
            if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.startBit))
            {
                var startBit = executeOutWorkAreaPara.OutWorkAreaEntity.startBit?.Trim();
                executeOutWorkAreaPara.StartLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();
                if (!executeOutWorkAreaPara.StartLocationExt.S_LOCK_STATE.Equals("无"))
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("当前起点货位状态为：" + executeOutWorkAreaPara.StartLocationExt.S_LOCK_STATE + "，不允许出库！");
                    return executeOutWorkAreaPara;
                }

                var AreaCode = executeOutWorkAreaPara.StartLocationExt.S_AREA_CODE;
                executeOutWorkAreaPara.StartStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == AreaCode)?.First();

                if (executeOutWorkAreaPara.StartStockAreaEntity == null)
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("给定起点位置：" + executeOutWorkAreaPara.OutWorkAreaEntity.startBit + "不存在！");
                    return executeOutWorkAreaPara;
                }
                executeOutWorkAreaPara.OutWorkAreaEntity.startArea = executeOutWorkAreaPara.StartStockAreaEntity.S_AREA_CODE;
                executeOutWorkAreaPara.OutWorkAreaEntity.startStock = executeOutWorkAreaPara.StartStockAreaEntity.S_WH_CODE;
                //SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();

                LocCntrRel trayLocation = new LocCntrRel();
                if (string.IsNullOrEmpty(executeOutWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY))
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("起点库区是否管控字段为空");
                    return executeOutWorkAreaPara;
                }
                if (executeOutWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY == "Y")
                {
                    if (executeOutWorkAreaPara.StartLocationExt.N_CAPACITY == 1)
                    {
                        trayLocation = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_LOC_CODE == startBit)?.First();
                        if (trayLocation == null)
                        {
                            executeOutWorkAreaPara.BasisResponse = OperateResult.Error("当前起点未绑定托盘！");
                            return executeOutWorkAreaPara;
                        }

                        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
                            {
                                executeOutWorkAreaPara.RollLocations.Add(executeOutWorkAreaPara.OutWorkAreaEntity.startBit);
                            }
                            newDb.CommitTran();
                        }
                        catch (System.Exception ex)
                        {
                            newDb.RollbackTran();
                            executeOutWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                            return executeOutWorkAreaPara;
                        }
                    }
                }
                if (!string.IsNullOrEmpty(trayLocation.S_CNTR_CODE))
                {
                    executeOutWorkAreaPara.OutWorkAreaEntity.trayCode = trayLocation.S_CNTR_CODE;
                }

            }
            #endregion
            #region 当起点为空且指定了托盘
            if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.startBit) && !string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.trayCode))
            {
                var trayCode = executeOutWorkAreaPara.OutWorkAreaEntity.trayCode;
                var Cns = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == trayCode)?.First();
                if (Cns == null)
                {
                    LogHelper.Info("任务下发", $"未查询到指定工装出库 指定的工装码为:{trayCode} 的工装货位信息");
                    throw new Exception($"未查询到指定工装出库 指定的工装码为:{trayCode} 的工装货位信息");
                }
                else
                {
                    var startBit = Cns.S_LOC_CODE;
                    executeOutWorkAreaPara.OutWorkAreaEntity.startBit = startBit;
                    executeOutWorkAreaPara.StartLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();
                    if (!executeOutWorkAreaPara.StartLocationExt.S_LOCK_STATE.Equals("无"))
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("当前起点货位状态为：" + executeOutWorkAreaPara.StartLocationExt.S_LOCK_STATE + "，不允许出库！");
                        return executeOutWorkAreaPara;
                    }

                    var AreaCode = executeOutWorkAreaPara.StartLocationExt.S_AREA_CODE;
                    executeOutWorkAreaPara.StartStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == AreaCode)?.First();

                    if (executeOutWorkAreaPara.StartStockAreaEntity == null)
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error($"给定工装 {trayCode} 的起点位置：" + executeOutWorkAreaPara.OutWorkAreaEntity.startBit + "不存在！");
                        return executeOutWorkAreaPara;
                    }

                    LocCntrRel trayLocation = new LocCntrRel();
                    if (string.IsNullOrEmpty(executeOutWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY))
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("起点库区是否管控字段为空");
                        return executeOutWorkAreaPara;
                    }
                    if (executeOutWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY == "Y")
                    {
                        if (executeOutWorkAreaPara.StartLocationExt.N_CAPACITY == 1)
                        {
                            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
                                {
                                    executeOutWorkAreaPara.RollLocations.Add(executeOutWorkAreaPara.OutWorkAreaEntity.startBit);
                                }
                                newDb.CommitTran();
                            }
                            catch (System.Exception ex)
                            {
                                newDb.RollbackTran();
                                executeOutWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                                return executeOutWorkAreaPara;
                            }
                        }
                    }
                }

            }
            #endregion
            #region 检验终点库区
            if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.endBit))
            {
                //if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.endBit))
                //{
                //executeOutWorkAreaPara.BasisResponse = BasisResponse.Error("给定的目的位置不存在！");
                //return executeOutWorkAreaPara;

                //获取终点库区信息
                var endBit = executeOutWorkAreaPara.OutWorkAreaEntity.endBit;
                executeOutWorkAreaPara.EndLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == endBit)?.First();
                LogHelper.OutDetail(logPara, "查询终点货位：" + JsonConvert.SerializeObject(executeOutWorkAreaPara.EndLocationExt));
                if (executeOutWorkAreaPara.EndLocationExt == null)
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("未查询到当前终点货位信息");
                    return executeOutWorkAreaPara;
                }
                if (executeOutWorkAreaPara.EndLocationExt.C_ENABLE != "Y")
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("查询到当前终点货位信息未在启用状态");
                    return executeOutWorkAreaPara;
                }
                var EndArea = executeOutWorkAreaPara.EndLocationExt.S_AREA_CODE;
                executeOutWorkAreaPara.EndStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == EndArea)?.First();
                LogHelper.OutDetail(logPara, "查询终点货位库区：" + JsonConvert.SerializeObject(executeOutWorkAreaPara.EndStockAreaEntity));

                if (executeOutWorkAreaPara.EndStockAreaEntity == null)
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("给定的目的位置未找到库区！");
                    return executeOutWorkAreaPara;
                }

                if (executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport == null)
                {
                    executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport = "N";
                }
                // 检查货位状态  是转运且管控数量时使用
                if (string.IsNullOrEmpty(executeOutWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY))
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("终点库区是否管控字段为空！");
                    return executeOutWorkAreaPara;
                }
                if (executeOutWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY.Equals("Y"))
                {
                    if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport))
                    {
                        executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport = "Y";
                    }
                    if (!executeOutWorkAreaPara.EndLocationExt.S_LOCK_STATE.Equals("无"))
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("当前终点货位状态为：" + executeOutWorkAreaPara.EndLocationExt.S_LOCK_STATE + "，货位不可用！");
                        return executeOutWorkAreaPara;
                    }
                    if (executeOutWorkAreaPara.EndLocationExt.N_CURRENT_NUM > 0)
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("当前货位容量为" + executeOutWorkAreaPara.EndLocationExt.N_CURRENT_NUM + "，货位不可用！");
                        return executeOutWorkAreaPara;
                    }
                    //锁定终点货位
                    if (executeOutWorkAreaPara.EndLocationExt.N_CAPACITY == 1)
                    {
                        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
                            {
                                executeOutWorkAreaPara.RollLocations.Add(executeOutWorkAreaPara.OutWorkAreaEntity.endBit);
                            }
                            newDb.CommitTran();
                        }
                        catch (System.Exception ex)
                        {
                            newDb.RollbackTran();
                            executeOutWorkAreaPara.BasisResponse = OperateResult.Error(ex.Message + ex.StackTrace);
                            return executeOutWorkAreaPara;
                        }
                    }

                }
                executeOutWorkAreaPara.OutWorkAreaEntity.startStock = executeOutWorkAreaPara.EndStockAreaEntity.S_WH_CODE;
                executeOutWorkAreaPara.OutWorkAreaEntity.endStock = executeOutWorkAreaPara.EndStockAreaEntity.S_WH_CODE;
                executeOutWorkAreaPara.OutWorkAreaEntity.endArea = executeOutWorkAreaPara.EndStockAreaEntity.S_AREA_CODE;
            }
            #endregion

            return executeOutWorkAreaPara;
        }

        public virtual ExecuteOutWorkAreaPara OutWorkAreaHandlePara(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            //任务号
            if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.taskNo))
            {
                executeOutWorkAreaPara.OutWorkAreaEntity.taskNo = BLLCreator.Create<IdGuid>().TaskNo("CK");
                if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.taskNo))
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("生成出库任务号异常！");
            }
            //这里--是否启用作业路径
            LogHelper.OutDetail(logPara, "是否有起点库区 " + JsonConvert.SerializeObject(executeOutWorkAreaPara.OutWorkAreaEntity));
            if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity?.startArea) && executeOutWorkAreaPara.OutWorkAreaEntity.NoAssist == "Y")
            {

                var chi = new SqlHelper<object>().GetInstance();
                var newDb = chi.CopyNew();
                var S_WH_CODE = executeOutWorkAreaPara.StartStockAreaEntity?.S_WH_CODE;
                var S_AREA_CODE = executeOutWorkAreaPara.StartStockAreaEntity?.S_AREA_CODE;
                if (executeOutWorkAreaPara.StartStockAreaEntity?.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 = newDb.Queryable<TN_SubsidiaryEntitys>().Where(Subs.ToExpression()).ToList();
                    // LogHelper.OutDetail(logPara, "是否启用作业路径： 辅助表数据 " + JsonConvert.SerializeObject(Subsidiary));
                    if (!Subsidiary.Any())
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("辅助表未查询到对应库区的数据！库区:" + S_AREA_CODE);
                    }
                    else
                    {
                        if (Subsidiary.FindAll(e => e.S_YN_JOBPATH == "Y").Count() == 0)
                        {
                            //不需要的话就直接返回
                            TN_WorkFlowEntitys Flow = new TN_WorkFlowEntitys();
                            Flow.S_StartArea = executeOutWorkAreaPara.StartStockAreaEntity.S_AREA_CODE;
                            Flow.S_EndArea = executeOutWorkAreaPara.EndStockAreaEntity.S_AREA_CODE;
                            if (string.IsNullOrEmpty(Flow.S_StartArea))
                            {
                                executeOutWorkAreaPara.BasisResponse = OperateResult.Error("未启用作业路径,并且未下达起点库区参数 库区:" + S_AREA_CODE);
                                throw new Exception("未启用作业路径,并且未下达起点库区参数！库区:" + S_AREA_CODE);
                            }
                            executeOutWorkAreaPara.WorkAreaProEntitys.Add(Flow);
                            LogHelper.OutDetail(logPara, "是否启用作业路径： 自己组建的作业流程 " + JsonConvert.SerializeObject(Flow));
                            return executeOutWorkAreaPara;
                        }
                    }
                }
                else
                {
                    //不需要的话就直接返回
                    TN_WorkFlowEntitys Flow = new TN_WorkFlowEntitys();
                    Flow.S_StartArea = executeOutWorkAreaPara.StartStockAreaEntity?.S_AREA_CODE;
                    Flow.S_EndArea = executeOutWorkAreaPara.EndStockAreaEntity?.S_AREA_CODE;
                    if (string.IsNullOrEmpty(Flow?.S_StartArea))
                    {
                        executeOutWorkAreaPara.BasisResponse = OperateResult.Error("未启用作业路径,并且未下达起点库区参数 库区:" + S_AREA_CODE);
                        throw new Exception("未启用作业路径,并且未下达起点库区参数！库区:" + S_AREA_CODE);
                    }
                    executeOutWorkAreaPara.WorkAreaProEntitys.Add(Flow);
                    LogHelper.OutDetail(logPara, "是否启用作业路径： 自己组建的作业流程 " + JsonConvert.SerializeObject(Flow));
                    return executeOutWorkAreaPara;
                }
            }
            executeOutWorkAreaPara.WorkAreaProEntitys = GetOutWorkPosition(executeOutWorkAreaPara);
            if (!executeOutWorkAreaPara.WorkAreaProEntitys.Any())
            {
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error(string.Format("未获取到当前库区：{0}货位：{1}下的作业路径！", executeOutWorkAreaPara.OutWorkAreaEntity.endArea, executeOutWorkAreaPara.OutWorkAreaEntity.endBit));
                return executeOutWorkAreaPara;
            }
            return executeOutWorkAreaPara;
        }

        /// <summary>
        /// 获取作业区流程列表
        /// </summary>
        /// <param name="executeInWorkAreaPara"></param>
        /// <returns></returns>
        public List<TN_WorkFlowEntitys> GetOutWorkPosition(ExecuteOutWorkAreaPara executeOutWorkAreaPara)
        {
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            //根据起始库区计算作业区
            var startArea = executeOutWorkAreaPara.OutWorkAreaEntity.startArea;
            var endArea = executeOutWorkAreaPara.OutWorkAreaEntity.endArea;
            var TaskFlow = executeOutWorkAreaPara.OutWorkAreaEntity.TaskFlow;
            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.AndIF(!string.IsNullOrEmpty(TaskFlow), it => it.S_FlowNo == TaskFlow);
            exp.And(it => it.S_IS_IN_OUT == "出库");
            var workAreaProList = newDb.Queryable<TN_WorkFlowEntitys>().Where(exp.ToExpression()).ToList();
            return workAreaProList;
        }


        public virtual ExecuteOutWorkAreaPara OutWorkAreaOutAss(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            #region 算法
            //List<string> Roadway = new List<string>();
            //if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.S_Roadway))
            //{
            //    Roadway.Add(executeOutWorkAreaPara.OutWorkAreaEntity.S_Roadway);
            //}
            //获取起点货位
            OutAssignEnitty oEntity = new OutAssignEnitty()
            {
                stockCode = executeOutWorkAreaPara.OutWorkAreaEntity.startStock,
                TrayType = executeOutWorkAreaPara.OutWorkAreaEntity.TrayType,
                S_TASK_NO = executeOutWorkAreaPara.OutWorkAreaEntity.taskNo,
                itemCode = executeOutWorkAreaPara.OutWorkAreaEntity.Data == null ? "" : executeOutWorkAreaPara.OutWorkAreaEntity.Data?.First()?.ItemCode,
                itemState = executeOutWorkAreaPara.OutWorkAreaEntity.Data == null ? "" : executeOutWorkAreaPara.OutWorkAreaEntity.Data?.First()?.itemState,
                projectCode = executeOutWorkAreaPara.OutWorkAreaEntity.projectCode,
                endBit = executeOutWorkAreaPara.OutWorkAreaEntity.endBit,
                // S_Roadway = Roadway,
                lstAreaPrior = executeOutWorkAreaPara.WorkAreaProEntitys.Select(p => new areaPriorClass { areaCode = p.S_StartArea, Prior = p.S_Priority, S_FlowNo = p.S_FlowNo }).ToList()
            };
            try
            {
                //执行算法
                OutAssignResultEntity ire = BLLCreator.Create<Out_AlgorBLL>().OutAssign(oEntity);
                if (!ire.Success)
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error("算法返回结果" + ire.Msg);
                    executeOutWorkAreaPara.BasisResponse.Code = ire.errCode;
                    return executeOutWorkAreaPara;
                }
                executeOutWorkAreaPara.StartLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == ire.locationCode)?.First();
                if ((ire.areaType == Constants.Area_Struc_PingStock || ire.areaType == Constants.Area_Struc_LiStock) && ire.isControlQty == "Y")
                {
                    executeOutWorkAreaPara.RollLocations.Add(ire.locationCode);
                }
                executeOutWorkAreaPara.OutWorkAreaEntity.startBit = ire.locationCode;
                executeOutWorkAreaPara.OutWorkAreaEntity.startArea = ire.areaCode;

                if (executeOutWorkAreaPara.StartStockAreaEntity == null)
                {
                    executeOutWorkAreaPara.StartStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == ire.areaCode)?.First();
                }
                if (string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.trayCode))
                {
                    executeOutWorkAreaPara.OutWorkAreaEntity.trayCode = ire.trayCode;
                    executeOutWorkAreaPara.LocCntr = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == ire.trayCode)?.First();

                    if (executeOutWorkAreaPara.OutWorkAreaEntity.Data != null)
                    {
                        foreach (var item in executeOutWorkAreaPara.OutWorkAreaEntity.Data)
                        {
                            item.TrayCode = ire.trayCode;
                            var trayItem = SqlSugarHelper.Db.Queryable<CntrItemRel>().Where(e => e.S_CNTR_CODE == ire.trayCode)?.First();
                            if (trayItem != null)
                            {
                                item.UnitQty = Convert.ToInt32(trayItem.F_QTY);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error("未找到合适的出库货位" + ex.Message);
            }

            #endregion

            return executeOutWorkAreaPara;
        }


        public virtual ExecuteOutWorkAreaPara InWorkAreaOutAss(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            var logicAreaCode = string.Empty;

            var aEntity = new InAssignEntity()
            {
                objectType = InAssignEntity.ObjectType.托盘,
                objectCode = executeOutWorkAreaPara.OutWorkAreaEntity.trayCode,
                lstAreaPrior = executeOutWorkAreaPara.WorkAreaProEntitys.Select(p => new areaPriorClass { areaCode = p.S_EndArea, Prior = p.S_Priority }).ToList(),
                //lockLocation = endArea != null ? endArea.CN_C_IS_CONTROL_QTY.Equals("Y") : false, //不管控数量时，不锁定目的货位
                projectCode = executeOutWorkAreaPara.OutWorkAreaEntity.projectCode,
                logicAreaCode = logicAreaCode,
                stockCode = executeOutWorkAreaPara.OutWorkAreaEntity.startStock,
                callSys = executeOutWorkAreaPara.OutWorkAreaEntity.sysName,
                needCalLock = true
            };

            //根据库区获取货位
            InAssignResultEntity resultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(aEntity);
            if (resultEntity.Success)
            {
                executeOutWorkAreaPara.OutWorkAreaEntity.endBit = resultEntity.locationCode;
                executeOutWorkAreaPara.OutWorkAreaEntity.qtyIndex = resultEntity.index;

                //增加到回滚记录里面
                if ((resultEntity.areaType == Constants.Area_Struc_PingStock || resultEntity.areaType == Constants.Area_Struc_LiStock) && resultEntity.isControlQty == "Y")
                {
                    executeOutWorkAreaPara.RollLocations.Add(resultEntity.locationCode);
                }

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

        public virtual ExecuteOutWorkAreaPara DoCreateTransportList(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            //创建转运任务
            var entity = new TN_WM_TRANSPORT_TASKEntity
            {
                CN_S_TASK_NO = executeOutWorkAreaPara.OutWorkAreaEntity.taskNo,
                CN_S_CIR_OBJ = "托盘",
                CN_S_CIR_OBJ_CODE = executeOutWorkAreaPara.OutWorkAreaEntity.trayCode,
                CN_S_START_BIT = executeOutWorkAreaPara.OutWorkAreaEntity.startBit,
                CN_S_START_AREA = executeOutWorkAreaPara.OutWorkAreaEntity.startArea ?? executeOutWorkAreaPara.StartStockAreaEntity.S_AREA_CODE,
                CN_S_STATE = "未执行",
                CN_N_PRIORITY = executeOutWorkAreaPara.OutWorkAreaEntity.priority,
                CN_S_END_AREA = executeOutWorkAreaPara.OutWorkAreaEntity.endArea ?? executeOutWorkAreaPara.EndStockAreaEntity.S_AREA_CODE,
                CN_S_END_BIT = executeOutWorkAreaPara.OutWorkAreaEntity.endBit,
                CN_T_START = DateTime.Now.ToString(CultureInfo.InvariantCulture),
                CN_T_CREATE = DateTime.Now.ToString(CultureInfo.InvariantCulture),
                CN_T_MODIFY = DateTime.Now.ToString(CultureInfo.InvariantCulture),
                CN_S_STOCK_CODE = executeOutWorkAreaPara.OutWorkAreaEntity.startStock,
                CN_S_TASK_TYPE = executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport == "Y" ? "转运" : "出库",
                CN_S_QTY_INDEX = executeOutWorkAreaPara.OutWorkAreaEntity.qtyIndex,
                CN_C_END_IS_CONTROL_QTY = executeOutWorkAreaPara.EndStockAreaEntity.S_CONTROL_QTY,
                CN_S_END_AREA_TYPE = executeOutWorkAreaPara.EndStockAreaEntity.S_NOTE,
                CN_C_START_IS_CONTROL_QTY = executeOutWorkAreaPara.StartStockAreaEntity.S_CONTROL_QTY,
                CN_S_START_AREA_TYPE = executeOutWorkAreaPara.StartStockAreaEntity.S_NOTE,
                CN_S_REMARK = executeOutWorkAreaPara.OutWorkAreaEntity.remark
            };
            executeOutWorkAreaPara.TransportList.Add(entity);
            return executeOutWorkAreaPara;
        }

        public virtual ExecuteOutWorkAreaPara OutWorkAreaCreateTask(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            var Subs = Expressionable.Create<TN_SubsidiaryEntitys>();
            WcsReturnEntityTwo WcsRet = new WcsReturnEntityTwo();
            var S_WH_CODE = executeOutWorkAreaPara.StartStockAreaEntity.S_WH_CODE;
            var S_AREA_CODE = executeOutWorkAreaPara.StartStockAreaEntity.S_AREA_CODE;
            var N_ROADWAY = executeOutWorkAreaPara.StartLocationExt.N_ROADWAY;
            var S_Jb_Bit = "";
            var S_Subtask = "";
            //任务
            var transport = executeOutWorkAreaPara.TransportList.FirstOrDefault();
            executeOutWorkAreaPara.WorkAreaProEntity = executeOutWorkAreaPara.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 == S_WH_CODE);
            Subs.And(it => it.S_AREA_CODE == S_AREA_CODE);
            Subs.And(it => it.N_ROADWAY == N_ROADWAY);
            Subs.And(it => it.S_IS_IN_OUT == "出库");
            var Subsidiary = SqlSugarHelper.Db.Queryable<TN_SubsidiaryEntitys>().Where(Subs.ToExpression()).ToList();
            if (Subsidiary.Count() == 0 && executeOutWorkAreaPara.OutWorkAreaEntity.NoAssist != "Y")
            {
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error($"辅助表未查询到对应的库区数据 请核实 仓库:{S_WH_CODE} 库区:{S_AREA_CODE} 巷道:{N_ROADWAY} 流程去向:出库");
                throw new Exception($"辅助表未查询到对应的库区数据 请核实 仓库:{S_WH_CODE} 库区:{S_AREA_CODE} 巷道:{N_ROADWAY} 流程去向:出库");
            }
            var Subsidia = Subsidiary.FirstOrDefault();
            executeOutWorkAreaPara.WorkSubsidiary = Subsidia;
            if (Subsidia?.S_AREA_TYPE == Constants.Area_Struc_LiStock && Subsidia?.S_YN_JOBPATH != "Y")
            {
                S_Jb_Bit = Subsidia.S_CONNECTION;
            }
            else
            {
                if (!string.IsNullOrEmpty(executeOutWorkAreaPara?.WorkAreaProEntity?.S_FlowNo))
                {
                    var S_FlowNo = executeOutWorkAreaPara?.WorkAreaProEntity?.S_FlowNo;
                    LogHelper.Info("出库", $"流程编码为:{S_FlowNo}");
                    var ttr = Subsidiary.Find(e => e.S_FlowNo == S_FlowNo);
                    LogHelper.Info("出库", $"作业流程编码查辅助表数据{JsonConvert.SerializeObject(ttr)}");

                    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>();
                        if (S_AREA_CODE == "LC11M")
                        {
                            WcsRet = BLLCreator.Create<WcsTask>().WcsPositionAvailableCk(executeOutWorkAreaPara.OutWorkAreaEntity.taskNo);
                        }
                        foreach (var item in Location)
                        {
                            if (S_AREA_CODE == "LC11M")
                            {
                                if (N_ROADWAY == 1)
                                {
                                    var Jbw1 = IsJb.Find(e => e.S_JbBit == "TMCKHCW-01");
                                    if (Jbw1 != null)
                                    {
                                        if (item == "TMCKJBW-02" || item == "TMCKJBW-03")
                                        {
                                            if (WcsRet.code == "0")
                                            {
                                                if (WcsRet.available.Contains("TMCKJBW-02") || WcsRet.available.Contains("TMCKJBW-03"))
                                                {
                                                    continue;
                                                }
                                            }
                                        }
                                    }
                                }
                                if (N_ROADWAY == 4)
                                {
                                    var Jbw3 = IsJb.Find(e => e.S_JbBit == "TMCKHCW-02");
                                    if (Jbw3 != null)
                                    {
                                        if (item == "TMCKJBW-05" || item == "TMCKJBW-06")
                                        {
                                            if (WcsRet.code == "0")
                                            {
                                                if (WcsRet.available.Contains("TMCKJBW-02") || WcsRet.available.Contains("TMCKJBW-03"))
                                                {
                                                    continue;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            if (S_AREA_CODE == "LC11M")
                            {
                                if (IsJb.FindAll(e => e.S_JbBit == item).ToList().Count() == 0 && WcsRet.available.Contains(item))
                                {
                                    A++;
                                    lo.Add(item);
                                }
                            }
                            else
                            {
                                if (IsJb.FindAll(e => e.S_JbBit == item).ToList().Count() == 0)
                                {
                                    A++;
                                    lo.Add(item);
                                }
                            }
                        }
                        if (Location.Count() == A && ttr != null)
                        {
                            S_Jb_Bit = ttr.S_CONNECTION;
                        }
                        else
                        {
                            S_Jb_Bit = String.Join(",", lo);
                        }
                    }
                    else
                    {
                        if (ttr != null)
                        {
                            //executeOutWorkAreaPara.WorkSubsidiary = ttr;
                            S_Jb_Bit = ttr.S_CONNECTION;
                        }
                        else
                        {
                            S_Jb_Bit = "";
                        }
                    }
                }
                else
                {
                    S_Jb_Bit = "";
                }
                //S_Jb_Bit = executeOutWorkAreaPara?.WorkAreaProEntity?.S_Jb_Bit;
                if (string.IsNullOrEmpty(S_Jb_Bit) && executeOutWorkAreaPara.OutWorkAreaEntity.NoAssist != "Y")
                {
                    executeOutWorkAreaPara.BasisResponse = OperateResult.Error($"未筛选出对应的作业流程接驳位,请查询核对{executeOutWorkAreaPara?.WorkAreaProEntity?.S_Jb_Bit} 仓库:{S_WH_CODE} 库区:{S_AREA_CODE} 巷道:{N_ROADWAY} 流程去向:出库 流程编码为{executeOutWorkAreaPara?.WorkAreaProEntity?.S_FlowNo} ,请确定立库是否报警");
                    throw new Exception($"未筛选出对应的作业流程接驳位,请查询核对{executeOutWorkAreaPara?.WorkAreaProEntity?.S_Jb_Bit} 仓库:{S_WH_CODE} 库区:{S_AREA_CODE} 巷道:{N_ROADWAY} 流程去向:出库  流程编码为{executeOutWorkAreaPara?.WorkAreaProEntity?.S_FlowNo}, 请确定立库是否报警");
                }
            }
            //添加任务
            string objectTask = "";
            if (string.IsNullOrEmpty(executeOutWorkAreaPara.WorkAreaProEntity?.S_Subtask))
            {
                S_Subtask = executeOutWorkAreaPara.OutWorkAreaEntity?.S_Subtask;
            }
            else
            {
                S_Subtask = executeOutWorkAreaPara.WorkAreaProEntity?.S_Subtask;
            }

            if (Subsidia?.S_YN_JOBPATH == "Y")
            {
                if (executeOutWorkAreaPara.WorkAreaProEntity?.S_Subtask != "Y")
                {
                    if (executeOutWorkAreaPara.WorkAreaProEntity?.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;
                        executeOutWorkAreaPara.objectTask = Constants.TaskFlag_AGV;
                    }
                    if (executeOutWorkAreaPara.WorkAreaProEntity?.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                        executeOutWorkAreaPara.objectTask = Constants.TaskFlag_LG;
                    }
                }
            }
            else
            {
                if (executeOutWorkAreaPara.OutWorkAreaEntity?.S_Subtask != "Y")
                {
                    if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;
                        executeOutWorkAreaPara.objectTask = Constants.TaskFlag_AGV;
                    }
                    if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                        executeOutWorkAreaPara.objectTask = Constants.TaskFlag_LG;
                    }
                    if (string.IsNullOrEmpty(S_Jb_Bit))
                    {
                        S_Jb_Bit = executeOutWorkAreaPara.OutWorkAreaEntity.S_Jb_Bit;
                    }
                }
                else
                {
                    if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;

                    }
                    if (executeOutWorkAreaPara.OutWorkAreaEntity.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                    }
                }
            }
            if (string.IsNullOrEmpty(executeOutWorkAreaPara.objectTask))
            {
                if (string.IsNullOrEmpty(S_Jb_Bit))
                {
                    throw new Exception("出库自管任务,接驳位为空");
                }
            }
            var S_TOOLS_TPYE = executeOutWorkAreaPara.LocCntr?.S_TYPE;

            //判断是否是 立库 如果是的话  获取接驳位和准备点
            SqlSugarHelper.Db.BeginTran();
            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_TYPE = executeOutWorkAreaPara.OutWorkAreaEntity.IsTransport == "Y" ? "转运" : "出库";
            Task.S_B_STATE = "未执行";
            Task.S_CNTRS = transport.CN_S_CIR_OBJ_CODE;
            Task.N_CNTR_COUNT = 1;
            Task.N_PRIORITY = transport.CN_N_PRIORITY;
            Task.S_NOTE = executeOutWorkAreaPara.objectTask ?? "自管任务";
            Task.S_READ_LOCK = "N";
            Task.S_Subtask = executeOutWorkAreaPara.WorkAreaProEntity?.S_Subtask;
            Task.S_FlowNo = executeOutWorkAreaPara.WorkAreaProEntity?.S_FlowNo;
            Task.S_Jb_Bit = S_Jb_Bit;
            Task.S_SRC_SYS = executeOutWorkAreaPara.OutWorkAreaEntity.TaskOrderType;
            Task.S_Zb_Bit = executeOutWorkAreaPara.WorkAreaProEntity?.S_Zb_Bit;
            Task.S_UpstreamNo = executeOutWorkAreaPara.OutWorkAreaEntity.mesTaskNo;
            Task.S_SRC_NO = transport.CN_S_TASK_NO;
            Task.S_TOOLS_TPYE = executeOutWorkAreaPara.OutWorkAreaEntity.TrayType ?? S_TOOLS_TPYE;
            Task.S_Main_task = "主任务";
            var C = SqlSugarHelper.Db.Insertable(Task).ExecuteCommand();
            executeOutWorkAreaPara.TaskEntity = Task;
            LogHelper.Info("出库", "   创建任务结束");
            if (C == 0)
            {
                SqlSugarHelper.Db.RollbackTran();
                executeOutWorkAreaPara.BasisResponse = OperateResult.Error("创建任务失败");
                throw new Exception("创建任务失败");
            }

            return executeOutWorkAreaPara;
        }

        public virtual ExecuteOutWorkAreaPara OutWorkAreaProcedure(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            executeOutWorkAreaPara.TaskExecuteState = new TaskExecuteState().Ok(OutWorkAreaOkTaskResponse(executeOutWorkAreaPara.TransportList[0], executeOutWorkAreaPara.OutWorkAreaEntity.itemCode, executeOutWorkAreaPara.index), null);
            return executeOutWorkAreaPara;
        }
        public virtual OkTask OutWorkAreaOkTaskResponse(TN_WM_TRANSPORT_TASKEntity trans, string itemCode, int index)
        {
            if (trans.CN_S_START_AREA_TYPE == Constants.Area_Struc_LiuLiStock || trans.CN_S_START_AREA_TYPE == Constants.Area_Struc_DuiDieStock)
            {
                trans.CN_S_START_BIT += "_" + trans.CN_S_QTY_INDEX;
            }

            var okTask = new OkTask()
            {
                index = index,
                taskNo = trans.CN_S_TASK_NO,
                startStock = trans.CN_S_STOCK_CODE,
                startArea = trans.CN_S_START_AREA,
                startBit = trans.CN_S_START_BIT,
                endStock = trans.CN_S_STOCK_CODE,
                endArea = trans.CN_S_END_AREA,
                endBit = trans.CN_S_END_BIT,
                priority = trans.CN_N_PRIORITY,
                trayCode = trans.CN_S_CIR_OBJ_CODE,
                itemCode = itemCode
            };
            return okTask;
        }
    }

    /// <summary>
    /// 转运
    /// </summary>
    public class TransportTaskBll
    {
        /// <summary>
        /// 点对点转运
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public OperateResult TransportTask(OutWorkAreaEntity Model)
        {
            var chi = new SqlHelper<object>().GetInstance();
            var newDb = chi.CopyNew();
            try
            {
                //判断起点终点是否为空
                if (string.IsNullOrEmpty(Model.startBit))
                {
                    throw new Exception("点对点任务起点不能为空");
                }
                if (string.IsNullOrEmpty(Model.endBit))
                {
                    throw new Exception("点对点任务终点不能为空");
                }
                if (string.IsNullOrEmpty(Model.S_Subtask))
                {
                    throw new Exception("是否下任务给AGV开关不允许为空 要么N 要么Y S_Subtask字段");
                }
                if (string.IsNullOrEmpty(Model.S_TransAgv))
                {
                    throw new Exception("是否下任务给立库开关不允许为空 要么N 要么Y S_TransAgv字段");
                }
                if (string.IsNullOrEmpty(Model.S_TransWcs))
                {
                    throw new Exception("是否分发立库任务开关不允许为空 要么N 要么Y S_TransWcs字段");
                }

                //验证起点
                #region 验证起点
                var startBit = Model.startBit?.Trim();
                var StartLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();
                if (!StartLocationExt.S_LOCK_STATE.Equals("无"))
                {
                    throw new Exception("当前起点货位状态为：" + StartLocationExt.S_LOCK_STATE + "，不允许下任务！");
                }

                var AreaCode = StartLocationExt.S_AREA_CODE;
                var StartStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == AreaCode)?.First();

                if (StartStockAreaEntity == null)
                {
                    throw new Exception("给定起点位置库区：" + startBit + "不存在！");
                }
                //SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == startBit)?.First();

                LocCntrRel trayLocation = new LocCntrRel();
                if (string.IsNullOrEmpty(StartStockAreaEntity.S_CONTROL_QTY))
                {
                    throw new Exception("起点库区是否管控字段为空");
                }
                if (StartStockAreaEntity.S_CONTROL_QTY == "Y")
                {
                    trayLocation = SqlSugarHelper.Db.Queryable<LocCntrRel>().Where(e => e.S_LOC_CODE == startBit)?.First();
                    if (trayLocation == null)
                    {
                        throw new Exception("当前起点未绑定托盘");
                    }
                    Model.trayCode = trayLocation.S_CNTR_CODE;
                }
                else
                {
                    if (string.IsNullOrEmpty(Model.trayCode))
                    {
                        throw new Exception("点对点任务工装编号不能为空");
                    }
                }
                #endregion

                //验证终点
                //获取终点库区信息
                #region 验证终点
                var endBit = Model.endBit;
                var EndLocationExt = SqlSugarHelper.Db.Queryable<Location>().Where(e => e.S_LOC_CODE == endBit)?.First();
                LogHelper.Info("转运", "查询终点货位：" + JsonConvert.SerializeObject(EndLocationExt));
                if (EndLocationExt == null)
                {
                    throw new Exception("未查询到当前终点货位信息");
                }
                if (EndLocationExt.C_ENABLE != "Y")
                {
                    throw new Exception("查询到当前终点货位信息未在启用状态");
                }
                var EndArea = EndLocationExt.S_AREA_CODE;
                var EndStockAreaEntity = SqlSugarHelper.Db.Queryable<TN_AreaEntitys>().Where(e => e.S_AREA_CODE == EndArea)?.First();
                LogHelper.Info("转运", "查询终点货位库区：" + JsonConvert.SerializeObject(EndStockAreaEntity));
                if (EndStockAreaEntity == null)
                {
                    throw new Exception("给定的目的位置未找到库区");
                }
                // 检查货位状态  是转运且管控数量时使用
                if (string.IsNullOrEmpty(EndStockAreaEntity.S_CONTROL_QTY))
                {
                    throw new Exception("终点库区是否管控字段为空");
                }
                if (EndStockAreaEntity.S_CONTROL_QTY.Equals("Y"))
                {
                    if (!EndLocationExt.S_LOCK_STATE.Equals("无"))
                    {
                        throw new Exception("当前终点货位状态为：" + EndLocationExt.S_LOCK_STATE + "，货位不可用！");
                    }
                    if (EndLocationExt.N_CURRENT_NUM > 0)
                    {
                        throw new Exception("当前货位容量为" + EndLocationExt.N_CURRENT_NUM + "，货位不可用！");
                    }
                }
                #endregion
                var objectTask = "";
                #region 判断任务类型
                if (Model.S_Subtask == "Y")
                {
                    objectTask = Constants.TaskFlag_ZG;
                    if (Model.S_TransAgv == "N" && Model.S_TransWcs == "N")
                    {
                        throw new Exception("禁止 通知任务AGV和立库开关全部为N");
                    }
                }
                else
                {
                    if (Model.S_TransAgv == "N" && Model.S_TransWcs == "N")
                    {
                        throw new Exception("禁止 通知任务开关全部为N");
                    }
                    if (Model.S_TransAgv == "Y")
                    {
                        objectTask = Constants.TaskFlag_AGV;
                    }
                    else if (Model.S_TransWcs == "Y")
                    {
                        objectTask = Constants.TaskFlag_LG;
                    }
                }

                #endregion
                #region 生成转运任务号
                var taskNo = BLLCreator.Create<IdGuid>().TaskNo("ZY");
                if (string.IsNullOrEmpty(taskNo))
                {
                    throw new Exception("任务");
                }
                #endregion
                #region 组装任务
                WMSTask Task = new WMSTask();
                Task.S_TASK_NO = taskNo;
                Task.S_START_LAREA = StartLocationExt.S_AREA_CODE;
                Task.S_END_LAREA = EndLocationExt.S_AREA_CODE;
                Task.S_START_LOC = StartLocationExt.S_LOC_CODE;
                Task.S_END_LOC = EndLocationExt.S_LOC_CODE;
                Task.S_TYPE = "出库";
                Task.S_B_STATE = "未执行";
                Task.S_CNTRS = Model.trayCode;
                Task.N_CNTR_COUNT = 1;
                Task.N_PRIORITY = Model.priority;
                Task.S_NOTE = objectTask;
                Task.S_READ_LOCK = "N";
                Task.S_Subtask = Model.S_Subtask;
                Task.S_FlowNo = "";
                Task.S_Jb_Bit = "";
                Task.S_SRC_SYS = "Mobox";
                Task.S_Zb_Bit = "";
                Task.S_UpstreamNo = taskNo;
                #endregion
                #region 事务即任务下达
                try
                {
                    newDb.BeginTran();
                    if (StartStockAreaEntity.S_CONTROL_QTY == "Y")
                    {
                        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("锁定起点货位失败!");
                        }
                        LogHelper.Info("转运", $"锁定起点货位成功 影响行数{I}");
                    }
                    if (EndStockAreaEntity.S_CONTROL_QTY == "Y")
                    {
                        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("锁定终点货位失败!");
                        }
                        LogHelper.Info("转运", $"锁定终点货位成功 影响行数{I}");
                    }
                    var C = newDb.Insertable(Task).ExecuteCommand();
                    if (C == 0)
                    {
                        throw new System.Exception("任务生成失败!");
                    }
                    LogHelper.Info("转运", $"生成任务 影响行数{C}");
                    #region 判断是否下任务给立库
                    if (Model.S_Subtask == "N" && Model.S_TransWcs == "Y")
                    {
                        LogHelper.Info("转运", "开始通知立库");
                        var ta = BLLCreator.CreateSingleton<WcsTask>().WcsTaskEntity(Task);
                        LogHelper.Info("转运", "通知立库是否成功:" + JsonConvert.SerializeObject(ta));
                        LogHelper.Info("转运", "结束通知立库");
                        if (!ta.Success)
                        {
                            throw new Exception("通知立库失败");
                        }
                    }
                    #endregion
                    newDb.CommitTran();
                    return OperateResult.Succeed("成功");
                }
                catch (Exception ex)
                {
                    newDb.RollbackTran();
                    LogHelper.Info("转运", "报错:" + ex.Message + ex.StackTrace);
                    return OperateResult.Error(ex.Message + ex.StackTrace);
                }
                #endregion
            }
            catch (Exception ex)
            {
                LogHelper.Info("转运", "报错:" + ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message + ex.StackTrace);
            }
        }
    }
}