using HH.WMS.BLL.Basic;
using HH.WMS.BLL.External;
using HH.WMS.BLL.Interface;
using HH.WMS.BLL.MiddleDB;
using HH.WMS.Common;
using HH.WMS.Common.External;
using HH.WMS.Common.Response;
using HH.WMS.DAL.Basic;
using HH.WMS.DAL.Pda;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Autobom;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.Entitys.Dto;
using HH.WMS.Entitys.Entitys.Mes;
using HH.WMS.Entitys.External;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.BLL.Pda
{
    public class ZCBLL : DapperBaseBLL
    {
        #region 保存任务

        public OperateResult SaveTask(TN_MES_TASK task)
        {
            OperateResult result = BLLCreator.CreateDapper<TN_MES_TASK>().Add(task);

            return result;
        }

        #endregion

        #region 根据库区取占用的货位
        /// <summary>
        /// 根据库区取占用的货位
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public List<TN_WM_LOCATION_EXTEntity> GetUsedLocationByArea(string areaCode)
        {
            return CreateDAL<GlDAL>().GetUsedLocationByArea(areaCode);
        }
        #endregion

        #region 移库
        /// <summary>
        /// 移库
        /// </summary>
        /// <param name="transferType"></param>
        public void TransferRubber(string transferType)
        {
            string workFlowName = string.Empty;
            switch (transferType)
            {
                case "transferOfFinalRubber":
                    workFlowName = WorkFlowName.FlowNameList["Z3"];
                    break;
                case "transferOfRawRubber":
                    workFlowName = WorkFlowName.FlowNameList["S2"];
                    break;
            }
            if (string.IsNullOrEmpty(workFlowName))
                TransferRubberThrow(new Exception("未找到移库工作流名称"), workFlowName);


            var isEnableAms = new GLTransferDto();
            var _isEnableAmsStr = JsonHelper.GetValue("isSendAms");
            if (!string.IsNullOrEmpty(_isEnableAmsStr))
            {
                isEnableAms = JsonConvert.DeserializeObject<GLTransferDto>(_isEnableAmsStr);
                isEnableAms = isEnableAms ?? new GLTransferDto();
            }

            try
            {
                var mapStr = JsonHelper.GetValue(transferType);
                if (string.IsNullOrEmpty(mapStr))
                    return;
                var config = JsonConvert.DeserializeObject<GLTransferDto>(mapStr);

                if (IsWorkTime(config))
                {
                    var usedLocations = BLLCreator.Create<GlBLL>().GetUsedLocationByArea(config.endArea);
                    if (usedLocations.Count < config.transferMax)
                    {
                        mapStr = JsonHelper.GetValue("workFlowTransType");
                        if (string.IsNullOrEmpty(mapStr))
                            return;
                        var workFlowTransType = JsonConvert.DeserializeObject<List<GLTransferDto>>(mapStr);
                        var existsWorkFlow = workFlowTransType.Find(f => f.workFlowName == workFlowName);
                        if (existsWorkFlow == null)
                        {
                            TransferRubberThrow(new Exception("未找到移库方向"), workFlowName);
                        }

                        TN_WM_B_MAKE_TASKEntity makeReq = new TN_WM_B_MAKE_TASKEntity()
                        {
                            CN_S_START_AREA = config.startArea,
                            CN_S_END_AREA = config.endArea,
                            CN_S_ITEM_CODE = config.itemCode,
                            CN_S_NEED_AMS = Constants.Y,
                            CN_S_WORKFLOW_NAME = workFlowName,
                            CN_S_ISTRANSPORT = isEnableAms.moveStockEnableAms,
                            //CN_F_QUANTITY = 1
                        };

                        var externalRes = new ExternalResponse();
                        if (existsWorkFlow.transType == "In")
                        {
                            try
                            {
                                var res = BLLCreator.Create<GlBLL>().GLInWorkArea(makeReq);
                                externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                            }
                            catch (Exception ex)
                            {
                                TransferRubberThrow(ex, workFlowName);
                            }
                        }
                        else
                        {
                            try
                            {
                                var res = BLLCreator.Create<GlBLL>().GLOutWorkArea(makeReq);
                                externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                            }
                            catch (Exception ex)
                            {
                                TransferRubberThrow(ex, workFlowName);
                            }
                        }

                        if (!externalRes.success)
                        {
                            TransferRubberThrow(new Exception(externalRes.errMsg), workFlowName);
                        }
                        else//成功的话写移库记录
                        {
                            var ok = externalRes.okList[0];
                            AGV_Transfer_record _log = new AGV_Transfer_record()
                            {
                                ID = Guid.NewGuid().ToString(),
                                LoadNo = ok.trayCode,
                                MaterielCode = config.itemCode,
                                MaterielName = config.itemName,
                                Quantity = 1,
                                LocationName_Source = ok.startBit,
                                LocationName_Dest = ok.endBit,
                                CreateDate = DateTime.Now,
                                HasBeenReceived = Constants.Y
                            };
                            var _or = BLLCreator.CreateMiddleDapper<AGV_Transfer_record>().Add(_log);
                            if (!_or.Success)
                            {
                                TransferRubberThrow(new Exception("下达成功,写入移库记录失败：" + _or.Msg), workFlowName);
                                //throw new Exception("下达成功,写入移库记录失败：" + _or.Msg);
                                //ors.Add(OperateResult.Succeed("下达成功,写入移送任务日志失败：" + _or.Msg, req));
                            }
                            var _serviceExec = new TN_WM_SERVICE_EXECEntity()
                            {
                                CN_S_TASK_NO = Guid.NewGuid().ToString(),
                                CN_S_ITEM_CODE = config.itemCode,
                                CN_S_ITEM_NAME = config.itemName,
                                CN_S_TASK_TYPE = "移库",
                                CN_S_TRANS_TYPE = workFlowName,
                                CN_S_TRAY_CODE = ok.trayCode,
                                CN_N_PRIORITY = 1,
                                CN_S_START_LOCATION = ok.startBit,
                                CN_S_END_LOCATION = ok.endBit,
                                CN_T_CREATE = DateTime.Now,
                                CN_C_COMPLETE = Constants.Y,
                                CN_C_SEND_MES = Constants.Y,
                                CN_S_MSG = "下达成功"
                            };

                            var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Add(_serviceExec);
                            if (!or.Success)
                                throw new Exception(or.Msg);

                            Log.DomainInfo(workFlowName + "移库成功", JsonConvert.SerializeObject(externalRes));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.DomainInfo(workFlowName + " Error", ex.Message);
            }
        }
        #endregion

        #region 移库异常记录
        /// <summary>
        /// 移库异常记录
        /// </summary>
        /// <param name="ex"></param>
        private void TransferRubberThrow(Exception ex, string workFlowName)
        {
            var lastServiceExec = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().GetSingleEntity(new
            {
                CN_S_TASK_TYPE = "移库",
                CN_S_TRANS_TYPE = workFlowName,
            }, " ORDER BY CN_T_CREATE DESC ");
            if (lastServiceExec != null && ex.Message == lastServiceExec.CN_S_MSG)
            {
                BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Update(new
                {
                    CN_T_CREATE = DateTime.Now
                }, new
                {
                    CN_S_TASK_NO = lastServiceExec.CN_S_TASK_NO
                });
                throw ex;
            }
            TN_WM_SERVICE_EXECEntity serviceExec = new TN_WM_SERVICE_EXECEntity()
            {
                CN_S_TASK_NO = Guid.NewGuid().ToString(),
                CN_S_TASK_TYPE = "移库",
                CN_S_TRANS_TYPE = workFlowName,
                CN_T_CREATE = DateTime.Now,
                CN_C_COMPLETE = Constants.Y,
                CN_C_SEND_MES = Constants.N,
                CN_S_MSG = ex.Message
            };
            var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Add(serviceExec);
            if (!or.Success)
                throw new Exception(or.Msg);
            throw ex;
        }
        #endregion

        #region 移送任务
        /// <summary>
        /// 移送任务
        /// </summary>
        /// <param name="transportReqs"></param>
        public List<OperateResult> ExecTransferTask(List<TN_MES_TASK> transportReqs)
        {
            var mapStr = JsonHelper.GetValue("workFlowTransType");
            if (string.IsNullOrEmpty(mapStr))
                throw new Exception("未找到配置：workFlowTransType");

            var isEnableAms = new ZCTransferDto();
            var _isEnableAmsStr = JsonHelper.GetValue("isSendAms");
            if (!string.IsNullOrEmpty(_isEnableAmsStr))
            {
                isEnableAms = JsonConvert.DeserializeObject<ZCTransferDto>(_isEnableAmsStr);
                isEnableAms = isEnableAms ?? new ZCTransferDto();
            }

            var workFlowTransType = JsonConvert.DeserializeObject<List<ZCTransferDto>>(mapStr);

            List<OperateResult> ors = new List<OperateResult>();
            if (transportReqs.Any())
            {
                foreach (var req in transportReqs)
                {
                    string startBit = req.Location_From;
                    string endBit = req.Location_To;

                    string startArea = string.Empty, endArea = string.Empty;
                    //校验起点
                    if (!string.IsNullOrEmpty(startBit))
                    {
                        var _location = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                        {
                            CN_S_LOCATION_CODE = startBit
                        });
                        if (_location == null)
                        {
                            ors.Add(OperateResult.Error("未找到起始货位：" + startBit, req));
                            continue;
                        }
                        startArea = Util.ToString(_location.CN_S_AREA_CODE).Trim();
                    }
                    //校验终点
                    if (!string.IsNullOrEmpty(endBit))
                    {
                        var _location = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                        {
                            CN_S_LOCATION_CODE = endBit
                        });
                        if (_location == null)
                        {
                            ors.Add(OperateResult.Error("未找到终点货位：" + endBit, req));
                            continue;
                        }
                        endArea = Util.ToString(_location.CN_S_AREA_CODE).Trim();
                    }
                    if (string.IsNullOrEmpty(startArea) && string.IsNullOrEmpty(endArea))
                    {
                        ors.Add(OperateResult.Error("起点终点不可同时为空"));
                        continue;
                    }
                    //找作业路径
                    //var workRoute = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetSingleRoute(startArea, endArea);
                    //if (workRoute == null)
                    //{
                    //    ors.Add(OperateResult.Error("未找到作业路径", req));
                    //    continue;
                    //}

                    var workRoute = new TN_AB_B_WORK_AREA_PROEntity();
                    var workRoutes = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetRoute("", startArea, endArea);
                    if (!workRoutes.Any())
                    {
                        ors.Add(OperateResult.Error("未找到作业路径", req));
                        continue;
                    }
                    else
                    {
                        workRoute = workRoutes[0];
                        if (workRoutes.Count > 1)
                        {
                            if (workRoutes.Exists(e => Util.ToString(e.CN_S_TYPE_CODE) == "X6" || Util.ToString(e.CN_S_TYPE_CODE) == "X7"))
                            {
                                if (string.IsNullOrEmpty(req.PROD_NO))
                                {
                                    workRoute = workRoutes.Find(f => f.CN_S_TYPE_CODE == "X6");
                                }
                                else
                                {
                                    workRoute = workRoutes.Find(f => f.CN_S_TYPE_CODE == "X7");
                                }
                            }
                        }
                        if (workRoute == null)
                        {
                            ors.Add(OperateResult.Error("未找到作业路径", req));
                            continue;
                        }
                    }


                    var existsWorkFlow = workFlowTransType.Find(f => f.workFlowCode == workRoute.CN_S_TYPE_CODE);
                    if (existsWorkFlow == null)
                    {
                        ors.Add(OperateResult.Error("未找到作业方向", req));
                        continue;
                    }

                    TN_WM_B_MAKE_TASKEntity makeReq = new TN_WM_B_MAKE_TASKEntity()
                    {
                        CN_S_ITEM_CODE = req.PROD_NO,
                        CN_S_ITEM_NAME = "",
                        CN_S_START_BIT = req.Location_From,
                        CN_S_START_AREA = workRoute.CN_S_START_AREA_CODE,
                        CN_S_END_BIT = req.Location_To,
                        CN_S_END_AREA = workRoute.CN_S_END_AREA_CODE,
                        CN_S_TRAY_CODE = req.TurnCardNum,
                        CN_S_PRIORITY = req.Priority.ToString(),
                        CN_S_WORKFLOW_NAME = WorkFlowName.FlowNameList[existsWorkFlow.workFlowCode],
                        CN_F_QUANTITY = Convert.ToDecimal(req.CURRENT_AMOUNT),
                        CN_S_NEED_AMS = isEnableAms.transferEnableAms,
                        CN_S_ISTRANSPORT = existsWorkFlow.isTransport
                    };

                    var externalRes = new ExternalResponse();
                    if (existsWorkFlow.transType == "In")
                    {
                        try
                        {
                            var res = BLLCreator.Create<ZCBLL>().GLInWorkArea(makeReq);
                            externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                        }
                        catch (Exception ex)
                        {
                            ors.Add(OperateResult.Error("入作业区失败：" + ex.Message, req));
                            continue;
                        }
                    }
                    else
                    {
                        try
                        {
                            var res = BLLCreator.Create<ZCBLL>().GLOutWorkArea(makeReq);
                            externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                        }
                        catch (Exception ex)
                        {
                            ors.Add(OperateResult.Error("出作业区失败：" + ex.Message, req));
                            continue;
                        }
                    }

                    var _serviceExec = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().GetSingleEntity(new
                    {
                        CN_S_TASK_NO = req.task_no
                    });
                    if (_serviceExec != null)
                    {
                        _serviceExec.Update = true;
                    }
                    else
                    {
                        _serviceExec = new TN_WM_SERVICE_EXECEntity()
                        {
                            CN_S_TASK_NO = req.task_no,
                            CN_S_ITEM_CODE = req.PROD_NO,
                            CN_S_ITEM_NAME = "",
                            CN_S_TASK_TYPE = "移送",
                            CN_S_TRANS_TYPE = WorkFlowName.FlowNameList[existsWorkFlow.workFlowCode],
                            CN_S_TRAY_CODE = req.TurnCardNum,
                            CN_N_PRIORITY = req.Priority,
                            CN_S_START_LOCATION = req.Location_From,
                            CN_S_END_LOCATION = req.Location_To,
                            CN_T_CREATE = DateTime.Now,
                            CN_C_COMPLETE = Constants.N,
                            CN_C_SEND_MES = Constants.N,
                            CN_F_QUANTITY = Convert.ToDecimal(req.CURRENT_AMOUNT),
                            CN_N_REQUEST_TYPE = 0,//req.RequestType,
                            CN_S_TRAY_TYPE = "0"//req.LoadType
                        };
                    }

                    if (!externalRes.success)
                    {
                        //写任务执行表，并回报mes
                        if (externalRes.errCode == "7" || externalRes.errCode == "8")
                        {

                            _serviceExec.CN_C_COMPLETE = Constants.Y;
                            _serviceExec.CN_C_SEND_MES = Constants.Y;
                            _serviceExec.CN_S_MSG = externalRes.errMsg;
                        }
                        else
                        {
                            _serviceExec.CN_C_COMPLETE = Constants.N;
                            _serviceExec.CN_C_SEND_MES = Constants.N;
                            _serviceExec.CN_S_MSG = externalRes.errMsg;
                        }

                        var _or = TransportSuccess(_serviceExec);

                        if (!_or.Success)
                        {
                            Log.DomainInfo("TransportSuccess error", _or.Msg);
                            Log.DomainInfo("externalRes Error： " + externalRes.errMsg, JsonConvert.SerializeObject(req));

                            ors.Add(OperateResult.Error("TransportSuccess error", _or.Msg));
                        }
                        else
                        {
                            if (externalRes.errCode == "7" || externalRes.errCode == "8")
                            {
                                ors.Add(OperateResult.Warning("已反馈至mes，消息： " + externalRes.errMsg, req));
                            }
                            else
                            {
                                ors.Add(OperateResult.Error("externalRes Error： " + externalRes.errMsg, req));
                            }
                        }
                    }
                    else//成功的话写移送任务日志
                    {
                        var ok = externalRes.okList[0];

                        _serviceExec.CN_S_START_LOCATION = ok.startBit;
                        _serviceExec.CN_S_END_LOCATION = ok.endBit;
                        _serviceExec.CN_C_COMPLETE = Constants.Y;
                        _serviceExec.CN_C_SEND_MES = Constants.Y;
                        _serviceExec.CN_S_MSG = "下达成功";
                        var _or = TransportSuccess(_serviceExec);
                        if (!_or.Success)
                        {
                            ors.Add(OperateResult.Warning("下达成功,更新移送任务日志失败：" + _or.Msg, req));
                            continue;
                        }
                        ors.Add(OperateResult.Succeed("下达成功", req));
                    }
                }
                Log.DomainInfo("移送任务 结果", JsonConvert.SerializeObject(ors));
            }
            return ors;
        }
        #endregion

        #region 判断是否在工作时间
        /// <summary>
        /// 判断是否在工作时间
        /// </summary>
        /// <param name="config"></param>
        /// <returns></returns>
        private bool IsWorkTime(GLTransferDto config)
        {
            try
            {
                TimeSpan dspWorkingDayAM = config.startTime.TimeOfDay;
                TimeSpan dspWorkingDayPM = config.endTime.TimeOfDay;
                TimeSpan dspNow = DateTime.Now.TimeOfDay;
                if (dspNow >= dspWorkingDayAM && dspNow <= dspWorkingDayPM)
                {
                    return true;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }
        #endregion

        /// <summary>
        /// 入作业区
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public string GLInWorkArea(TN_WM_B_MAKE_TASKEntity entity)
        {
            ExternalResponse result = new ExternalResponse();
            try
            {
                Log.Info("处理位置信息开始：", JsonConvert.SerializeObject(entity));
                //处理位置信息
                CheckPosition(ref entity);
                Log.Info("处理位置信息结束：", JsonConvert.SerializeObject(entity));

                //传递参数
                List<InWorkAreaEntity> inWorkAreaEntitys = new List<InWorkAreaEntity>();





                InWorkAreaEntity model = new InWorkAreaEntity();

                model.itemCode = entity.CN_S_ITEM_CODE;
                model.trayCode = entity.CN_S_TRAY_CODE;
                model.priority = Convert.ToInt32(entity.CN_S_PRIORITY);
                model.startBit = entity.CN_S_START_BIT;
                model.startArea = entity.CN_S_START_AREA;
                model.startStock = entity.CN_S_START_STOCK;
                model.endBit = entity.CN_S_END_BIT;
                model.endArea = entity.CN_S_END_AREA;
                model.endStock = entity.CN_S_END_STOCK;
                model.remark = entity.CN_S_WORKFLOW_NAME;
                model.isBackItem = "";
                model.needCreateAMSTask = entity.CN_S_NEED_AMS;

                //标记是否是退回物料(生胶、小料、母胶、终炼胶小盘料退回，余料格栅车退回，余料帘布退回)
                string workFlowName = entity.CN_S_WORKFLOW_NAME;
                if (workFlowName == WorkFlowName.FlowNameList["S5"] || workFlowName == WorkFlowName.FlowNameList["X7"] || workFlowName == WorkFlowName.FlowNameList["M5"] || workFlowName == WorkFlowName.FlowNameList["Z6"] || workFlowName == WorkFlowName.FlowNameList["T5"] || workFlowName == WorkFlowName.FlowNameList["L5"])
                {
                    model.isBackItem = Constants.Y;
                }

                List<string> keyList = (from q in WorkFlowName.FlowNameList
                                        where q.Value == entity.CN_S_WORKFLOW_NAME
                                        select q.Key).ToList<string>(); //get all keys

                var funcName = WorkFlowName.FlowNameList.FirstOrDefault(q => q.Value == entity.CN_S_WORKFLOW_NAME).Key;

                if (funcName != "" && funcName != null)
                {
                    model.funCode = funcName;
                }

                //物料编码不为空时 才组织Data
                if (!string.IsNullOrEmpty(entity.CN_S_ITEM_CODE))
                {

                    var item = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(entity.CN_S_ITEM_CODE);

                    List<ChaoYangItemDataEntity> DataList = new List<ChaoYangItemDataEntity>();

                    DataList.Add(new ChaoYangItemDataEntity
                    {
                        itemCode = entity.CN_S_ITEM_CODE,
                        qty = Convert.ToInt32(entity.CN_F_QUANTITY),
                        itemModel = item == null ? "" : item.CN_S_MODEL,
                        itemPackUnit = item == null ? "" : item.CN_S_MEASURE_UNIT,
                        itemName = item == null ? "" : item.CN_S_ITEM_NAME,
                        itemState = "合格"
                    });
                    model.data = DataList;
                }

                inWorkAreaEntitys.Add(model);

                Log.Info("开始进入入库，传参：", JsonConvert.SerializeObject(inWorkAreaEntitys));
                result = BLLCreator.Create<WmsApiBaseBLL>().InWorkArea(inWorkAreaEntitys);
                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                result.errCode = "5";//程序异常
                result.errMsg = ex.Message;//程序异常
                Log.DomainInfo(entity.CN_S_WORKFLOW_NAME + "： InError", ex.Message);
                return JsonConvert.SerializeObject(result);
            }

        }

        /// <summary>
        /// 出作业区
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public string GLOutWorkArea(TN_WM_B_MAKE_TASKEntity entity)
        {
            ExternalResponse result = new ExternalResponse();

            try
            {
                Log.Info("处理位置信息开始：", JsonConvert.SerializeObject(entity));
                //处理位置信息
                CheckPosition(ref entity);
                Log.Info("处理位置信息结束：", JsonConvert.SerializeObject(entity));

                //传递参数
                List<OutWorkAreaEntity> outWorkAreaEntitys = new List<OutWorkAreaEntity>();

                List<OutWorkDataEntity> DataList = new List<OutWorkDataEntity>();

                //物料编码不为空时 才组织Data
                if (!string.IsNullOrEmpty(entity.CN_S_ITEM_CODE))
                {
                    DataList.Add(new OutWorkDataEntity
                    {
                        ItemCode = entity.CN_S_ITEM_CODE,
                        TrayCode = entity.CN_S_TRAY_CODE,
                        UnitQty = Convert.ToInt32(entity.CN_F_QUANTITY)
                    });
                }
                string funCode = "";
                List<string> keyList = (from q in WorkFlowName.FlowNameList
                                        where q.Value == entity.CN_S_WORKFLOW_NAME
                                        select q.Key).ToList<string>(); //get all keys

                var funcName = WorkFlowName.FlowNameList.FirstOrDefault(q => q.Value == entity.CN_S_WORKFLOW_NAME).Key;

                if (funcName != "" && funcName != null)
                {
                    funCode = funcName;
                }

                outWorkAreaEntitys.Add(new OutWorkAreaEntity()
                {
                    itemCode = entity.CN_S_ITEM_CODE,
                    trayCode = entity.CN_S_TRAY_CODE,
                    priority = Convert.ToInt32(entity.CN_S_PRIORITY),
                    startBit = entity.CN_S_START_BIT,
                    startArea = entity.CN_S_START_AREA,
                    startStock = entity.CN_S_START_STOCK,
                    endBit = entity.CN_S_END_BIT,
                    endArea = entity.CN_S_END_AREA,
                    endStock = entity.CN_S_END_STOCK,
                    remark = entity.CN_S_WORKFLOW_NAME,
                    Data = DataList,
                    needCreateAMSTask = entity.CN_S_NEED_AMS,
                    IsTransport = entity.CN_S_ISTRANSPORT,
                    funCode = string.IsNullOrEmpty(funCode) ? "" : funCode
                });

                Log.Info("开始进入出库，传参：", JsonConvert.SerializeObject(entity));

                result = BLLCreator.Create<WmsApiBaseBLL>().OutWorkArea(outWorkAreaEntitys);
                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                result.errCode = "5";//程序异常
                result.errMsg = ex.Message;//程序异常
                Log.DomainInfo(entity.CN_S_WORKFLOW_NAME + "： OutError", ex.Message);
                return JsonConvert.SerializeObject(result);
            }
        }

        /// <summary>
        /// 处理位置信息
        /// </summary>
        /// <param name="entity"></param>
        private void CheckPosition(ref TN_WM_B_MAKE_TASKEntity entity)
        {
            //防止传了起始位置，没传起始库区
            if (!string.IsNullOrEmpty(entity.CN_S_START_BIT))
            {
                TN_WM_LOCATION_EXTEntity locationModel = BLL.BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetExtModel(" WHERE CN_S_LOCATION_CODE='" + entity.CN_S_START_BIT + "' ");
                if (locationModel != null)
                {
                    entity.CN_S_START_AREA = locationModel.CN_S_AREA_CODE.Trim();
                    entity.CN_S_START_STOCK = locationModel.CN_S_STOCK_CODE.Trim();
                }
            }
            //防止传了目的位置，没传目的库区
            if (!string.IsNullOrEmpty(entity.CN_S_END_BIT))
            {
                TN_WM_LOCATION_EXTEntity locationModel = BLL.BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetExtModel(" WHERE CN_S_LOCATION_CODE='" + entity.CN_S_END_BIT + "' ");
                if (locationModel != null)
                {
                    entity.CN_S_END_AREA = locationModel.CN_S_AREA_CODE.Trim();
                    entity.CN_S_END_STOCK = locationModel.CN_S_STOCK_CODE.Trim();
                }
            }

            Log.Info("处理位置信息位置一：", JsonConvert.SerializeObject(entity));

            if (string.IsNullOrEmpty(entity.CN_S_START_AREA) || string.IsNullOrEmpty(entity.CN_S_END_AREA))
            {
                //找作业路径
                var workRoute = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetSingleRoute(entity.CN_S_START_AREA, entity.CN_S_END_AREA);
                if (workRoute == null)
                {
                    throw new Exception("失败，未找到作业路径！");
                }

                if (string.IsNullOrEmpty(entity.CN_S_START_AREA))
                {
                    entity.CN_S_START_AREA = workRoute.CN_S_START_AREA_CODE;
                }

                if (string.IsNullOrEmpty(entity.CN_S_END_AREA))
                {
                    entity.CN_S_END_AREA = workRoute.CN_S_END_AREA_CODE;
                }
            }

            Log.Info("处理位置信息位置二：", JsonConvert.SerializeObject(entity));

            var SareaEntity = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetStockAreaEntity(entity.CN_S_START_AREA.Trim());
            if (SareaEntity != null)
                entity.CN_S_START_STOCK = SareaEntity.CN_S_STOCK_CODE;


            var EareaEntity = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetStockAreaEntity(entity.CN_S_END_AREA.Trim());
            if (EareaEntity != null)
                entity.CN_S_END_STOCK = EareaEntity.CN_S_STOCK_CODE;

            Log.Info("处理位置信息位置三：", JsonConvert.SerializeObject(entity));
        }

        private OperateResult TransportSuccess(TN_WM_SERVICE_EXECEntity _serviceExec)
        {
            return UseTransaction(trans =>
            {
                if (_serviceExec.Update)
                {
                    var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Update(new
                    {
                        CN_S_START_LOCATION = _serviceExec.CN_S_START_LOCATION,
                        CN_S_END_LOCATION = _serviceExec.CN_S_END_LOCATION,
                        CN_C_COMPLETE = _serviceExec.CN_C_COMPLETE,
                        CN_C_SEND_MES = _serviceExec.CN_C_SEND_MES,
                        CN_S_MSG = _serviceExec.CN_S_MSG
                    }, new
                    {
                        CN_S_TASK_NO = _serviceExec.CN_S_TASK_NO
                    });
                    if (!or.Success)
                        throw new Exception(or.Msg);
                }
                else
                {
                    var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Add(_serviceExec);
                    if (!or.Success)
                        throw new Exception(or.Msg);
                }
            });
        }

        #region 服务执行记录日志分页
        /// <summary>
        /// 服务执行记录日志分页
        /// </summary>
        /// <param name="sm"></param>
        /// <returns></returns>
        public OperateResult GetServiceExecList(SearchModel sm)
        {
            return CreateDAL<GlDAL>().GetServiceExecList(sm);
        }
        #endregion

        public void SelfManageTask()
        {
            try
            {
                //取未执行、完成一半、完成部分的自管任务
                var tasks = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetList(new
                {
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_STATE = new List<string>() { Constants.TaskState_NoExecuted, Constants.TaskState_CompleteHalf, Constants.TaskState_CompletePart }
                });

                // 接驳位配置
                var connectBitStr = JsonHelper.GetValue("connectBit");
                if (string.IsNullOrEmpty(connectBitStr))
                    throw new Exception("未找到配置：connectBit");

                List<OperateResult> ors = new List<OperateResult>();
                foreach (var task in tasks)
                {
                    try
                    {
                        var connectBits = JsonConvert.DeserializeObject<List<ConnectBitDto>>(connectBitStr);

                        OperateResult or = OperateResult.Error("未知错误");

                        #region 半成品

                        #region 空托出库

                        if (task.CN_S_EXT3 == TaskSectionConstants.BCP_KTCK)
                        {
                            // 空托出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecBCP_KTCK_Add(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecBCP_KTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_2)
                            {
                                // 执行第二条任务
                                or = ExecBCP_KTCK_Sub2(task, connectBit);
                            }
                        }

                        #endregion

                        #region 满托入库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.BCP_MTRK)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                or = ExecBCP_MTRK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecBCP_MTRK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_2)
                            {
                                // 执行第二条子任务
                                or = ExecBCP_MTRK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.BCP_MTRK_SECOND)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                or = ExecBCP_MTRK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion

                        #region 成型机

                        #region 半成品回库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_BCPHK)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecCXJ_BCPHK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                            {
                                // 执行第一条子任务
                                ExecCXJ_BCPHK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecCXJ_BCPHK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_BCPHK_SECOND)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecCXJ_BCPHK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #region 空托回库

                        #region 记录

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_RECORD)
                        {
                            // 只用于记录
                            // 在同一线边货位的满托出库任务完成后执行
                        }

                        #endregion

                        #region 空托入库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_KTRK)
                        {
                            // 空托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecCXJ_KTHK_KTRK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                            {
                                // 执行第一条子任务
                                ExecCXJ_KTHK_KTRK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecCXJ_KTHK_KTRK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_KTRK_SECOND)
                        {
                            // 空托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecCXJ_KTHK_KTRK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion

                        #region 满托出库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_MTCK)
                        {
                            // 满托出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecCXJ_MTCK_Add(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecCXJ_MTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_2)
                            {
                                // 执行第二条任务
                                or = ExecCXJ_MTCK_Sub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion

                        #region 带束

                        #region 半成品/空托回库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_BCPKTHK)
                        {
                            // 带束入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecDS_BCPKTHK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                            {
                                // 执行第一条子任务
                                ExecDS_BCPKTHK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecDS_BCPKTHK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_BCPKTHK_SECOND)
                        {
                            // 带束入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecDS_BCPKTHK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #region 满托出库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_MTCK)
                        {
                            // 带束出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecCXJ_MTCK_Add(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecCXJ_MTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_2)
                            {
                                // 执行第二条任务
                                or = ExecCXJ_MTCK_Sub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion
                    }
                    catch (Exception ex)
                    {
                        ors.Add(OperateResult.Error(ex.Message));
                    }
                }
                Log.DomainInfo("SelfManageTask", JsonConvert.SerializeObject(ors));
            }
            catch (Exception ex)
            {
                Log.DomainInfo("SelfManageTask Error", ex.Message);
            }
        }

        /// <summary>
        /// 遍历中间表，根据业务类型创建WMS任务
        /// </summary>
        public void ExecTransferTask()
        {
            // 已接收待处理任务
            var receiveTasks = BLLCreator.CreateDapper<TN_MES_TASK>().GetList(new TN_MES_TASK
            {
                NeedTrig = "Y"
            }).OrderBy(t => t.CreateDate).ToList();

            List<OperateResult> ors = new List<OperateResult>();

            foreach (var task in receiveTasks)
            {
                try
                {
                    // 从mongo中获取货位相关的信息 - 起始货位
                    AutoBomLocationEntity start_location = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetModel(task.Location_From);
                    // 从mongo中获取货位相关的信息 - 终点货位
                    AutoBomLocationEntity end_location = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetModel(task.Location_To);

                    // 主任务执行流程中的起始阶段
                    string section = "";
                    switch (task.BUSI_TYPE)
                    {
                        case "1":
                            section = TaskSectionConstants.BCP_KTCK;
                            break;
                        case "2":
                            section = TaskSectionConstants.CXJ_BCPHK;
                            break;
                        case "3":
                            section = TaskSectionConstants.CXJ_KTHK_RECORD;
                            break;
                        case "4":
                            section = TaskSectionConstants.CXJ_MTCK;
                            break;
                        case "5":
                            section = TaskSectionConstants.DS_BCPKTHK;
                            break;
                        case "6":
                            section = TaskSectionConstants.DS_MTCK;
                            break;
                    }
                    // 创建WMS主任务
                    TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                    {
                        CN_S_TASK_NO = task.task_no,
                        CN_S_TRAY_CODE = task.TurnCardNum,
                        CN_S_STATE = Constants.TaskState_NoExecuted,
                        CN_S_BF_TASK_NO = "",
                        CN_S_AF_TASK_NO = "",
                        CN_S_STOCK_CODE = start_location.CN_S_STOCK_CODE,
                        CN_S_START_AREA = start_location.CN_S_AREA_CODE,
                        CN_S_START_BIT = start_location.CN_S_LOCATION_CODE,
                        CN_S_END_AREA = end_location.CN_S_AREA_CODE,
                        CN_S_END_BIT = end_location.CN_S_LOCATION_CODE,
                        CN_N_PRIORITY = 1,
                        CN_S_CREATOR = "sys",
                        CN_S_CREATOR_BY = "sys",
                        CN_T_CREATE = DateTime.Now,
                        CN_T_MODIFY = DateTime.Now,
                        CN_S_REMARK = "",
                        CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                        CN_S_EXT1 = "",
                        CN_S_EXT2 = TaskFlagConstants.ROOT,
                        CN_S_EXT3 = section
                    };
                    UseTransaction(trans =>
                    {
                        // 增加WMS主任务
                        OperateResult re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity);
                        if (!re.Success)
                            throw new Exception(re.Msg);
                        // 更新TN_MES_TASK状态
                        CreateDapperDAL<TN_MES_TASK>().Update(new
                        {
                            NeedTrig = "N"
                        }, new { task_no = task.task_no }, trans);
                        if (!re.Success)
                            throw new Exception(re.Msg);
                    });

                    ors.Add(OperateResult.Succeed("生成成功"));
                }
                catch (Exception ex)
                {
                    ors.Add(OperateResult.Error(ex.Message));
                }
                Log.DomainInfo("ExecTransferTask", JsonConvert.SerializeObject(ors));
            }
        }

        #region 货位状态

        // 接驳位锁定状态：预入库锁定、预出库锁定
        // 接驳位空闲状态：正常
        // 准备点状态同接驳位
        // 立库锁定状态：  预入库锁定、预出库锁定
        // 立库空闲状态：  空(入库前)、满(出库前)

        // 创建任务前、执行任务前      检查货位状态
        // 完成任务后                  清除货位状态
        // 执行失败后                  如何处理?

        #endregion

        #region 半成品

        #region 空托出库

        /// <summary>
        /// 创建空托出库并行子任务
        /// </summary>
        public OperateResult ExecBCP_KTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 空托出库和满托入库是反向的
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_END_AREA,
                    CN_S_START_BIT = task.CN_S_END_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_KTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_START_AREA,
                    CN_S_END_BIT = task.CN_S_START_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_KTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建半成品-空托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建半成品-空托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-空托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行空托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecBCP_KTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-空托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行空托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecBCP_KTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-空托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托入库

        /// <summary>
        /// 创建 半成品-满托入库 子任务一
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_3",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_MTRK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建半成品-满托入库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-满托入库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 半成品-满托入库 子任务二
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_4",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_MTRK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建满托入库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-满托入库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行半成品-满托入库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecBCP_MTRK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-满托入库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行半成品-满托入库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecBCP_MTRK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-满托入库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion

        #region 成型机

        #region 半成品回库

        /// <summary>
        /// 创建 成型机-半成品回库 子任务一
        /// </summary>
        public OperateResult ExecCXJ_BCPHK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_BCPHK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-半成品回库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-半成品回库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机-半成品回库 子任务二
        /// </summary>
        public OperateResult ExecCXJ_BCPHK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_BCPHK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-半成品回库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-半成品回库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机-半成品回库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_BCPHK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-半成品回库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机-半成品回库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_BCPHK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-半成品回库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托出库

        /// <summary>
        /// 创建满托出库并行子任务
        /// </summary>
        public OperateResult ExecCXJ_MTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_MTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_MTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-满托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建成型机-满托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-满托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行满托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_MTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-满托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行满托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_MTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-满托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 回托回库-空托入库

        /// <summary>
        /// 创建 成型机-空托回库-空托入库 子任务一
        /// </summary>
        public OperateResult ExecCXJ_KTHK_KTRK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_KTHK_KTRK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-空托回库-空托入库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-空托回库-空托入库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机-空托回库-空托入库 子任务二
        /// </summary>
        public OperateResult ExecCXJ_KTHK_KTRK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_KTHK_KTRK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-空托回库-空托入库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-空托回库-空托入库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机-空托回库-空托入库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_KTHK_KTRK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-空托回库-空托入库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机-空托回库-空托入库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_KTHK_KTRK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-空托回库-空托入库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion

        #region 带束

        #region 半成品及空托回库

        /// <summary>
        /// 创建 成型机带束-半成品/空托回库 子任务一
        /// </summary>
        public OperateResult ExecDS_BCPKTHK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_BCPKTHK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-半成品/空托回库-子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-半成品/空托回库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机带束-半成品/空托回库 子任务二
        /// </summary>
        public OperateResult ExecDS_BCPKTHK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_BCPKTHK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-半成品/空托回库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-半成品/空托回库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机带束-半成品/空托回库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecDS_BCPKTHK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-半成品/空托回库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机带束-半成品/空托回库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecDS_BCPKTHK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-半成品/空托回库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托出库

        /// <summary>
        /// 创建满托出库并行子任务
        /// </summary>
        public OperateResult ExecDS_MTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_MTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_MTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-满托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建成型机带束-满托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-满托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行满托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecDS_MTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-满托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行满托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecDS_MTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-满托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion
    }

    /// <summary>
    /// 配置文件中的常量定义
    /// </summary>
    public class ConnectBitConstants
    {
        /// <summary>
        /// 带束入库
        /// </summary>
        public static string DSRK = "带束入库";
        /// <summary>
        /// 带束出库
        /// </summary>
        public static string DSCK = "带束出库";
        /// <summary>
        /// 满托入库
        /// </summary>
        public static string MTRK = "满托入库";
        /// <summary>
        /// 空托出库
        /// </summary>
        public static string KTCK = "空托出库";
        /// <summary>
        /// 满托出库
        /// </summary>
        public static string MTCK = "满托出库";
        /// <summary>
        /// 空托入库
        /// </summary>
        public static string KTRK = "空托入库";
    }

    /// <summary>
    /// 接口同步的业务类型定义
    /// </summary>
    public class BusinessTypeConstants
    {
        /// <summary>
        /// 半成品满托入库
        /// </summary>
        public static string BCP_MTRK = "1";
        /// <summary>
        /// 成型机半成品回库
        /// </summary>
        public static string CXJ_BCPHK = "2";
        /// <summary>
        /// 成型机空桶回库
        /// </summary>
        public static string CXJ_KTHK = "3";
        /// <summary>
        /// 成型机满托出库
        /// </summary>
        public static string CXJ_MTCK = "4";
        /// <summary>
        /// 成型机带束回库
        /// </summary>
        public static string CXJ_DSHK = "5";
        /// <summary>
        /// 成型机带束满托出库
        /// </summary>
        public static string CXJ_DSMTCK = "6";
    }

    /// <summary>
    /// 任务阶段常量
    /// </summary>
    public class TaskSectionConstants
    {
        /// <summary>
        /// 任务完成
        /// </summary>
        public static string COMPLETE = "任务完成";

        #region 半成品

        /// <summary>
        /// 半成品-空托出库
        /// </summary>
        public static string BCP_KTCK = "空托出库";
        /// <summary>
        /// 半成品-满托入库
        /// </summary>
        public static string BCP_MTRK = "半成品-满托入库";
        /// <summary>
        /// 半成品-满托入库-第二阶段
        /// </summary>
        public static string BCP_MTRK_SECOND = "半成品-满托入库-第二阶段";

        #endregion

        #region 成型机

        /// <summary>
        /// 成型机-半成品回库
        /// </summary>
        public static string CXJ_BCPHK = "成型机-半成品回库";

        /// <summary>
        /// 成型机-半成品回库-第二阶段
        /// </summary>
        public static string CXJ_BCPHK_SECOND = "成型机-半成品回库-第二阶段";
        /// <summary>
        /// 成型机-空托回库-记录阶段
        /// </summary>
        public static string CXJ_KTHK_RECORD = "成型机-空托回库-记录阶段";
        /// <summary>
        /// 成型机-空托回库-入库阶段
        /// </summary>
        public static string CXJ_KTHK_KTRK = "成型机-空托回库-入库阶段";
        /// <summary>
        /// 成型机-空托回库-入库阶段-第二阶段
        /// </summary>
        public static string CXJ_KTHK_KTRK_SECOND = "成型机-空托回库-入库阶段-第二阶段";
        /// <summary>
        /// 成型机-满托出库
        /// </summary>
        public static string CXJ_MTCK = "成型机-满托出库";
        /// <summary>
        /// 成型机-空托入库
        /// </summary>
        public static string CXJ_KTRK = "成型机-空托入库";

        #endregion

        #region 带束

        /// <summary>
        /// 带束-半成品/空托回库
        /// </summary>
        public static string DS_BCPKTHK = "成型机带束-半成品/空托回库";
        /// <summary>
        /// 带束-半成品/空托回库-第二阶段
        /// </summary>
        public static string DS_BCPKTHK_SECOND = "成型机带束-半成品/空托回库-第二阶段";
        /// <summary>
        /// 带束-满托出库
        /// </summary>
        public static string DS_MTCK = "成型机带束-满托出库";

        #endregion
    }

    /// <summary>
    /// 任务标识常量
    /// </summary>
    public class TaskFlagConstants
    {
        /// <summary>
        /// 主任务
        /// </summary>
        public static string ROOT = "主任务";

        #region 半成品

        /// <summary>
        /// 半成品-空托出库子任务一
        /// </summary>
        public static string BCP_KTCK_SUB_1 = "半成品-空托出库-子任务一";
        /// <summary>
        /// 半成品-空托出库子任务二
        /// </summary>
        public static string BCP_KTCK_SUB_2 = "半成品-空托出库-子任务二";
        /// <summary>
        /// 半成品-满托入库子任务一
        /// </summary>
        public static string BCP_MTRK_SUB_1 = "半成品-满托入库-子任务一";
        /// <summary>
        /// 半成品-满托入库子任务二
        /// </summary>
        public static string BCP_MTRK_SUB_2 = "半成品-满托入库-子任务二";

        #endregion

        #region 成型机

        /// <summary>
        /// 成型机-半成品回库-子任务一
        /// </summary>
        public static string CXJ_BCPHK_SUB_1 = "成型机-半成品回库-子任务一";
        /// <summary>
        /// 成型机-半成品回库-子任务二
        /// </summary>
        public static string CXJ_BCPHK_SUB_2 = "成型机-半成品回库-子任务一";
        /// <summary>
        /// 成型机-空托回库-记录任务
        /// </summary>
        public static string CXJ_KTHK_RECORD = "成型机-空托回库-记录任务";
        /// <summary>
        /// 成型机-空托回库-入库阶段-子任务一
        /// </summary>
        public static string CXJ_KTHK_KTRK_SUB_1 = "成型机-空托回库-入库阶段-子任务一";
        /// <summary>
        /// 成型机-空托回库-入库阶段-子任务二
        /// </summary>
        public static string CXJ_KTHK_KTRK_SUB_2 = "成型机-空托回库-入库阶段-子任务二";
        /// <summary>
        /// 成型机-满托出库-子任务一
        /// </summary>
        public static string CXJ_MTCK_SUB_1 = "成型机-满托出库-子任务一";
        /// <summary>
        /// 成型机-满托出库-子任务二
        /// </summary>
        public static string CXJ_MTCK_SUB_2 = "成型机-满托出库-子任务二";

        #endregion

        #region 带束

        /// <summary>
        /// 成型机带束-半成品/空托回库-子任务一
        /// </summary>
        public static string DS_BCPKTHK_SUB_1 = "成型机带束-半成品/空托回库-子任务一";
        /// <summary>
        /// 成型机带束-半成品/空托回库-子任务二
        /// </summary>
        public static string DS_BCPKTHK_SUB_2 = "成型机带束-半成品/空托回库-子任务二";
        /// <summary>
        /// 成型机带束-满托出库-子任务一
        /// </summary>
        public static string DS_MTCK_SUB_1 = "成型机带束-满托出库-子任务一";
        /// <summary>
        /// 成型机带束-满托出库-子任务二
        /// </summary>
        public static string DS_MTCK_SUB_2 = "成型机带束-满托出库-子任务二";

        #endregion
    }
}