using HH.Redis.ReisModel;
using HH.WMS.BLL;
using HH.WMS.BLL.Algorithm;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.Common;
using HH.WMS.BLL.OutStock;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.Algorithm.Out;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.Entitys.Entitys.PrintDataSource;
using HH.WMS.WebApi.Areas.Common.Controllers;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.OutStock.Controllers
{
    public class WaveController : BaseController
    {
        #region 打单
        /// <summary>
        /// 打单
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public OperateResult CreateBill(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {
                //出库订单，可能多个
                string opNos = Util.ToString(postEntity.PostData.opNos);
                //打印机
                string printer = Util.ToString(postEntity.PostData.printer);
                //打印模板
                string printTemplet = Util.ToString(postEntity.PostData.printTemplet);
                if (string.IsNullOrEmpty(opNos))
                    return OperateResult.Error("出库订单号不可为空");
                //登陆信息&生成单号
                UserRuleEntity user = new UserRuleEntity()
                {
                    LoginCode = Util.ToString(t.CN_S_LOGIN).Trim(),
                    LoginName = Util.ToString(t.CN_S_NAME).Trim(),
                    OrgCode = Util.ToString(t.CN_S_ORGCODE).Trim(),
                    OrgFlag = Util.ToString(t.CN_S_ORGFLAG).Trim(),
                    RuleCode = Constants.Rule_WaveNo
                };
                //生成波次号
                string waveNo = user.GenerateNo();
                if (string.IsNullOrEmpty(waveNo))
                    return OperateResult.Error("生成波次号失败");

                return ChangeOutOperate(opNos, (outMstList, batchesList, stockList, lstStrate) =>
                {
                    //if (outMstList.GroupBy(x => x.CN_S_CUSTOMER).Count() != 1)
                    //    return OperateResult.Error("请选择同一客户的出库单");
                    //反批分分配量，并且生成出库单
                    var bResult = stockList.BatchesStockQty(batchesList, BatchesType.ReverseBatch, StockBatchesField.AllocationQty, lstStrate, true);
                    if (!bResult.Success)
                        return bResult;
                    //批分结果数据
                    var batchesResult = bResult.GetData<BatchesResult>();
                    if (batchesResult == null)
                        return OperateResult.Error("生成打单数据异常");
                    //出库单子表数据
                    List<TN_WM_REDUCE_INVENTORY_DTLEntity> reduceInventoryDtlList = new List<TN_WM_REDUCE_INVENTORY_DTLEntity>();
                    batchesResult.ReduceInventoryMstList.ForEach(p =>
                    {
                        reduceInventoryDtlList.AddRange(p.DTLEntity);
                    });
                    batchesResult.ReduceInventoryDtlList = reduceInventoryDtlList;
                    //出库订单子表数据
                    List<TN_WM_OUT_DTLEntity> outDtlAllList = new List<TN_WM_OUT_DTLEntity>();
                    outMstList.ForEach(p =>
                    {
                        //子表货主赋值
                        p.OutDtlList.ForEach(q => q.CN_S_OWNER = p.CN_S_OWNER);
                        outDtlAllList.AddRange(p.OutDtlList);
                    });
                    //初始化调用算法数据
                    List<itemQueryClass> itemQuerys =
                    outDtlAllList.GroupBy(p => new
                    {
                        p.CN_S_ITEM_CODE,
                        p.CN_S_ITEM_STATE,
                        p.CN_S_OWNER,
                        p.CN_S_LOT_CODE,
                        p.CN_S_PRODUCTION_BATCH
                    })
                     .Select(x => new itemQueryClass()
                     {
                         itemCode = x.Key.CN_S_ITEM_CODE,
                         batchCode = x.Key.CN_S_LOT_CODE,
                         prodBatchCode = x.Key.CN_S_PRODUCTION_BATCH,
                         itemState = x.Key.CN_S_ITEM_STATE,
                         ownerName = x.Key.CN_S_OWNER,
                         stockCode = batchesResult.OutMstList[0].CN_S_STOCK_CODE,
                         itemQty = x.Sum(y => y.CN_F_QUANTITY)
                     }).ToList();
                    var allArea = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetArea(4, batchesResult.OutMstList[0].CN_S_STOCK_CODE);
                    List<areaPriorClass> lstAreaPrior = allArea.Select(p => new areaPriorClass()
                    {
                        areaCode = p.CN_S_AREA_CODE,
                        Prior = p.CN_N_PRIORITY
                    }).ToList();
                    Log.Info("调用OutArea参数 itemQuerys", JsonConvert.SerializeObject(itemQuerys));
                    Log.Info("调用OutArea参数 lstAreaPrior", JsonConvert.SerializeObject(lstAreaPrior));
                    //调用出库算法
                    var algorResultEntity = BLLCreator.Create<Out_AlgorBLL>().OutArea(itemQuerys, lstAreaPrior);

                    if (!algorResultEntity.Success)
                        return OperateResult.Error("算法异常：" + algorResultEntity.Msg);
                    Log.Info("调用OutArea返回值 algorResultEntity", JsonConvert.SerializeObject(algorResultEntity));
                    //算法结果
                    var algorResult = algorResultEntity.itemOutAreaResult;
                    Log.Info("调用OutArea返回值 algorResult", JsonConvert.SerializeObject(algorResult));

                    if (algorResult == null)
                        return OperateResult.Error("库存不足，请先完成来料区的上架");

                    //获取分拣单数据
                    var sortingDataResult = BLLCreator.Create<TN_WM_SORTING_LISTBLL>().GetSortingData(algorResult, user, waveNo);
                    if (!sortingDataResult.Success)
                        return sortingDataResult;

                    //生成的分拣单数据
                    var sortingList = sortingDataResult.GetData<List<TN_WM_SORTING_LISTEntity>>();
                    List<string> itemCodes = new List<string>();
                    sortingList.ForEach(x =>
                    {
                        if (x.SortingDtlList != null)
                            x.SortingDtlList.ForEach(y =>
                            {
                                itemCodes.Add(y.CN_S_ITEM_CODE);
                            });
                    });
                    //分拣单的所有库区量表数据
                    var stockAreaList = BLLCreator.Create<DapperBLL<TN_WM_B_AREA_QTYEntity>>().GetList(new
                    {
                        CN_S_STOCK_AREA = sortingList.Select(x => x.CN_S_STOCK_AREA).ToList(),
                        CN_S_ITEM_CODE = itemCodes
                    });

                    //批分库区量表结果
                    //List<TN_WM_B_OUTLOCKING_DTLEntity> outLockList = new List<TN_WM_B_OUTLOCKING_DTLEntity>();
                    Log.Info("批分库区参数 sortingList:", JsonConvert.SerializeObject(sortingList));
                    Log.Info("批分库区参数 lstStrate:", JsonConvert.SerializeObject(lstStrate));
                    var batchesAreaResult = stockAreaList.BatchesAreaQty(sortingList, lstStrate);
                    if (!batchesAreaResult.Success)
                        return batchesAreaResult;
                    Log.Info("批分库区结果 batchesAreaResult:", JsonConvert.SerializeObject(batchesAreaResult));


                    //批分托盘物料分配量，改到执行分拣单的时候分配
                    var sortingLocations = new List<TN_WM_SORTING_LOCATIONEntity>();
                    sortingList.ForEach(x => { sortingLocations.AddRange(x.SortingLocationList); });
                    //组织批分实体
                    var batchesTrayItem = sortingLocations.Select(x => new BatchesEntity()
                    {
                        TrayCode = x.CN_S_TRAY_CODE,
                        ItemCode = x.CN_S_ITEM_CODE,
                        Qty = x.CN_F_QUANTITY
                    }).ToList();
                    var trayItem = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                    {
                        CN_S_ITEM_CODE = batchesTrayItem.Select(x => x.ItemCode).ToList()
                    });
                    trayItem.BatchesTrayItemQty(batchesTrayItem, BatchesType.ForwardBatch);

                    //托盘物料
                    batchesResult.TrayItemList = trayItem;

                    //波次实体
                    batchesResult.WaveMst = GetWaveEntity(batchesResult, waveNo, t);
                    //分拣单实体
                    batchesResult.SortingList = sortingList;
                    //库区量表实体
                    batchesResult.StockAreaList = stockAreaList;
                    //打单
                    return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().CreateBill(batchesResult);
                });

            });
        }
        #endregion

        #region 打单
        /// <summary>
        /// 打单
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public OperateResult SimCreateBill(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {
                //出库订单，可能多个
                string opNos = Util.ToString(postEntity.PostData.opNos);
                //打印机
                string printer = Util.ToString(postEntity.PostData.printer);
                //打印模板
                string printTemplet = Util.ToString(postEntity.PostData.printTemplet);
                if (string.IsNullOrEmpty(opNos))
                    return OperateResult.Error("出库订单号不可为空");
                //登陆信息&生成单号
                UserRuleEntity user = new UserRuleEntity()
                {
                    LoginCode = Util.ToString(t.CN_S_LOGIN).Trim(),
                    LoginName = Util.ToString(t.CN_S_NAME).Trim(),
                    OrgCode = Util.ToString(t.CN_S_ORGCODE).Trim(),
                    OrgFlag = Util.ToString(t.CN_S_ORGFLAG).Trim(),
                    RuleCode = Constants.Rule_WaveNo
                };
                //生成波次号
                string waveNo = user.GenerateNo();
                if (string.IsNullOrEmpty(waveNo))
                    return OperateResult.Error("生成波次号失败");

                return ChangeOutOperate(opNos, (outMstList, batchesList, stockList, lstStrate) =>
                {
                    //if (outMstList.GroupBy(x => x.CN_S_CUSTOMER).Count() != 1)
                    //    return OperateResult.Error("请选择同一客户的出库单");
                    //反批分分配量，并且生成出库单
                    var bResult = stockList.BatchesStockQty(batchesList, BatchesType.ReverseBatch, StockBatchesField.AllocationQty, lstStrate, true);
                    if (!bResult.Success)
                        return bResult;
                    //批分结果数据
                    var batchesResult = bResult.GetData<BatchesResult>();
                    if (batchesResult == null)
                        return OperateResult.Error("生成打单数据异常");
                    //出库单子表数据
                    List<TN_WM_REDUCE_INVENTORY_DTLEntity> reduceInventoryDtlList = new List<TN_WM_REDUCE_INVENTORY_DTLEntity>();
                    batchesResult.ReduceInventoryMstList.ForEach(p =>
                    {
                        reduceInventoryDtlList.AddRange(p.DTLEntity);
                    });
                    batchesResult.ReduceInventoryDtlList = reduceInventoryDtlList;
                    //出库订单子表数据
                    List<TN_WM_OUT_DTLEntity> outDtlAllList = new List<TN_WM_OUT_DTLEntity>();
                    outMstList.ForEach(p =>
                    {
                        //子表货主赋值
                        p.OutDtlList.ForEach(q => q.CN_S_OWNER = p.CN_S_OWNER);
                        outDtlAllList.AddRange(p.OutDtlList);
                    });
                    //初始化调用算法数据
                    List<itemQueryClass> itemQuerys =
                    outDtlAllList.GroupBy(p => new
                    {
                        p.CN_S_ITEM_CODE,
                        p.CN_S_ITEM_STATE,
                        p.CN_S_OWNER,
                        p.CN_S_LOT_CODE,
                        p.CN_S_PRODUCTION_BATCH
                    })
                     .Select(x => new itemQueryClass()
                     {
                         itemCode = x.Key.CN_S_ITEM_CODE,
                         batchCode = x.Key.CN_S_LOT_CODE,
                         prodBatchCode = x.Key.CN_S_PRODUCTION_BATCH,
                         itemState = x.Key.CN_S_ITEM_STATE,
                         ownerName = x.Key.CN_S_OWNER,
                         stockCode = batchesResult.OutMstList[0].CN_S_STOCK_CODE,
                         itemQty = x.Sum(y => y.CN_F_QUANTITY)
                     }).ToList();
                    var allArea = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetArea(4, batchesResult.OutMstList[0].CN_S_STOCK_CODE);
                    List<areaPriorClass> lstAreaPrior = allArea.Select(p => new areaPriorClass()
                    {
                        areaCode = p.CN_S_AREA_CODE,
                        Prior = p.CN_N_PRIORITY
                    }).ToList();
                    Log.Info("调用OutArea参数 itemQuerys", JsonConvert.SerializeObject(itemQuerys));
                    Log.Info("调用OutArea参数 lstAreaPrior", JsonConvert.SerializeObject(lstAreaPrior));
                    //调用出库算法
                    var algorResultEntity = BLLCreator.Create<Out_AlgorBLL>().OutArea(itemQuerys, lstAreaPrior);

                    if (!algorResultEntity.Success)
                        return OperateResult.Error("算法异常：" + algorResultEntity.Msg);
                    Log.Info("调用OutArea返回值 algorResultEntity", JsonConvert.SerializeObject(algorResultEntity));
                    //算法结果
                    var algorResult = algorResultEntity.itemOutAreaResult;
                    Log.Info("调用OutArea返回值 algorResult", JsonConvert.SerializeObject(algorResult));

                    if (algorResult == null)
                        return OperateResult.Error("库存不足，请先完成来料区的上架");

                    //获取分拣单数据
                    var sortingDataResult = BLLCreator.Create<TN_WM_SORTING_LISTBLL>().GetSortingData(algorResult, user, waveNo);
                    if (!sortingDataResult.Success)
                        return sortingDataResult;

                    //生成的分拣单数据
                    var sortingList = sortingDataResult.GetData<List<TN_WM_SORTING_LISTEntity>>();
                    List<string> itemCodes = new List<string>();
                    sortingList.ForEach(x =>
                    {
                        if (x.SortingDtlList != null)
                            x.SortingDtlList.ForEach(y =>
                            {
                                itemCodes.Add(y.CN_S_ITEM_CODE);
                            });
                    });
                    //分拣单的所有库区量表数据
                    var stockAreaList = BLLCreator.Create<DapperBLL<TN_WM_B_AREA_QTYEntity>>().GetList(new
                    {
                        CN_S_STOCK_AREA = sortingList.Select(x => x.CN_S_STOCK_AREA).ToList(),
                        CN_S_ITEM_CODE = itemCodes
                    });

                    //批分库区量表结果
                    //List<TN_WM_B_OUTLOCKING_DTLEntity> outLockList = new List<TN_WM_B_OUTLOCKING_DTLEntity>();
                    Log.Info("批分库区参数 sortingList:", JsonConvert.SerializeObject(sortingList));
                    Log.Info("批分库区参数 lstStrate:", JsonConvert.SerializeObject(lstStrate));
                    var batchesAreaResult = stockAreaList.BatchesAreaQty(sortingList, lstStrate);
                    if (!batchesAreaResult.Success)
                        return batchesAreaResult;
                    Log.Info("批分库区结果 batchesAreaResult:", JsonConvert.SerializeObject(batchesAreaResult));


                    //批分托盘物料分配量，改到执行分拣单的时候分配
                    var sortingLocations = new List<TN_WM_SORTING_LOCATIONEntity>();
                    sortingList.ForEach(x => { sortingLocations.AddRange(x.SortingLocationList); });
                    //组织批分实体
                    var batchesTrayItem = sortingLocations.Select(x => new BatchesEntity()
                    {
                        TrayCode = x.CN_S_TRAY_CODE,
                        ItemCode = x.CN_S_ITEM_CODE,
                        Qty = x.CN_F_QUANTITY
                    }).ToList();
                    var trayItem = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
                    {
                        CN_S_ITEM_CODE = batchesTrayItem.Select(x => x.ItemCode).ToList()
                    });
                    trayItem.BatchesTrayItemQty(batchesTrayItem, BatchesType.ForwardBatch);

                    //托盘物料
                    batchesResult.TrayItemList = trayItem;

                    //波次实体
                    batchesResult.WaveMst = GetWaveEntity(batchesResult, waveNo, t);
                    //分拣单实体
                    batchesResult.SortingList = sortingList;
                    //库区量表实体
                    batchesResult.StockAreaList = stockAreaList;
                    //打单
                    return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().CreateBill(batchesResult);
                });

            });
        }
        #endregion

        #region 获取波次实体
        /// <summary>
        /// 获取波次实体
        /// </summary>
        /// <param name="bResult"></param>
        /// <returns></returns>
        private TN_WM_WAVE_MSTEntity GetWaveEntity(BatchesResult bResult, string waveNo, RedisUserEntity user)
        {
            TN_WM_WAVE_MSTEntity waveMstEntity = new TN_WM_WAVE_MSTEntity()
            {
                CN_S_CREATE_TYPE = Constants.CreateType_Manual,
                CN_S_WAVE_NO = waveNo,
                CN_S_FROM = "WMS",
                CN_GUID = Guid.NewGuid().ToString(),
                CN_S_STATE = Constants.Sorting_Stay,
                CN_T_CREATE = DateTime.Now,
                CN_T_MODIFY = DateTime.Now,
                CN_T_OPERATE = DateTime.Now,
                CN_S_CREATOR = user.CN_S_NAME,
                CN_S_CREATOR_BY = user.CN_S_LOGIN,
                CN_S_MODIFY = user.CN_S_NAME,
                CN_S_MODIFY_BY = user.CN_S_LOGIN,
                CN_C_NEED_SEEDING = Constants.Y,
                CN_S_STATUS = Constants.State_New,
                CN_S_SEEDING_MODE = "",
                CN_S_STOCK_CODE = bResult.OutMstList[0].CN_S_STOCK_CODE
            };
            waveMstEntity.WaveDtlList = new List<TN_WM_WAVE_DTLEntity>();
            int index = 1;
            foreach (var outDtl in bResult.OutMstList)
            {
                TN_WM_WAVE_DTLEntity waveDtlEntity = new TN_WM_WAVE_DTLEntity()
                {
                    CN_GUID = Guid.NewGuid().ToString(),
                    CN_S_WAVE_NO = waveNo,
                    CN_S_ORDER_NO = outDtl.CN_S_OP_NO,
                    CN_S_STATE = Constants.State_New,
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_CREATOR = user.CN_S_NAME,
                    CN_S_CREATOR_BY = user.CN_S_LOGIN,
                    CN_S_MODIFY = user.CN_S_NAME,
                    CN_S_MODIFY_BY = user.CN_S_LOGIN,
                    CN_S_MSTGUID = waveMstEntity.CN_GUID,
                    CN_N_ORDER = index++
                };
                waveMstEntity.WaveDtlList.Add(waveDtlEntity);
            }
            return waveMstEntity;
        }
        #endregion

        #region 带出出库订单,批分,仓库实体
        /// <summary>
        /// 带出出库订单实体
        /// </summary>
        /// <param name="opNo"></param>
        /// <param name="funcOut"></param>
        /// <returns></returns>
        public OperateResult ChangeOutOperate(string opNos, Func<List<TN_WM_OUT_MSTEntity>, List<BatchesEntity>, List<TN_WM_B_STOCK_QTYEntity>, List<string>, OperateResult> funcOut)
        {
            try
            {
                if (string.IsNullOrEmpty(opNos))
                    return OperateResult.Error("出库订单号不可为空");
                var outMst = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetList(new
                {
                    CN_S_OP_NO = opNos.Split(',').ToList()
                });
                if (!outMst.Any())
                    return OperateResult.Error("未找到出库订单号：" + opNos);

                List<BatchesEntity> batchesList = new List<BatchesEntity>();

                foreach (var _out in outMst)
                {
                    _out.OutDtlList = BLLCreator.Create<DapperBLL<TN_WM_OUT_DTLEntity>>().GetList(new
                    {
                        CN_S_OP_NO = _out.CN_S_OP_NO,
                        CN_C_AUTO_INOUT = false
                    });
                    batchesList.AddRange(_out.OutDtlList.Select(p =>
                    {
                        return new BatchesEntity()
                        {
                            ItemCode = p.CN_S_ITEM_CODE,
                            ItemState = p.CN_S_ITEM_STATE,
                            ItemArrivalLot = p.CN_S_LOT_CODE,
                            ItemProductionLot = p.CN_S_PRODUCTION_BATCH,
                            Owner = _out.CN_S_OWNER,
                            Qty = p.CN_F_QUANTITY,
                            OpNo = _out.CN_S_OP_NO,
                            OutMst = _out,
                            IsFilter = p.CN_C_AUTO_INOUT
                        };
                    }).ToList());
                }
                //当前子表物料库存
                var stockList = BLLCreator.Create<DapperBLL<TN_WM_B_STOCK_QTYEntity>>().GetList(new
                {
                    CN_S_ITEM_CODE = batchesList.Select(p => p.ItemCode).ToList()
                });
                //算法策略
                List<string> lstStrate = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetStrateListByAreaOrStock("", "", Constants.Out)
                     .OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();
                return funcOut(outMst, batchesList, stockList, lstStrate);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 获取出库订单子表
        /// <summary>
        /// 获取出库订单子表
        /// </summary>
        /// <param name="opNo"></param>
        /// <returns></returns>
        public OperateResult GetOutDtl(string opNo)
        {
            try
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTBLL>>().GetList(new
                {
                    CN_S_OP_NO = opNo
                });
                return OperateResult.Succeed(null, list);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 保存物流
        /// <summary>
        /// 保存物流
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public OperateResult SaveWayBill(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {
                var outMstList = postEntity.GetPostData<List<TN_WM_OUT_MSTEntity>>();
                if (outMstList == null || !outMstList.Any())
                    return OperateResult.Error("数据不正确");
                var logisticsEntity = BLLCreator.Create<DapperBLL<TN_WM_LOGISTICS_COMPANYEntity>>().GetSingleEntity(
                    new
                    {
                        CN_S_LOGISTICS_FLAG = outMstList[0].CN_S_LOGISTICS_FLAG
                    });
                if (logisticsEntity == null)
                    return OperateResult.Error("未找到物流公司标识：" + outMstList[0].CN_S_LOGISTICS_FLAG);
                //是否使用过该物流单号
                var existsWayBill = BLLCreator.Create<MONGO_KEYTYPE_MAPBLL>().GetList(outMstList.Select(x => x.CN_S_WAYBILL_NO).ToList());

                if (existsWayBill.Any())
                    return OperateResult.Error("物流单号：" + string.Join(",", existsWayBill.Select(x => x.Key)) + "已使用");

                outMstList.ForEach(p =>
                {
                    p.CN_S_LOGISTICS_NAME = logisticsEntity.CN_S_LOGISTICS_NAME;
                    p.CN_S_FORWARDING_WAY = Constants.Forwarding_Logistics;
                });
                List<MONGO_KEYTYPE_MAP> wayBillKeyType = outMstList
                    .Select(x => new MONGO_KEYTYPE_MAP()
                    {
                        Key = x.CN_S_WAYBILL_NO,
                        Type = "5"
                    }).ToList();
                //物流单号新增到mongo
                BLLCreator.Create<MONGO_KEYTYPE_MAPBLL>().Insert(wayBillKeyType);
                return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().SaveWayBill(outMstList);
            });
        }
        #endregion

        #region 波次列表
        /// <summary>
        /// 波次列表
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public string WaveList(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, t =>
            {
                var result = BLLCreator.Create<TN_WM_WAVE_MSTBLL>().WaveList(searchModel);
                IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
                return JsonConvert.SerializeObject(result, timeFormat);
            });
        }
        #endregion

        #region 保存打印
        /// <summary>
        /// 保存打印
        /// </summary>
        /// <param name="postEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult SavePrinter(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {
                //仓库编码
                string stockCode = Util.ToString(postEntity.PostData.stockCode);
                //打印机
                string printer = Util.ToString(postEntity.PostData.printer);
                //打印模板
                string printTemplet = Util.ToString(postEntity.PostData.printTemplet);
                //发货单号,多条
                string opNos = Util.ToString(postEntity.PostData.opNos);
                //打印类型
                PrintType printType = (PrintType)Convert.ToInt32(Util.ToString(postEntity.PostData.printType));

                var currentPrint = BLLCreator.Create<DapperBLL<TN_WM_PRINT_TEMPLETEntity>>().GetSingleEntity(new
                {
                    CN_S_STOCK_CODE = stockCode,
                    CN_S_PRINTER = printer,
                    CN_S_TEMPLET_NAME = printTemplet
                });
                if (currentPrint == null)
                    return OperateResult.Error("未找到该打印机");
                var outMstList = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetList(new
                {
                    CN_S_OP_NO = opNos.Split(',').ToList()
                });
                if (!outMstList.Any())
                    return OperateResult.Error("未找到发货单信息");

                //装箱
                List<TN_WM_B_OUT_PACKEntity> outPackList = new List<TN_WM_B_OUT_PACKEntity>();
                string content = string.Empty;
                switch (printType)
                {
                    case PrintType.Logistics://物流单
                        List<LogisticsEntity> logisticsList = new List<LogisticsEntity>();
                        foreach (var outMst in outMstList)
                        {
                            LogisticsEntity logistics = new LogisticsEntity()
                            {
                                ReceiverName = outMst.CN_S_RECEIVER_NAME,
                                ReceiverPhone = outMst.CN_S_PHONE,
                                ReceiverTel = outMst.CN_S_TEL,
                                PrintLot = outMst.CN_S_WAVE_CODE,
                                LogisticsNum = outMst.CN_S_WAYBILL_NO,
                                GoodsNum = 0,    //托寄物数
                                ActualWeight = 0,//实际重量
                                ChargeWeight = 0,//计费重量
                                ReceiverAddress = outMst.CN_S_DETAIL_ADDRESS,
                                Remark = outMst.CN_S_NOTE,
                                City = outMst.CN_S_CITY,
                                Province = outMst.CN_S_PROVINCE
                            };
                            logisticsList.Add(logistics);
                        }
                        content = JsonConvert.SerializeObject(logisticsList).Replace('[', '<').Replace('{', '(').Replace('\"', '\'').Replace('}', ')').Replace(']', '>');
                        break;
                    case PrintType.Pack://包装码
                        int packNum = Convert.ToInt32(Util.ToString(postEntity.PostData.packNum));
                        List<OutPackTagEntity> optList = new List<OutPackTagEntity>();
                        var user = new UserRuleEntity()
                        {
                            LoginCode = Util.ToString(t.CN_S_LOGIN).Trim(),
                            LoginName = Util.ToString(t.CN_S_NAME).Trim(),
                            OrgCode = Util.ToString(t.CN_S_ORGCODE).Trim(),
                            OrgFlag = Util.ToString(t.CN_S_ORGFLAG).Trim(),
                            RuleCode = Constants.PackCode
                        };
                        for (int i = 1; i <= packNum; i++)
                        {
                            OutPackTagEntity optEntity = new OutPackTagEntity()
                            {
                                PackNo = user.GenerateNo(),
                                TotalNum = packNum,
                                CurrentNum = i,
                                ReceiverName = outMstList[0].CN_S_RECEIVER_NAME,
                                ReceiverPhone = outMstList[0].CN_S_PHONE,
                                Province = Util.ToString(outMstList[0].CN_S_PROVINCE),
                                City = Util.ToString(outMstList[0].CN_S_CITY),
                                Area = Util.ToString(outMstList[0].CN_S_AREA),
                                Town = Util.ToString(outMstList[0].CN_S_TOWN),
                                ReceiverAddress = outMstList[0].CN_S_DETAIL_ADDRESS,
                                Logistics = outMstList[0].CN_S_LOGISTICS_NAME,
                            };
                            TN_WM_B_OUT_PACKEntity outPackEntity = new TN_WM_B_OUT_PACKEntity()
                            {
                                CN_GUID = Guid.NewGuid().ToString(),
                                CN_S_OP_NO = outMstList[0].CN_S_OP_NO,
                                CN_S_OPERATOR = t.CN_S_NAME,
                                CN_S_PACKING_CODE = optEntity.PackNo,
                                CN_T_DATE = DateTime.Now,
                                CN_S_BOX_STYLE = Constants.PackCode
                            };
                            outPackList.Add(outPackEntity);
                            optList.Add(optEntity);
                        }
                        content = JsonConvert.SerializeObject(optList).Replace('[', '<').Replace('{', '(').Replace('\"', '\'').Replace('}', ')').Replace(']', '>');
                        break;
                    case PrintType.Invoice://出库单
                        break;
                }
                var printTask = new TN_WM_PRINT_TASKEntity()
                {
                    CN_S_TEMPLET_TYPE = currentPrint.CN_S_TEMPLET_TYPE,
                    CN_S_TEMPLET_NAME = currentPrint.CN_S_TEMPLET_NAME,
                    CN_S_PRINTER = currentPrint.CN_S_PRINTER,
                    CN_S_IP = currentPrint.CN_S_IP,
                    CN_S_CONTENT = content,
                    CN_GUID = Guid.NewGuid().ToString(),
                    CN_C_IS_PRINTED = "N",
                    CN_S_MAC = currentPrint.CN_S_MAC,
                    CN_T_CREATE = DateTime.Now
                };
                return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().SavePrinter(outMstList, printTask, printType, outPackList);
            });
        }
        #endregion

        #region 验证打单数据
        /// <summary>
        /// 验证打单数据
        /// </summary>
        /// <param name="opNos"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ValidatePrint(string opNos)
        {
            return ValidateToken(t =>
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetList(new
                {
                    CN_S_OP_NO = opNos.Split(',').ToList()
                });
                if (!list.Any())
                    return OperateResult.Error("所选单据不存在");
                if (list.GroupBy(x => new
                {
                    x.CN_S_STOCK_CODE,
                    x.CN_S_STATE,
                    x.CN_S_LOGISTICS_FLAG
                }).Count() != 1)
                {
                    return OperateResult.Error("所选单据不允许打单，单据状态、所属仓库、物流公司必须一致！");
                }
                return OperateResult.Succeed(null, list);
            });
        }
        #endregion

        #region 获取订单日志
        /// <summary>
        /// 获取订单日志
        /// </summary>
        /// <param name="opNo"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetBillExec(string opNo)
        {
            return ValidateToken(t =>
            {
                var billExecList = BLLCreator.Create<DapperBLL<TN_WM_B_BILL_EXECEntity>>().GetList(new
                {
                    CN_S_OP_NO = opNo
                }, " ORDER BY CN_T_EXECUTE ");
                IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
                return JsonConvert.SerializeObject(OperateResult.Succeed(null, billExecList), timeFormat);
            });
        }
        #endregion

        #region 生成顺丰物流单号
        /// <summary>
        /// 生成顺丰物流单号
        /// </summary>
        /// <param name="outNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult CreateLogistics(string outNos)
        {
            return ValidateToken(t =>
            {
                var outMstList = BLLCreator.Create<TN_WM_OUT_MSTBLL>().GetOutList(outNos.Split(',').ToList());
                List<KdEBusiness> kdEBusinessList = new List<KdEBusiness>();
                outMstList.ForEach(x => kdEBusinessList.Add(KdApiEOrderHelper.GenerateLogistics(x)));
                return OperateResult.Succeed(null, kdEBusinessList);
            });
        }
        #endregion

        #region 缺货查询列表
        /// <summary>
        /// 缺货查询列表
        /// </summary>
        /// <param name="postEntity"></param>
        /// <returns></returns>
        public OperateResult OutOfStockList(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {

                return OperateResult.Succeed();
            });
        }
        #endregion

    }
}