using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.Algorithm.Out;
using HH.WMS.DAL.Algorithm;
using HH.WMS.DAL.Basic;
using HH.WMS.Entitys.Algorithm;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HH.WMS.DAL.InStock;
using HH.WMS.BLL.Common;
using Newtonsoft.Json;
using HH.WMS.Entitys.Dto;
using HH.WMS.Entitys;

namespace HH.WMS.BLL.Algorithm
{
    /// <summary>
    /// 出库算法BLL层
    /// </summary>
    public class Out_AlgorBLL : BaseBLL
    {
        /**************计算  返回物料所在货位的算法开始/**************/

        #region 非作业区  出库算法
        /// <summary>
        /// 返回物料 先进先出、质保期将近的先出 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        //public List<OutResultEntity> Out(OutAlgorEnitty model)
        //{
        //    List<OutResultEntity> lstResultEntity = new List<OutResultEntity>();
        //    Log.AlgorInfo("Out_AlgorBLL—Out", "出库算法开始，传入参数:" + JsonConvert.SerializeObject(model));
        //    //获取项目策略
        //    List<STRATEGYALGOREntity> lstStrategy = new List<STRATEGYALGOREntity>();
        //    HH.WMS.Entitys.Basic.AutoBomStockAreaEntity stockEntity = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(model.lstQueryItem[0].areaCode);
        //    lstStrategy = CreateDAL<TN_WM_B_STRATEGYDAL>().GetStrateListByAreaOrStock(stockEntity.CN_S_STOCK_CODE, "", "");
        //    List<string> lstStrate = lstStrategy.Select(o => o.CN_S_NAME).ToList();
        //    //if (lstStrate.Contains("JXXAlgor"))
        //    //{
        //    lstResultEntity = OutJxxFlat(model);
        //    //}
        //    //if (lstStrate.Contains("SszyAlgor"))
        //    //{
        //    //    lstResultEntity = OutSszyFlat(model);
        //    //}
        //    return lstResultEntity;
        //}
        #endregion

        #region 非作业区  平库立库出库算法，根据物料的数量出库
        ///// <summary>
        ///// 非作业区  平库立库出库算法，根据物料的数量出库
        ///// </summary>
        ///// <param name="model"></param>
        ///// <returns></returns>
        //public List<OutResultEntity> OutJxxFlat(OutAlgorEnitty model)
        //{
        //    Log.AlgorInfo("Out_AlgorBLL—Out", "OutJxxFlat");
        //    List<OutResultEntity> lstResultEntity = new List<OutResultEntity>();
        //    //将传递过来的参数按货主、状态、等查询条件分组
        //    List<Out_AreaItemClass> lstAreaItemGroup = GroupAreaCode(model.lstQueryItem);
        //    foreach (Out_AreaItemClass areaItemEntity in lstAreaItemGroup)
        //    {
        //        Log.AlgorInfo("Out_AlgorBLL—Out", "循环处理lstAreaItemGroup数据:" + JsonConvert.SerializeObject(areaItemEntity));
        //        string areaCode = areaItemEntity.areaCode;
        //        string itemCodes = string.Join(",", areaItemEntity.lstItem.Select(o => o.itemCode)).Replace(",", "','");
        //        //组合查询条件
        //        string strWhere = GetPropWhereStr(itemCodes, areaItemEntity.itemState, areaItemEntity.batchCode, areaItemEntity.prodBatchCode, areaItemEntity.ownerName);

        //        //查询该库区配置的出库策略及优先级(生产日期早先出、先进先出、出库整托优先)
        //        List<STRATEGYALGOREntity> lstStrategy = new List<STRATEGYALGOREntity>();
        //        lstStrategy = CreateDAL<TN_WM_B_STRATEGYDAL>().GetStrateListByAreaOrStock("", areaCode, "出库");
        //        List<string> lstStrate = lstStrategy.Select(o => o.CN_S_NAME).ToList();

        //        //获得库区中所有匹配的物料
        //        List<itemQty> v = CreateDAL<Out_AlgorDAL>().GetItemQtyJxx(strWhere, areaCode);
        //        Log.AlgorInfo("Out_AlgorBLL—Out", "List<itemQty>数据:" + JsonConvert.SerializeObject(v));
        //        //循环处理批分分配量
        //        List<itemQty> lstAllocQty = v.Select(g => new itemQty()
        //        {
        //            trayCode = g.trayCode,
        //            CN_F_ALLOC_QTY = g.CN_F_ALLOC_QTY,
        //            CN_S_OWNER = g.CN_S_OWNER,
        //            CN_S_ITEM_STATE = g.CN_S_ITEM_STATE,
        //            itemCode = g.itemCode,
        //        }).Distinct().ToList();

        //        int tmpAllocQty = 0;
        //        foreach (itemQty item in v)
        //        {
        //            //循环托盘物料详细数据，按生产批次早、入库批次早批分分配量
        //            tmpAllocQty = lstAllocQty.Where(o => (o.trayCode == item.trayCode && o.CN_S_OWNER == item.CN_S_OWNER && o.CN_S_ITEM_STATE == item.CN_S_ITEM_STATE && o.itemCode == item.itemCode)).FirstOrDefault().CN_F_ALLOC_QTY;
        //            if (tmpAllocQty > 0)
        //            {
        //                item.Qty = item.Qty - tmpAllocQty;
        //                lstAllocQty.Where(o => (o.trayCode == item.trayCode && o.CN_S_OWNER == item.CN_S_OWNER && o.CN_S_ITEM_STATE == item.CN_S_ITEM_STATE && o.itemCode == item.itemCode)).FirstOrDefault().CN_F_ALLOC_QTY = item.Qty - tmpAllocQty;
        //            }
        //        }
        //        v.RemoveAll(o => o.Qty <= 0);

        //        Log.AlgorInfo("Out_AlgorBLL—Out", "获得库区中所有匹配的物料:lstItemQty:" + JsonConvert.SerializeObject(v));

        //        List<string> lstCodes = v.GroupBy(a => a.locationCode).Select(o => o.Key).ToList();
        //        //到mongodb中查询每个货位的基本信息排除货位被报废的数据
        //        List<AutoBomLocationAbbreEntity> lstFalseLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetScrapLocationCode(lstCodes);
        //        lstCodes = lstFalseLocation.Select(a => a.CN_S_LOCATION_CODE).ToList();
        //        v.RemoveAll(o => lstCodes.Contains(o.locationCode));

        //        //循环前端物料列表
        //        foreach (itemInClass item in areaItemEntity.lstItem)
        //        {
        //            //定义返回值
        //            OutResultEntity resultEntity = new OutResultEntity();
        //            //验证过的物料货位集合
        //            List<itemQty> lstTrueItem = new List<itemQty>();
        //            //判断是否合法
        //            MsgEntity msgEntity = IsPassItem(item, v, out lstTrueItem);
        //            if (!msgEntity.Success)//不合法
        //            {
        //                resultEntity.Success = false;
        //                resultEntity.Msg = msgEntity.Msg;
        //                resultEntity.itemCode = item.itemCode;
        //            }
        //            else //合法
        //            {
        //                resultEntity.Success = true;
        //                resultEntity.itemCode = item.itemCode;
        //                /*返回时加入条件*/
        //                resultEntity.areaCode = areaItemEntity.areaCode;
        //                resultEntity.batchCode = areaItemEntity.batchCode;
        //                resultEntity.prodBatchCode = areaItemEntity.prodBatchCode;
        //                resultEntity.itemState = areaItemEntity.itemState;
        //                resultEntity.ownerName = areaItemEntity.ownerName;
        //                /*条件结束*/
        //                List<itemTrayLocation> lstResult = GetJXXTrayLocation(lstStrate, item, model.lstDevice, lstTrueItem, model.lockLocation);
        //                resultEntity.itemLocations = lstResult.GroupBy(a => new
        //                {
        //                    a.agvLocationCode,
        //                    a.locationCode,
        //                    a.trayCode,
        //                    a.trayGrid
        //                }).Select(g => new itemTrayLocation()
        //               {
        //                   itemQty = g.Sum(s => s.itemQty),
        //                   agvLocationCode = g.Key.agvLocationCode,
        //                   locationCode = g.Key.locationCode,
        //                   trayCode = g.Key.trayCode,
        //                   trayGrid = g.Key.trayGrid
        //               }).ToList();
        //            }
        //            lstResultEntity.Add(resultEntity);
        //        }
        //    }
        //    return lstResultEntity;
        //}

        #endregion



        public OutResultEntityNew OutNew(OutAlgorEnitty model)
        {
            OutResultEntityNew resultE = new OutResultEntityNew();
            Log.AlgorInfo("Out_AlgorBLL—Out", "出库算法开始，传入参数:" + JsonConvert.SerializeObject(model));

            resultE = OutCommonFlat(model);

            return resultE;
        }
        #region 非作业区  平库立库出库算法，根据物料的数量出库


