using HH.WMS.BLL;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.Common;
using HH.WMS.BLL.OutStock;
using HH.WMS.Common;
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 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 PackReviewController : BaseController
    {
        #region 扫描出库订单&扫描物流单
        /// <summary>
        /// 扫描出库订单&扫描物流单
        /// </summary>
        /// <param name="outNo"></param>
        /// <param name="scanNo">是否为物流单</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ScanOut(string scanNo, bool wayBill = false)
        {
            return ValidateToken(t =>
            {
                //参数校验
                if (string.IsNullOrEmpty(scanNo))
                    return OperateResult.Error("单据号不可为空");

                TN_WM_OUT_MSTEntity outMst = new TN_WM_OUT_MSTEntity();
                if (wayBill)
                {
                    outMst = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_WAYBILL_NO = scanNo
                    });
                    if (outMst == null)
                        return OperateResult.Error("未找到物流单号：" + scanNo + "所属的出库单");
                    scanNo = outMst.CN_S_OP_NO;
                }
                else
                {
                    outMst = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_OP_NO = scanNo
                    });
                    if (outMst == null)
                        return OperateResult.Error("未找到出库订单：" + scanNo);
                }
                if (outMst.CN_S_STATE == Constants.State_Cancel)
                    return OperateResult.Error("该单据已取消！");
                if (!(outMst.CN_S_STATE == Constants.State_WaitOut ||
                    outMst.CN_S_STATE == Constants.Sorting_Being ||
                    outMst.CN_S_STATE == Constants.Sorting_Sorted))
                    return OperateResult.Error("当前出库单状态不允许包装复验！");

                var waveMst = BLLCreator.Create<DapperBLL<TN_WM_WAVE_MSTEntity>>().GetSingleEntity(new
                {
                    CN_S_WAVE_NO = outMst.CN_S_WAVE_CODE
                });
                if (waveMst == null)
                    return OperateResult.Error("未找到该出库单波次，请先打印分拣单！");
                if (waveMst.CN_S_STATE == Constants.Sorting_Stay || waveMst.CN_S_STATE == Constants.Sorting_Being)
                    return OperateResult.Error("当前出库单波次存在未分拣的物料！");

                var outDtl = BLLCreator.Create<DapperBLL<TN_WM_OUT_DTLEntity>>().GetList(new
                {
                    CN_S_OP_NO = scanNo,
                    CN_C_AUTO_INOUT = false
                });
                if (!outDtl.Any())
                    return OperateResult.Error("未找到出库订单：" + scanNo + "的出库明细");
                var reviewList = BLLCreator.Create<DapperBLL<TN_WM_ORDER_SORTING_RELEntity>>().GetList(new
                {
                    CN_S_ORDER_NO = scanNo
                });
                List<AutoBomItemEntity> items = (BLLCreator.Create<TN_WMS_ITEMBLL>().GetItemList(outDtl.Select(x => x.CN_S_ITEM_CODE).ToList()) ?? new List<AutoBomItemEntity>());

                //TN_WM_B_UNIQUE_BARCODEEntity uniqueBig = CreateDAL<DapperDAL<TN_WM_B_UNIQUE_BARCODEEntity>>().GetSingleEntity(new { CN_S_ITEM_CODE = itemenity.CN_S_ITEM_CODE, CN_S_PARENT_CODE = "" });
                //if (uniqueBig != null)
                //{
                //    itemenity.CN_F_BOXPACKING_QTY = Math.Round(Convert.ToDecimal(uniqueBig.CN_F_PACKING_QTY), 0).ToString();
                //    itemenity.CN_F_BOXPACKING_UNIT = uniqueBig.CN_S_PACKING_UNIT.ToString();
                //}
                var result = new
                {
                    OutNo = scanNo,
                    PackCode = "",
                    PackItems = outDtl.Select(x =>
                    {
                        //TN_WM_B_UNIQUE_BARCODEEntity uniqueBig = BLLCreator.CreateDapper<TN_WM_B_UNIQUE_BARCODEEntity>().GetSingleEntity(new
                        //{
                        //    CN_S_ITEM_CODE = x.CN_S_ITEM_CODE,
                        //    CN_S_PARENT_CODE = ""
                        //});
                        //string packingQty = "";
                        //string packingUnit = "";
                        //if (uniqueBig != null)
                        //{
                        //    packingQty = Math.Round(Convert.ToDecimal(uniqueBig.CN_F_PACKING_QTY), 0).ToString();
                        //    packingUnit = uniqueBig.CN_S_PACKING_UNIT.ToString();
                        //}
                        var currentItem = items.Find(m => m.CN_S_ITEM_CODE == x.CN_S_ITEM_CODE);

                        string isSn = "N";
                        var _currentItem = items.Find(m => m.CN_S_ITEM_CODE.Equals(x.CN_S_ITEM_CODE));
                        if (_currentItem != null)
                        {
                            if (!string.IsNullOrEmpty(_currentItem.CN_C_IS_SN))
                            {
                                isSn = _currentItem.CN_C_IS_SN;
                            }
                        }

                        return new
                        {
                            //CN_F_BOXPACKING_QTY = packingQty,
                            //CN_F_BOXPACKING_UNIT = packingUnit,
                            AuxiliaryUnitList = currentItem.AuxiliaryUnitList ?? new List<AuxiliaryEntity>(),
                            ItemCode = x.CN_S_ITEM_CODE,
                            ItemName = x.CN_S_ITEM_NAME,
                            ItemState = x.CN_S_ITEM_STATE,
                            ItemLotNo = x.CN_S_LOT_CODE,
                            ItemProLotNo = x.CN_S_PRODUCTION_BATCH,
                            ItemModel = x.CN_S_MODEL,
                            ItemFigureNo = x.CN_S_FIGURE_NO,
                            ItemUnit = x.CN_S_MEASURE_UNIT,
                            Owner = outMst.CN_S_OWNER,
                            Qty = x.CN_F_QUANTITY,
                            IsSn = isSn,
                            PrQty = reviewList.FindAll(s =>
                            {
                                s.CN_S_LOT_NO = s.CN_S_LOT_NO ?? "";
                                s.CN_S_PRODUCTION_BATCH = s.CN_S_PRODUCTION_BATCH ?? "";
                                x.CN_S_LOT_CODE = x.CN_S_LOT_CODE ?? "";
                                x.CN_S_PRODUCTION_BATCH = x.CN_S_PRODUCTION_BATCH ?? "";
                                return s.CN_S_ITEM_CODE.Equals(x.CN_S_ITEM_CODE) &&
                                       s.CN_S_ITEM_STATE.Equals(x.CN_S_ITEM_STATE) &&
                                       s.CN_S_OWNER.Equals(outMst.CN_S_OWNER) &&
                                       //s.CN_S_LOT_NO.Equals(x.CN_S_LOT_CODE) &&
                                       (string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) || s.CN_S_PRODUCTION_BATCH.Equals(x.CN_S_PRODUCTION_BATCH));
                            }).Sum(q => q.CN_F_RECHECK)
                        };
                    })
                };
                return OperateResult.Succeed(null, result);
            });

        }
        #endregion

        #region 保存包装复验物料
        /// <summary>
        /// 保存包装复验物料
        /// </summary>
        /// <param name="confirmReview"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult ConfirmReview(dynamic confirmReview)
        {
            string tokenId = Util.ToString(confirmReview.tokenId);
            return ValidateToken(tokenId, t =>
            {
                //出库订单
                string outNo = Util.ToString(confirmReview.OutNo);
                //是否全部包装复验完
                bool isAllReview = Convert.ToBoolean(confirmReview.IsAllReview ?? false);
                //是否强制完成
                bool forceComplete = Convert.ToBoolean(confirmReview.ForceComplete ?? false);
                //包装码
                string packCode = Util.ToString(confirmReview.PackCode);
                if (confirmReview.ReviewItems == null)
                    return OperateResult.Error("包装复验物料不可为空");
                //包装复验的物料
                List<TN_WM_ORDER_SORTING_RELEntity> reviewItems = JsonConvert.DeserializeObject<List<TN_WM_ORDER_SORTING_RELEntity>>(Util.ToString(confirmReview.ReviewItems));

                reviewItems.ForEach(p =>
                {
                    p.CN_S_ORDER_NO = outNo;
                    p.CN_GUID = Guid.NewGuid().ToString();
                    p.CN_S_SERIAL_NO = p.CN_S_SERIAL_NO ?? "";
                    p.CN_S_GROUP = p.CN_S_GROUP ?? "";
                    p.CN_S_TURNOVERBOX_CODE = p.CN_S_TURNOVERBOX_CODE ?? "";
                    p.CN_S_SORTING_CAR = p.CN_S_SORTING_CAR ?? "";
                    p.CN_S_PACKING_CODE = p.CN_S_PACKING_CODE ?? packCode;
                    p.CN_C_ISPACK = Constants.Y;
                    p.CN_S_ISSOWING = Constants.Y;
                    p.CN_S_CREATOR = t.CN_S_LOGIN;
                    p.CN_S_CREATOR_BY = t.CN_S_NAME;
                    p.CN_T_CREATE = DateTime.Now;
                    p.CN_S_MODIFY = t.CN_S_LOGIN;
                    p.CN_S_MODIFY_BY = t.CN_S_NAME;
                    p.CN_T_MODIFY = DateTime.Now;
                });
                List<TN_WM_B_BOX_DTLEntity> boxDtlList = new List<TN_WM_B_BOX_DTLEntity>();
                if (!string.IsNullOrEmpty(packCode))
                {
                    var existsBoxDtl = BLLCreator.Create<DapperBLL<TN_WM_B_BOX_DTLEntity>>().GetList(new
                    {
                        CN_S_PACKING_CODE = packCode
                    });
                    int rowNo = 1;
                    if (existsBoxDtl.Any())
                        rowNo = existsBoxDtl.Max(x => x.CN_N_ROW_NO) ?? 1;
                    foreach (var reviewItem in reviewItems)
                    {
                        TN_WM_B_BOX_DTLEntity boxDtlEntity = new TN_WM_B_BOX_DTLEntity()
                        {
                            CN_F_QUANTITY = reviewItem.CN_F_QUANTITY,
                            CN_N_ROW_NO = rowNo,
                            CN_S_IN_FROM_NO = reviewItem.CN_S_IN_FROM_NO,
                            CN_S_IN_OP_FROM = reviewItem.CN_S_IN_OP_FROM,
                            CN_S_ITEM_CODE = reviewItem.CN_S_ITEM_CODE,
                            CN_S_ITEM_NAME = reviewItem.CN_S_ITEM_NAME,
                            CN_S_ITEM_STATE = reviewItem.CN_S_ITEM_STATE,
                            CN_S_LOT_CODE = reviewItem.CN_S_LOT_NO,
                            CN_S_MEASURE_UNIT = reviewItem.CN_S_MEASURE_UNIT,//计量单位
                            CN_S_OWNER = reviewItem.CN_S_OWNER,
                            CN_S_PACKCODE = reviewItem.CN_S_PACK_CODE,
                            CN_S_PACKING_CODE = packCode,
                            CN_S_SERIAL_NO = reviewItem.CN_S_SERIAL_NO,
                        };
                        boxDtlList.Add(boxDtlEntity);
                    }
                }
                //非强制完成
                if (!forceComplete)
                {
                    var osAllList = BLLCreator.Create<DapperBLL<TN_WM_ORDER_SORTING_RELEntity>>().GetList(new
                    {
                        CN_S_ORDER_NO = outNo,
                        CN_C_ISPACK = Constants.Y
                    });
                    var outDtl = BLLCreator.Create<DapperBLL<TN_WM_OUT_DTLEntity>>().GetList(new
                    {
                        CN_S_OP_NO = outNo,
                        CN_C_AUTO_INOUT = false
                    });
                    if (outDtl.Sum(x => x.CN_F_QUANTITY) ==
                       (osAllList.Sum(x => x.CN_F_QUANTITY) + reviewItems.Sum(x => x.CN_F_QUANTITY)))
                        isAllReview = true;
                }
                else
                {
                    isAllReview = true;
                }
                return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().ConfirmReview(isAllReview, outNo, reviewItems, boxDtlList);
            });
        }
        #endregion

        #region 扫描包装码
        /// <summary>
        /// 扫描包装码
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ScanPack(string packCode, string outNo)
        {
            return ValidateToken(t =>
            {
                if (string.IsNullOrEmpty(packCode))
                    return OperateResult.Error("包装码不可为空！");
                if (string.IsNullOrEmpty(outNo))
                    return OperateResult.Error("出库单不可为空！");
                var outPackEntity = BLLCreator.Create<DapperBLL<TN_WM_B_OUT_PACKEntity>>().GetSingleEntity(new
                {
                    CN_S_PACKING_CODE = packCode
                });
                if (outPackEntity == null)
                    return OperateResult.Error("未找到包装码：" + packCode);
                if (outPackEntity.CN_S_OP_NO.Equals(outNo))
                {
                    return OperateResult.Succeed(null, outPackEntity);
                }
                else
                {
                    return OperateResult.Error("包装码：" + packCode + "已绑定了出库单：" + outPackEntity.CN_S_OP_NO);
                }
            });
        }
        #endregion

        #region 获取出库单包装信息
        /// <summary>
        /// 获取出库单包装信息
        /// </summary>
        /// <param name="scanNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GenerateOutPack(string scanNo, int packNum = 0, bool wayBill = false)
        {
            return ValidateToken(t =>
            {
                if (packNum <= 0)
                    return OperateResult.Error("数量必须大于0");

                TN_WM_OUT_MSTEntity outMst = new TN_WM_OUT_MSTEntity();
                if (wayBill)
                {
                    outMst = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_WAYBILL_NO = scanNo
                    });
                    if (outMst == null)
                        return OperateResult.Error("未找到物流单号：" + scanNo + "所属的出库单");
                    scanNo = outMst.CN_S_OP_NO;
                }
                else
                {
                    outMst = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_OP_NO = scanNo
                    });
                }
                if (outMst == null)
                    return OperateResult.Error("未找到出库单：" + scanNo);

                //装箱
                List<TN_WM_B_OUT_PACKEntity> outPackList = new List<TN_WM_B_OUT_PACKEntity>();
                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 = Util.ToString(outMst.CN_S_RECEIVER_NAME),
                        ReceiverPhone = Util.ToString(outMst.CN_S_PHONE),
                        Province = Util.ToString(outMst.CN_S_PROVINCE),
                        City = Util.ToString(outMst.CN_S_CITY),
                        Area = Util.ToString(outMst.CN_S_AREA),
                        Town = Util.ToString(outMst.CN_S_TOWN),
                        ReceiverAddress = Util.ToString(outMst.CN_S_DETAIL_ADDRESS),
                        Logistics = Util.ToString(outMst.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 = outMst.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);
                }
                var result = BLLCreator.Create<DapperBLL<TN_WM_B_OUT_PACKEntity>>().AddRange(outPackList);
                if (!result.Success)
                    return result;
                return OperateResult.Succeed(null, optList);
            });
        }
        #endregion

        #region 扫描条码 返回条码实体
        /// <summary>
        /// 扫描条码 返回条码实体
        /// </summary>
        /// <param name="barCode">扫描条码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpGet]
        public string AnalysisCode(string barCode)
        {
            return ValidateToken(t =>
            {

                MONGO_KEYTYPE_MAP map = BLLCreator.Create<MONGO_KEYTYPE_MAPBLL>().GetEntity(barCode);

                if (map == null) return null;
                ScanCodeClass scanCodeMode = new ScanCodeClass();
                switch (map.Type)
                {
                    case "1"://CS程序打印条码
                        MONGO_PRINT_BARCODE barcode = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().GetValue(barCode);
                        scanCodeMode = new ScanCodeClass() { Key = map.Key, Type = map.Type, PrintBarCode = barcode };
                        break;
                    case "2"://三生XML唯一码
                        var existsUniqueCode = BLLCreator.CreateDapper<TN_WM_ORDER_SORTING_RELEntity>().GetSingleEntity(new
                        {
                            CN_S_UNIQUE_CODE = barCode,
                            CN_C_ISPACK = Constants.Y
                        });
                        if (existsUniqueCode != null)
                            return JsonConvert.SerializeObject(OperateResult.Error("该唯一码已扫描过！"));
                        TN_WM_B_UNIQUE_BARCODEEntity uniqueCode = BLLCreator.Create<TN_WM_B_UNIQUE_BARCODEBLL>().GetValue(barCode);
                        if (uniqueCode == null)
                        {
                            scanCodeMode = null;
                            break;
                        }
                        AutoBomItemEntity itemEnity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(uniqueCode.CN_S_ITEM_CODE);
                        if (uniqueCode != null)
                        {
                            if (itemEnity == null)
                            {
                                scanCodeMode = null;
                            }
                            else
                            {

                                uniqueCode.CN_F_MIN_PACK_QTY = Convert.ToString(itemEnity.CN_F_MIN_PACK_QTY);
                                uniqueCode.CN_C_IS_LOT_OUT = Convert.ToString(itemEnity.CN_C_IS_LOT_OUT);
                                uniqueCode.CN_C_IS_SN = Convert.ToString(itemEnity.CN_C_IS_SN);

                                uniqueCode.AuxiliaryUnitList = itemEnity.AuxiliaryUnitList;//辅助单位

                                scanCodeMode = new ScanCodeClass() { Key = map.Key, Type = map.Type, uniqueCode = uniqueCode };
                            }

                        }
                        break;
                    case "3":
                        break;
                    case "4"://准物料编码
                        var index = barCode.IndexOf("*");
                        var qty = 0;
                        if (index > 0)
                        {
                            qty = Convert.ToInt32(barCode.Substring(barCode.IndexOf("*"), barCode.Length));
                            barCode = barCode.Substring(0, barCode.IndexOf("*"));
                        }
                        AutoBomItemEntity itemenity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(barCode);

                        AutoBomItemQtyEntity qtyEntity = new AutoBomItemQtyEntity()
                        {
                            itemEntity = itemenity,
                            itemEntityQty = qty
                        };
                        scanCodeMode = new ScanCodeClass() { Key = map.Key, Type = map.Type, Item = qtyEntity };
                        break;
                    case "5"://物流单号
                        scanCodeMode = new ScanCodeClass() { Key = map.Key, Type = map.Type, Item = null };
                        break;
                    default:
                        break;
                }
                if (scanCodeMode == null) return JsonConvert.SerializeObject(OperateResult.Error("找不到物料！"));
                return JsonConvert.SerializeObject(OperateResult.Succeed("", scanCodeMode));
            });
        }
        #endregion

        #region (cs端)获取包装复验的出库单
        /// <summary>
        /// (cs端)获取包装复验的出库单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetPackReviewOut()
        {
            return ValidateToken(t =>
            {
                string collectCode = "HBQ01";
                var waveMst = BLLCreator.CreateDapper<TN_WM_WAVE_MSTEntity>().GetSingleEntity(new
                {
                    CN_S_COLLECT_CODE = collectCode
                });
                if (waveMst == null)
                    return OperateResult.Error("当前没有需要包装复验的出库单");
                var outList = BLLCreator.Create<TN_WM_OUT_MSTBLL>().GetOutListByWave(waveMst.CN_S_WAVE_NO);
                var orderSortingRel = BLLCreator.CreateDapper<TN_WM_ORDER_SORTING_RELEntity>().GetList(new
                {
                    CN_S_ORDER_NO = outList.Select(s => s.CN_S_OP_NO).ToList()
                });

                var result = outList.Select(s => new TN_WM_OUT_MSTEntity()
                {
                    CN_S_OP_NO = s.CN_S_OP_NO,
                    Sowed = s.OutDtlList.Sum(m => m.CN_F_QUANTITY) == orderSortingRel.Where(w => w.CN_S_ORDER_NO == s.CN_S_OP_NO).Sum(m => m.CN_F_RECHECK)
                }).ToList();
                return OperateResult.Succeed(null, result);
            });
        }
        #endregion

        #region (cs端)包装复验扫位置码/出库单
        /// <summary>
        /// (cs端)包装复验扫位置码/出库单
        /// </summary>
        /// <param name="outNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetPackReviewOutDtl(string outNo)
        {
            return ValidateToken(t =>
            {
                var outMst = BLLCreator.Create<TN_WM_OUT_MSTBLL>().GetOut(outNo);
                var orderSortingRel = BLLCreator.CreateDapper<TN_WM_ORDER_SORTING_RELEntity>().GetList(new
                {
                    CN_S_ORDER_NO = outNo
                });
                var result = outMst.OutDtlList.Select(s => new TN_WM_OUT_DTLEntity()
                {
                    CN_S_ITEM_CODE = s.CN_S_ITEM_CODE,
                    CN_S_ITEM_NAME = s.CN_S_ITEM_NAME,
                    CN_S_MODEL = s.CN_S_MODEL,
                    CN_S_FIGURE_NO = s.CN_S_FIGURE_NO,
                    CN_F_QUANTITY = s.CN_F_QUANTITY,
                    CN_F_PACKED_QTY = orderSortingRel.Where(w => w.CN_S_ITEM_CODE == s.CN_S_ITEM_CODE).Sum(m => m.CN_F_RECHECK) ?? 0,
                    CN_S_MEASURE_UNIT = s.CN_S_MEASURE_UNIT
                });

                return OperateResult.Succeed(null, result);
            });
        }
        #endregion

        #region (cs端)扫包装码，并保存之前扫过的包装物料
        /// <summary>
        /// 扫包装码，并保存之前扫过的包装物料
        /// </summary>
        /// <param name="postEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult ScanPackingBox(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
             {
                 string boxNo = Util.ToString(postEntity.PostData.BoxNo);
                 string outNo = Util.ToString(postEntity.PostData.OutNo);
                 List<TN_WM_B_BOX_DTLEntity> boxDtl = JsonConvert.DeserializeObject<List<TN_WM_B_BOX_DTLEntity>>(Util.ToString(postEntity.PostData.BoxDtl));
                 var currentBox = BLLCreator.CreateDapper<TN_WM_B_OUT_PACKEntity>().GetSingleEntity(new
                 {
                     CN_S_PACKING_CODE = boxNo
                 });
                 if (currentBox == null)
                     return OperateResult.Error("未找到装箱码：" + boxNo);
                 if (!string.IsNullOrEmpty(currentBox.CN_S_OP_NO) && currentBox.CN_S_OP_NO != outNo)
                     return OperateResult.Error("当前装箱码已绑定了出库单：" + outNo);
                 if (boxDtl.Any())
                 {
                     var result = SaveBoxDtl(outNo, boxDtl);
                     if (!result.Success)
                         return result;
                 }
                 var currentBoxDtl = BLLCreator.CreateDapper<TN_WM_B_BOX_DTLEntity>().GetList(new
                 {
                     CN_S_PACKING_CODE = boxNo
                 });
                 return OperateResult.Succeed(null, currentBoxDtl);
             });
        }
        #endregion

        #region (cs端)保存包装复验
        /// <summary>
        /// 保存包装复验 
        /// </summary>
        /// <param name="outNo"></param>
        /// <param name="boxDtl"></param>
        /// <returns></returns>
        private OperateResult SaveBoxDtl(string outNo, List<TN_WM_B_BOX_DTLEntity> boxDtl)
        {
            var orderSortingRel = BLLCreator.CreateDapper<TN_WM_ORDER_SORTING_RELEntity>().GetList(new
            {
                CN_S_ORDER_NO = outNo
            });
            foreach (var d in boxDtl)
            {
                var qty = d.CN_F_QUANTITY;
                var currentItemOS = orderSortingRel.Where(w => w.CN_S_ITEM_CODE == d.CN_S_ITEM_CODE);
                foreach (var cos in currentItemOS)
                {
                    var sQty = cos.CN_F_QUANTITY - cos.CN_F_RECHECK;
                    if (qty == 0) break;
                    if (sQty == 0) continue;
                    if (sQty >= qty)
                    {
                        cos.CN_F_RECHECK += qty;
                        qty = 0;
                    }
                    else
                    {
                        qty -= sQty;
                        cos.CN_F_RECHECK += sQty;
                    }
                }
                if (qty > 0)
                    return OperateResult.Error("物料：" + d.CN_S_ITEM_CODE + "复验数大于出库数");
            }
            return BLLCreator.Create<TN_WM_ORDER_SORTING_RELBLL>().SaveBoxDtl(outNo, orderSortingRel, boxDtl);
        }
        #endregion

        #region (cs端)保存包装复验
        /// <summary>
        /// 保存包装复验
        /// </summary>
        /// <param name="postEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult SaveBoxDtl(PostEntity postEntity)
        {
            return ValidateToken(postEntity.TokenId, t =>
            {
                string outNo = Util.ToString(postEntity.PostData.OutNo);
                List<TN_WM_B_BOX_DTLEntity> boxDtl = JsonConvert.DeserializeObject<List<TN_WM_B_BOX_DTLEntity>>(Util.ToString(postEntity.PostData.BoxDtl));
                return SaveBoxDtl(outNo, boxDtl);
            });
        }
        #endregion
    }
}