using HH.Redis.ReisModel;
using HH.WMS.BLL.Interface;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
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;
using Newtonsoft.Json.Linq;
using HH.WMS.Entitys.Algorithm;
using HH.WMS.DAL.Algorithm;

namespace HH.WMS.BLL.InStock
{
    public class TN_WM_INCREASE_INVENTORYBLL : DapperBaseBLL
    {

        #region 新增入库单
        /// <summary>
        /// 新增入库单
        /// </summary>
        /// <param name="Entity">入库单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        public OperateResult AddIncreaseInventory(TN_WM_INCREASE_INVENTORY_MSTEntity Entity, RedisUserEntity redisUserEntity)
        {

            TN_WM_LOT_INFOEntity lotInfo = new TN_WM_LOT_INFOEntity();
            string oldLotCode = Entity.CN_S_LOT_NO;
            if (string.IsNullOrEmpty(oldLotCode))
            {
                string postData = "{\"appCode\":\"AutoWMS\",\"ruleName\":\"" + Constants.BatchNo + "\",\"orgId\":\"" + redisUserEntity.CN_S_ORGCODE + "\",\"orgFlag\":\"" + redisUserEntity.CN_S_ORGFLAG + "\"}";
                string CN_S_LOT_CODE = WebApiManager.HttpAutoBom_Post("Api/BillRule/GenBillNo", postData);

                Entity.CN_S_LOT_NO = CN_S_LOT_CODE;
                lotInfo.CN_GUID = System.Guid.NewGuid().ToString().ToUpper();
                lotInfo.CN_S_LOT_CODE = CN_S_LOT_CODE;
                lotInfo.CN_S_VENDOR_NO = Entity.CN_S_VENDOR_NO;
                lotInfo.CN_S_CREATOR = Entity.CN_S_CREATOR;
                lotInfo.CN_S_CREATOR_BY = Entity.CN_S_CREATOR_BY;
                lotInfo.CN_T_CREATE = DateTime.Now;
            }
            else
            {
                lotInfo.CN_GUID = System.Guid.NewGuid().ToString().ToUpper();
                lotInfo.CN_S_LOT_CODE = oldLotCode;
                lotInfo.CN_S_VENDOR_NO = Entity.CN_S_VENDOR_NO;
                lotInfo.CN_S_CREATOR = Entity.CN_S_CREATOR;
                lotInfo.CN_S_CREATOR_BY = Entity.CN_S_CREATOR_BY;
                lotInfo.CN_T_CREATE = DateTime.Now;
            }

            //子表数据集合
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> DTLEntity = Entity.DTLEntity;

            OperateResult operateResult = UseTransaction(trans =>
            {
                //新增主表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().Add(Entity, trans);
                //新增子表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().AddRange(DTLEntity, trans);
                if (lotInfo != null)
                {
                    CreateDAL<DapperDAL<TN_WM_LOT_INFOEntity>>().Add(lotInfo, trans);
                }
            });

            return operateResult;
        }
        #endregion

        #region 修改入库单
        /// <summary>
        /// 修改入库单
        /// </summary>
        /// <param name="Entity">入库单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult UpdateIncreaseInventory(TN_WM_INCREASE_INVENTORY_MSTEntity entity)
        {
            //子表数据集合
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> DTLEntity = entity.DTLEntity;

            OperateResult operateResult = UseTransaction(trans =>
            {
                //修改主表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().Update(entity, new { CN_S_OP_NO = entity.CN_S_OP_NO }, trans);
                //删除子表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().Delete(new { CN_S_OP_NO = entity.CN_S_OP_NO }, trans);
                //新增子表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().AddRange(DTLEntity, trans);
            });

            return operateResult;
        }
        #endregion