        /// <summary>
        /// 非作业区  平库立库出库算法，根据物料的数量出库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public OutResultEntityNew OutCommonFlat(OutAlgorEnitty model)
        {
            OutResultEntityNew resultEntity = new OutResultEntityNew();
            resultEntity.Success = true;
            resultEntity.Msg = "";
            try
            {
                #region 定义变量
                Log.AlgorInfo("Out_AlgorBLL—Out", "OutCommonFlat");
                StringBuilder sbWhere = new StringBuilder();
                List<itemQty> lstAllIQ = new List<itemQty>();
                List<trayOutItem> lstTray = new List<trayOutItem>();
                resultEntity.lstItemNotEnough = new List<itemQueryClass>();
                #endregion

                #region 查询该库区配置的出库策略及优先级
                List<STRATEGYALGOREntity> lstStrategy = new List<STRATEGYALGOREntity>();
                lstStrategy = CreateDAL<TN_WM_B_STRATEGYDAL>().GetStrateListByAreaOrStock("", model.lstQueryItem[0].areaCode, "出库");
                List<string> lstStrate = lstStrategy.OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();
                #endregion

                #region 缓存记录托盘、货主、物料、状态对应的待分配量，循环itemQueryClass时根据结果实时更新
                //List<itemQty> lstWaitAlloc = new List<itemQty>();
                //List<itemQty> lstForAlloc = new List<itemQty>();
                //foreach (itemQueryClass itemQuery in model.lstQueryItem)
                //{
                //    lstForAlloc = CreateDAL<Out_AlgorDAL>().GetOutItemAllocQty(itemQuery.itemCode, itemQuery.itemState, itemQuery.ownerName, itemQuery.areaCode);
                //    if (lstForAlloc != null && lstForAlloc.Count > 0)
                //    {
                //        lstWaitAlloc.AddRange(lstForAlloc);
                //    }
                //}
                //lstWaitAlloc = lstWaitAlloc.Distinct().ToList();
                //if (lstWaitAlloc.Count == 0)
                //{
                //    //如果从库区中查找不到符合出库条件的托盘，则将传入物料记录到物料不足列表中反馈
                //    resultEntity.lstItemNotEnough.AddRange(model.lstQueryItem);
                //    return resultEntity;
                //}
                #endregion

                foreach (itemQueryClass itemQuery in model.lstQueryItem)
                {
                    Log.AlgorInfo("Out_AlgorBLL—Out", "循环处理lstQueryItem数据:" + JsonConvert.SerializeObject(itemQuery));

                    #region 循环处理批分分配量
                    //获得库区中所有匹配的待出库的物料库存数据
                    List<itemQty> lstIQ = CreateDAL<Out_AlgorDAL>().GetOutItemQty(itemQuery.itemCode, itemQuery.itemState, itemQuery.prodBatchCode, itemQuery.batchCode, itemQuery.ownerName, itemQuery.areaCode);
                    if (lstIQ.Count == 0)
                    {
                        resultEntity.lstItemNotEnough.Add(itemQuery);
                        continue;
                    }
                    //Log.AlgorInfo("Out_AlgorBLL—Out", "批分前库区中所有匹配的物料数据:" + JsonConvert.SerializeObject(lstIQ));
                    ////过滤lstWaitAlloc中不在lstIQ中的托盘,因为这些托盘的待分配量不需要处理
                    //List<string> lstTrayCode = lstIQ.Select(o => o.trayCode).Distinct().ToList();
                    //List<itemQty> lstAllocQty = lstWaitAlloc.Where(o => o.CN_F_ALLOC_QTY > 0 && lstTrayCode.Contains(o.trayCode) && o.itemCode == itemQuery.itemCode && o.CN_S_OWNER == itemQuery.ownerName && o.CN_S_ITEM_STATE == itemQuery.itemState).Select(g => new itemQty()
                    //{
                    //    trayCode = g.trayCode,
                    //    CN_F_ALLOC_QTY = g.CN_F_ALLOC_QTY,
                    //    CN_S_OWNER = g.CN_S_OWNER,
                    //    CN_S_ITEM_STATE = g.CN_S_ITEM_STATE,
                    //    itemCode = g.itemCode
                    //}).Distinct().ToList();

                    //decimal alloc_qty = 0;
                    //foreach (itemQty iQty in lstAllocQty)
                    //{
                    //    alloc_qty = iQty.CN_F_ALLOC_QTY;
                    //    //递归批分处理货位托盘中的待分配量，去除lstIQ中已经被批分的数据（已被其他分拣单占用的数据）
                    //    DivideAllocQty(ref lstIQ, iQty, ref alloc_qty, lstStrate);
                    //}
                    //Log.AlgorInfo("Out_AlgorBLL—Out", "批分后库区中所有匹配的物料数据:" + JsonConvert.SerializeObject(lstIQ));
                    #endregion

                    #region 到mongodb中查询每个货位的基本信息，排除货位被报废的数据
                    List<string> lstCodes = lstIQ.GroupBy(a => a.locationCode).Select(o => o.Key).ToList();
                    List<AutoBomLocationAbbreEntity> lstFalseLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetScrapLocationCode(lstCodes);
                    lstCodes = lstFalseLocation.Select(a => a.CN_S_LOCATION_CODE).ToList();
                    //此时的lstIQ是去除批分量、货位无故障的可出库物料数据
                    lstIQ.RemoveAll(o => lstCodes.Contains(o.locationCode));
                    #endregion

                    #region 处理不满足出库数量的物料并计算可出库货位

                    //按照库区等查询条件分组
                    var lstItemGroup = lstIQ.GroupBy(a => new
                    {
                        a.itemCode
                    }).Select(g => (new
                    {
                        itemCode = g.Key.itemCode,
                        itemQty = g.Sum(p => p.Qty)
                    }));
                    var equalItem = lstItemGroup.Where(o => o.itemCode == itemQuery.itemCode).FirstOrDefault();

                    if (equalItem == null || equalItem.itemQty < itemQuery.itemQty)
                    {
                        //记录不满足出库条件的物料
                        itemQuery.itemQty = itemQuery.itemQty - equalItem.itemQty;
                        resultEntity.lstItemNotEnough.Add(itemQuery);
                    }
                    else
                    {
                        Log.AlgorInfo("Out_AlgorBLL—Out", "计算具体出库货位开始:");
                        decimal needOutQty = itemQuery.itemQty;
                        lstTray.AddRange(CalculateOutLocation(itemQuery, ref needOutQty, ref lstIQ, lstStrate));
                        //增加缓存批分量
                        //foreach (trayOutItem toItem in lstTray)
                        //{
                        //    tmpItemQty = lstWaitAlloc.Where(o => o.trayCode == toItem.trayCode && o.itemCode == toItem.itemCode && o.CN_S_OWNER == toItem.ownerName && o.CN_S_ITEM_STATE == toItem.itemState).FirstOrDefault();
                        //    if (tmpItemQty != null)
                        //    {
                        //        tmpItemQty.CN_F_ALLOC_QTY = tmpItemQty.CN_F_ALLOC_QTY + toItem.itemQty;
                        //    }
                        //}
                        List<string> needLock = lstTray.Select(o => o.locationCode).Distinct().ToList();
                        foreach (string itemLoc in needLock)
                        {
                            //更新货位状态
                            if (model.lockLocation)
                            {
                                SqlExecuteResult result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(itemLoc, Constants.Location_State_OutLock, "出库", null);
                                Log.AlgorInfo("Out_AlgorBLL", "货位" + itemLoc + "更改为预出库锁定，执行结果为：" + result.Success.ToString() + result.Row.ToString());
                            }
                        }
                    }

                    #endregion
                }
                resultEntity.itemLocations = lstTray;
            }
            catch (Exception ex)
            {
                resultEntity.Success = false;
                resultEntity.Msg = ex.Message;
            }
            Log.AlgorInfo("Out_AlgorBLL—Out", "返回计算结果:" + JsonConvert.SerializeObject(resultEntity));
            return resultEntity;

        }

        public List<trayOutItem> CalculateOutLocation(itemQueryClass itemQC, ref decimal needOutQty, ref  List<itemQty> lstAllIQ, List<string> lstStrate)
        {
            bool isNoDivide = false;
            bool forceDivide = false;
            List<itemQty> lstFilterItem = CalculateItemByStegy(needOutQty, lstAllIQ, lstStrate, out isNoDivide, out forceDivide);
            List<trayOutItem> lstTray = new List<trayOutItem>();
            decimal tmpQty = 0;
            List<string> lstNeedRemove = new List<string>();


            #region 不可拆包，优先拣包装数量较大的
            foreach (itemQty item in lstFilterItem)
            {
                Log.AlgorInfo("Out_AlgorBLL—Out", "循环lstFilterItem物料数据:" + JsonConvert.SerializeObject(item));
                trayOutItem trayItem = new trayOutItem();
                trayItem.itemCode = item.itemCode;
                trayItem.itemState = item.CN_S_ITEM_STATE;
                trayItem.ownerName = item.CN_S_OWNER;
                trayItem.batchCode = item.lotNo;
                trayItem.prodBatchCode = item.prodBatchCode;
                trayItem.trayCode = item.trayCode;
                trayItem.trayGrid = item.trayGrid;
                trayItem.locationCode = item.locationCode;
                trayItem.areaCode = itemQC.areaCode;
                trayItem.CN_S_TIMESTAMP = item.CN_S_TIMESTAMP;
                trayItem.packUnit = item.packUnit;
                trayItem.packQty = item.PAKQty;
                Log.AlgorInfo("Out_AlgorBLL—Out", "needOutQty < item.Qty:" + needOutQty.ToString() + "," + item.Qty.ToString());
                if (needOutQty < item.Qty)
                {
                    Log.AlgorInfo("Out_AlgorBLL—Out", "needOutQty < item.PAKQty:" + needOutQty.ToString() + "," + item.PAKQty.ToString());
                    //待出库量比该托盘中物料数量小
                    if (needOutQty >= item.PAKQty)
                    {
                        trayItem.itemQty = needOutQty - needOutQty % item.PAKQty;
                        if (item.Qty - trayItem.itemQty >= 0)
                        {
                            //降低该记录的可出库量，
                            lstAllIQ.Find(O => O.ID == item.ID).Qty = item.Qty - trayItem.itemQty;
                        }
                        else
                        {
                            lstNeedRemove.Add(item.ID);
                        }
                        needOutQty = needOutQty % item.PAKQty;
                        lstTray.Add(trayItem);
                        Log.AlgorInfo("Out_AlgorBLL—Out", "needOutQty >= item.PAKQty,trayItem:" + JsonConvert.SerializeObject(trayItem));
                    }
                    else
                    {
                        Log.AlgorInfo("Out_AlgorBLL—Out", "forceDivide:" + forceDivide.ToString());
                        if (forceDivide)
                        {
                            //库区中无不拆包可出库数据，强制拆包
                            trayItem.itemQty = needOutQty;
                            lstAllIQ.Find(O => O.ID == item.ID).Qty = item.Qty - needOutQty;
                            needOutQty = 0;
                            lstTray.Add(trayItem);
                            Log.AlgorInfo("Out_AlgorBLL—Out", "forceDivide,trayItem:" + JsonConvert.SerializeObject(trayItem));
                        }
                        else
                        {
                            //待出库量比该托盘中该单位的包装数量小，则跳出循环，寻找比该包装规格小的物料数据  
                            break;
                        }
                    }
                }
                else
                {
                    //待出库量比该托盘中物料数量大，将该托盘中物料全出
                    trayItem.itemQty = item.Qty;
                    lstNeedRemove.Add(item.ID);
                    needOutQty = needOutQty - item.Qty;
                    lstTray.Add(trayItem);
                    Log.AlgorInfo("Out_AlgorBLL—Out", "待出库量比该托盘中物料数量大,trayItem:" + JsonConvert.SerializeObject(trayItem));
                }

                if (needOutQty < item.PAKQty)
                {
                    //待出库量小于规格数量则结束循环
                    break;
                }
            }
            #endregion

            lstAllIQ.RemoveAll(o => lstNeedRemove.Contains(o.ID));
            if (needOutQty > 0 && lstAllIQ.Count > 0)
            {
                //如果未分配完则递归循环
                lstTray.AddRange(CalculateOutLocation(itemQC, ref needOutQty, ref lstAllIQ, lstStrate));
            }
            return lstTray;

        }

