using HH.WMS.BLL.Algorithm;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.Common;
using HH.WMS.BLL.CoreServer;
using HH.WMS.BLL.Interface;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.Algorithm.Out;
using HH.WMS.DAL;
using HH.WMS.DAL.Basic;
using HH.WMS.DAL.InStock;
using HH.WMS.DAL.OutStock;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.Entitys.Entitys;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.BLL.OutStock
{
    public class TN_WM_SORTING_LISTBLL : DapperBaseBLL
    {
        #region 分拣单列表
        /// <summary>
        /// 分拣单列表
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<TN_WM_SORTING_LISTEntity> GetSortings(string key)
        {
            return CreateDAL<TN_WM_SORTING_LISTDAL>().GetSortings(key);
        }
        #endregion

        #region 确认分拣
        /// <summary>
        /// 确认分拣
        /// </summary>
        /// <param name="sortingPicked"></param>
        /// <param name="sortingResult"></param>
        /// <returns></returns>
        public OperateResult ConfirmSorting(bool sortingPicked, bool wavePicked, string waveNo, List<TN_WM_SORTING_RESULTEntity> sortingResult, string boxNo = "")
        {
            //分拣单捡完了，根据分拣单获取库区锁定明细
            //List<TN_WM_B_OUTLOCKING_DTLEntity> outLockDtl = new List<TN_WM_B_OUTLOCKING_DTLEntity>();
            List<TN_WM_B_AREA_QTYEntity> areaQtyList = new List<TN_WM_B_AREA_QTYEntity>();
            //算法策略
            List<string> lstStrate = BLLCreator.Create<SysMgr.TN_WM_B_STRATEGYBLL>().GetStrateListByAreaOrStock("", "", Constants.Out)
                 .OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();
            Log.Info("确认分拣", "lstStrate");
            Log.Info("确认分拣", JsonConvert.SerializeObject(lstStrate));

            if (sortingPicked)
            {
                Log.Info("确认分拣sortingResult", JsonConvert.SerializeObject(sortingResult));
                var currentSorting = CreateDAL<DapperDAL<TN_WM_SORTING_LISTEntity>>()
                    .GetSingleEntity(new
                    {
                        CN_S_SORTING_NO = sortingResult[0].CN_S_SORTING_NO
                    });
                if (currentSorting != null)
                {
                    var currentSortingDtl = CreateDAL<DapperDAL<TN_WM_SORTING_DTLEntity>>()
                        .GetList(new
                        {
                            CN_S_SORTING_NO = currentSorting.CN_S_SORTING_NO
                        });
                    currentSorting.SortingDtlList = currentSortingDtl;

                    areaQtyList = CreateDAL<DapperDAL<TN_WM_B_AREA_QTYEntity>>().GetList(new
                    {
                        CN_S_ITEM_CODE = currentSortingDtl.Select(x => x.CN_S_ITEM_CODE).ToList()
                    });
                    //反批分库区分配量
                    Log.Info("确认分拣", "BatchesAreaQty");
                    var result = areaQtyList.BatchesAreaQty(new List<TN_WM_SORTING_LISTEntity>() { currentSorting }, lstStrate, true);
                    Log.Info("确认分拣", JsonConvert.SerializeObject(result));
                    if (!result.Success)
                        return result;
                }
            }

            //分拣结果的托盘物料关联数据
            var trayItemMstList = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
            {
                CN_S_TRAY_CODE = sortingResult.Select(x => x.CN_S_TRAY_CODE).ToList(),
                CN_S_ITEM_CODE = sortingResult.Select(x => x.CN_S_ITEM_CODE).ToList()
            });

            foreach (var trayItemMst in trayItemMstList)
            {
                trayItemMst.TrayItemDtlList = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
                trayItemMst.UnpackingDtl = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
                //属于当前托盘,当前物料的分拣明细
                var currentSortingResult = sortingResult.Where(x => x.CN_S_ITEM_CODE == trayItemMst.CN_S_ITEM_CODE && x.CN_S_TRAY_CODE == trayItemMst.CN_S_TRAY_CODE);
                decimal qty = currentSortingResult.Sum(y => y.CN_F_QUANTITY);
                if (trayItemMst.CN_F_QUANTITY >= qty &&
                    trayItemMst.CN_F_ALLOC_QTY >= qty)
                {
                    trayItemMst.CN_F_QUANTITY -= qty;
                    trayItemMst.CN_F_ALLOC_QTY -= qty;

                    Log.Info("确认分拣", "0001");
                    trayItemMst.TrayItemDtlList = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new
                    {
                        CN_PARENT_GUID = trayItemMst.CN_GUID
                    }).OrderBy(x => x.CN_S_LOT_NO).ToList();

                    Log.Info("确认分拣", "0002");
                    //空的生产批次放后面
                    currentSortingResult = currentSortingResult.Select(x => new
                    {
                        index = string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) ? 0 : 1,
                        x
                    }).OrderByDescending(y => y.index).ThenBy(z => z.x.CN_S_PRODUCTION_BATCH).Select(m => m.x);
                    Log.Info("确认分拣", "0003");
                    foreach (string stegy in lstStrate)
                    {
                        //逐个策略进行计算
                        switch (stegy)
                        {
                            case "FirstInFirstOut":
                                trayItemMst.TrayItemDtlList = trayItemMst.TrayItemDtlList.OrderBy(o => o.CN_S_LOT_NO).ToList();
                                break;
                            case "FirstWarrantFirstOut":
                                trayItemMst.TrayItemDtlList = trayItemMst.TrayItemDtlList.Select(x => new
                                {
                                    index = string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) ? 0 : 1,
                                    x
                                }).OrderByDescending(y => y.index).ThenBy(z => z.x.CN_S_PRODUCTION_BATCH).Select(m => m.x).ToList();
                                break;
                        }
                    }
                    Log.Info("确认分拣", "0004");
                    foreach (var cs in currentSortingResult)
                    {
                        var csQty = cs.CN_F_QUANTITY;
                        if (csQty == 0) continue;
                        //箱码(箱码只扣除箱码)
                        if (!string.IsNullOrEmpty(cs.CN_S_PACKING_UNIT))
                        {
                            var existsPackingUnit = trayItemMst.TrayItemDtlList.FindAll(f => f.CN_S_PACKING_UNIT == cs.CN_S_PACKING_UNIT && (string.IsNullOrEmpty(cs.CN_S_PRODUCTION_BATCH) || cs.CN_S_PRODUCTION_BATCH == f.CN_S_PRODUCTION_BATCH));
                            if (!existsPackingUnit.Any())
                                return OperateResult.Error("托盘：" + trayItemMst.CN_S_TRAY_CODE + "中未找到包装单位为：" + cs.CN_S_PACKING_UNIT + ",物料编码：" + cs.CN_S_ITEM_CODE + ",生产批次：" + cs.CN_S_PRODUCTION_BATCH + " 的物料");

                            foreach (var ep in existsPackingUnit)
                            {
                                if (csQty == 0) break;
                                if (ep.CN_F_QUANTITY >= csQty)
                                {
                                    ep.CN_F_QUANTITY -= csQty;
                                    csQty = 0;
                                }
                                else
                                {
                                    csQty -= ep.CN_F_QUANTITY;
                                    ep.CN_F_QUANTITY = 0;
                                }
                            }
                        }
                        else
                        {
                            //当前分拣的是单独包装
                            //可能不存在单个包装(拆包)，可能存在单独包装但不够(拆包)，可能单独包装都够
                            //先找所有为单独包装的,把没有包装单位的放前面,然后把最小个包装的放前面
                            trayItemMst.TrayItemDtlList = trayItemMst.TrayItemDtlList.Select(x => new
                            {
                                emptyPackingUnitIndex = string.IsNullOrEmpty(x.CN_S_PACKING_UNIT) ? 0 : 1,
                                x
                            }).OrderBy(o => o.emptyPackingUnitIndex).ThenBy(o => o.x.CN_F_PACKING_QTY).Select(s => s.x).ToList();
                            foreach (var tdtl in trayItemMst.TrayItemDtlList)
                            {
                                //需要拆包的
                                if (!string.IsNullOrEmpty(tdtl.CN_S_PACKING_UNIT))
                                {
                                    //一包装内的个数
                                    var packingQty = !tdtl.CN_F_PACKING_QTY.HasValue || tdtl.CN_F_PACKING_QTY == 0 ? 1 : tdtl.CN_F_PACKING_QTY.Value;
                                    //有几个包装呢
                                    decimal multiple = tdtl.CN_F_QUANTITY / packingQty;
                                    if (tdtl.CN_F_QUANTITY > csQty)
                                    {
                                        tdtl.CN_F_QUANTITY -= csQty;
                                        csQty = 0;
                                        //不止一个包装时
                                        if (multiple > 1)//取余拆单
                                        {
                                            int restQty = (int)tdtl.CN_F_QUANTITY / (int)packingQty;
                                            if (restQty > 0)
                                            {
                                                var restAloneQty = tdtl.CN_F_QUANTITY % packingQty;
                                                if (restAloneQty > 0)
                                                {
                                                    tdtl.CN_F_QUANTITY = restQty * packingQty;
                                                    //多余出来的部分创建一条新记录
                                                    var aloneDtl = tdtl.Clone() as TN_WM_B_TRAY_ITEM_DTLEntity;
                                                    aloneDtl.CN_GUID = Guid.NewGuid().ToString();
                                                    aloneDtl.CN_F_QUANTITY = restAloneQty;
                                                    aloneDtl.CN_F_PACKING_QTY = 0;
                                                    aloneDtl.CN_S_PACKING_UNIT = "";
                                                    trayItemMst.UnpackingDtl.Add(aloneDtl);
                                                }
                                            }
                                            else//拆的只剩单个
                                            {
                                                tdtl.CN_F_PACKING_QTY = 0;
                                                tdtl.CN_S_PACKING_UNIT = "";
                                            }
                                        }
                                        else//直接可以拆
                                        {
                                            tdtl.CN_F_PACKING_QTY = 0;
                                            tdtl.CN_S_PACKING_UNIT = "";
                                        }
                                    }
                                    else//数量大于等于包装数时全部扣完
                                    {
                                        csQty -= tdtl.CN_F_QUANTITY;
                                        tdtl.CN_F_QUANTITY = 0;
                                    }
                                }
                                else//不需要拆包，直接扣
                                {
                                    if (tdtl.CN_F_QUANTITY >= csQty)
                                    {
                                        tdtl.CN_F_QUANTITY -= csQty;
                                        csQty = 0;
                                    }
                                    else
                                    {
                                        csQty -= tdtl.CN_F_QUANTITY;
                                        tdtl.CN_F_QUANTITY = 0;
                                    }
                                }
                            }
                        }
                        if (csQty > 0)
                            return OperateResult.Error("物料：" + cs.CN_S_ITEM_CODE + ",包装单位：" + cs.CN_S_PACKING_UNIT + "在托盘：" + cs.CN_S_TRAY_CODE + "中不足");
                        //Log.Info("确认分拣cs", "000401");
                        //foreach (var trayItemDtl in trayItemMst.TrayItemDtlList)
                        //{
                        //    if (csQty == 0) break;
                        //    if (trayItemDtl.CN_F_QUANTITY == 0) continue;
                        //    if (((cs.CN_F_PACKING_QTY <= 1 && trayItemDtl.CN_F_PACKING_QTY <= 1) || cs.CN_S_PACKING_UNIT == trayItemDtl.CN_S_PACKING_UNIT) &&
                        //        (string.IsNullOrEmpty(cs.CN_S_PRODUCTION_BATCH) || cs.CN_S_PRODUCTION_BATCH == trayItemDtl.CN_S_PRODUCTION_BATCH)
                        //        //&&
                        //        //(string.IsNullOrEmpty(cs.CN_S_LOT_NO) || cs.CN_S_LOT_NO
                        //        //.Equals(trayItemDtl.CN_S_LOT_NO))
                        //        )
                        //    {
                        //        if (trayItemDtl.CN_F_QUANTITY >= csQty)
                        //        {
                        //            trayItemDtl.CN_F_QUANTITY -= csQty;
                        //            //如果扣的当前是包，并且拣货不是按包来拣，拆包!
                        //            if (trayItemDtl.CN_F_PACKING_QTY > 1 &&
                        //                         cs.CN_F_PACKING_QTY > 1 &&
                        //                         (cs.CN_F_PACKING_QTY != trayItemDtl.CN_F_PACKING_QTY))
                        //            {
                        //                trayItemDtl.CN_F_PACKING_QTY = 1;
                        //                trayItemDtl.CN_S_PACKING_UNIT = cs.CN_S_MEASURE_UNIT;
                        //            }
                        //            csQty = 0;
                        //        }
                        //        else
                        //        {
                        //            csQty -= trayItemDtl.CN_F_QUANTITY;
                        //            trayItemDtl.CN_F_QUANTITY = 0;
                        //        }
                        //    }
                        //}
                    }
                }
            }
            var currentTrayLocation = CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().GetSingleEntity(new
            {
                CN_S_TRAY_CODE = sortingResult[0].CN_S_TRAY_CODE
            });

            Log.Info("ConfirmSorting 分拣结果的托盘物料关联数据", JsonConvert.SerializeObject(trayItemMstList));

            Log.Info("确认分拣", "UseTransaction start");
            var operateResult = UseTransaction(trans =>
            {
                Log.Info("ConfirmSorting ", "确认分拣开始-------------------------------------------------------");
                //保存分拣结果
                CreateDAL<DapperDAL<TN_WM_SORTING_RESULTEntity>>().AddRange(sortingResult, trans);
                Log.Info("ConfirmSorting ", "保存分拣结果完成");
                //下降托盘物料数据量

                Log.Info("ConfirmSorting 下降托盘物料数据量数据:trayItemMstList", JsonConvert.SerializeObject(trayItemMstList));
                Log.Info("ConfirmSorting 下降托盘物料数据量数据:currentTrayLocation", JsonConvert.SerializeObject(currentTrayLocation));
                CreateDAL<TN_WM_SORTING_LISTDAL>().DropTrayItemQty(trayItemMstList, currentTrayLocation, trans);
                //是否有拆包新增的数据
                foreach (var m in trayItemMstList)
                {
                    if (m.UnpackingDtl.Any())
                        CreateDapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>().AddRange(m.UnpackingDtl, trans);
                }
                Log.Info("ConfirmSorting ", "下降托盘物料数据量");
                //分拣单全部捡完置为已分拣
                if (sortingPicked)
                {
                    CreateDAL<DapperDAL<TN_WM_SORTING_LISTEntity>>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_SORTING_NO = sortingResult[0].CN_S_SORTING_NO
                    }, trans);
                    Log.Info("ConfirmSorting ", "分拣单全部捡完置为已分拣");
                    if (areaQtyList.Any())
                    {
                        Log.Info("ConfirmSorting ", "降库存");
                        Log.Info("ConfirmSorting 降库存数据", JsonConvert.SerializeObject(areaQtyList));
                        CreateDAL<TN_WM_B_AREA_QTYDAL>().UpdateAreaQtyAndAlloc(areaQtyList, trans);
                        Log.Info("ConfirmSorting ", "降库存完成");
                    }
                    //降库存
                    //if (outLockDtl.Any())
                    //{
                    //    //CreateDAL<TN_WM_B_STOCK_QTYDAL>().UpdateAllocQtyByLock(Constants.Rule_SortingNo, outLockDtl, trans);
                    //    Log.Info("ConfirmSorting ", "降库存");
                    //    CreateDAL<TN_WM_B_STOCK_QTYDAL>().DeleteOutLock(outLockDtl, trans);
                    //    Log.Info("ConfirmSorting ", "删除锁定明细");
                    //}
                }
                //波次捡完置为已分拣
                if (wavePicked)
                {
                    CreateDAL<DapperDAL<TN_WM_WAVE_MSTEntity>>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_WAVE_NO = waveNo
                    }, trans);
                    Log.Info("ConfirmSorting ", "波次捡完置为已分拣");
                    //出库单状态，已分拣
                    CreateDAL<DapperDAL<TN_WM_OUT_MSTEntity>>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_WAVE_CODE = waveNo
                    }, trans);
                }
                if (!string.IsNullOrEmpty(boxNo))
                {
                    //容器绑定
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                    {
                        CN_S_SORTING_CODE = sortingResult[0].CN_S_SORTING_NO,
                        CN_S_STATE = Constants.TrayState_InUse
                    }, new
                    {
                        CN_S_TRAY_CODE = boxNo
                    }, trans);
                    Log.Info("ConfirmSorting ", "容器绑定");
                }
                Log.Info("ConfirmSorting ", "确认分拣完成-------------------------------------------------------");
            });
            if (operateResult.Success && currentTrayLocation != null)
            {
                var currentTrayItemMst = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                {
                    CN_S_TRAY_CODE = currentTrayLocation.CN_S_TRAY_CODE
                });
                if (!currentTrayItemMst.Any())
                {
                    operateResult = UseTransaction(trans =>
                    {
                        CreateDAL<TN_WM_SORTING_LISTDAL>().ClearLocationByTrayCode(currentTrayLocation, trans);
                    });
                }
            }
            return operateResult;
        }
        #endregion

        public void SavePickData(SavePickEntity entity, IDbTransaction trans)
        {
            //保存分拣结果
            CreateDAL<DapperDAL<TN_WM_SORTING_RESULTEntity>>().AddRange(entity.SortingResult, trans);
            Log.Info("SavePickData ", "保存分拣结果完成");
            //更新分拣明细已拣数量
            if (entity.SortingLocation != null)
            {
                entity.SortingLocation.ForEach(e =>
                {
                    CreateDapperDAL<TN_WM_SORTING_LOCATIONEntity>().Update(new
                    {
                        CN_F_PICKED_QTY = e.CN_F_QUANTITY
                    }, new
                    {
                        CN_GUID = e.CN_GUID
                    }, trans);
                });
            }
            //下降托盘物料数据量
            Log.Info("SavePickData 下降托盘物料数据量数据:trayItemMstList", JsonConvert.SerializeObject(entity.TrayItemList));
            Log.Info("SavePickData 下降托盘物料数据量数据:currentTrayLocation", JsonConvert.SerializeObject(entity.TrayLocation));
            CreateDAL<TN_WM_SORTING_LISTDAL>().DropTrayItemQty(entity.TrayItemList, entity.TrayLocation, trans);
            Log.Info("SavePickData ", "下降托盘物料数据量");
            //分拣单全部捡完置为已分拣
            if (entity.SortingPicked)
            {
                CreateDAL<DapperDAL<TN_WM_SORTING_LISTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Sorted
                }, new
                {
                    CN_S_SORTING_NO = entity.SortingNo
                }, trans);
                Log.Info("SavePickData ", "分拣单全部捡完置为已分拣");
                //分拣单全部拣完，降库区库存
                if (entity.AreaQtyList.Any())
                {
                    Log.Info("SavePickData ", "降库存");
                    Log.Info("SavePickData 降库存数据", JsonConvert.SerializeObject(entity.AreaQtyList));
                    CreateDAL<TN_WM_B_AREA_QTYDAL>().UpdateAreaQtyAndAlloc(entity.AreaQtyList, trans);
                    Log.Info("SavePickData ", "降库存完成");
                }
            }
            //波次捡完置为已分拣
            if (entity.WavePicked)
            {
                CreateDAL<DapperDAL<TN_WM_WAVE_MSTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Sorted
                }, new
                {
                    CN_S_WAVE_NO = entity.WaveNo
                }, trans);
                Log.Info("SavePickData ", "波次捡完置为已分拣");
                //出库单状态，已分拣
                CreateDAL<DapperDAL<TN_WM_OUT_MSTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Sorted
                }, new
                {
                    CN_S_WAVE_CODE = entity.WaveNo
                }, trans);
            }
            if (!string.IsNullOrEmpty(entity.BoxNo))
            {
                //容器绑定
                CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                {
                    CN_S_SORTING_CODE = entity.SortingNo,
                    CN_S_STATE = Constants.TrayState_InUse
                }, new
                {
                    CN_S_TRAY_CODE = entity.BoxNo
                }, trans);
                Log.Info("SavePickData ", "容器绑定");
            }

        }

        #region (PDA汇聚)保存边拣边播
        /// <summary>
        /// (PDA汇聚)保存边拣边播
        /// </summary>
        /// <returns></returns>
        public OperateResult SaveBJBB(SavePickEntity entity)
        {
            Log.Info("保存边拣边播", "UseTransaction start");
            var operateResult = UseTransaction(trans =>
            {
                Log.Info("保存边拣边播", "保存边拣边播开始--------------------------------------------------------");
                //保存订单拣货明细
                CreateDAL<DapperDAL<TN_WM_ORDER_SORTING_RELEntity>>().AddRange(entity.OrderSortingRel, trans);
                Log.Info("SaveBJBB ", "保存订单拣货完成");
                //保存拣货信息
                SavePickData(entity, trans);

                Log.Info("保存边拣边播", "保存边拣边播结束--------------------------------------------------------");
            });

            #region 非自动库才会全部捡完才会解绑托盘和货位关系
            var currentArea = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(entity.CurrentSorting.CN_S_STOCK_AREA);
            //非自动库才会全部捡完才会解绑托盘和货位关系
            if (currentArea != null && currentArea.CN_C_IS_AUTO != Constants.Y && operateResult.Success && entity.TrayLocation != null)
            {
                var currentTrayItemMst = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                {
                    CN_S_TRAY_CODE = entity.TrayLocation.CN_S_TRAY_CODE
                });
                if (!currentTrayItemMst.Any())
                {
                    operateResult = UseTransaction(trans =>
                    {
                        CreateDAL<TN_WM_SORTING_LISTDAL>().ClearLocationByTrayCode(entity.TrayLocation, trans);
                    });
                }
            }
            #endregion

            return operateResult;
        }
        #endregion

        public OperateResult SaveXJHB(SavePickEntity entity)
        {
            Log.Info("保存先拣后播", "UseTransaction start");
            var operateResult = UseTransaction(trans =>
            {
                Log.Info("保存先拣后播", "保存先拣后播开始--------------------------------------------------------");
                //保存拣货信息
                SavePickData(entity, trans);
                Log.Info("保存边拣边播", "保存先拣后播结束--------------------------------------------------------");
            });

            #region 非自动库才会全部捡完才会解绑托盘和货位关系
            var currentArea = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(entity.CurrentSorting.CN_S_STOCK_AREA);
            //非自动库才会全部捡完才会解绑托盘和货位关系
            if (currentArea != null && currentArea.CN_C_IS_AUTO != Constants.Y && operateResult.Success && entity.TrayLocation != null)
            {
                var currentTrayItemMst = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                {
                    CN_S_TRAY_CODE = entity.TrayLocation.CN_S_TRAY_CODE
                });
                if (!currentTrayItemMst.Any())
                {
                    operateResult = UseTransaction(trans =>
                    {
                        CreateDAL<TN_WM_SORTING_LISTDAL>().ClearLocationByTrayCode(entity.TrayLocation, trans);
                    });
                }
            }
            #endregion

            return operateResult;
        }

        #region (PDA汇聚)分拣入
        /// <summary>
        /// (PDA汇聚)分拣回和搬运
        /// </summary>
        /// <param name="taskEntity"></param>
        /// <returns></returns>
        public OperateResult Transport(TN_WM_TASKEntity taskEntity)
        {
            return UseTransaction(trans =>
            {
                CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Add(taskEntity, trans);
                CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new
                {
                    CN_S_LOCATION_STATE = Constants.Location_State_InLock
                }, new
                {
                    taskEntity.CN_S_END_BIT
                }, trans);
                var sendAms = BLLCreator.Create<OtherSysApi>().SendAmsTask(taskEntity);
                if (!sendAms.Success)
                    throw new Exception(sendAms.Msg);
            });
        }
        #endregion

        #region 执行分拣单
        /// <summary>
        /// 执行分拣单
        /// </summary>
        /// <param name="sortingEntity"></param>
        /// <returns></returns>
        public OperateResult ExecuteSorting(TN_WM_SORTING_LISTEntity sortingEntity, List<TN_WM_B_TRAY_ITEM_MSTEntity> trayItem = null)
        {
            return UseTransaction(trans =>
            {
                //分拣单设为分拣中
                CreateDAL<DapperDAL<TN_WM_SORTING_LISTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                }, new
                {
                    CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                }, trans);
                //分拣单子表设为分拣中
                CreateDAL<DapperDAL<TN_WM_SORTING_DTLEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                }, new
                {
                    CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                }, trans);
                //波次设为分拣中
                CreateDAL<DapperDAL<TN_WM_WAVE_MSTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                }, new
                {
                    CN_S_WAVE_NO = sortingEntity.CN_S_FROM_NO
                }, trans);
                //出库单分拣中
                CreateDAL<DapperDAL<TN_WM_OUT_MSTEntity>>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                }, new
                {
                    CN_S_WAVE_CODE = sortingEntity.CN_S_FROM_NO
                }, trans);

                //生成分拣单明细
                //if (sortingEntity.SortingLocationList != null)
                //    CreateDAL<DapperDAL<TN_WM_SORTING_LOCATIONEntity>>().AddRange(sortingEntity.SortingLocationList, trans);
                //托盘物料分配量上升
                //if (trayItem != null)
                //    CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().UpdateTrayItemAllocQty(trayItem, trans);

                //生成任务
                if (sortingEntity.Tasks.Any())
                {
                    //增加出库任务
                    CreateDAL<DapperDAL<TN_WM_TASKEntity>>().AddRange(sortingEntity.Tasks, trans);
                    //起点置为预出库锁定,终点预入库锁定
                    foreach (var task in sortingEntity.Tasks)
                    {
                        CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                        }, new
                        {
                            CN_S_LOCATION_CODE = task.CN_S_START_BIT
                        }, trans);
                        //存在终点
                        if (!string.IsNullOrEmpty(task.CN_S_END_BIT))
                        {
                            CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new
                            {
                                CN_S_LOCATION_STATE = Constants.Location_State_InLock
                            }, new
                            {
                                CN_S_LOCATION_CODE = task.CN_S_END_BIT
                            }, trans);

                            //发送ams任务
                            var sendAms = BLLCreator.Create<OtherSysApi>().SendAmsTask(task);
                            if (!sendAms.Success)
                                throw new Exception(sendAms.Msg);
                        }
                    }

                }
            });
        }
        #endregion

        #region 合箱
        /// <summary>
        /// 合箱
        /// </summary>
        /// <param name="sortingResult"></param>
        /// <param name="sortingPicked"></param>
        /// <returns></returns>
        public OperateResult MergeBox(List<TN_WM_SORTING_RESULTEntity> sortingResult, bool sortingPicked, bool wavePicked, string waveNo)
        {
            return UseTransaction(trans =>
            {
                //分拣结果绑定周转箱
                CreateDAL<TN_WM_SORTING_LISTDAL>().MergeBox(sortingResult, trans);
                if (sortingPicked)
                    //分拣单设为已分拣
                    CreateDAL<DapperDAL<TN_WM_SORTING_LISTEntity>>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_SORTING_NO = sortingResult[0].CN_S_SORTING_NO
                    }, trans);
                //波次捡完置为已分拣
                if (wavePicked)
                    CreateDAL<DapperDAL<TN_WM_WAVE_MSTEntity>>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_WAVE_NO = waveNo
                    }, trans);
            });
        }
        #endregion

        #region 根据托盘获取分拣中的分拣单数据
        /// <summary>
        /// 根据托盘获取分拣中的分拣单数据
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        public List<TN_WM_SORTING_LISTEntity> GetPickDataByTray(string trayCode)
        {
            //分拣单
            var sortings = CreateDAL<TN_WM_SORTING_LISTDAL>().GetPickSortingByTray(trayCode);
            if (!sortings.Any()) return null;
            //分拣单子表
            var sortingDtls = CreateDAL<DapperDAL<TN_WM_SORTING_DTLEntity>>().GetList(new
            {
                CN_S_SORTING_NO = sortings.Select(s => s.CN_S_SORTING_NO).ToList()
            });
            //分拣明细
            var sortingLocations = CreateDAL<DapperDAL<TN_WM_SORTING_LOCATIONEntity>>().GetList(new
            {
                CN_S_SORTING_NO = sortings.Select(s => s.CN_S_SORTING_NO).ToList()
            });
            //分拣结果
            var sortingResults = CreateDAL<DapperDAL<TN_WM_SORTING_RESULTEntity>>().GetList(new
            {
                CN_S_SORTING_NO = sortings.Select(s => s.CN_S_SORTING_NO).ToList()
            });
            //赋值
            sortings.ForEach(e =>
            {
                e.SortingDtlList = sortingDtls.Where(w => w.CN_S_SORTING_NO == e.CN_S_SORTING_NO).ToList();
                e.SortingLocationList = sortingLocations.Where(w => w.CN_S_SORTING_NO == e.CN_S_SORTING_NO).ToList();
                e.SortingResultList = sortingResults.Where(w => w.CN_S_SORTING_NO == e.CN_S_SORTING_NO).ToList();
            });
            return sortings;
        }
        #endregion

        #region (cs端)先拣后播扫物料
        /// <summary>
        /// (cs端)先拣后播扫物料
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public OperateResult ScanItem(SavePickEntity entity)
        {
            var operateResult = UseTransaction(trans =>
           {
               //保存分拣结果
               CreateDAL<DapperDAL<TN_WM_SORTING_RESULTEntity>>().AddRange(entity.SortingResult, trans);
               //下降托盘物料数据量
               Log.Info("ScanItem 下降托盘物料数据量数据:trayItemMstList", JsonConvert.SerializeObject(entity.TrayItemList));
               Log.Info("ScanItem 下降托盘物料数据量数据:currentTrayLocation", JsonConvert.SerializeObject(entity.TrayLocation));
               CreateDAL<TN_WM_SORTING_LISTDAL>().DropTrayItemQty(entity.TrayItemList, entity.TrayLocation, trans);
               Log.Info("ScanItem ", "下降托盘物料数据量");
           });

            #region 非自动库才会全部捡完才会解绑托盘和货位关系
            var currentArea = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(entity.CurrentSorting.CN_S_STOCK_AREA);
            //非自动库才会全部捡完才会解绑托盘和货位关系
            if (currentArea != null && currentArea.CN_C_IS_AUTO != Constants.Y && operateResult.Success && entity.TrayLocation != null)
            {
                var currentTrayItemMst = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                {
                    CN_S_TRAY_CODE = entity.TrayLocation.CN_S_TRAY_CODE
                });
                if (!currentTrayItemMst.Any())
                {
                    operateResult = UseTransaction(trans =>
                    {
                        CreateDAL<TN_WM_SORTING_LISTDAL>().ClearLocationByTrayCode(entity.TrayLocation, trans);
                    });
                }
            }
            #endregion

            return operateResult;
        }
        #endregion

        #region (cs端)先拣后播扫周转箱
        /// <summary>
        /// (cs端)先拣后播扫周转箱
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public OperateResult ScanTurnoverBox(SavePickEntity entity)
        {
            return UseTransaction(trans =>
            {
                //分拣单全部捡完
                if (entity.SortingPicked)
                {
                    //修改分拣单状态为已分拣
                    CreateDapperDAL<TN_WM_SORTING_LISTEntity>().Update(new
                    {
                        CN_S_STATE = Constants.Sorting_Sorted
                    }, new
                    {
                        CN_S_SORTING_NO = entity.SortingNo
                    }, trans);
                    //波次值为已分拣
                    if (entity.WavePicked)
                    {
                        CreateDapperDAL<TN_WM_WAVE_MSTEntity>().Update(new
                        {
                            CN_S_STATE = Constants.Sorting_Sorted
                        }, new
                        {
                            CN_S_WAVE_NO = entity.CurrentSorting.CN_S_FROM_NO
                        }, trans);
                    }
                    //外销时
                    if (entity.IsWx)
                    {
                        //出库订单，减少库存业务表状态置为 “预出库”状态
                        CreateDapperDAL<TN_WM_OUT_MSTEntity>().Update(new
                        {
                            CN_S_STATE = Constants.State_PreOut
                        }, new
                        {
                            CN_S_OP_NO = entity.OutMst.CN_S_OP_NO
                        }, trans);
                        CreateDapperDAL<TN_WM_OUT_DTLEntity>().Update(new
                        {
                            CN_S_STATE = Constants.State_PreOut
                        }, new
                        {
                            CN_S_OP_NO = entity.OutMst.CN_S_OP_NO
                        }, trans);
                        CreateDapperDAL<TN_WM_REDUCE_INVENTORY_MSTEntity>().Update(new
                        {
                            CN_S_STATE = Constants.State_PreOut
                        }, new
                        {
                            CN_S_FROM_NO = entity.OutMst.CN_S_OP_NO
                        }, trans);
                    }
                }
                //合箱
                foreach (var s in entity.SortingResult)
                {
                    CreateDapperDAL<TN_WM_SORTING_RESULTEntity>().Update(new
                    {
                        CN_S_TURNOVERBOX_CODE = entity.BoxNo
                    }, new
                    {
                        CN_GUID = s.CN_GUID
                    }, trans);
                }
                //设置容器状态绑定
                CreateDapperDAL<TN_WM_B_TRAY_INFOEntity>().Update(new
                {
                    CN_S_STATE = Constants.TrayState_InUse,
                    CN_S_SORTING_CODE = entity.SortingNo
                }, new
                {
                    CN_S_TRAY_CODE = entity.BoxNo
                }, trans);
                //设置分拣单周转箱位置
                CreateDapperDAL<TN_WM_SORTING_LISTEntity>().Update(new
                {
                    CN_S_COLLECT_LOCATION = entity.EndBit
                }, new
                {
                    CN_S_SORTING_CODE = entity.SortingNo
                }, trans);
                //当前位置预出库锁定
                CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                {
                    CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                }, new
                {
                    CN_S_LOCATION_CODE = entity.StartBit
                }, trans);
                //终点位置与入库锁定
                CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                {
                    CN_S_LOCATION_STATE = Constants.Location_State_InLock
                }, new
                {
                    CN_S_LOCATION_CODE = entity.EndBit
                }, trans);
            });
        }
        #endregion

        #region 获取任务
        /// <summary>
        /// 获取任务
        /// </summary>
        /// <param name="sortingEntity"></param>
        /// <param name="endAreas"></param>
        /// <returns></returns>
        public OperateResult GetOutTask(ref TN_WM_SORTING_LISTEntity sortingEntity, ref List<string> endAreas, string endArea = "", string endBit = "")
        {
            try
            {
                //当前分拣单库区
                var currentArea = BLLCreator.Create<MongoBLL>().GetArea(sortingEntity.CN_S_STOCK_AREA);
                if (currentArea == null)
                    return OperateResult.Error("未找到库区：" + sortingEntity.CN_S_STOCK_AREA);

                //托盘货位分组
                var trayGroup = sortingEntity.SortingLocationList.GroupBy(g => new
                {
                    g.CN_S_SORTING_NO,
                    g.CN_S_TRAY_CODE,
                    g.CN_S_LOCATION_CODE
                }).Select(s => new
                {
                    s.Key.CN_S_SORTING_NO,
                    s.Key.CN_S_TRAY_CODE,
                    s.Key.CN_S_LOCATION_CODE,
                    CN_F_QUANTITY = s.Sum(m => m.CN_F_QUANTITY)
                });
                List<TN_WM_TASKEntity> taskList = new List<TN_WM_TASKEntity>();
                //存在非整托货位托盘
                var pickTrays = trayGroup
                    .Select(e => new TN_WM_SORTING_LOCATIONEntity()
                    {
                        CN_S_SORTING_NO = e.CN_S_SORTING_NO,
                        CN_S_TRAY_CODE = e.CN_S_TRAY_CODE,
                        CN_S_LOCATION_CODE = e.CN_S_LOCATION_CODE,
                    }).ToList();
                if (pickTrays.Any())
                {
                    #region  根据终点货位生成任务
                    if (string.IsNullOrEmpty(endArea))
                    {
                        //有终点货位，直接找库区
                        if (!string.IsNullOrEmpty(endBit))
                        {
                            var locationEntity = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetLocationModel(endBit);
                            if (locationEntity == null)
                                return OperateResult.Error("未找到货位：" + endBit);
                            endArea = locationEntity.CN_S_AREA_CODE;
                        }
                        else
                        {
                            //非整托任务
                            WorkflowEntity workflowEntity = new WorkflowEntity(Constants.Workflow_Out)
                            {
                                CirObj = Constants.Tray,
                                StartArea = currentArea.CN_S_AREA_CODE,
                                ReturnList = true
                            };
                            //找站点 GetWorkPosition
                            var trayWorkflow = BLLCreator.Create<WorkflowBLL>().GetWorkPosition(workflowEntity);
                            if (!trayWorkflow.Success) return trayWorkflow;
                            var workAreaPro = trayWorkflow.GetData<List<TN_WM_WORK_AREA_PROEntity>>();
                            endAreas.AddRange(workAreaPro.Select(s => s.CN_S_END_AREA_CODE).ToList());
                            endArea = workAreaPro[0].CN_S_END_AREA_CODE;
                        }
                    }
                    else
                    {
                        endAreas.Add(endArea);
                    }
                    #endregion
                    #region 根据终点库区生成任务
                    if (string.IsNullOrEmpty(endBit))
                    {
                        //存在任务调度策略时，不生成货位，通过服务去生成
                        var taskDispatch = GetStrategy(sortingEntity.CN_S_STOCK_CODE,
                              StrategyKey.TaskDispatch);
                        if (taskDispatch != Constants.Y)
                        {
                            //需要调作业区入库算法，算出货位给出库任务
                            var inAssignEntity = new InAssignEntity
                            {
                                objectType = InAssignEntity.ObjectType.托盘,
                                objectCode = pickTrays[0].CN_S_TRAY_CODE,
                                lockLocation = false,
                                lstAreaPrior = new List<areaPriorClass>()
                                    {
                                        {
                                            new areaPriorClass{
                                                  areaCode = endArea,
                                                  Prior = 1
                                            }
                                        }
                                    }
                            };
                            Log.Info("调用算法InAssign参数", JsonConvert.SerializeObject(inAssignEntity));
                            InAssignResultEntity inAssignResultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(inAssignEntity);
                            Log.Info("调用算法InAssign结果", JsonConvert.SerializeObject(inAssignResultEntity));
                            if (!inAssignResultEntity.Success) return OperateResult.Error(inAssignResultEntity.Msg);
                            endBit = inAssignResultEntity.locationCode;
                        }
                    }
                    #endregion
                    //分拣出库任务
                    var pickTasks = GetTaskEntity(sortingEntity.CN_S_STOCK_AREA, endArea, pickTrays, endBit);

                    taskList.AddRange(pickTasks);
                }

                sortingEntity.Tasks = taskList;
                sortingEntity.EndBits = endAreas;

                return OperateResult.Succeed(null, taskList);

            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 获取任务实体
        /// <summary>
        /// 获取任务实体
        /// </summary>
        /// <param name="workArea"></param>
        /// <param name="sortingEntity"></param>
        /// <returns></returns>
        private List<TN_WM_TASKEntity> GetTaskEntity(string startArea, string endArea, List<TN_WM_SORTING_LOCATIONEntity> sortingLocations, string endBit = "")
        {
            var trayLocationGroup = sortingLocations.GroupBy(g => new
            {
                g.CN_S_TRAY_CODE,
                g.CN_S_LOCATION_CODE,
                g.CN_S_SORTING_NO
            }).Select(s => new
            {
                s.Key.CN_S_TRAY_CODE,
                s.Key.CN_S_LOCATION_CODE,
                s.Key.CN_S_SORTING_NO
            });
            List<TN_WM_TASKEntity> taskList = new List<TN_WM_TASKEntity>();
            foreach (var task in trayLocationGroup)
            {
                string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_OutTaskNo + "\",\"orgId\":\"\",\"orgFlag\":\"\"}";
                string taskNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
                AutoBomStockAreaEntity startAreaE = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(startArea);
                AutoBomStockAreaEntity endAreaE = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(endArea);
                TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = taskNo,
                    CN_S_TASK_TYPE = Constants.TaskType_SortingOut,
                    CN_S_FROM_OP = Constants.Out,
                    CN_S_FROM_NO = task.CN_S_SORTING_NO,
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STOCK_CODE = BLLCreator.Create<MongoBLL>().GetArea(endArea).CN_S_STOCK_CODE,
                    CN_S_START_AREA = startArea,
                    CN_S_START_BIT = task.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = endArea,
                    CN_S_END_BIT = endBit,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_START_AREA_TYPE = startAreaE.CN_S_STRUCTURE,
                    CN_S_END_AREA_TYPE = endAreaE.CN_S_STRUCTURE,
                    CN_C_START_IS_CONTROL_QTY = startAreaE.CN_C_IS_CONTROL_QTY,
                    CN_C_END_IS_CONTROL_QTY = endAreaE.CN_C_IS_CONTROL_QTY,
                    CN_S_START_CONTROL_INV = startAreaE.CN_C_IS_INVENTORY,
                    CN_S_END_CONTROL_INV = endAreaE.CN_C_IS_INVENTORY,
                    EndAreaEntity = endAreaE
              
                };
                taskList.Add(taskEntity);
            }
            return taskList;
        }
        #endregion

        #region 出库单获取分拣明细
        /// <summary>
        /// 出库单获取分拣明细
        /// </summary>
        /// <param name="outNo"></param>
        /// <returns></returns>
        public List<TN_WM_SORTING_LOCATIONEntity> GetTrayLocationByOut(string outNo)
        {
            return CreateDAL<TN_WM_SORTING_LISTDAL>().GetTrayLocationByOut(outNo);
        }
        #endregion

        #region 批分托盘物料关联(不含三生拆包部分)
        /// <summary>
        /// 批分托盘物料关联(不含三生拆包部分)
        /// </summary>
        /// <param name="sortingResult"></param>
        /// <returns></returns>
        public List<TN_WM_B_TRAY_ITEM_MSTEntity> BatchesTrayItemByResult(List<TN_WM_SORTING_RESULTEntity> sortingResult)
        {
            //算法策略
            List<string> lstStrate = BLLCreator.Create<SysMgr.TN_WM_B_STRATEGYBLL>().GetStrateListByAreaOrStock("", "", Constants.Out)
                 .OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();

            //分拣结果的托盘物料关联数据
            var trayItemMstList = BLLCreator.CreateDapper<TN_WM_B_TRAY_ITEM_MSTEntity>().GetList(new
            {
                CN_S_TRAY_CODE = sortingResult.Select(x => x.CN_S_TRAY_CODE).ToList(),
                CN_S_ITEM_CODE = sortingResult.Select(x => x.CN_S_ITEM_CODE).ToList()
            });

            foreach (var trayItemMst in trayItemMstList)
            {
                trayItemMst.TrayItemDtlList = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
                //属于当前托盘,当前物料的分拣明细
                var currentSortingResult = sortingResult.Where(x => x.CN_S_ITEM_CODE == trayItemMst.CN_S_ITEM_CODE && x.CN_S_TRAY_CODE == trayItemMst.CN_S_TRAY_CODE);
                decimal qty = currentSortingResult.Sum(y => y.CN_F_QUANTITY);
                if (trayItemMst.CN_F_QUANTITY >= qty &&
                    trayItemMst.CN_F_ALLOC_QTY >= qty)
                {
                    trayItemMst.CN_F_QUANTITY -= qty;
                    trayItemMst.CN_F_ALLOC_QTY -= qty;

                    Log.Info("确认分拣", "0001");
                    trayItemMst.TrayItemDtlList = BLLCreator.CreateDapper<TN_WM_B_TRAY_ITEM_DTLEntity>().GetList(new
                    {
                        CN_PARENT_GUID = trayItemMst.CN_GUID
                    }).OrderBy(x => x.CN_S_LOT_NO).ToList();

                    Log.Info("确认分拣", "0002");
                    //空的生产批次放后面
                    currentSortingResult = currentSortingResult.Select(x => new
                    {
                        index = string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) ? 0 : 1,
                        x
                    }).OrderByDescending(y => y.index).ThenBy(z => z.x.CN_S_PRODUCTION_BATCH).Select(m => m.x);
                    Log.Info("确认分拣", "0003");
                    foreach (string stegy in lstStrate)
                    {
                        //逐个策略进行计算
                        switch (stegy)
                        {
                            case "FirstInFirstOut":
                                trayItemMst.TrayItemDtlList = trayItemMst.TrayItemDtlList.OrderBy(o => o.CN_S_LOT_NO).ToList();
                                break;
                            case "FirstWarrantFirstOut":
                                trayItemMst.TrayItemDtlList = trayItemMst.TrayItemDtlList.Select(x => new
                                {
                                    index = string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) ? 0 : 1,
                                    x
                                }).OrderByDescending(y => y.index).ThenBy(z => z.x.CN_S_PRODUCTION_BATCH).Select(m => m.x).ToList();
                                break;
                        }
                    }
                    Log.Info("确认分拣", "0004");
                    foreach (var cs in currentSortingResult)
                    {
                        var csQty = cs.CN_F_QUANTITY;

                        foreach (var trayItemDtl in trayItemMst.TrayItemDtlList)
                        {
                            if (csQty == 0) break;
                            if (trayItemDtl.CN_F_QUANTITY == 0) continue;
                            if (trayItemDtl.CN_F_QUANTITY >= csQty)
                            {
                                trayItemDtl.CN_F_QUANTITY -= csQty;
                                csQty = 0;
                            }
                            else
                            {
                                csQty -= trayItemDtl.CN_F_QUANTITY;
                                trayItemDtl.CN_F_QUANTITY = 0;
                            }
                        }
                    }
                }
            }
            return trayItemMstList;

        }
        #endregion

        #region 根据库区算法结果生成分拣单数据
        /// <summary>
        /// 根据库区算法结果生成分拣单数据
        /// </summary>
        /// <param name="outAreaResultList"></param>
        /// <param name="user"></param>
        /// <param name="waveNo"></param>
        /// <returns></returns>
        public OperateResult GetSortingData(List<OutAreaResultEntity> outAreaResultList, UserRuleEntity user, string waveNo, string taskEndBit = "")
        {
            try
            {
                List<TN_WM_SORTING_LISTEntity> sortingList = new List<TN_WM_SORTING_LISTEntity>();
                user.RuleCode = Constants.SortingGroup;
                //分拣单组别
                string sortingGroup = user.GenerateNo();
                user.RuleCode = Constants.SortingNo;
                int sortingIndex = 1;
                IEnumerable<IGrouping<dynamic, OutAreaResultEntity>> igOutAreaResult = outAreaResultList.GroupBy(x => new { x.stockCode, x.areaCode });
                foreach (var _igOutAreaResult in igOutAreaResult)
                {
                    //分拣单
                    TN_WM_SORTING_LISTEntity sortingEntity = new TN_WM_SORTING_LISTEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_S_SORTING_NO = waveNo + "-" + sortingIndex++,
                        CN_S_OP_FROM = Constants.Rule_WaveNo,
                        CN_S_FROM_NO = waveNo,
                        CN_T_OPERATE = DateTime.Now.ToString(),// "", //丢里咯木
                        CN_S_STOCK_CODE = _igOutAreaResult.Key.stockCode,
                        CN_S_STOCK_AREA = _igOutAreaResult.Key.areaCode,
                        CN_S_STATE = Constants.Sorting_Stay,
                        CN_S_SEEDING_MODE = "",
                        CN_S_GROUP = sortingGroup,
                        CN_S_CREATOR = user.LoginCode,
                        CN_S_CREATOR_BY = user.LoginName,
                        CN_T_CREATE = DateTime.Now,
                        CN_S_MODIFY = user.LoginCode,
                        CN_S_MODIFY_BY = user.LoginName,
                        CN_T_MODIFY = DateTime.Now
                    };
                    //分拣单子表行索引
                    int sortingDtlindex = 1;
                    //分拣单子表
                    sortingEntity.SortingDtlList = new List<TN_WM_SORTING_DTLEntity>();
                    //分拣明细
                    sortingEntity.SortingLocationList = new List<TN_WM_SORTING_LOCATIONEntity>();
                    foreach (var outArea in _igOutAreaResult.AsEnumerable())
                    {
                        foreach (var d in outArea.lstItem)
                        {
                            //物料详细
                            AutoBomItemEntity item = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(d.itemCode) ?? new AutoBomItemEntity();
                            //分拣单子行
                            TN_WM_SORTING_DTLEntity sortingDtlEntity = new TN_WM_SORTING_DTLEntity()
                            {
                                CN_GUID = Guid.NewGuid().ToString(),
                                CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO,
                                CN_N_ROW_NO = sortingDtlindex++,
                                CN_F_QUANTITY = d.itemQty,
                                CN_S_ITEM_CODE = d.itemCode,
                                CN_S_ITEM_NAME = item.CN_S_ITEM_NAME,
                                CN_S_STATE = Constants.Sorting_Stay,
                                CN_S_LOT_NO = outArea.batchCode,
                                CN_S_PRODUCTION_BATCH = outArea.prodBatchCode,
                                CN_S_ITEM_STATE = outArea.itemState,
                                CN_S_OWNER = outArea.ownerName,
                                CN_S_MODEL = item.CN_S_MODEL,
                                CN_S_FIGURE_NO = item.CN_S_FIGURE_NO,
                                CN_S_MEASURE_UNIT = item.CN_S_MEASURE_UNIT
                            };
                            sortingEntity.SortingDtlList.Add(sortingDtlEntity);
                        }
                    }

                    #region 生成分拣明细
                    //调用算法获取分拣明细,分拣明细改到执行分拣单的时候生成
                    var sortingLocationResult = BLLCreator.Create<TN_WM_SORTING_LISTBLL>().GetSortingLocation(sortingEntity, user);
                    if (!sortingLocationResult.Success)
                        return sortingLocationResult;
                    var sortingLocations = sortingLocationResult.GetData<List<TN_WM_SORTING_LOCATIONEntity>>();
                    sortingEntity.SortingLocationList.AddRange(sortingLocations);
                    #endregion

                    #region 自动库需要生成出库任务
                    //生成任务
                    //List<string> endAreas = new List<string>();
                    //var outTaskResult = GetOutTask(ref sortingEntity, ref endAreas, taskEndBit);
                    //if (!outTaskResult.Success)
                    //{
                    //    return outTaskResult;
                    //}
                    #endregion

                    sortingList.Add(sortingEntity);
                }
                return OperateResult.Succeed(null, sortingList);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 调算法获取分拣明细
        /// <summary>
        ///调算法获取分拣明细
        /// </summary>
        /// <param name="sortingEntity"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public OperateResult GetSortingLocation(TN_WM_SORTING_LISTEntity sortingEntity, UserRuleEntity user)
        {
            try
            {
                List<TN_WM_SORTING_LOCATIONEntity> sortingLocationList = new List<TN_WM_SORTING_LOCATIONEntity>();
                if (!sortingEntity.SortingDtlList.Any())
                    sortingEntity.SortingDtlList = BLLCreator.CreateDapper<TN_WM_SORTING_DTLEntity>().GetList(new
                    {
                        CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                    });
                //初始化调用算法数据
                List<itemQueryClass> algorItems = sortingEntity.SortingDtlList.GroupBy(x => new
                {
                    x.CN_S_ITEM_CODE,
                    x.CN_S_ITEM_STATE,
                    x.CN_S_OWNER,
                    x.CN_S_LOT_NO,
                    x.CN_S_PRODUCTION_BATCH
                }).Select(y => new itemQueryClass()
                {
                    stockCode = sortingEntity.CN_S_STOCK_CODE,
                    areaCode = sortingEntity.CN_S_STOCK_AREA,
                    itemCode = y.Key.CN_S_ITEM_CODE,
                    batchCode = y.Key.CN_S_LOT_NO,
                    prodBatchCode = y.Key.CN_S_PRODUCTION_BATCH,
                    itemState = y.Key.CN_S_ITEM_STATE,
                    ownerName = y.Key.CN_S_OWNER,
                    itemQty = y.Sum(z => z.CN_F_QUANTITY)
                }).ToList();
                var lstAreaPrior = algorItems.Select(x => new areaPriorClass()
                {
                    areaCode = x.areaCode,
                    Prior = 1
                }).ToList();

                Log.Info("调用OutNew参数 algorItems", JsonConvert.SerializeObject(algorItems));
                var outResult = BLLCreator.Create<Out_AlgorBLL>().OutNew(new OutAlgorEnitty()
                {
                    lstDevice = new List<Device>(),
                    lstAreaPrior = lstAreaPrior,
                    lstQueryItem = algorItems,
                    lockLocation = false
                });
                Log.Info("调用OutNew返回值 outResult", JsonConvert.SerializeObject(outResult));
                if (outResult.lstItemNotEnough.Any())
                {
                    outResult.lstItemNotEnough.ForEach(x =>
                    {
                        var currentNotEnough = sortingEntity.SortingDtlList.Find(s => s.CN_S_ITEM_CODE.Equals(x.itemCode));
                        if (currentNotEnough != null)
                            x.itemName = currentNotEnough.CN_S_ITEM_NAME;
                    });
                    return OperateResult.Warning("物料：" + string.Join(";", outResult.lstItemNotEnough.Select(x => x.itemCode)) + "库存不足，请先完成来料区的上架", outResult.lstItemNotEnough);
                }
                if (!outResult.Success)
                    return OperateResult.Error("算法异常：" + outResult.Msg);

                if (sortingEntity.SortingDtlList.Sum(x => x.CN_F_QUANTITY) != Convert.ToDecimal(outResult.itemLocations.Sum(x => x.itemQty)))
                {
                    return OperateResult.Error("算法异常：返回的物料信息不完整！");
                }
                var locations = outResult.itemLocations.Select(m =>
                {
                    AutoBomItemEntity mm = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(m.itemCode) ?? new AutoBomItemEntity();
                    return new TN_WM_SORTING_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_S_LOT_NO = m.batchCode,
                        CN_S_ITEM_STATE = m.itemState,
                        CN_S_OWNER = m.ownerName,
                        CN_F_QUANTITY = m.itemQty,
                        CN_F_PICKED_QTY = 0,
                        CN_S_ITEM_CODE = m.itemCode,
                        CN_S_LOCATION_CODE = m.locationCode,
                        CN_S_TRAY_CODE = m.trayCode,
                        CN_S_TRAY_GRID = m.trayGrid,
                        CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO,
                        CN_S_STATE = sortingEntity.CN_S_STATE,
                        CN_S_ORDER_NO = "",
                        CN_S_CREATOR = user.LoginCode,
                        CN_S_CREATOR_BY = user.LoginName,
                        CN_S_ITEM_NAME = mm.CN_S_ITEM_NAME,
                        CN_S_MODEL = mm.CN_S_MODEL,
                        CN_S_FIGURE_NO = mm.CN_S_FIGURE_NO,
                        CN_S_MEASURE_UNIT = mm.CN_S_MEASURE_UNIT,
                        CN_S_PACKING_UNIT = m.packUnit,
                        CN_F_PACKING_QTY = m.packQty,
                        CN_S_PRODUCTION_BATCH = m.prodBatchCode,
                        CN_T_CREATE = DateTime.Now,
                        CN_T_MODIFY = DateTime.Now
                    };
                }).ToList();
                sortingLocationList.AddRange(locations);
                return OperateResult.Succeed(null, sortingLocationList);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion



    }
}