        #region 删除入库单
        /// <summary>
        /// 删除入库单
        /// </summary>
        /// <param name="opNo">入库单单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult DeleteIncreaseInventory(string opNo)
        {
            var IncreaseMst = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new
            {
                CN_S_OP_NO = opNo
            });
            TN_WM_INSPECT_MSTEntity inspectMst = new TN_WM_INSPECT_MSTEntity();
            if (!string.IsNullOrEmpty(IncreaseMst.CN_S_OP_NO))
            {
                //非手工的入库单所需要处理的
                if (!string.IsNullOrEmpty(IncreaseMst.CN_S_FROM_NO))
                {
                    inspectMst = BLLCreator.Create<DapperBLL<TN_WM_INSPECT_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_FROM_NO = IncreaseMst.CN_S_FROM_NO
                    });
                }
            }

            //到货是否需要检验
            string ArrivalNeedInspect = GetStrategy(IncreaseMst.CN_S_STOCK_CODE, "ArrivalAutoInspect");


            OperateResult operateResult = UseTransaction(trans =>
            {
                //非手工的入库单所需要处理的
                if (!string.IsNullOrEmpty(IncreaseMst.CN_S_FROM_NO))
                {
                    if (ArrivalNeedInspect.Equals("Y"))
                    {
                        //更新检验单状态
                        CreateDAL<DapperDAL<TN_WM_INSPECT_MSTEntity>>().Update(new { CN_S_STATE = Constants.State_BeenCheck }, new { CN_S_INSPECT_NO = inspectMst.CN_S_INSPECT_NO }, trans);
                        //WMS调用OMS删除入库单发送删除指令
                        OperateResult orresult = new InfOMSRequest().InspectUpdateCheckResultDesc(opNo);
                        if (!orresult.Success)
                        {
                            throw new Exception(orresult.Msg);
                        }
                    }
                    else
                    {
                        //更新到货单状态
                        CreateDAL<DapperDAL<TN_WM_ARRIVAL_MSTEntity>>().Update(new { CN_S_STATE = Constants.State_Submit }, new { CN_S_ARRIVAL_NO = IncreaseMst.CN_S_FROM_NO }, trans);
                        // WMS到货单反审核调用OMS接口发送反审指令
                        List<string> opList = new List<string>();
                        opList.Add(opNo);
                        OperateResult orresult = new InfOMSRequest().ReArrivalDoOmsConfirm(opList);
                        if (!orresult.Success)
                        {
                            throw new Exception(orresult.Msg);
                        }
                    }
                }

                //删除主表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().Delete(new { CN_S_OP_NO = opNo }, trans);
                //删除子表
                CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().Delete(new { CN_S_OP_NO = opNo }, trans);
            });

            return operateResult;
        }
        #endregion

        #region 提交入库单
        /// <summary>
        /// 提交入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult Submit(List<TN_WM_B_EXAMINEEntity> entity)
        {
            //获取策略：入库是否免审
            TN_WM_INCREASE_INVENTORY_MSTEntity inMst = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new { CN_S_OP_NO = entity[0].CN_S_FROM_NO });
            if (inMst == null)
            {
                return OperateResult.Error("未获取到提交单据实体！");
            }
            string IncreaseAutoAudit = GetStrategy(inMst.CN_S_STOCK_CODE, "IncreaseAutoAudit");

            OperateResult operateResult = new OperateResult();
            //入库单免审-自动审核
            if (IncreaseAutoAudit == Constants.Y)
            {
                operateResult = Audit(entity);
            }
            else
            {
                operateResult = UseTransaction(trans =>
                          {
                              //提交主表
                              CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineMst(entity, Constants.State_Submit, trans);
                              //提交子表
                              CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineDtl(entity, Constants.State_Submit, trans);
                          });
            }
            return operateResult;
        }
        #endregion

        #region 审核入库单
        /// <summary>
        /// 审核入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult Audit(List<TN_WM_B_EXAMINEEntity> entity)
        {
            string inOpNo = entity[0].CN_S_FROM_NO;
            bool isNeedAddStockQty = true;//策略控制：入库是否需要影响仓库和库区（到货区）量
            List<TN_WM_B_STOCK_QTYEntity> stockQtyList = new List<TN_WM_B_STOCK_QTYEntity>();//影响仓库量表
            List<TN_WM_B_AREA_QTYEntity> stockAreaQtyList = new List<TN_WM_B_AREA_QTYEntity>();//影响库区量表
            List<OmsAccStockInNumEntity> AccStockInNumlist = new List<OmsAccStockInNumEntity>();

            //K3对接，外购入库
            string isUseK3 = "";
            string stockCode = "";
            string isUseOms = "";
            List<K3_PurchaseReceiptEntity> K3purchaseReceiptList = new List<K3_PurchaseReceiptEntity>();

            List<TN_WM_B_TRAY_LOCATIONEntity> trayLocationList = new List<TN_WM_B_TRAY_LOCATIONEntity>();
            List<TN_WM_B_TRAY_ITEM_MSTEntity> trayItemMstList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
            List<TN_WM_B_TRAY_ITEM_DTLEntity> trayItemDtlList = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();


            foreach (TN_WM_B_EXAMINEEntity examineEntity in entity)
            {
                DataTable dt = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetIncreaseData(examineEntity.CN_S_FROM_NO);
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    string itemCode = dt.Rows[i]["CN_S_ITEM_CODE"].ToString();

                    AutoBomItemEntity itemenity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(itemCode);
                    if (itemenity == null)
                    {
                        return OperateResult.Error("未获取到物料 " + itemCode + " 的实体！");
                    }
                    string itemName = dt.Rows[i]["CN_S_ITEM_NAME"].ToString();
                    string itemState = dt.Rows[i]["CN_S_ITEM_STATE"].ToString();
                    string lotCode = dt.Rows[i]["CN_S_LOT_NO"].ToString();
                    string productionBatch = dt.Rows[i]["CN_S_PRODUCTION_BATCH"].ToString();
                    string owner = dt.Rows[i]["CN_S_OWNER"].ToString();
                    stockCode = dt.Rows[i]["CN_S_STOCK_CODE"].ToString();
                    string qty = dt.Rows[i]["CN_F_QUANTITY"].ToString();
                    DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)); // 当地时区
                    long timeStamp = (long)(DateTime.Now - startTime).TotalMilliseconds; // 相差毫秒数

                    #region 拼接仓库量表实体
                    stockQtyList.Add(new TN_WM_B_STOCK_QTYEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_OWNER = owner,
                        CN_S_ITEM_CODE = itemCode,
                        CN_S_ITEM_NAME = itemName,
                        CN_S_ITEM_STATE = itemState,
                        CN_S_LOT_NO = lotCode,
                        CN_S_PRODUCTION_BATCH = productionBatch,
                        CN_S_STOCK_CODE = stockCode,
                        CN_F_QUANTITY = Convert.ToDecimal(qty),
                        CN_F_PLANNED_QTY = 0,
                        CN_F_ALLOC_QTY = 0,
                        CN_F_PRELOCK_QTY = 0,
                        CN_S_TIMESTAMP = timeStamp.ToString(),
                        CN_S_FIGURE_NO = itemenity.CN_S_FIGURE_NO,
                        CN_S_MEASURE_UNIT = itemenity.CN_S_MEASURE_UNIT,
                        CN_S_MODEL = itemenity.CN_S_MODEL
                    });
                    #endregion

                    #region 拼接库区量表实体
                    List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetSHLocationArea(Constants.ReceivingArea);
                    if (!areaList.Any())
                    {
                        return OperateResult.Error("未获取到收货区实体，请配置库区<收货区>！");
                    }

                    stockAreaQtyList.Add(new TN_WM_B_AREA_QTYEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_OWNER = owner,
                        CN_S_ITEM_CODE = itemCode,
                        CN_S_ITEM_NAME = itemName,
                        CN_S_ITEM_STATE = itemState,
                        CN_S_LOT_NO = lotCode,
                        CN_S_PRODUCTION_BATCH = productionBatch,
                        CN_S_STOCK_CODE = stockCode,
                        CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE,
                        CN_F_QUANTITY = Convert.ToDecimal(qty),
                        CN_F_PLANNED_QTY = 0,
                        CN_F_ALLOC_QTY = 0,
                        CN_S_TIMESTAMP = timeStamp.ToString(),
                        CN_S_FIGURE_NO = itemenity.CN_S_FIGURE_NO,
                        CN_S_MEASURE_UNIT = itemenity.CN_S_MEASURE_UNIT,
                        CN_S_MODEL = itemenity.CN_S_MODEL
                    });
                    #endregion
                }

                #region 拼接缺货信息

                List<TN_WM_OUT_MSTEntity> outMst = CreateDAL<TN_WM_OUT_MSTDAL>().GetShortageData(examineEntity.CN_S_FROM_NO);
                if (outMst.Any())
                {
                    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());
                    }

                    //算法策略
                    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();

                    var bResult = stockQtyList.BatchesStockAllocQty(batchesList, lstStrate);
                }

                foreach (var item in stockAreaQtyList)
                {
                    var allocQty = stockQtyList.Where(x => x.CN_S_ITEM_CODE == item.CN_S_ITEM_CODE).ToList();
                    if (allocQty.Count > 0)
                    {
                        item.CN_F_ALLOC_QTY = allocQty[0].CN_F_ALLOC_QTY;
                    }
                }
                #endregion

                #region 拼接托盘物料、托盘货位表

                if (dt.Rows.Count == 0) continue;
                if (string.IsNullOrEmpty(dt.Rows[0]["CN_S_FROM_NO"].ToString())) continue;

                DataTable dtDtl = CreateDAL<TN_WM_ARRIVALDAL>().GetArrivalDtlData(dt.Rows[0]["CN_S_FROM_NO"].ToString());

                for (int a = 0; a < dtDtl.Rows.Count; a++)
                {
                    string putPos = dtDtl.Rows[a]["CN_S_PUT_POSITION"].ToString();
                    if (string.IsNullOrEmpty(putPos)) continue;

                    string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.VirtualTray + "\",\"orgId\":\"\",\"orgFlag\":\"0\"}";
                    string trayNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);

                    AutoBomItemEntity itemEntity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(dtDtl.Rows[a]["CN_S_ITEM_CODE"].ToString());
                    if (itemEntity == null)
                    {
                        return OperateResult.Error("物料" + dtDtl.Rows[a]["CN_S_ITEM_CODE"].ToString() + "实体不存在！");
                    }

                    var stocklocation = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetLocationModel(putPos);
                    if (stocklocation == null)
                    {
                        return OperateResult.Error("摆放位置" + putPos + "货位实体不存在！");
                    }

                    #region 拼接托盘物料
                    string mstGuid = System.Guid.NewGuid().ToString().ToUpper();
                    trayItemDtlList.Add(new TN_WM_B_TRAY_ITEM_DTLEntity()
                    {
                        CN_PARENT_GUID = mstGuid,
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_LOT_NO = dtDtl.Rows[a]["CN_S_LOT_CODE"].ToString(),
                        CN_S_PRODUCTION_BATCH = dtDtl.Rows[a]["CN_S_PRODUCTION_BATCH"].ToString(),
                        CN_S_SERIAL_NO = dtDtl.Rows[a]["CN_S_SERIAL_NO"].ToString(),
                        CN_S_PACKING_UNIT = "个",
                        CN_F_QUANTITY = decimal.Parse(dtDtl.Rows[a]["CN_F_QUANTITY"].ToString()),
                        CN_S_VENDOR_NO = dtDtl.Rows[a]["CN_S_VENDOR_NO"].ToString(),
                        CN_S_VENDOR_NAME = dtDtl.Rows[a]["CN_S_VENDOR_NAME"].ToString(),
                        CN_F_PURCHASE_PRICE = decimal.Parse(!string.IsNullOrEmpty(dtDtl.Rows[a]["CN_F_PURCHASE_PRICE"].ToString()) ? dtDtl.Rows[a]["CN_F_PURCHASE_PRICE"].ToString() : "0"),
                        CN_F_RETAIL_PRICE = decimal.Parse(!string.IsNullOrEmpty(dtDtl.Rows[a]["CN_F_RETAIL_PRICE"].ToString()) ? dtDtl.Rows[a]["CN_F_RETAIL_PRICE"].ToString() : "0"),
                        CN_T_PRODUCTION = DateTime.Parse(!string.IsNullOrEmpty(dtDtl.Rows[a]["CN_T_PRODUCTION"].ToString()) ? dtDtl.Rows[a]["CN_T_PRODUCTION"].ToString() : "1900-01-01"),
                        CN_T_EXPIRATION = DateTime.Parse(!string.IsNullOrEmpty(dtDtl.Rows[a]["CN_T_EXPIRATION"].ToString()) ? dtDtl.Rows[a]["CN_T_EXPIRATION"].ToString() : "1900-01-01"),
                        CN_S_CREATOR = examineEntity.CN_S_CREATOR,
                        CN_S_CREATOR_BY = examineEntity.CN_S_CREATOR_BY,
                        CN_T_CREATE = DateTime.Now,
                        CN_S_MODIFY = examineEntity.CN_S_CREATOR,
                        CN_S_MODIFY_BY = examineEntity.CN_S_CREATOR_BY,
                        CN_T_MODIFY = DateTime.Now,
                        CN_S_NOTE = "到货单审核-绑定摆放位置-虚拟托盘"

                    });
                    trayItemMstList.Add(new TN_WM_B_TRAY_ITEM_MSTEntity()
                    {
                        CN_GUID = mstGuid,
                        CN_S_TRAY_CODE = trayNo,
                        CN_S_TRAY_GRID = "1",
                        CN_S_LOT_NO = dtDtl.Rows[a]["CN_S_LOT_CODE"].ToString(),
                        CN_S_OWNER = dtDtl.Rows[a]["CN_S_OWNER"].ToString(),
                        CN_S_ITEM_CODE = dtDtl.Rows[a]["CN_S_ITEM_CODE"].ToString(),
                        CN_S_ITEM_NAME = dtDtl.Rows[a]["CN_S_ITEM_NAME"].ToString(),
                        CN_S_ITEM_STATE = dtDtl.Rows[a]["CN_S_ITEM_STATE"].ToString(),
                        CN_S_PACKING_UNIT = "个",
                        CN_F_QUANTITY = decimal.Parse(dtDtl.Rows[a]["CN_F_QUANTITY"].ToString()),
                        //获取物料的图号、规格型号、计量单位
                        CN_S_FIGURE_NO = itemEntity == null ? "" : itemEntity.CN_S_FIGURE_NO,
                        CN_S_MODEL = itemEntity == null ? "" : itemEntity.CN_S_MODEL,
                        CN_S_MEASURE_UNIT = itemEntity == null ? "" : itemEntity.CN_S_MEASURE_UNIT

                    });
                    #endregion

                    #region 托盘货位关联
                    trayLocationList.Add(new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_TRAY_CODE = trayNo,
                        CN_S_STOCK_CODE = stocklocation.CN_S_STOCK_CODE,
                        CN_S_STOCK_AREA = stocklocation.CN_S_AREA_CODE,
                        CN_S_LOCATION_CODE = dtDtl.Rows[a]["CN_S_PUT_POSITION"].ToString(),
                        CN_T_CREATE = DateTime.Now
                    });
                    #endregion
                }
                #endregion

                #region 拼接K3对接数据
                //获取策略：是否需要与K3对接
                isUseK3 = GetStrategy(stockCode, StrategyKey.IsUseK3);
                //吉鑫祥项目需要反馈K3系统 
                if (isUseK3.Equals("Y"))
                {
                    //拼接实体
                    List<K3_PurchaseReceiptEntity> returnEntity = new InfK3Request().GetPurchaseReceiptData(examineEntity.CN_S_FROM_NO);
                    if (returnEntity.Any())
                    {
                        K3purchaseReceiptList.AddRange(returnEntity);
                    }
                }
                #endregion

                #region 拼接OMS对接数据
                isUseOms = GetStrategy(stockCode, StrategyKey.IsUseOms);
                if (isUseOms.Equals("Y"))
                {
                    OmsAccStockInNumEntity AccStockInNum = new OmsAccStockInNumEntity();
                    DataTable dtall = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetOmsInOrderModel(examineEntity.CN_S_FROM_NO);
                    if (dtall.Rows[0]["CN_S_OP_TYPE"].ToString() == "初始化入库") continue;
                    if (dtall.Rows.Count == 0 || dtall.Rows[0]["CN_S_FROM_NO"].ToString() == "")// 手工到货生成入库单 时审核
                    {
                        DataTable dtin = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetOmsInModel(examineEntity.CN_S_FROM_NO);
                        if (dt.Rows[0]["CN_S_OP_TYPE"].ToString() == "初始化入库") continue;
                        List<InOrder> InOrderList = new List<InOrder>();
                        for (int i = 0; i < dtin.Rows.Count; i++)
                        {
                            string postData = "{\"appCode\":\"" + Constants.appOmsCode + "\",\"ruleName\":\"" + Constants.PURCHASE_TICKET_NO + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                            string opNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);

                            InOrder inorder = new InOrder();
                            inorder.CN_S_OP_FROM_NO = dtin.Rows[i]["CN_S_FROM_NO"].ToString();                //入库单号
                            inorder.CN_S_ITEM_CODE = dtin.Rows[i]["CN_S_ITEM_CODE"].ToString();               //物料编码
                            inorder.CN_S_ITEM_NAME = dtin.Rows[i]["CN_S_ITEM_NAME"].ToString();               //物料名称
                            inorder.CN_S_STOCKIN_QTY = int.Parse(decimal.Parse(dtin.Rows[i]["CN_F_QUANTITY"].ToString()).ToString("0"));   //入库数量
                            inorder.CN_S_OP_TYPE = dtin.Rows[i]["CN_S_OP_TYPE"].ToString();                   //类型
                            inorder.CN_S_STOCK_CODE = dtin.Rows[i]["CN_S_STOCK_CODE"].ToString();             //入库仓库
                            inorder.CN_S_VENDOR_NO = dtin.Rows[i]["CN_S_VENDOR_NO"].ToString();               //供应商
                            inorder.CN_S_VENDOR_SHORTNAME = dtin.Rows[i]["CN_S_VENDOR_NAME"].ToString();      //供应商名称
                            inorder.CN_S_ORDER_NO = "";                                                       //采购订单号
                            inorder.CN_N_ROW_NO = 0;                                                          //采购订单行号
                            inorder.CN_F_PRICE = decimal.Parse(string.IsNullOrEmpty(dtin.Rows[i]["CN_F_PRICE"].ToString()) ? "0" : dtin.Rows[i]["CN_F_PRICE"].ToString());           //单价
                            inorder.CN_F_MONEY_SUM = decimal.Parse(string.IsNullOrEmpty(dtin.Rows[i]["CN_F_MONEY_SUM"].ToString()) ? "0" : dtin.Rows[i]["CN_F_MONEY_SUM"].ToString());      //金额
                            inorder.CN_S_OP_NO = opNo;                                                      //发票初始化编码
                            inorder.CN_S_FIGURE_NO = dtin.Rows[i]["CN_S_FIGURE_NO"].ToString();               //物料图号
                            inorder.CN_S_MODEL = dtin.Rows[i]["CN_S_MODEL"].ToString();                       //规格型号
                            inorder.CN_S_DELIVERY_NO = dtin.Rows[i]["CN_S_DELIVERY_NOTE"].ToString();
                            inorder.CN_S_MEASURE_UNIT = dtin.Rows[i]["CN_S_MEASURE_UNIT"].ToString();
                            inorder.CN_S_NOTE = dtin.Rows[i]["CN_S_NOTE"].ToString();

                            InOrderList.Add(inorder);
                        }
                        AccStockInNum.CN_S_OP_NO = dtin.Rows[0]["CN_S_FROM_NO"].ToString();
                        AccStockInNum.InOrderList = InOrderList;
                        AccStockInNumlist.Add(AccStockInNum);
                    }
                    else
                    {
                        List<InOrder> InOrderList = new List<InOrder>();
                        for (int i = 0; i < dtall.Rows.Count; i++)
                        {
                            string postData = "{\"appCode\":\"" + Constants.appOmsCode + "\",\"ruleName\":\"" + Constants.PURCHASE_TICKET_NO + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                            string opNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);

                            InOrder inorder = new InOrder();
                            inorder.CN_S_OP_FROM_NO = dtall.Rows[i]["CN_S_FROM_NO"].ToString();                //入库单号
                            inorder.CN_S_ITEM_CODE = dtall.Rows[i]["CN_S_ITEM_CODE"].ToString();               //物料编码
                            inorder.CN_S_ITEM_NAME = dtall.Rows[i]["CN_S_ITEM_NAME"].ToString();               //物料名称
                            inorder.CN_S_STOCKIN_QTY = int.Parse(decimal.Parse(dtall.Rows[i]["CN_F_QUANTITY"].ToString()).ToString("0"));   //入库数量
                            inorder.CN_S_OP_TYPE = dtall.Rows[i]["CN_S_OP_TYPE"].ToString();                   //类型
                            inorder.CN_S_STOCK_CODE = dtall.Rows[i]["CN_S_STOCK_CODE"].ToString();             //入库仓库
                            inorder.CN_S_VENDOR_NO = dtall.Rows[i]["CN_S_VENDOR_NO"].ToString();               //供应商
                            inorder.CN_S_VENDOR_SHORTNAME = dtall.Rows[i]["CN_S_VENDOR_NAME"].ToString();      //供应商名称
                            inorder.CN_S_ORDER_NO = dtall.Rows[i]["CN_S_OP_NO"].ToString();                    //采购订单号
                            inorder.CN_N_ROW_NO = int.Parse(dtall.Rows[i]["CN_N_ROW_NO"].ToString());          //采购订单行号
                            inorder.CN_F_PRICE = decimal.Parse(string.IsNullOrEmpty(dtall.Rows[i]["CN_F_PRICE"].ToString()) ? "0" : dtall.Rows[i]["CN_F_PRICE"].ToString());           //单价
                            inorder.CN_F_MONEY_SUM = decimal.Parse(string.IsNullOrEmpty(dtall.Rows[i]["CN_F_MONEY_SUM"].ToString()) ? "0" : dtall.Rows[i]["CN_F_MONEY_SUM"].ToString());      //金额
                            inorder.CN_S_OP_NO = opNo;                                                      //发票初始化编码
                            inorder.CN_S_FIGURE_NO = dtall.Rows[i]["CN_S_FIGURE_NO"].ToString();               //物料图号
                            inorder.CN_S_MODEL = dtall.Rows[i]["CN_S_MODEL"].ToString();                       //规格型号
                            inorder.CN_S_DELIVERY_NO = dtall.Rows[i]["CN_S_DELIVERY_NOTE"].ToString();

                            InOrderList.Add(inorder);
                        }
                        AccStockInNum.CN_S_OP_NO = dtall.Rows[0]["CN_S_FROM_NO"].ToString();
                        AccStockInNum.InOrderList = InOrderList;
                        AccStockInNumlist.Add(AccStockInNum);
                    }
                }

                #endregion
            }

            OperateResult operateResult = UseTransaction(trans =>
            {
                #region 调用K3接口
                //吉鑫祥项目需要反馈K3系统 
                if (K3purchaseReceiptList.Any())
                {
                    OperateResult re = new InfK3Request().sendK3_Purchase_Receipt(K3purchaseReceiptList);
                    if (!re.Success)
                    {
                        throw new Exception(re.Msg);
                    }
                }
                #endregion

                #region 调用OMS接口
                if (isUseOms.Equals("Y") && AccStockInNumlist.Count > 0)
                {
                    string postOmsData = JsonConvert.SerializeObject(AccStockInNumlist);
                    string resultEntity = WebApiManager.HttpOms_Post("api/PurchaseService/UpdateAccStockInNum", postOmsData);
                    OmsAccStockInNumResponse qir = JsonConvert.DeserializeObject<OmsAccStockInNumResponse>(resultEntity);
                    TN_WMS_REQ_LOGEntity ril = new TN_WMS_REQ_LOGEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_INTERFACE = "Inspect-DoSubmit",
                        CN_S_INTERFACE_NAME = "WMS调用OMS更新累积入库数接口发送指令",
                        CN_S_REQUEST = postOmsData,
                        CN_S_RESPONSE = resultEntity,
                        CN_T_CREATE = DateTime.Now
                    };
                    CreateDAL<DapperDAL<TN_WMS_REQ_LOGEntity>>().Add(ril);
                    if (qir != null)
                    {
                        if (!qir.success)
                        {
                            throw new Exception("更新累积入库数失败！" + qir.errorMes);
                        }
                    }
                    else
                    {
                        throw new Exception("OMS更新累积入库数未调通！" + qir.errorMes);
                    }
                }
                #endregion

                #region 审核入库单主子表
                //审核主表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineMst(entity, Constants.State_Audit, trans);
                //审核子表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineDtl(entity, Constants.State_Audit, trans);
                #endregion

                #region 影响量表
                if (isNeedAddStockQty)
                {
                    //影响仓库量表
                    CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(stockQtyList, trans);
                    //影响库区量表
                    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(stockAreaQtyList, trans);
                }
                #endregion

                #region 新增托盘货位、托盘物料关联
                //新增托盘货位关联
                CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().AddRange(trayLocationList, trans);

                //新增托盘物料主表
                if (trayItemMstList.Any())
                {
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().AddRange(trayItemMstList, trans);
                }
                //新增托盘物料子表
                if (trayItemDtlList.Any())
                {
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().AddRange(trayItemDtlList, trans);
                }
                #endregion
            });
            return operateResult;
        }

        #endregion

        #region 反审入库单
        /// <summary>
        /// 反审入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult ReAudit(List<TN_WM_B_EXAMINEEntity> entity)
        {
            bool isNeedAddStockQty = true;//策略控制：入库是否需要影响仓库和库区（到货区）量
            string opNoList = "";
            foreach (TN_WM_B_EXAMINEEntity item in entity)
            {
                opNoList = opNoList + "'" + item.CN_S_FROM_NO + "',";
            }
            if (!string.IsNullOrEmpty(opNoList))
            {
                opNoList = opNoList.Substring(0, opNoList.Length - 1);
            }

            #region 判断物料是否已上架
            List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetSHLocationArea(Constants.ReceivingArea);
            if (!areaList.Any())
            {
                return OperateResult.Error("未获取到收货区实体，请配置库区<收货区>！");
            }

            var calCancel = true;
            var itemCode = "";
            List<TN_WM_B_AREA_QTYEntity> areaQtyList = CreateDAL<TN_WM_B_AREA_QTYDAL>().GetCancelData(opNoList);
            foreach (var item in areaQtyList)
            {
                if (item.CN_S_STOCK_AREA != areaList[0].CN_S_AREA_CODE)//说明物料不在收货区了，物料存在上架，不准取消单据
                {
                    itemCode = item.CN_S_ITEM_CODE;
                    calCancel = false;
                    break;
                }
            }
            if (!calCancel)
            {
                return OperateResult.Error("单据中物料 " + itemCode + " 已不在收货区，操作失败！");
            }
            #endregion

            List<TN_WM_B_TRAY_LOCATIONEntity> lstTrayCode = CreateDAL<TN_WM_B_TRAY_LOCATIONDAL>().GetTrayCodeByIncrease(opNoList);
            string opTrayCodeList = "";
            if (lstTrayCode.Any())
            {
                foreach (TN_WM_B_TRAY_LOCATIONEntity item in lstTrayCode)
                {
                    opTrayCodeList = opTrayCodeList + "'" + item.CN_S_TRAY_CODE + "',";
                }
            }
            if (!string.IsNullOrEmpty(opTrayCodeList))
            {
                opTrayCodeList = opTrayCodeList.Substring(0, opTrayCodeList.Length - 1);
            }
            TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new { CN_S_OP_NO = entity[0].CN_S_FROM_NO });


            //获取策略：是否需要与外部对接
            string isUseK3 = SysCache.GetStrategyValue(inMstEntity.CN_S_STOCK_CODE, StrategyKey.IsUseK3);
            string isUseOms = SysCache.GetStrategyValue(inMstEntity.CN_S_STOCK_CODE, StrategyKey.IsUseOms);

            //吉鑫祥项目需要反馈K3系统 
            if (isUseK3.Equals("Y"))
            {

            }

            //拼接OMS数据
            WmsReAuditToOmsEntity ReAuditToOmsEntity = new WmsReAuditToOmsEntity();
            if (isUseOms.Equals("Y"))
            {
                foreach (var item in entity)
                {
                    DataTable dt = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetOmsInOrderModel(item.CN_S_FROM_NO);
                    if (dt.Rows.Count == 0 || dt.Rows[0]["CN_S_FROM_NO"].ToString() == "")
                    {
                        DataTable dtin = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetOmsInModel(item.CN_S_FROM_NO);
                        List<InOrderList> inorderList = new List<InOrderList>();
                        for (int i = 0; i < dtin.Rows.Count; i++)
                        {
                            InOrderList inorderEntity = new InOrderList()
                            {
                                stockInNo = dtin.Rows[i]["CN_S_FROM_NO"].ToString(),                 //入库订单号
                                purchaseOrderCode = "",                                               //采购单
                                itemCode = dtin.Rows[i]["CN_S_ITEM_CODE"].ToString(),                //物料编码
                                rowNum = 0,                                                          //采购单行号
                                Nums = decimal.Parse(string.IsNullOrEmpty(dtin.Rows[i]["CN_F_QUANTITY"].ToString()) ? "0" : dtin.Rows[i]["CN_F_QUANTITY"].ToString())           //到货数量
                            };
                            inorderList.Add(inorderEntity);
                        }
                        ReAuditToOmsEntity.InOrderList = inorderList;
                    }
                    else
                    {
                        List<InOrderList> inorderList = new List<InOrderList>();
                        for (int i = 0; i < dt.Rows.Count; i++)
                        {
                            InOrderList inorderEntity = new InOrderList()
                            {
                                stockInNo = dt.Rows[i]["CN_S_FROM_NO"].ToString(),                 //入库订单号
                                purchaseOrderCode = dt.Rows[i]["CN_S_OP_NO"].ToString(),           //采购单
                                itemCode = dt.Rows[i]["CN_S_ITEM_CODE"].ToString(),                //物料编码
                                rowNum = int.Parse(string.IsNullOrEmpty(dt.Rows[i]["CN_N_FROM_ROW_NO"].ToString()) ? "0" : dt.Rows[i]["CN_N_FROM_ROW_NO"].ToString()),//采购单行号
                                Nums = decimal.Parse(string.IsNullOrEmpty(dt.Rows[i]["CN_F_QUANTITY"].ToString()) ? "0" : dt.Rows[i]["CN_F_QUANTITY"].ToString())           //到货数量
                            };
                            inorderList.Add(inorderEntity);
                        }
                        ReAuditToOmsEntity.InOrderList = inorderList;
                    }
                }
            }

            OperateResult operateResult = UseTransaction(trans =>
            {
                if (isUseOms.Equals("Y"))
                {
                    string postData = JsonConvert.SerializeObject(ReAuditToOmsEntity.InOrderList);
                    string resultEntity = WebApiManager.HttpOms_Post("api/PurchaseService/UpdateAccStockInNumDesc", postData);

                    if (string.IsNullOrEmpty(resultEntity))
                    {
                        throw new Exception("UpdateAccStockInNumDesc更新累积入库数接口未调通！");
                    }

                    QiMenInConfirmResponse qir = JsonConvert.DeserializeObject<QiMenInConfirmResponse>(resultEntity);

                    TN_WMS_REQ_LOGEntity ril = new TN_WMS_REQ_LOGEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_INTERFACE = "ReConfirmOms",
                        CN_S_INTERFACE_NAME = "WMS入库确认调用OMS接口发送反审核指令",
                        CN_S_REQUEST = postData,
                        CN_S_RESPONSE = resultEntity,
                        CN_T_CREATE = DateTime.Now
                    };
                    CreateDAL<DapperDAL<TN_WMS_REQ_LOGEntity>>().Add(ril);

                    if (qir.flag == "failure")
                    {
                        throw new Exception("更新累积入库数失败！" + qir.message);
                    }
                }
                if (isNeedAddStockQty)
                {
                    //影响仓库量表
                    CreateDAL<TN_WM_B_STOCK_QTYDAL>().DeleteStockQty(opNoList, trans);
                    //影响库区量表
                    CreateDAL<TN_WM_B_AREA_QTYDAL>().DeleteAreaQty(opNoList, trans);
                }
                //反审主表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineMst(entity, Constants.State_ReAudit, trans);
                //反审子表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineDtl(entity, Constants.State_ReAudit, trans);

                //  撤销托盘货位关联数据
                CreateDAL<TN_WM_B_TRAY_LOCATIONDAL>().DeleteByTrayCode(opTrayCodeList, trans);

                //  撤销托盘产品关联主子表数据
                CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().DeleteByFromNo(opTrayCodeList, trans);

            });
            return operateResult;
        }

        #endregion

        #region 取消入库单
        /// <summary>
        /// 取消入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-11</History>
        public OperateResult CancelIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            string opNoList = "";
            foreach (TN_WM_B_EXAMINEEntity item in entity)
            {
                opNoList = opNoList + "'" + item.CN_S_FROM_NO + "',";
            }
            if (!string.IsNullOrEmpty(opNoList))
            {
                opNoList = opNoList.Substring(0, opNoList.Length - 1);
            }

            #region 判断物料是否已上架 
            List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetSHLocationArea(Constants.ReceivingArea);
            if (!areaList.Any())
            {
                return OperateResult.Error("未获取到收货区实体，请配置库区<收货区>！");
            }

            var calCancel = true;
            var itemCode = "";
            List<TN_WM_B_AREA_QTYEntity> areaQtyList = CreateDAL<TN_WM_B_AREA_QTYDAL>().GetCancelData(opNoList);
            foreach (var item in areaQtyList)
            {
                if (item.CN_S_STOCK_AREA != areaList[0].CN_S_AREA_CODE)//说明物料不在收货区了，物料存在上架，不准取消单据
                {
                    itemCode = item.CN_S_ITEM_CODE;
                    calCancel = false;
                    break;
                }
            }
            if (!calCancel)
            {
                return OperateResult.Error("单据中物料 " + itemCode + " 已不在收货区，操作失败！");
            }
            #endregion 

            OperateResult operateResult = UseTransaction(trans =>
            {
                //影响仓库量表
                CreateDAL<TN_WM_B_STOCK_QTYDAL>().DeleteStockQty(opNoList, trans);
                //影响库区量表
                CreateDAL<TN_WM_B_AREA_QTYDAL>().DeleteAreaQty(opNoList, trans);

                //反审主表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineMst(entity, Constants.State_Cancel, trans);
                //反审子表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineDtl(entity, Constants.State_Cancel, trans);

            });
            return operateResult;
        }
        #endregion

        #region 驳回入库单
        /// <summary>
        /// 驳回入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <param name="entity">驳回记录实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        public OperateResult Reject(List<TN_WM_B_EXAMINEEntity> entity, TN_WM_B_REJECTEntity rejectEntity)
        {
            OperateResult operateResult = UseTransaction(trans =>
            {
                //驳回主表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineMst(entity, Constants.State_Reject, trans);
                //驳回子表
                CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().ExamineDtl(entity, Constants.State_Reject, trans);
                //插入驳回记录
                CreateDAL<DapperDAL<TN_WM_B_REJECTEntity>>().Add(rejectEntity, trans);
            });
            return operateResult;
        }
        #endregion

        #region 获取入库
        /// <summary>
        /// 获取入库
        /// </summary>
        /// <param name="sqlwhere">条件</param>
        /// <returns></returns>
        /// <History>[HANHE(lt)] CREATED BY 2018-11-15</History>
        public DataTable GetDataTableInventory(string sqlwhere)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetDataTableInventory(sqlwhere);
        }
        #endregion

        #region 获取入库列表
        /// <summary>
        /// 获取入库列表
        /// </summary>
        /// <param name="sqlwhere">条件</param>
        /// <returns></returns>
        /// <History>[HANHE(lt)] CREATED BY 2018-11-22</History>
        public DataTable GetList(string sqlwhere)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetList(sqlwhere);
        }
        #endregion

        #region 获取入库订单列表
        /// <summary>
        /// 获取入库订单列表
        /// </summary>
        /// <param name="sqlwhere">条件</param>
        /// <returns></returns>
        /// <History>[HANHE(lt)] CREATED BY 2018-11-22</History>
        public DataTable GetInMstList(string sqlwhere)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetInMstList(sqlwhere);
        }


        /// <summary>
        /// 获取入库订单列表
        /// </summary>
        /// <param name="sqlwhere">条件</param>
        /// <returns></returns>
        /// <History>[HANHE(lt)] CREATED BY 2018-11-22</History>
        public DataTable GetInDtlList(string sqlwhere)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetInDtlList(sqlwhere);
        }

        public DataTable GetIncreaseList(SearchModel searchModel, out long total, bool isExport)
        {
            DataTable dt = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetIncreaseList(searchModel, out total, isExport);

            dt.Columns["CN_S_STOCK_CODE"].ReadOnly = false;
            //foreach (DataRow dr in dt.Rows)
            //{
            //    dr["CN_S_STOCK_CODE"] = GetStock().Find(x => x.CN_S_STOCK_CODE.Equals(dr["CN_S_STOCK_CODE"].ToString().Trim())).CN_S_STOCK_NAME;
            //}
            return dt;
        }

        /// <summary>
        /// 获取采购单
        /// </summary>
        /// <param name="sqlwhere">条件</param>
        /// <returns></returns>
        /// <History>[HANHE(lt)] CREATED BY 2018-11-15</History>
        public DataTable GetMstJoinDtl(string sqlwhere)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetMstJoinDtl(sqlwhere);
        }
        #endregion

        #region 根据生产批次获取入库单子表数据
        /// <summary>
        /// 根据生产批次获取入库单子表数据
        /// </summary>
        /// <param name="batchNo">生产批次</param>
        /// <returns></returns>
        public List<TN_WM_INCREASE_INVENTORY_DTLEntity> GetDtlByBatch(string batchNo)
        {
            return CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().GetList(new { CN_S_PRODUCTION_BATCH = batchNo });
        }
        #endregion

        #region 获取未完全打印的入库单记录
        /// <summary>
        /// 获取未完全打印的入库单记录
        /// </summary>
        /// <param name="stockCode">仓库号</param>
        /// <returns></returns>
        /// <History>[HANHE(DBS)] CREATED BY 2019-02-28</History>
        public OperateResult GetWaitPrintOrder(string stockCode)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetWaitPrintOrder(stockCode);
        }
        #endregion

        #region 获取所有待上架（暂存区）的物料(到货入+移库入)
        /// <summary>
        /// 获取所有待上架（暂存区）的物料(到货入+移库入)
        /// </summary>
        /// <param name="itemCode">物料编号</param>
        /// <returns></returns>
        /// <History>[HANHE(DBS)] CREATED BY 2019-03-7</History>
        public List<TN_WM_B_TRAY_ITEM_MSTEntity> GetWaitUpShelvesItems(string itemCode)
        {
            List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetZCLocationArea(Constants.TempStorageArea);
            if (!areaList.Any())
            {
                // return OperateResult.Error("未获取到暂存区实体，请配置库区<暂存区>！");
                return new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
            }

            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetWaitUpShelvesItems(itemCode, areaList);
        }
        #endregion

        #region PDA、外部调用全部接口

        #region U8服务调用-调拨单更新物料状态
        /// <summary>
        /// U8服务调用-调拨单更新物料状态
        /// </summary>
        /// <param name="transVouchList">批次对应物料集合</param>
        /// <returns></returns>
        public OperateResult UpdateTransVouchItemState(List<U8_TransVouchEntity> transVouchList)
        {
            OperateResult operateResult = UseTransaction(trans =>
           {
               //更新托盘物料关联主子表
               CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().UpdateTrayItemState(transVouchList, trans);

               //更新仓库、库区量表
               CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().UpdateStockQtyItemState(transVouchList, trans);

               CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().UpdateAreaQtyItemState(transVouchList, trans);

               //更新XML导入表
               CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().UpdateXmlItemState(transVouchList, trans);
           });
            return operateResult;
        }
        #endregion

        #region U8服务调用-新增入库单主子表、仓库库区量表
        /// <summary>
        /// U8服务调用-新增入库单主子表、仓库库区量表
        /// </summary>
        /// <param name="mstList">入库单主子表集合</param>
        /// <returns></returns>
        public OperateResult AddU8InData(List<TN_WM_INCREASE_INVENTORY_MSTEntity> mstList)
        {
            List<TN_WM_B_STOCK_QTYEntity> stockQtyList = new List<TN_WM_B_STOCK_QTYEntity>();//影响仓库量表
            List<TN_WM_B_AREA_QTYEntity> stockAreaQtyList = new List<TN_WM_B_AREA_QTYEntity>();//影响库区量表

            List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetSHLocationArea(Constants.ReceivingArea);
            if (!areaList.Any())
            {
                return OperateResult.Error("未获取到收货区实体，请配置库区<收货区>！");
            }

            for (int i = 0; i < mstList.Count; i++)
            {
                for (int j = 0; j < mstList[i].DTLEntity.Count; j++)
                {
                    string itemCode = mstList[i].DTLEntity[j].CN_S_ITEM_CODE;
                    string itemName = mstList[i].DTLEntity[j].CN_S_ITEM_NAME;
                    string itemState = mstList[i].DTLEntity[j].CN_S_ITEM_STATE;
                    string lotCode = mstList[i].CN_S_LOT_NO;
                    string productionBatch = mstList[i].DTLEntity[j].CN_S_PRODUCTION_BATCH;
                    string owner = mstList[i].CN_S_OWNER;
                    string stockCode = mstList[i].CN_S_STOCK_CODE;
                    string qty = mstList[i].DTLEntity[j].CN_F_QUANTITY.ToString();
                    DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)); // 当地时区
                    long timeStamp = (long)(DateTime.Now - startTime).TotalMilliseconds; // 相差毫秒数

                    #region 拼接仓库量表实体
                    stockQtyList.Add(new TN_WM_B_STOCK_QTYEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_OWNER = owner,
                        CN_S_ITEM_CODE = itemCode,
                        CN_S_ITEM_NAME = itemName,
                        CN_S_ITEM_STATE = itemState,
                        CN_S_LOT_NO = lotCode,
                        CN_S_PRODUCTION_BATCH = productionBatch,
                        CN_S_STOCK_CODE = stockCode,
                        CN_F_QUANTITY = Convert.ToDecimal(qty),
                        CN_F_PLANNED_QTY = 0,
                        CN_F_ALLOC_QTY = 0,
                        CN_F_PRELOCK_QTY = 0,
                        CN_S_TIMESTAMP = timeStamp.ToString()
                    });
                    #endregion

                    #region 拼接库区量表实体
                    stockAreaQtyList.Add(new TN_WM_B_AREA_QTYEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_OWNER = owner,
                        CN_S_ITEM_CODE = itemCode,
                        CN_S_ITEM_NAME = itemName,
                        CN_S_ITEM_STATE = itemState,
                        CN_S_LOT_NO = lotCode,
                        CN_S_PRODUCTION_BATCH = productionBatch,
                        CN_S_STOCK_CODE = stockCode,
                        CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE,
                        CN_F_QUANTITY = Convert.ToDecimal(qty),
                        CN_F_PLANNED_QTY = 0,
                        CN_F_ALLOC_QTY = 0,
                        CN_S_TIMESTAMP = timeStamp.ToString()
                    });
                    #endregion
                }
            }

            OperateResult operateResult = new OperateResult();
            operateResult = UseTransaction(trans =>
            {
                for (int i = 0; i < mstList.Count; i++)
                {
                    CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().Add(mstList[i]);

                    CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().AddRange(mstList[i].DTLEntity);
                }
                //影响仓库量表
                CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(stockQtyList, trans);
                //影响库区量表
                CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(stockAreaQtyList, trans);
            });
            return operateResult;
        }
        #endregion

        #region 获取可上架入库单列表(PDA)
        /// <summary>
        /// 获取可上架入库单列表
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        public List<TN_WM_INCREASE_INVENTORY_MSTEntity> GetIncreaseInventoryList(string CN_S_OP_NO)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetIncreaseInventoryList(CN_S_OP_NO);
        }
        #endregion

        #region 获取可码盘入库单列表(PDA)
        /// <summary>
        /// 获取可码盘入库单列表
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-12-5</History>
        public List<TN_WM_INCREASE_INVENTORY_MSTEntity> GetInListWithCodedisc(string CN_S_OP_NO)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetInListWithCodedisc(CN_S_OP_NO);
        }
        #endregion

        #region 根据单号获取主子表信息(PDA)
        /// <summary>
        /// 根据单号获取主子表信息
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-19</History>
        public TN_WM_INCREASE_INVENTORY_MSTEntity GetIncreaseInventoryMstAndDtl(string CN_S_OP_NO)
        {
            TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new { CN_S_OP_NO = CN_S_OP_NO });
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> inDtlEntity = CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().GetList(new { CN_S_OP_NO = CN_S_OP_NO });

            foreach (var entity in inDtlEntity)
            {
                AutoBomItemEntity itemenity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(entity.CN_S_ITEM_CODE);
                if (itemenity != null)
                {
                    entity.CN_F_WARRNTY_PARTS = itemenity.CN_F_WARRNTY_PARTS;
                    entity.AuxiliaryUnitList = itemenity.AuxiliaryUnitList;
                }
            }
            inMstEntity.DTLEntity = inDtlEntity;
            return inMstEntity;
        }

        /// <summary>
        /// 根据入库单号获取可码盘明细
        /// </summary>
        /// <param name="CN_S_OP_NO">入库单号</param>
        /// <returns></returns>
        public TN_WM_INCREASE_INVENTORY_MSTEntity GetInMstAndDtl_OnTray(string CN_S_OP_NO)
        {
            TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new { CN_S_OP_NO = CN_S_OP_NO });
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> inDtlEntity = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetDtlList_OnTray(CN_S_OP_NO);

            foreach (var entity in inDtlEntity)
            {
                AutoBomItemEntity itemenity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(entity.CN_S_ITEM_CODE);
                entity.CN_F_WARRNTY_PARTS = itemenity.CN_F_WARRNTY_PARTS;

                entity.AuxiliaryUnitList = itemenity.AuxiliaryUnitList;
            }
            inMstEntity.DTLEntity = inDtlEntity;
            return inMstEntity;
        }

        /// <summary>
        /// 根据入库单号获取可上架明细
        /// </summary>
        /// <param name="CN_S_OP_NO">入库单号</param>
        /// <returns></returns>
        public TN_WM_INCREASE_INVENTORY_MSTEntity GetInMstAndDtl_OnShelf(string CN_S_OP_NO)
        {
            TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = CreateDAL<DapperDAL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new { CN_S_OP_NO = CN_S_OP_NO });
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> inDtlEntity = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetInMstAndDtl_OnShelf(CN_S_OP_NO);

            foreach (var entity in inDtlEntity)
            {
                AutoBomItemEntity itemenity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(entity.CN_S_ITEM_CODE);
                entity.CN_F_WARRNTY_PARTS = itemenity.CN_F_WARRNTY_PARTS;

                entity.AuxiliaryUnitList = itemenity.AuxiliaryUnitList;
            }
            inMstEntity.DTLEntity = inDtlEntity;
            return inMstEntity;
        }

        #endregion

        #region 根据入库单号获取入库单明细(PDA)
        /// <summary>
        /// 根据入库单号获取入库单明细
        /// </summary>
        /// <param name="CN_S_OP_NO">入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        public List<TN_WM_INCREASE_INVENTORY_DTLEntity> GetIncreaseInventoryDetail(string CN_S_OP_NO)
        {
            List<TN_WM_INCREASE_INVENTORY_DTLEntity> newList = new List<TN_WM_INCREASE_INVENTORY_DTLEntity>();

            newList = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetIncreaseInventoryDetail(CN_S_OP_NO);

            foreach (var item in newList)
            {
                var itemCode = item.CN_S_ITEM_CODE;
                AutoBomItemEntity itementity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(itemCode);//获取物料判断物料类型
                item.CN_S_SIZEPRODUCT = itementity.CN_S_SIZEPRODUCT;

                List<ItemCapacityEntity> ItemCapacityList = new List<ItemCapacityEntity>();

                List<TN_WM_B_TRAY_CAPACITYEntity> itemCapacity = CreateDAL<DapperDAL<TN_WM_B_TRAY_CAPACITYEntity>>().GetList(new { CN_S_ITEM_CODE = itemCode });
                foreach (var itemC in itemCapacity)
                {
                    ItemCapacityList.Add(new ItemCapacityEntity
                    {
                        CN_S_ITEM_CODE = itemC.CN_S_ITEM_CODE,
                        CN_S_SPEC = itemC.CN_S_SPEC,
                        CN_S_STORE_UNIT = itemC.CN_S_STORE_UNIT,
                        CN_F_QUANTITY = itemC.CN_F_QUANTITY
                    });
                }
                item.ItemCapacityList = ItemCapacityList;
            }

            return newList;
        }
        #endregion

        #region PDA贴码-搬运接口(PDA)
        /// <summary>
        /// PDA接口-获取待贴码信息
        /// </summary>
        /// <param name="printBarCode">打码实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        public DataTable GetFixedData(MONGO_PRINT_BARCODE printBarCode)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetFixedData(printBarCode);
        }

        /// <summary>
        /// 贴码确认
        /// </summary>
        /// <param name="printBarCode">打码实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        public OperateResult FixedConfirm(MONGO_PRINT_BARCODE printBarCode)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().FixedConfirm(printBarCode);
        }

        /// <summary>
        /// PDA接口-获取搬运信息
        /// </summary>
        /// <param name="printBarCode">打码实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        public OperateResult GetTransData(MONGO_PRINT_BARCODE printBarCode)
        {
            List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetSHLocationArea(Constants.ReceivingArea);
            if (!areaList.Any())
            {
                return OperateResult.Error("未获取到收货区实体，请配置库区<收货区>！");
            }

            //查询到获去搬运的物料量
            List<TN_WM_B_AREA_QTYEntity> areaQtyList = BLLCreator.Create<DapperBLL<TN_WM_B_AREA_QTYEntity>>().GetList(new
            {
                CN_S_ITEM_CODE = printBarCode.CN_S_ITEM_CODE,
                CN_S_ITEM_STATE = printBarCode.CN_S_ITEM_STATE,
                CN_S_LOT_NO = printBarCode.CN_S_LOT_NO,
                CN_S_PRODUCTION_BATCH = printBarCode.CN_S_PRODUCTION_BATCH,
                CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE,
            });

            if (areaQtyList.Count == 0)
            {
                return OperateResult.Error("无收货区物料可供搬运！");
            }

            //获取缺货数量，看看是否需要补缺
            List<TN_WM_OUT_DTLEntity> dtlList = CreateDAL<TN_WM_OUT_MSTDAL>().GetBuqueOutList(printBarCode);

            //获取搬运的数据
            DataTable dt = CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetTransData(printBarCode);

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                List<TN_WM_B_AREA_QTYEntity> areaQty = areaQtyList.Where(x => x.CN_S_ITEM_CODE == dt.Rows[i]["CN_S_ITEM_CODE"].ToString()).ToList();
                if (areaQty.Count == 0) continue;
                dt.Rows[i]["CN_F_QUANTITY"] = areaQty[0].CN_F_QUANTITY;//正常需要搬运的数量
                if (dtlList.Count > 0)
                {
                    dt.Rows[i]["CN_F_QUANTITY"] = Convert.ToDecimal(dtlList[0].CN_F_QUANTITY);//缺货数量
                    dt.Rows[i]["CN_S_PUT_POSITION"] = Constants.State_Shortage;//缺货
                }
            }

            return OperateResult.Succeed("", dt);
        }

        /// <summary>
        ///  PDA接口-搬运确认
        /// </summary>
        /// <param name="_json"></param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        public OperateResult TransConfirm(JObject json)
        {
            string arrivalCode = json.Value<string>("ArrivalCode");
            string itemCode = json.Value<string>("ItemCode");
            string transLocationCode = json.Value<string>("TransLocationCode");//搬运位置,仅补缺的情况下存值
            string quantity = json.Value<string>("Quantity");//数量

            //暂存区生成实体
            List<TN_WM_B_TRAY_LOCATIONEntity> objZanCunEntityList = new List<TN_WM_B_TRAY_LOCATIONEntity>();

            #region 摆放位置校验
            DataTable dtPos = CreateDAL<TN_WM_ARRIVALDAL>().GetPutPosition(arrivalCode, itemCode);
            if (dtPos.Rows.Count > 0)
            {
                string putPos = dtPos.Rows[0]["CN_S_PUT_POSITION"].ToString();
                return OperateResult.Error("未找到物料所在的摆放位置！");
            }
            string putPosition = dtPos.Rows[0]["CN_S_PUT_POSITION"].ToString();
            AutoBomLocationEntity putPositionEntity = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetLocationModel(putPosition);
            if (putPositionEntity == null)
            {
                return OperateResult.Error("摆放位置无效！");
            }
            #endregion

            //库区量表
            List<TN_WM_B_AREA_QTYEntity> lstModel = new List<TN_WM_B_AREA_QTYEntity>();

            //说明搬至暂存区
            if (string.IsNullOrEmpty(transLocationCode))
            {
                //搬往暂存位
                List<AutoBomStockAreaEntity> areaList = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetZCLocationArea(Constants.TempStorageArea);
                if (!areaList.Any())
                {
                    return OperateResult.Error("未获取到暂存区实体，请配置库区<暂存区>！");
                }

                List<AutoBomLocationEntity> locationList = CreateDAL<DapperDAL<AutoBomLocationEntity>>().GetList(new { CN_S_AREA_CODE = areaList[0].CN_S_AREA_CODE });
                string zancunLocationCode = "CK001_ZANCUN";
                if (locationList.Any())
                {
                    zancunLocationCode = locationList[0].CN_S_LOCATION_CODE;
                }

                //管控维度到货位，需要生成托盘货位关联表
                if (areaList[0].CN_S_CONTROL_LEVE == "货位")
                {
                    //transLocationCode暂存区位置
                    string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.VirtualTray + "\",\"orgId\":\"\",\"orgFlag\":\"0\"}";
                    string trayNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
                    if (string.IsNullOrEmpty(trayNo))
                    {
                        return OperateResult.Error("虚拟托盘号生成失败！");
                    }
                    objZanCunEntityList.Add(new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                        CN_S_TRAY_CODE = trayNo,
                        CN_S_STOCK_CODE = areaList[0].CN_S_STOCK_CODE,
                        CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE,
                        CN_S_LOCATION_CODE = zancunLocationCode,
                        CN_T_CREATE = DateTime.Now
                    });
                }
                //升暂存货位的库区量表
                TN_WM_B_AREA_QTYEntity AreaQtyEntity = new TN_WM_B_AREA_QTYEntity();
                AreaQtyEntity.CN_GUID = System.Guid.NewGuid().ToString();
                AreaQtyEntity.CN_S_OWNER = dtPos.Rows[0]["CN_S_OWNER"].ToString();
                AreaQtyEntity.CN_S_ITEM_CODE = dtPos.Rows[0]["CN_S_ITEM_CODE"].ToString();
                AreaQtyEntity.CN_S_ITEM_NAME = dtPos.Rows[0]["CN_S_ITEM_NAME"].ToString();
                AreaQtyEntity.CN_S_ITEM_STATE = dtPos.Rows[0]["CN_S_ITEM_STATE"].ToString();
                AreaQtyEntity.CN_S_PRODUCTION_BATCH = dtPos.Rows[0]["CN_S_PRODUCTION_BATCH"].ToString();
                AreaQtyEntity.CN_S_LOT_NO = dtPos.Rows[0]["CN_S_LOT_CODE"].ToString();
                AreaQtyEntity.CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE;// LocationEntity.CN_S_AREA_CODE;
                AreaQtyEntity.CN_S_STOCK_CODE = areaList[0].CN_S_STOCK_CODE;
                AreaQtyEntity.CN_F_QUANTITY = Convert.ToDecimal(quantity);
                AreaQtyEntity.CN_F_ALLOC_QTY = 0;
                AreaQtyEntity.CN_F_PLANNED_QTY = 0;
                AreaQtyEntity.CN_S_NOTE = "";
                AreaQtyEntity.SqlWhere = " Where CN_S_STOCK_CODE='" + putPositionEntity.CN_S_STOCK_CODE + @"'  
                                         and CN_S_ITEM_CODE='" + dtPos.Rows[0]["CN_S_ITEM_CODE"] + @"' and CN_S_STOCK_AREA='" + areaList[0].CN_S_AREA_CODE + @"'
                                         and CN_S_ITEM_STATE='" + dtPos.Rows[0]["CN_S_ITEM_STATE"] + @"'  and CN_S_PRODUCTION_BATCH='" + dtPos.Rows[0]["CN_S_PRODUCTION_BATCH"] + @"'
                                         and CN_S_LOT_NO='" + dtPos.Rows[0]["CN_S_LOT_CODE"] + "' and CN_S_OWNER='" + dtPos.Rows[0]["CN_S_OWNER"] + "' ";

                lstModel.Add(AreaQtyEntity);
            }
            else
            {
                //搬往发货区
                List<AutoBomStockAreaEntity> areaList = CreateDAL<DapperDAL<AutoBomStockAreaEntity>>().GetList(new { CN_S_AREA_CLASS = Constants.ShippingArea });
                if (!areaList.Any())
                {
                    return OperateResult.Error("未获取到发货区实体，请配置库区<发货区>！");
                }
                //升发货区的库区量表
                TN_WM_B_AREA_QTYEntity AreaQtyEntity = new TN_WM_B_AREA_QTYEntity();
                AreaQtyEntity.CN_GUID = System.Guid.NewGuid().ToString();
                AreaQtyEntity.CN_S_OWNER = dtPos.Rows[0]["CN_S_OWNER"].ToString();
                AreaQtyEntity.CN_S_ITEM_CODE = dtPos.Rows[0]["CN_S_ITEM_CODE"].ToString();
                AreaQtyEntity.CN_S_ITEM_NAME = dtPos.Rows[0]["CN_S_ITEM_NAME"].ToString();
                AreaQtyEntity.CN_S_ITEM_STATE = dtPos.Rows[0]["CN_S_ITEM_STATE"].ToString();
                AreaQtyEntity.CN_S_PRODUCTION_BATCH = dtPos.Rows[0]["CN_S_PRODUCTION_BATCH"].ToString();
                AreaQtyEntity.CN_S_LOT_NO = dtPos.Rows[0]["CN_S_LOT_CODE"].ToString();
                AreaQtyEntity.CN_S_STOCK_AREA = areaList[0].CN_S_AREA_CODE;// LocationEntity.CN_S_AREA_CODE;
                AreaQtyEntity.CN_S_STOCK_CODE = areaList[0].CN_S_STOCK_CODE;
                AreaQtyEntity.CN_F_QUANTITY = Convert.ToDecimal(quantity);
                AreaQtyEntity.CN_F_ALLOC_QTY = 0;
                AreaQtyEntity.CN_F_PLANNED_QTY = 0;
                AreaQtyEntity.CN_S_NOTE = "";
                AreaQtyEntity.SqlWhere = " Where CN_S_STOCK_CODE='" + areaList[0].CN_S_STOCK_CODE + @"'  
                                         and CN_S_ITEM_CODE='" + dtPos.Rows[0]["CN_S_ITEM_CODE"] + @"' and CN_S_STOCK_AREA='" + areaList[0].CN_S_AREA_CODE + @"'
                                         and CN_S_ITEM_STATE='" + dtPos.Rows[0]["CN_S_ITEM_STATE"] + @"'  and CN_S_PRODUCTION_BATCH='" + dtPos.Rows[0]["CN_S_PRODUCTION_BATCH"] + @"'
                                         and CN_S_LOT_NO='" + dtPos.Rows[0]["CN_S_LOT_CODE"] + "' and CN_S_OWNER='" + dtPos.Rows[0]["CN_S_OWNER"] + "' ";

                lstModel.Add(AreaQtyEntity);
            }

            //管控维度到库区，需要降到货区的库区量，升暂存区的库区量，删摆放位置关联
            OperateResult operateResult = UseTransaction(trans =>
             {
                 //删到货区托盘货位关联
                 CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new { CN_S_LOCATION_CODE = putPosition }, trans);
                 //新增暂存区托盘货位关联
                 if (objZanCunEntityList.Any())
                 {
                     CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().AddRange(objZanCunEntityList, trans);
                 }

                 if (lstModel.Any())
                 {
                     CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(lstModel, trans);
                 }

                 //降到货区所在的库区量表
                 CreateDAL<TN_WM_B_AREA_QTYDAL>().DeleteAreaQtyByAreaCode(arrivalCode, itemCode, putPositionEntity.CN_S_AREA_CODE, quantity, trans);

             });
            return operateResult;
        }
        #endregion

        #region  PDA接口-获取物料所在库区
        /// <summary>
        /// PDA接口-获取物料所在库区
        /// </summary>
        /// <param name="packingCode">产品唯一码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-19</History>
        public OperateResult GetItemStockArea(MONGO_PRINT_BARCODE printBarCode)
        {
            OperateResult oresult = new OperateResult();
            string CN_S_ITEM_CODE = printBarCode.CN_S_ITEM_CODE;
            AutoBomItemEntity itementity = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(CN_S_ITEM_CODE);//获取物料判断物料类型
            List<AutoBomPartition_Item_REntity> list = new List<AutoBomPartition_Item_REntity>();
            List<AutoBomAreaLocation_REntity> listr = new List<AutoBomAreaLocation_REntity>();

            if (string.IsNullOrEmpty(itementity.CN_S_STORE_TYPE))//判断物料存储类别是否为空
            {
                list = CreateDAL<TN_WMS_AREADAL>().GetPartitionItem(CN_S_ITEM_CODE, 2);
            }
            else
            {
                list = CreateDAL<TN_WMS_AREADAL>().GetPartitionItem(itementity.CN_S_STORE_TYPE, 1);
            }
            if (list.Count > 0)
            {
                listr = CreateDAL<TN_WMS_AREADAL>().GetAreaLocationByGuid(list[0].CN_S_AREA_GUID);//获取逻辑分区表数据
            }
            if (listr.Count > 0)
            {
                AutoBomStockAreaEntity entityarea = CreateDAL<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(listr[0].CN_S_STOCK_AREA);

                oresult.Success = true; oresult.Data = entityarea;
            }
            return oresult;
        }
        #endregion

        #endregion
        public DataTable GetIncreaseDetail(string CN_S_OP_NO)
        {
            return CreateDAL<TN_WM_INCREASE_INVENTORYDAL>().GetIncreaseDetail(CN_S_OP_NO);
        }
    }
}