        /// <summary>
        /// 将货位中的物料数据按照策略排序
        /// </summary>
        /// <param name="lstIQ"></param>
        /// <param name="lstStrate"></param>
        /// <returns></returns>
        public List<itemQty> CalculateItemByStegy(decimal needOutQty, List<itemQty> lstIQ, List<string> lstStrate, out bool isNoDivide, out bool forceDivide)
        {
            List<itemQty> lstFilterItem = lstIQ;
            List<itemQty> lstEmptyPBC;
            List<itemQty> lstTpm;
            List<itemQty> lstTpm1;
            bool IsIntegerOut = false;
            isNoDivide = false;
            forceDivide = false;
            foreach (string stegy in lstStrate)
            {
                //逐个策略进行计算
                switch (stegy)
                {
                    case "RowOutFirst":
                        lstFilterItem = lstFilterItem.OrderBy(o => o.CN_S_ROW).ThenBy(o => o.CN_S_COL).ToList();
                        lstFilterItem = lstFilterItem.Where(o => o.CN_S_ROW == lstFilterItem.FirstOrDefault().CN_S_ROW && o.CN_S_COL == lstFilterItem.FirstOrDefault().CN_S_COL).ToList();
                        break;
                    case "ProductTimeOutFirst":
                        lstFilterItem = lstFilterItem.OrderBy(o => o.productDate).ToList();
                        lstFilterItem = lstFilterItem.Where(o => o.productDate == lstFilterItem.FirstOrDefault().productDate).ToList();
                        break;
                    case "FirstWarrantFirstOut":
                        lstEmptyPBC = lstFilterItem.Where(o => string.IsNullOrEmpty(o.prodBatchCode)).ToList();
                        lstFilterItem = lstFilterItem.Where(o => !string.IsNullOrEmpty(o.prodBatchCode)).OrderBy(o => o.prodBatchCode).ToList();
                        lstFilterItem.AddRange(lstEmptyPBC);
                        lstFilterItem = lstFilterItem.Where(o => o.prodBatchCode == lstFilterItem.FirstOrDefault().prodBatchCode).ToList();
                        break;
                    case "IntegerTrayFirstOut":
                        IsIntegerOut = true;
                        lstTpm = lstFilterItem.GroupBy(a => new { a.trayCode }).Select(g => new itemQty()
                        {
                            Qty = g.Sum(s => s.Qty),
                            trayCode = g.Key.trayCode
                        }).ToList();
                        lstTpm = lstTpm.OrderByDescending(o => o.Qty).ToList();
                        lstTpm1 = lstTpm.Where(o => o.Qty >= needOutQty).ToList();
                        if (lstTpm1 == null || lstTpm1.Count == 0)
                        {
                            //该托盘中总数量不满足出库需求，则找最大数量的托盘
                            lstFilterItem = lstFilterItem.Where(o => o.trayCode == lstTpm.FirstOrDefault().trayCode).ToList();
                        }
                        else
                        {
                            //该托盘中总数量满足出库需求
                            lstTpm1 = lstTpm1.OrderBy(o => o.Qty).ToList();
                            lstFilterItem = lstFilterItem.Where(o => o.trayCode == lstTpm1.FirstOrDefault().trayCode).ToList();
                        }
                        break;
                    case "NoDivideFirstOut":
                        IsIntegerOut = true;
                        isNoDivide = true;
                        lstFilterItem = lstFilterItem.OrderByDescending(o => o.PAKQty).ToList();
                        Log.AlgorInfo("Out_AlgorBLL—Out", "NoDivideFirstOut前lstFilterItem物料数据:" + JsonConvert.SerializeObject(lstFilterItem));
                        lstTpm1 = lstFilterItem.Where(o => o.PAKQty <= needOutQty).ToList();
                        if (lstTpm1.Count == 0)
                        {
                            //货位中物料匹配数据中无包装单位比待出库数量小的数据，只有拆包
                            forceDivide = true;
                            lstTpm1 = lstFilterItem.OrderBy(o => o.PAKQty).ToList();
                            //寻找最接近出库数量的包装拆包
                            lstFilterItem = lstFilterItem.Where(o => o.Qty == lstTpm1.FirstOrDefault().Qty).ToList();
                        }
                        else
                        {
                            //货位中物料匹配数据中存在包装单位比带出库数量小的数据，先计算大包装的
                            lstFilterItem = lstFilterItem.Where(o => o.PAKQty == lstTpm1.FirstOrDefault().PAKQty).ToList();
                        }
                        Log.AlgorInfo("Out_AlgorBLL—Out", "NoDivideFirstOut后lstFilterItem物料数据:" + JsonConvert.SerializeObject(lstFilterItem));
                        break;
                }
                if (IsIntegerOut)
                {
                    break;
                }
            }
            return lstFilterItem;
        }



        /// <summary>
        /// 降低货位库存分配量
        /// </summary>
        /// <param name="lstIQ"></param>
        /// <param name="allocItem"></param>
        /// <param name="needDivideQty"></param>
        /// <param name="lstStrate"></param>
        public void DivideAllocQty(ref List<itemQty> lstIQ, itemQty allocItem, ref decimal needDivideQty, List<string> lstStrate)
        {
            List<itemQty> lstFilterItem = FilterItemByStegy(lstIQ.Where(o => o.trayCode == allocItem.trayCode && o.itemCode == allocItem.itemCode && o.CN_S_OWNER == allocItem.CN_S_OWNER && o.CN_S_ITEM_STATE == allocItem.CN_S_ITEM_STATE).ToList(), lstStrate);
            decimal tmpQty = 0;
            List<string> lstNeedRemove = new List<string>();
            foreach (itemQty item in lstFilterItem)
            {
                tmpQty = needDivideQty - item.Qty;
                if (tmpQty < 0)
                {

                    //降低该记录的可出库量，并跳出循环
                    lstIQ.Find(O => O.ID == item.ID).Qty = item.Qty - needDivideQty;
                    needDivideQty = tmpQty;
                    break;
                }
                else
                {
                    needDivideQty = tmpQty;
                    //删除该记录
                    lstNeedRemove.Add(item.ID);

                }
            }
            lstIQ.RemoveAll(o => lstNeedRemove.Contains(o.ID));
            if (needDivideQty > 0 && lstIQ.Count > 0)
            {
                //如果未分配完则递归循环
                DivideAllocQty(ref lstIQ, allocItem, ref needDivideQty, lstStrate);
            }
        }
        /// <summary>
        /// 将货位中的物料数据按照策略排序
        /// </summary>
        /// <param name="lstIQ"></param>
        /// <param name="lstStrate"></param>
        /// <returns></returns>
        public List<itemQty> FilterItemByStegy(List<itemQty> lstIQ, List<string> lstStrate)
        {
            List<itemQty> lstFilterItem = lstIQ;
            List<itemQty> lstEmptyPBC;
            foreach (string stegy in lstStrate)
            {
                //逐个策略进行计算
                switch (stegy)
                {
                    case "FirstInFirstOut":
                        lstFilterItem = lstFilterItem.OrderBy(o => o.lotNo).ToList();
                        lstFilterItem = lstFilterItem.Where(o => o.lotNo == lstFilterItem.FirstOrDefault().lotNo).ToList();
                        break;
                    case "FirstWarrantFirstOut":
                        lstEmptyPBC = lstFilterItem.Where(o => string.IsNullOrEmpty(o.prodBatchCode)).ToList();
                        lstFilterItem = lstFilterItem.Where(o => !string.IsNullOrEmpty(o.prodBatchCode)).OrderBy(o => o.prodBatchCode).ToList();
                        lstFilterItem.AddRange(lstEmptyPBC);
                        lstFilterItem = lstFilterItem.Where(o => o.prodBatchCode == lstFilterItem.FirstOrDefault().prodBatchCode).ToList();
                        break;
                }
            }
            return lstFilterItem;
        }
        #endregion




        #region 生成查询条件
        /// <summary>
        /// 生成查询条件
        /// </summary>
        /// <param name="itemCodes"></param>
        /// <param name="itemState"></param>
        /// <param name="batchCode"></param>
        /// <param name="ownerName"></param>
        /// <returns></returns>
        public string GetPropWhereStr1(string itemCodes, string itemState, string batchCode, string prodBatchCode, string ownerName)
        {
            StringBuilder strWhere = new StringBuilder();
            // strWhere.Append(" 1=1 ");

            //物料编码
            if (!string.IsNullOrEmpty(itemCodes))
            {
                strWhere.AppendLine(" AND CN_S_ITEM_CODE IN ('" + itemCodes + "') ");
            }
            //物料状态
            if (!string.IsNullOrEmpty(itemState))
            {
                strWhere.AppendLine(" AND CN_S_ITEM_STATE = '" + itemState + "' ");
            }
            //批次号
            if (!string.IsNullOrEmpty(batchCode))
            {
                strWhere.AppendLine(" AND CN_S_LOT_NO = '" + batchCode + "' ");
            }
            //生产批次号
            if (!string.IsNullOrEmpty(prodBatchCode))
            {
                strWhere.AppendLine(" AND CN_S_PRODUCTION_BATCH = '" + prodBatchCode + "' ");
            }
            //货主
            if (!string.IsNullOrEmpty(ownerName))
            {
                strWhere.AppendLine(" AND CN_S_OWNER = '" + ownerName + "' ");
            }
            return strWhere.ToString();
        }
        #endregion
        #region 出库调用的方法 将传递过来的请求出库的物料进行分组
        /// <summary>
        /// 将传递过来的请求出库的物料进行分组 保证算法的执行速度
        /// </summary>
        /// <param name="lstAreaItem"></param>
        /// <returns></returns>
        private List<Out_AreaItemClass> GroupAreaCode(List<itemQueryClass> lstQueryItem)
        {
            //定义分组后的物料数据
            List<Out_AreaItemClass> lstAreaItemGroup = new List<Out_AreaItemClass>();
            if (lstQueryItem == null || lstQueryItem.Count == 0)
            {
                return lstAreaItemGroup;
            }
            //按照库区等查询条件分组
            var v_AreaGroup = lstQueryItem.GroupBy(a => new
            {
                //追加条件后 需要在此处加入分组条件定义  &&&&
                a.stockCode,
                a.areaCode,
                a.ownerName,
                a.batchCode,
                a.prodBatchCode,
                a.itemState,
                a.itemCode
            }).Select(g => (new
            {
                //追加条件后 需要在此处加入分组条件定义  &&&&
                stockCode = g.Key.stockCode,
                areaCode = g.Key.areaCode,
                ownerName = g.Key.ownerName,
                batchCode = g.Key.batchCode,
                prodBatchCode = g.Key.prodBatchCode,
                itemState = g.Key.itemState,
                itemCode = g.Key.itemCode,
                itemQty = g.Sum(p => p.itemQty)
            }));
            Out_AreaItemClass areaItemEntity = new Out_AreaItemClass();
            //循环传递的实体参数数量
            foreach (var areaItem in v_AreaGroup)
            {
                //则将物料列表信息传递给分组后的列表
                areaItemEntity.areaCode = areaItem.areaCode;
                areaItemEntity.stockCode = areaItem.stockCode;
                areaItemEntity.ownerName = areaItem.ownerName;
                areaItemEntity.batchCode = areaItem.batchCode;
                areaItemEntity.prodBatchCode = areaItem.prodBatchCode;
                areaItemEntity.itemState = areaItem.itemState;
                areaItemEntity.itemCode = areaItem.itemCode;
                areaItemEntity.itemQty = decimal.Parse(areaItem.itemQty.ToString());
                lstAreaItemGroup.Add(areaItemEntity);
            }
            return lstAreaItemGroup;
        }
        #endregion

        /**************计算  返回物料所在货位的算法结束/**************/


        /*****************计算  返回库区的算法开始/*****************/

        #region 非作业区平库立库  返回库区对应出库物料的算法，该算法只算到库区可出库数量
        /// <summary>
        /// 出库  返回库区对应出库物料的算法，该算法只算到库区，不到货位
        /// </summary>
        /// <param name="model">返回库区算法传递的类</param>
        /// <returns></returns>
        public OutAreaResultAllEntity OutArea(List<itemQueryClass> lstQueryOut, List<areaPriorClass> lstAreaPrior)
        {
            Log.AlgorInfo("Out_AlgorBLL—OutArea", "算法开始,传入参数lstQueryOut:" + JsonConvert.SerializeObject(lstQueryOut) + ",lstAreaPrior:" + JsonConvert.SerializeObject(lstAreaPrior));
            //返回数据的实体集合   
            OutAreaResultAllEntity outAreaResult = new OutAreaResultAllEntity();
            //存放计算物料库存结果
            List<OutAreaResultEntity> lstOutResultEntity = new List<OutAreaResultEntity>();
            bool checkEnough = true;
            //将传递过来的参数按货主、批次号、物料状态分组后再按物料分组
            List<Out_AreaItemClass> lstAreaItemGroup = GroupAreaCode(lstQueryOut);
            //循环处理
            foreach (var i_Group in lstAreaItemGroup)
            {
                Log.AlgorInfo("Out_AlgorBLL—OutArea", "循环处理lstAreaItemGroup:" + i_Group.areaCode + "," + i_Group.batchCode + "," + i_Group.itemState + "," + i_Group.ownerName);
                string stockCode = i_Group.stockCode;
                #region 判断库存是否足够
                //获得所有物料
                string itemCodes = i_Group.itemCode;
                //获得查询条件
                string strWhere = GetPropWhereStr1(itemCodes, i_Group.itemState, i_Group.batchCode, i_Group.prodBatchCode, i_Group.ownerName);
                //获得物料在仓库中的数量
                List<OutAreaItemQty> lstAreaItemQty = null;
                lstAreaItemQty = CreateDAL<TN_WM_B_AREA_QTYDAL>().GetAreaQty(strWhere, stockCode);
                lstAreaItemQty.ForEach(x => x.areaCode = x.areaCode.Trim());
                lstAreaItemQty.RemoveAll(o => o.Qty <= 0);
                lstAreaItemQty = lstAreaItemQty.Join(lstAreaPrior, u => u.areaCode, d => d.areaCode, (u, d) => new { u, d })
                .Select(o => new OutAreaItemQty
                {
                    areaCode = o.u.areaCode,
                    itemCode = o.u.itemCode,
                    Qty = o.u.Qty,
                    Prior = o.d.Prior
                }
                ).OrderBy(p => p.Prior).ToList();

                var lstStockItemQty = lstAreaItemQty.GroupBy(a => a.itemCode).Select(g => new
                {
                    itemCode = g.Key,
                    stockNum = g.Sum(p => p.Qty)
                });

                List<itemOutClass> lstFalseItem = new List<itemOutClass>();

                #region 循环处理查询不满足出库数量的物料
                itemOutClass outClassEntity = new itemOutClass();
                var itemEntity = lstStockItemQty.Where(o => o.itemCode == i_Group.itemCode).SingleOrDefault();
                if (itemEntity != null)
                {
                    //获得仓库内该物料的数量
                    decimal qty = (decimal)i_Group.itemQty;
                    if (qty < (decimal)i_Group.itemQty)
                    {
                        outClassEntity.Success = false;
                        outClassEntity.Msg = "当前仓库中该物料的数量不满足需要出库的数量";
                        outClassEntity.itemCode = i_Group.itemCode;
                        outClassEntity.itemQty = qty;
                        lstFalseItem.Add(outClassEntity);
                    }
                }
                else
                {
                    outClassEntity.Success = false;
                    outClassEntity.Msg = "在仓库中未找到该物料对应的库存数量信息";
                    outClassEntity.itemCode = i_Group.itemCode;
                    outClassEntity.itemQty = 0;
                    lstFalseItem.Add(outClassEntity);
                }
                #endregion

                if (lstFalseItem != null && lstFalseItem.Count > 0)
                {
                    checkEnough = false;
                }
                lstOutResultEntity.AddRange(GetOutAreaList(stockCode, lstAreaItemQty, i_Group, lstAreaPrior));
                #endregion

            }
            if (!checkEnough)
            {
                outAreaResult.Success = false;
                outAreaResult.Msg = "物料库存不足";
            }
            else
            {
                outAreaResult.Success = true;
                outAreaResult.Msg = "";
            }
            outAreaResult.itemOutAreaResult = lstOutResultEntity;
            Log.AlgorInfo("Out_AlgorBLL—OutArea", "计算结果outAreaResult：" + JsonConvert.SerializeObject(outAreaResult));
            return outAreaResult;
        }
        #endregion
        #region 用于计算返回库区的算法
        /// <summary>
        /// 用于计算返回库区的算法
        /// </summary>
        /// <param name="stockCode"></param>
        /// <param name="lstAreaOutItemQty">每个库区对应的物料数量</param>
        /// <param name="lstItem"></param>
        /// <returns></returns>
        private List<OutAreaResultEntity> GetOutAreaList(string stockCode, List<OutAreaItemQty> lstAreaOutItemQty, Out_AreaItemClass outAreaItem, List<areaPriorClass> lstAreaPrior)
        {
            List<OutAreaResultEntity> lstOutResultEntity = new List<OutAreaResultEntity>();
            List<string> lstArea = lstAreaPrior.OrderByDescending(o => o.Prior).Select(p => p.areaCode).ToList();
            Out_AreaItemClass divideItemEntity = new Out_AreaItemClass();
            //则将物料列表信息传递给分组后的列表
            decimal remainder = 0;
            Out_AreaItemClass itemRemaind = null;
            if (outAreaItem.itemQty >= 12)
            {
                remainder = outAreaItem.itemQty % 12;
                outAreaItem.itemQty = outAreaItem.itemQty - remainder;
                if (remainder != 0)
                {
                    itemRemaind = new Out_AreaItemClass();
                    itemRemaind.areaCode = outAreaItem.areaCode;
                    itemRemaind.stockCode = outAreaItem.stockCode;
                    itemRemaind.ownerName = outAreaItem.ownerName;
                    itemRemaind.batchCode = outAreaItem.batchCode;
                    itemRemaind.prodBatchCode = outAreaItem.prodBatchCode;
                    itemRemaind.itemState = outAreaItem.itemState;
                    itemRemaind.itemCode = outAreaItem.itemCode;
                    itemRemaind.itemQty = remainder;
                }
            }
            else
            {
                lstArea = lstAreaPrior.OrderBy(o => o.Prior).Select(p => p.areaCode).ToList();
            }

            //循环所有库区
            List<itemOutClass> LstItemOut = new List<itemOutClass>();
            for (int i = 0; i < lstArea.Count; i++)
            {
                #region 循环库区获取可出库物料
                if (outAreaItem.itemQty == 0)
                {
                    break;
                }
                //找到该库区下的物料
                List<OutAreaItemQty> lst_item_Area = lstAreaOutItemQty.Where(o => o.areaCode == lstArea[i] && o.itemCode == outAreaItem.itemCode).ToList();
                if (lst_item_Area.Count > 0)
                {
                    foreach (OutAreaItemQty item_Area in lst_item_Area)
                    {
                        OutAreaResultEntity resultEntity = new OutAreaResultEntity();
                        resultEntity.stockCode = stockCode;
                        resultEntity.areaCode = lstArea[i];
                        resultEntity.ownerName = outAreaItem.ownerName;
                        resultEntity.batchCode = outAreaItem.batchCode;
                        resultEntity.prodBatchCode = outAreaItem.prodBatchCode;
                        resultEntity.itemState = outAreaItem.itemState;
                        //获取当前库区下可分配的物料列表               
                        if (outAreaItem.itemQty > 0)
                        {
                            itemOutClass outEntity = new itemOutClass();
                            if (outAreaItem.itemQty <= item_Area.Qty)
                            {
                                //表示需求物料数量在该库区中满足要求
                                outAreaItem.itemQty = 0;
                                outEntity.itemCode = outAreaItem.itemCode;
                                outEntity.itemQty = outAreaItem.itemQty;
                            }
                            else
                            {
                                //等于该库区中的数量
                                outAreaItem.itemQty = outAreaItem.itemQty - item_Area.Qty;
                                outEntity.itemCode = outAreaItem.itemCode;
                                outEntity.itemQty = item_Area.Qty;
                            }
                            LstItemOut.Add(outEntity);
                            resultEntity.lstItem = LstItemOut;
                            lstOutResultEntity.Add(resultEntity);
                        }
                        else
                        {

                            break;
                        }
                    }
                }
                #endregion
            }
            //循环所有库区
            List<itemOutClass> LstItemOutRemaind = new List<itemOutClass>();
            if (itemRemaind != null)
            {
                lstArea = lstAreaPrior.OrderBy(o => o.Prior).Select(p => p.areaCode).ToList();
                for (int i = 0; i < lstArea.Count; i++)
                {
                    #region 循环库区获取可出库物料
                    if (itemRemaind.itemQty == 0)
                    {
                        break;
                    }
                    //找到该库区下的物料
                    List<OutAreaItemQty> lst_item_Area = lstAreaOutItemQty.Where(o => o.areaCode == lstArea[i] && o.itemCode == itemRemaind.itemCode).ToList();
                    if (lst_item_Area.Count > 0)
                    {
                        foreach (OutAreaItemQty item_Area in lst_item_Area)
                        {
                            OutAreaResultEntity resultEntity = new OutAreaResultEntity();
                            resultEntity.stockCode = stockCode;
                            resultEntity.areaCode = lstArea[i];
                            resultEntity.ownerName = itemRemaind.ownerName;
                            resultEntity.batchCode = itemRemaind.batchCode;
                            resultEntity.prodBatchCode = itemRemaind.prodBatchCode;
                            resultEntity.itemState = itemRemaind.itemState;
                            //获取当前库区下可分配的物料列表               
                            if (itemRemaind.itemQty > 0)
                            {
                                itemOutClass outEntity = new itemOutClass();
                                if (itemRemaind.itemQty <= item_Area.Qty)
                                {
                                    //表示需求物料数量在该库区中满足要求
                                    itemRemaind.itemQty = 0;
                                    outEntity.itemCode = itemRemaind.itemCode;
                                    outEntity.itemQty = itemRemaind.itemQty;
                                }
                                else
                                {
                                    //等于该库区中的数量
                                    itemRemaind.itemQty = itemRemaind.itemQty - item_Area.Qty;
                                    outEntity.itemCode = itemRemaind.itemCode;
                                    outEntity.itemQty = item_Area.Qty;
                                }
                                LstItemOutRemaind.Add(outEntity);
                                resultEntity.lstItem = LstItemOutRemaind;
                                lstOutResultEntity.Add(resultEntity);
                            }
                            else
                            {

                                break;
                            }
                        }
                    }
                    #endregion
                }
            }

            return lstOutResultEntity;
        }
        #endregion


        //*****************计算  返回库区的算法结束/*****************/

        #region 作业区出库算法入口

        public OutAssignResultEntity OutAssign(OutAssignEnitty model)
        {
            Log.AlgorInfo("OutAssign", "出库算法参数：" + JsonConvert.SerializeObject(model));
            OutAssignResultEntity outResult = new OutAssignResultEntity();
            try
            {
                //标准出库算法
                string areaType = CreateDAL<TN_WMS_AREADAL>().GetAreaTypeByCode(model.lstAreaPrior[0].areaCode.ToString());
                if (areaType == Constants.Area_Struc_PingStock || areaType == Constants.Area_Struc_LiStock)
                {
                    outResult = FlatAreaOutLocation(model);
                }
                else if (areaType == Constants.Area_Struc_LiuLiStock)
                {

                }
                outResult.areaType = areaType;
                Log.AlgorInfo("OutAssign", "出库返回结果：" + JsonConvert.SerializeObject(outResult));
                return outResult;
            }
            catch (Exception ex)
            {
                Log.AlgorInfo("OutAssign", "异常：" + ex.Message + ex.StackTrace);
                outResult.Msg = "算法异常," + ex.Message + ex.StackTrace;
                return outResult;
            }
        }

        #endregion

        #region 平库出库算法
        public OutAssignResultEntity FlatAreaOutLocation(OutAssignEnitty model)
        {
            OutAssignResultEntity outResult = new OutAssignResultEntity();
            #region 传入参数判断
            if (model == null)
            {
                outResult.Success = false;
                outResult.Msg = "参数实体不能为 null ！";
                return outResult;
            }
            //判断指定的入作业库对象类型不能为空
            if (string.IsNullOrEmpty(model.stockCode.ToString()))
            {
                outResult.Success = false;
                outResult.Msg = "指定的出库仓库编号不能为空！";
                return outResult;
            }
            //判断传入库区列表不能为空
            if (model.lstAreaPrior == null || model.lstAreaPrior.Count == 0)
            {
                outResult.Success = false;
                outResult.Msg = "指定的出作业库库区列表不能为空！";
                return outResult;
            }
            #endregion
            List<STRATEGYALGOREntity> lstStrategy = CreateDAL<TN_WM_B_STRATEGYDAL>().GetStrateListByAreaOrStock(model.stockCode, "", "出库");
            List<string> lstStrate = lstStrategy.Select(o => o.CN_S_NAME).ToList();
            if (lstStrate.Count > 0)
            {
                //如果仓库配置策略（如生产日期早先出等），则优先响应仓库策略
                outResult = OutStockPrior(model, lstStrate);
            }
            else
            {
                //如果仓库没有配置策略则优先响应库区优先策略
                outResult = OutAreaPrior(model);

            }
            return outResult;
        }


        /// <summary>
        /// 作业区出库算法  优先仓库策略
        /// </summary>
        /// <param name="model"></param>
        /// <param name="lstStrategy"></param>
        /// <returns></returns>
        private OutAssignResultEntity OutStockPrior(OutAssignEnitty model, List<string> lstStrategy)
        {
            //返回实体集合
            OutAssignResultEntity outResult = new OutAssignResultEntity();
            outResult.Success = false;
            if (string.IsNullOrEmpty(model.itemCode))
            {
                outResult.Msg = "库区中无该规格的空托";
            }
            else
            {
                outResult.Msg = "库存不足";
            }
            SqlExecuteResult result = null;
            List<Device> lstDevice = model.lstDevice;
            string deviceCode = string.Empty;
            AutoBomLocationAbbreEntity at_l_Entity = null;
            List<AutoBomLocationAbbreEntity> lstTmp_Location = new List<AutoBomLocationAbbreEntity>();
            List<AutoBomLocationAbbreEntity> lstTrueLocation = new List<AutoBomLocationAbbreEntity>();
            string isControlQty = CreateDAL<TN_WMS_AREADAL>().GetIsControlQtyByCode(model.lstAreaPrior[0].areaCode.ToString());
            model.lockLocation = isControlQty.Equals("Y") ? true : false;//不管控数量时，不锁定起点货位
            outResult.isControlQty = isControlQty;
            string areaCodes = string.Join("','", model.lstAreaPrior.Select(o => o.areaCode));
            //获得作业区中所有匹配条件（物料等）的货位
            List<outAssignLocation> lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatItemQty(model.itemCode, areaCodes);
            if (lstCanOutL.Count == 0)
            {
                return outResult;
            }
            if (lstStrategy.Contains("ProductTimeOutFirst"))
            {
                lstCanOutL = lstCanOutL.OrderBy(o => o.productDate).ToList();
                at_l_Entity = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCodeAbbre(lstCanOutL[0].ToString());
            }
            else if (lstStrategy.Contains("InStockTimeOutFirst"))
            {
                lstCanOutL = lstCanOutL.OrderBy(o => o.opTime).ToList();
                at_l_Entity = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCodeAbbre(lstCanOutL[0].ToString());
            }

            if (at_l_Entity == null)
            {
                return outResult;
            }

            else
            {
                //更新货位状态
                if (model.lockLocation)
                {
                    result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.CN_S_LOCATION_CODE, Constants.Location_State_OutLock, "出库", null);
                    if (result != null)
                    {
                        if (result.Success && result.Row > 0)
                        {
                            outResult.Success = true;
                            outResult.Msg = "";
                            outResult.locationCode = at_l_Entity.CN_S_LOCATION_CODE;
                            outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.CN_S_LOCATION_CODE).FirstOrDefault().trayCode;
                        }
                        else
                        {
                            outResult.Success = false;
                            outResult.Msg = "锁定出库货位失败";
                        }
                    }
                }
                else
                {
                    outResult.Success = true;
                    outResult.Msg = "";
                    outResult.locationCode = at_l_Entity.CN_S_LOCATION_CODE;
                    outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.CN_S_LOCATION_CODE).FirstOrDefault().trayCode;
                }
            }

            return outResult;
        }

        /// <summary>
        /// 作业区出库算法  优先库区
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private OutAssignResultEntity OutAreaPrior(OutAssignEnitty model)
        {
            //返回实体集合
            OutAssignResultEntity outResult = new OutAssignResultEntity();
            outResult.Success = false;
            if (string.IsNullOrEmpty(model.itemCode))
            {
                if (model.projectCode == "ys001")
                {
                    outResult.Msg = "库区中无该规格的空托";
                }
                else if (model.projectCode == "hcbh")
                {
                    outResult.Msg = "库区中无可出托盘";
                }
                else
                {
                    outResult.Msg = "库区中无空托";
                }
            }
            else
            {
                outResult.Msg = "库存不足";
            }

            List<STRATEGYALGOREntity> lstStrategy = null;
            List<outAssignLocation> lstCanOutL = null;
            List<Device> lstDevice = model.lstDevice;
            string deviceCode = string.Empty;
            List<string> lstStrate = null;
            SqlExecuteResult result = null;
            outAssignLocation at_l_Entity = null;
            List<outAssignLocation> lstTmp_Location = new List<outAssignLocation>();
            List<AutoBomLocationAbbreEntity> lstTrueLocation = new List<AutoBomLocationAbbreEntity>();
            List<AutoBomLocationAbbreEntity> lstAllLocation = new List<AutoBomLocationAbbreEntity>();
            //被锁定的货位
            List<AutoBomLocationAbbreEntity> lstLockLItem = new List<AutoBomLocationAbbreEntity>();
            List<AutoBomLocationAbbreEntity> lstLocation = new List<AutoBomLocationAbbreEntity>();
            string isControlQty = string.Empty;
            string isControlInv = string.Empty;
            decimal needOutWeight = 0;
            AutoBomItemEntity autoBomE = null;
            if (model.projectCode == "ys001")
            {
                if (!string.IsNullOrEmpty(model.itemCode))
                {
                    autoBomE = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(model.itemCode);
                }
            }
            //将传递过来的库区列表按库区出库优先级排序
            List<areaPriorClass> lstAreaPrior = model.lstAreaPrior.OrderBy(o => o.Prior).ToList();
            if (model.projectCode == "ntsd")
            {
                foreach (areaPriorClass item in lstAreaPrior)
                {
                    List<TN_WM_TASKEntity> lstTask = CreateDAL<HH.WMS.DAL.SysMgr.TN_WM_TASKDAL>().GetTaskByAreaCode(item.areaCode);
                    item.Prior = lstTask.Count;
                }
                lstAreaPrior = lstAreaPrior.OrderBy(o => o.Prior).ToList();
                Log.AlgorInfo("InAssign-FlatAreaGetLocation", "lstAreaPrior数据：" + JsonConvert.SerializeObject(lstAreaPrior));
            }

            foreach (areaPriorClass item in lstAreaPrior)
            {
                AutoBomStockAreaEntity areaModel = CreateDAL<TN_WMS_AREADAL>().GetModel(item.areaCode.ToString());
                isControlQty = areaModel.CN_C_IS_CONTROL_QTY;
                isControlInv = areaModel.CN_C_IS_INVENTORY;
                if (model.needCalLock)
                {
                    model.lockLocation = isControlQty.Equals("Y") ? true : false;//不管控数量时，不锁定目的货位
                }
                lstStrategy = CreateDAL<TN_WM_B_STRATEGYDAL>().GetStrateListByAreaOrStock("", item.areaCode, "出库");
                lstStrate = lstStrategy.Select(o => o.CN_S_CODE).ToList();
                if (string.IsNullOrEmpty(model.itemCode))
                {
                    if (model.projectCode == "hcbh")
                    {
                        #region 托盘出库,忽略托盘中物料
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatEmptySpecTrayBH(model.traySpec, item.areaCode);
                        if (lstCanOutL.Count == 0)
                        {
                            continue;
                        }
                        else
                        {
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE

                            }).ToList();
                            //获取该终点对应的出库的排
                            var rowMapStr = JsonHelper.GetValue("rowMapping");
                            var rowMaps = JsonConvert.DeserializeObject<List<RowMapDto>>(rowMapStr);
                            RowMapDto rMap = rowMaps.Where(o => o.endBit == model.endBit).FirstOrDefault();
                            if (rMap != null)
                            {
                                lstCanOutL = lstCanOutL.Where(o => o.CN_S_ROW == rMap.startRow).ToList();
                            }
                            List<TN_WM_LOCATIONCODE_EXT_Entity> locationInLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_State_InLock);
                            Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationInLock数据:" + JsonConvert.SerializeObject(locationInLock));
                            foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationInLock)
                            {
                                lstCanOutL.RemoveAll(o => o.CN_S_ROW == lEntity.CN_S_ROW);
                            }
                            lstTmp_Location = CalculateLocByStegy(ref lstDevice, lstCanOutL, lstStrate, out deviceCode);
                            if (lstTmp_Location.Count > 0)
                            {
                                at_l_Entity = lstTmp_Location[0];
                                #region 锁定待出库货位
                                if (at_l_Entity != null)
                                {
                                    if (model.lockLocation)
                                    {
                                        result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.locationCode, Constants.Location_State_OutLock, "出库", null);
                                        if (result != null)
                                        {
                                            if (result.Success && result.Row > 0)
                                            {
                                                outResult.Success = true;
                                                outResult.Msg = "";
                                                outResult.locationCode = at_l_Entity.locationCode;
                                                outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                                outResult.areaCode = item.areaCode;
                                                outResult.isControlQty = isControlQty;
                                                outResult.isControlInv = isControlInv;
                                                break;
                                            }

                                        }
                                    }
                                    else
                                    {
                                        outResult.Success = true;
                                        outResult.Msg = "";
                                        outResult.locationCode = at_l_Entity.locationCode;
                                        outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                        outResult.areaCode = item.areaCode;
                                        outResult.isControlQty = isControlQty;
                                        outResult.isControlInv = isControlInv;
                                        break;
                                    }
                                }
                                #endregion
                                break;
                            }
                        }
                        #endregion
                    }
                    else if (model.projectCode == "tzlj")
                    {
                        #region 泰州隆基空托盘出库
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatEmptySpecTrayLJ(model.traySpec, item.areaCode);
                        if (lstCanOutL.Count == 0)
                        {
                            continue;
                        }
                        else
                        {
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE

                            }).ToList();
                            lstTmp_Location = CalculateLocByStegy(ref lstDevice, lstCanOutL, lstStrate, out deviceCode);
                            if (lstTmp_Location.Count > 0)
                            {
                                at_l_Entity = lstTmp_Location[0];
                                #region 锁定待出库货位
                                if (at_l_Entity != null)
                                {
                                    if (model.lockLocation)
                                    {
                                        result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.locationCode, Constants.Location_State_OutLock, "出库", null);
                                        if (result != null)
                                        {
                                            if (result.Success && result.Row > 0)
                                            {
                                                outResult.Success = true;
                                                outResult.Msg = "";
                                                outResult.locationCode = at_l_Entity.locationCode;
                                                outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                                outResult.areaCode = item.areaCode;
                                                outResult.isControlQty = isControlQty;
                                                outResult.isControlInv = isControlInv;
                                                break;
                                            }

                                        }
                                    }
                                    else
                                    {
                                        outResult.Success = true;
                                        outResult.Msg = "";
                                        outResult.locationCode = at_l_Entity.locationCode;
                                        outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                        outResult.areaCode = item.areaCode;
                                        outResult.isControlQty = isControlQty;
                                        outResult.isControlInv = isControlInv;
                                        break;
                                    }
                                }
                                #endregion
                                break;
                            }
                        }
                        #endregion
                    }
                    else if (model.projectCode == "masym")
                    {
                        #region 马鞍山粤美空托盘出库
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatEmptySpecTrayYM(model.traySpec, item.areaCode);
                        if (lstCanOutL.Count == 0)
                        {
                            continue;
                        }
                        else
                        {
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE

                            }).ToList();
                            lstTmp_Location = CalculateLocByStegy(ref lstDevice, lstCanOutL, lstStrate, out deviceCode);
                            if (lstTmp_Location.Count > 0)
                            {
                                at_l_Entity = lstTmp_Location[0];
                                #region 锁定待出库货位
                                if (at_l_Entity != null)
                                {
                                    if (model.lockLocation)
                                    {
                                        result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.locationCode, Constants.Location_State_OutLock, "出库", null);
                                        if (result != null)
                                        {
                                            if (result.Success && result.Row > 0)
                                            {
                                                outResult.Success = true;
                                                outResult.Msg = "";
                                                outResult.locationCode = at_l_Entity.locationCode;
                                                outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                                outResult.areaCode = item.areaCode;
                                                outResult.isControlQty = isControlQty;
                                                outResult.isControlInv = isControlInv;
                                                break;
                                            }

                                        }
                                    }
                                    else
                                    {
                                        outResult.Success = true;
                                        outResult.Msg = "";
                                        outResult.locationCode = at_l_Entity.locationCode;
                                        outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                        outResult.areaCode = item.areaCode;
                                        outResult.isControlQty = isControlQty;
                                        outResult.isControlInv = isControlInv;
                                        break;
                                    }
                                }
                                #endregion
                                break;
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        #region 空托盘出库
                        //空托盘出库,add by ly 20190102  增加根据托盘类型出库
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatEmptySpecTray(model.traySpec, item.areaCode);
                        if (lstCanOutL.Count == 0)
                        {
                            continue;
                        }
                        else
                        {
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE

                            }).ToList();
                            lstTmp_Location = CalculateLocByStegy(ref lstDevice, lstCanOutL, lstStrate, out deviceCode);
                            if (lstTmp_Location.Count > 0)
                            {
                                at_l_Entity = lstTmp_Location[0];
                                #region 锁定待出库货位
                                if (at_l_Entity != null)
                                {
                                    if (model.lockLocation)
                                    {
                                        result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.locationCode, Constants.Location_State_OutLock, "出库", null);
                                        if (result != null)
                                        {
                                            if (result.Success && result.Row > 0)
                                            {
                                                outResult.Success = true;
                                                outResult.Msg = "";
                                                outResult.locationCode = at_l_Entity.locationCode;
                                                outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                                outResult.areaCode = item.areaCode;
                                                outResult.isControlQty = isControlQty;
                                                outResult.isControlInv = isControlInv;
                                                break;
                                            }

                                        }
                                    }
                                    else
                                    {
                                        outResult.Success = true;
                                        outResult.Msg = "";
                                        outResult.locationCode = at_l_Entity.locationCode;
                                        outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                        outResult.areaCode = item.areaCode;
                                        outResult.isControlQty = isControlQty;
                                        outResult.isControlInv = isControlInv;
                                        break;
                                    }
                                }
                                #endregion
                                break;
                            }
                        }
                        #endregion
                    }
                }
                else
                {
                    #region 满托盘出库
                    if (model.projectCode == "ys001")
                    {
                        #region  宇寿满托盘出库
                        // needOutWeight = autoBomE.CN_F_NW * model.itemQty;
                        needOutWeight = model.itemQty;
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatItemQtyYS(model.itemCode, model.lotNo, item.areaCode);
                        lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                        lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                        {
                            trayCode = o.u.trayCode,
                            locationCode = o.u.locationCode,
                            stockAreaCode = o.u.stockAreaCode,
                            useState = o.u.useState,
                            opTime = o.u.opTime,
                            productDate = o.u.productDate,
                            lotNo = o.u.lotNo,
                            CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                            CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                            CN_S_ROW = o.d.CN_S_ROW,
                            CN_S_COL = o.d.CN_S_COL,
                            CN_S_FLOOR = o.d.CN_S_FLOOR,
                            CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE,
                            needWeight = needOutWeight,
                            totalWeight = o.u.totalWeight
                        }).ToList();

                        List<TN_WM_LOCATIONCODE_EXT_Entity> locationInLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_State_InLock);
                        Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationInLock数据:" + JsonConvert.SerializeObject(locationInLock));
                        foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationInLock)
                        {
                            lstCanOutL.RemoveAll(o => o.CN_S_ROW == lEntity.CN_S_ROW && o.CN_S_COL == lEntity.CN_S_COL);
                        }
                        List<TN_WM_LOCATIONCODE_EXT_Entity> locationCheckLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_Check_Lock);
                        Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationCheckLock数据:" + JsonConvert.SerializeObject(locationCheckLock));
                        foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationCheckLock)
                        {
                            lstCanOutL.RemoveAll(o => o.CN_S_ROW == lEntity.CN_S_ROW && o.CN_S_COL == lEntity.CN_S_COL);
                        }
                        List<TN_WM_LOCATIONCODE_EXT_Entity> locationCarryLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_Carry_Lock);
                        Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationCarryLock数据:" + JsonConvert.SerializeObject(locationCarryLock));
                        foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationCarryLock)
                        {
                            lstCanOutL.RemoveAll(o => o.CN_S_ROW == lEntity.CN_S_ROW && o.CN_S_COL == lEntity.CN_S_COL);
                        }
                        locationInLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_State_OutLock);
                        Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationOutLock数据:" + JsonConvert.SerializeObject(locationInLock));
                        foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationInLock)
                        {
                            lstCanOutL.RemoveAll(o => o.CN_S_ROW == lEntity.CN_S_ROW && o.CN_S_COL == lEntity.CN_S_COL && int.Parse(o.CN_S_FLOOR) > int.Parse(lEntity.CN_S_FLOOR));
                        }

                        List<AutoBomLocationAbbreEntity> lstLocationItem = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLocationByItemCode("", item.areaCode);
                        foreach (outAssignLocation outL in lstCanOutL)
                        {
                            //计算出该物料需要移动多少托盘
                            outL.moveStep = lstLocationItem.Where(o => o.CN_S_ROW == outL.CN_S_ROW && o.CN_S_COL == outL.CN_S_COL && int.Parse(o.CN_S_FLOOR) > int.Parse(outL.CN_S_FLOOR)).Count();
                        }
                        #endregion
                    }

                    else if (model.projectCode == "tzlj")
                    {
                        #region  隆基满托盘出库
                        List<TN_WM_LOCATIONCODE_EXT_Entity> locationInLock = new List<TN_WM_LOCATIONCODE_EXT_Entity>();
                        List<TN_WM_LOCATIONCODE_EXT_Entity> locationOutLock = new List<TN_WM_LOCATIONCODE_EXT_Entity>();
                        if (lstStrategy.Select(o => o.CN_S_CODE).ToList().Contains("FirstInLastOutLj"))
                        {
                            lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatItemQty(model.itemCode, item.areaCode);
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE
                            }).ToList();
                            Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "lstCanOutL数据:" + JsonConvert.SerializeObject(lstCanOutL));
                            locationInLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_State_InLock);
                            Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationInLock数据:" + JsonConvert.SerializeObject(locationInLock));
                            //控制有入的不能出
                            foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationInLock)
                            {
                                lstCanOutL.RemoveAll(o => o.CN_S_COL == lEntity.CN_S_COL);
                            }
                            locationOutLock = CreateDAL<TN_WM_LOCATION_EXTDAL>().GetLockLocationByState(model.stockCode.Trim(), item.areaCode, null, Constants.Location_State_OutLock);
                            Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "locationOutLock数据:" + JsonConvert.SerializeObject(locationOutLock));

                        }
                        if (lstStrategy.Select(o => o.CN_S_CODE).ToList().Contains("AdjoinColNoTask"))
                        {
                            foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationOutLock)
                            {
                                lstCanOutL.RemoveAll(o => int.Parse(o.CN_S_COL) == int.Parse(lEntity.CN_S_COL) + 1);
                                lstCanOutL.RemoveAll(o => int.Parse(o.CN_S_COL) == int.Parse(lEntity.CN_S_COL) - 1);
                            }
                            foreach (TN_WM_LOCATIONCODE_EXT_Entity lEntity in locationInLock)
                            {
                                lstCanOutL.RemoveAll(o => int.Parse(o.CN_S_COL) == int.Parse(lEntity.CN_S_COL) + 1);
                                lstCanOutL.RemoveAll(o => int.Parse(o.CN_S_COL) == int.Parse(lEntity.CN_S_COL) - 1);
                            }
                        }
                        if (lstStrategy.Select(o => o.CN_S_CODE).ToList().Contains("FirstInLastOutLj"))
                        {
                            List<string> lstSameItemRow = lstCanOutL.Select(o => o.CN_S_COL).Distinct().ToList();
                            List<rowTaskNT> lstRowTask = new List<rowTaskNT>();
                            foreach (string sRow in lstSameItemRow)
                            {
                                Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "sRow数据:" + sRow.ToString());
                                rowTaskNT rowT = new rowTaskNT();
                                rowT.row = sRow;
                                rowT.taskNum = locationOutLock.Where(o => o.CN_S_COL == sRow).Count();
                                rowT.canOutLocation = lstCanOutL.Where(o => o.CN_S_COL == sRow).Count();
                                Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "rowTaskNT数据:" + JsonConvert.SerializeObject(rowT));
                                if (rowT.canOutLocation > 0)
                                {
                                    lstRowTask.Add(rowT);
                                }
                            }
                            Log.AlgorInfo("OutAssign-FlatAreaOutLocation", "lstRowTask数据:" + JsonConvert.SerializeObject(lstRowTask));
                            if (lstRowTask.Count > 0)
                            {
                                lstCanOutL = lstCanOutL.Where(a => a.CN_S_COL == lstRowTask.OrderBy(o => o.taskNum).ThenByDescending(b => b.canOutLocation).FirstOrDefault().row).ToList();
                            }
                            else
                            {
                                lstCanOutL.Clear();
                            }

                        }
                        else
                        {
                            lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatItemQty(model.itemCode, item.areaCode);
                            lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                            lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                            {
                                trayCode = o.u.trayCode,
                                locationCode = o.u.locationCode,
                                stockAreaCode = o.u.stockAreaCode,
                                useState = o.u.useState,
                                opTime = o.u.opTime,
                                productDate = o.u.productDate,
                                lotNo = o.u.lotNo,
                                CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                                CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                                CN_S_ROW = o.d.CN_S_ROW,
                                CN_S_COL = o.d.CN_S_COL,
                                CN_S_FLOOR = o.d.CN_S_FLOOR,
                                CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE
                            }).ToList();
                        }
                        #endregion
                    }
                    else
                    {
                        lstCanOutL = CreateDAL<Out_AlgorDAL>().GetAssignFlatItemQty(model.itemCode, item.areaCode);
                        lstTrueLocation = CreateDAL<TN_WMS_LOCATIONDAL>().GetLocationByLocationCode(lstCanOutL.Select(o => o.locationCode).ToList());
                        lstCanOutL = lstCanOutL.Join(lstTrueLocation, u => u.locationCode, d => d.CN_S_LOCATION_CODE, (u, d) => new { u, d }).Select(o => new outAssignLocation
                        {
                            trayCode = o.u.trayCode,
                            locationCode = o.u.locationCode,
                            stockAreaCode = o.u.stockAreaCode,
                            useState = o.u.useState,
                            opTime = o.u.opTime,
                            productDate = o.u.productDate,
                            lotNo = o.u.lotNo,
                            CN_S_STOCK_CODE = o.d.CN_S_STOCK_CODE,
                            CN_S_ROADWAY = o.d.CN_S_ROADWAY,
                            CN_S_ROW = o.d.CN_S_ROW,
                            CN_S_COL = o.d.CN_S_COL,
                            CN_S_FLOOR = o.d.CN_S_FLOOR,
                            CN_S_LOCATION_STATE = o.d.CN_S_LOCATION_STATE
                        }).ToList();
                    }

                    Log.AlgorInfo("OutAssign-GetAssignFlatItemQty结果", JsonConvert.SerializeObject(lstCanOutL));
                    if (lstCanOutL.Count > 0)
                    {
                        //获取该库区中可用货位的信息
                        Log.AlgorInfo("OutAssign-lstStrate", JsonConvert.SerializeObject(lstStrate));
                        lstTmp_Location = CalculateLocByStegy(ref lstDevice, lstCanOutL, lstStrate, out deviceCode);
                        if (lstTmp_Location.Count > 0)
                        {
                            at_l_Entity = lstTmp_Location[0];
                            #region 锁定待出库货位
                            if (at_l_Entity != null)
                            {
                                if (model.lockLocation)
                                {
                                    result = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationState(at_l_Entity.locationCode, Constants.Location_State_OutLock, "出库", null);
                                    if (result != null)
                                    {
                                        if (result.Success && result.Row > 0)
                                        {
                                            outResult.Success = true;
                                            if (model.projectCode == "ys001")
                                            {
                                                if (at_l_Entity.needWeight > at_l_Entity.totalWeight)
                                                {
                                                    int itemQty = Decimal.ToInt32(Math.Round(at_l_Entity.totalWeight, 0));
                                                    outResult.Msg = "该托盘大约有该物料" + itemQty.ToString() + autoBomE.CN_S_MEASURE_UNIT + ",不满足出库数量要求,还差" + Decimal.ToInt32(model.itemQty - itemQty).ToString() + autoBomE.CN_S_MEASURE_UNIT;
                                                }
                                                else
                                                {
                                                    outResult.Msg = "";
                                                }

                                            }
                                            else if (model.projectCode == "ntsd")
                                            {
                                                if (at_l_Entity.needQty > at_l_Entity.totalQty)
                                                {
                                                    outResult.Msg = "该托盘有该物料" + at_l_Entity.totalQty.ToString() + ",不满足出库数量要求,还差" + Decimal.ToInt32(at_l_Entity.needQty - at_l_Entity.totalQty).ToString();
                                                }
                                                else
                                                {
                                                    outResult.Msg = "";
                                                }

                                            }
                                            outResult.locationCode = at_l_Entity.locationCode;
                                            outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                            outResult.areaCode = item.areaCode;
                                            outResult.isControlQty = isControlQty;
                                            outResult.isControlInv = isControlInv;
                                            break;
                                        }

                                    }
                                }
                                else
                                {
                                    outResult.Success = true;
                                    if (model.projectCode == "ys001")
                                    {
                                        if (at_l_Entity.needWeight > at_l_Entity.totalWeight)
                                        {
                                            int itemQty = Decimal.ToInt32(at_l_Entity.totalWeight);
                                            outResult.Msg = "该托盘大约有该物料" + itemQty.ToString() + autoBomE.CN_S_MEASURE_UNIT + ",不满足出库数量要求,还差" + Decimal.ToInt32(model.itemQty - itemQty).ToString() + autoBomE.CN_S_MEASURE_UNIT;
                                        }
                                        else
                                        {
                                            outResult.Msg = "";
                                        }


                                    }
                                    else if (model.projectCode == "ntsd")
                                    {
                                        if (at_l_Entity.needQty > at_l_Entity.totalQty)
                                        {
                                            outResult.Msg = "该托盘有该物料" + at_l_Entity.totalQty.ToString() + ",不满足出库数量要求,还差" + Decimal.ToInt32(at_l_Entity.needQty - at_l_Entity.totalQty).ToString();
                                        }
                                        else
                                        {
                                            outResult.Msg = "";
                                        }

                                    }
                                    else
                                    {
                                        outResult.Msg = "";
                                    }
                                    outResult.locationCode = at_l_Entity.locationCode;
                                    outResult.trayCode = lstCanOutL.Where(o => o.locationCode == at_l_Entity.locationCode).FirstOrDefault().trayCode;
                                    outResult.areaCode = item.areaCode;
                                    outResult.isControlQty = isControlQty;
                                    outResult.isControlInv = isControlInv;
                                    break;
                                }
                            }
                            #endregion
                            break;
                        }
                    }
                    #endregion

                }


            }
            return outResult;

        }

        /// <summary>
        /// 根据入库策略筛选符合条件的货位
        /// </summary>
        /// <param name="lstDevice"></param>
        /// <param name="lstLocation"></param>
        /// <param name="lstStrate"></param>
        /// <param name="deviceCode"></param>
        /// <returns></returns>
        public List<outAssignLocation> CalculateLocByStegy(ref List<Device> lstDevice, List<outAssignLocation> lstLocation, List<string> lstStrate, out string deviceCode)
        {
            List<outAssignLocation> lstFilterLoc = lstLocation;
            deviceCode = string.Empty;
            AlgorTacticsCommon Trctics = new AlgorTacticsCommon();
            foreach (string stegy in lstStrate)
            {
                //逐个策略进行计算
                switch (stegy)
                {
                    case "EquipmentBalance":   //设备均衡
                        lstFilterLoc = Trctics.EquipmentBalanceOut(lstDevice, lstFilterLoc, out deviceCode);
                        break;
                    case "RoadWayBalance":    //巷道均衡
                        lstFilterLoc = Trctics.RoadWayBalanceOut(lstFilterLoc); ;
                        break;
                    case "NearbyBalance":     //就近原则
                        lstFilterLoc = Trctics.NearbyBalanceOut(lstFilterLoc); ;
                        break;
                    case "ProductTimeOutFirst":  //生产日期早先出
                        lstFilterLoc = lstFilterLoc.OrderBy(o => o.productDate).ToList();
                        lstFilterLoc = lstFilterLoc.Where(o => o.productDate == lstFilterLoc.FirstOrDefault().productDate).ToList();
                        break;
                    case "InStockTimeOutFirst":    //入库时间早先出
                        lstFilterLoc = lstFilterLoc.OrderBy(o => o.opTime).ToList();
                        lstFilterLoc = lstFilterLoc.Where(o => o.opTime == lstFilterLoc.FirstOrDefault().opTime).ToList();
                        break;
                    case "SatisfyWeightFirst":    //满足重量托盘先出
                        lstFilterLoc = lstFilterLoc.OrderByDescending(o => o.totalWeight).ToList();
                        if (lstFilterLoc[0].totalWeight >= lstFilterLoc[0].needWeight)
                        {
                            lstFilterLoc = lstFilterLoc.Where(o => o.totalWeight >= lstFilterLoc[0].needWeight).ToList();
                        }
                        else
                        {
                            lstFilterLoc = lstFilterLoc.Where(o => o.totalWeight == lstFilterLoc[0].totalWeight).ToList();
                        }
                        break;
                    case "MinMoveTray":    //移动托盘小列先出
                        lstFilterLoc = lstFilterLoc.OrderBy(o => o.moveStep).ToList();
                        lstFilterLoc = lstFilterLoc.Where(o => o.moveStep == lstFilterLoc[0].moveStep).ToList();
                        break;
                    case "FirstInLastOut":    //先进后出
                        Log.AlgorInfo("OutAssign-CalculateLocByStegy", "FirstInLastOut");
                        if (lstStrate.Contains("OutBigToSmall"))
                        {
                            Log.AlgorInfo("OutAssign-OutBigToSmall", "OutBigToSmall");
                            lstFilterLoc = lstFilterLoc.OrderBy(o => int.Parse(o.CN_S_ROW)).ThenByDescending(o => int.Parse(o.CN_S_COL)).ThenByDescending(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        else if (lstStrate.Contains("OutSmallToBig"))
                        {
                            Log.AlgorInfo("OutAssign-OutSmallToBig", "OutSmallToBig");
                            lstFilterLoc = lstFilterLoc.OrderBy(o => int.Parse(o.CN_S_ROW)).ThenBy(o => int.Parse(o.CN_S_COL)).ThenByDescending(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        else
                        {
                            lstFilterLoc = lstFilterLoc.OrderByDescending(o => int.Parse(o.CN_S_COL)).ThenBy(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        Log.AlgorInfo("OutAssign-lstFilterLoc", JsonConvert.SerializeObject(lstFilterLoc));
                        lstFilterLoc = lstFilterLoc.Where(o => o.CN_S_COL == lstFilterLoc.FirstOrDefault().CN_S_COL && o.CN_S_FLOOR == lstFilterLoc.FirstOrDefault().CN_S_FLOOR).ToList();
                        break;
                    case "FirstInLastOutLj":    //先进后出
                        Log.AlgorInfo("OutAssign-CalculateLocByStegy", "FirstInLastOut");
                        if (lstStrate.Contains("OutBigToSmall"))
                        {
                            Log.AlgorInfo("OutAssign-OutBigToSmall", "OutBigToSmall");
                            lstFilterLoc = lstFilterLoc.OrderBy(o => int.Parse(o.CN_S_ROW)).ThenByDescending(o => int.Parse(o.CN_S_COL)).ThenByDescending(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        else if (lstStrate.Contains("OutSmallToBig"))
                        {
                            Log.AlgorInfo("OutAssign-OutSmallToBig", "OutSmallToBig");
                            lstFilterLoc = lstFilterLoc.OrderBy(o => int.Parse(o.CN_S_ROW)).ThenBy(o => int.Parse(o.CN_S_COL)).ThenByDescending(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        else
                        {
                            lstFilterLoc = lstFilterLoc.OrderByDescending(o => o.CN_S_ROW).ThenBy(b => int.Parse(b.CN_S_FLOOR)).ToList();
                        }
                        Log.AlgorInfo("OutAssign-lstFilterLoc", JsonConvert.SerializeObject(lstFilterLoc));
                        lstFilterLoc = lstFilterLoc.Where(o => o.CN_S_ROW == lstFilterLoc.FirstOrDefault().CN_S_ROW && o.CN_S_FLOOR == lstFilterLoc.FirstOrDefault().CN_S_FLOOR).ToList();
                        break;

                }

            }
            return lstFilterLoc;
        }
        /// <summary>
        /// 根据入库策略筛选符合条件的货位
        /// </summary>
        /// <param name="lstDevice"></param>
        /// <param name="lstLocation"></param>
        /// <param name="lstStrate"></param>
        /// <param name="deviceCode"></param>
        /// <returns></returns>
        public List<outAssignLocation> CalculateCanOutByStegy(List<outAssignLocation> lstCanOutL, List<string> lstStrate, decimal needOutWeight)
        {
            List<outAssignLocation> lstFilterLoc = lstCanOutL;
            foreach (string stegy in lstStrate)
            {
                //逐个策略进行计算
                switch (stegy)
                {
                    case "ProductTimeOutFirst":  //生产日期早先出
                        lstFilterLoc = lstFilterLoc.OrderBy(o => o.productDate).ToList();
                        lstFilterLoc = lstFilterLoc.Where(o => o.productDate == lstFilterLoc.FirstOrDefault().productDate).ToList();
                        break;
                    case "InStockTimeOutFirst":    //入库时间早先出
                        lstFilterLoc = lstFilterLoc.OrderBy(o => o.opTime).ToList();
                        lstFilterLoc = lstFilterLoc.Where(o => o.opTime == lstFilterLoc.FirstOrDefault().opTime).ToList();
                        break;

                }

            }
            return lstFilterLoc;
        }

        #endregion

    }
}