using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using WMS.Model.Stock;
using System.Data;
using WMS.IData;
using WMS.Common;
using WMS.Business.Base;
using WMS.Model.Base;
using WMS.Model.CK;

namespace WMS.Business.Stock
{
    public class BussAreaRep : IBussFactory
    {
        /// <summary>
        /// 获取库区间调拨单结果集
        /// </summary>
        /// <returns>库区间调拨单</returns>
        public List<AreaRepModel> GetAreaRepList(AreaRepModel model)
        {
            DataTable table = DataProvider.Instance.AreaRep.GetAreaRepDT(model);
            List<AreaRepModel> AreaRepModel = ConvertHelper<AreaRepModel>.ConvertToList(table);

            if (DataLogErrWrite(table, "获取库区间调拨单"))
            {
                return AreaRepModel;
            }
            return null;
        }

        /// <summary>
        /// 删除库区间调拨单信息
        /// </summary>
        /// <param name="AreaRep">库区间调拨单</param>
        /// <returns>是否成功</returns>
        public string DeleteAreaRep(string AreaRepID)
        {

            DataProvider.Instance.AreaRep.DeleteAreaRep(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            //删除规格明细
            //SKUTabModel skuTab = new SKUTabModel();
            //skuTab.DOCCTNUMBER = AreaRepID;
            //DataProvider.Instance.SKUTab.DelSKUTab(skuTab);
            //logList.Add(DataProvider.Instance.logData);

            //删除消息
            DataProvider.Instance.Message.DeleteMessByRelativeNumber(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            TaCmtOrRak();
            return ErrText;
        }

        /// <summary>
        /// 删除库区间调拨单(包括明细)
        /// </summary>
        /// <param name="AreaRep">库区间调拨单</param>
        /// <returns>是否成功</returns>
        public string DeleteAreaRepAndTab(string AreaRepID)
        {
            DataProvider.Instance.AreaRep.DeleteAreaRep(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            //获取原来的所有明细,减去原来的已占用库存
            AreaRepOutModel tab = new AreaRepOutModel();
            tab.AREA_REP_ID = AreaRepID;
            DataTable table = DataProvider.Instance.AreaRepOut.GetAreaRepOutDT(tab);
            List<AreaRepOutModel> list = ConvertHelper<AreaRepOutModel>.ConvertToList(table);
            foreach (var item in list)
            {
                MIStockModel mi = new MIStockModel();
                mi.PUTIN_ID = item.PUTIN_ID;
                mi.GOODS_ID = item.GOODS_ID;
                mi.LOCATION_ID = item.OUT_LOC_ID;
                mi.OCCUPY_NUM = -item.PLAN_COUNT;
                DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                logList.Add(DataProvider.Instance.logData);

                //删除库存占用记录表相应记录
                MIStockOccupyModel queryOccupy = new MIStockOccupyModel();
                queryOccupy.GOODS_ID = mi.GOODS_ID;
                queryOccupy.LOCATION_ID = mi.LOCATION_ID;
                queryOccupy.PUTIN_ID = mi.PUTIN_ID;
                List<MIStockOccupyModel> occupy = ConvertHelper<MIStockOccupyModel>.ConvertToList(DataProvider.Instance.MIStockOccupy.GetMIStockOccupyDT(queryOccupy));
                DataProvider.Instance.MIStockOccupy.DeleteMIStockOccupy(occupy[0]);
                logList.Add(DataProvider.Instance.logData);
            }

            DataProvider.Instance.AreaRepOut.DeleteAreaRepOutByAreaRepID(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRepIn.DeleteAreaRepInByAreaRepID(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            //删除规格明细
            //SKUTabModel skuTab = new SKUTabModel();
            //skuTab.DOCCTNUMBER = AreaRepID;
            //DataProvider.Instance.SKUTab.DelSKUTab(skuTab);
            //logList.Add(DataProvider.Instance.logData);

            //删除消息
            DataProvider.Instance.Message.DeleteMessByRelativeNumber(AreaRepID);
            logList.Add(DataProvider.Instance.logData);

            TaCmtOrRak();
            return ErrText;
        }

        /// <summary>
        /// 新增库区间调拨单(包括明细)
        /// </summary>
        /// <param name="AreaRepModel">库区间调拨单Model</param>
        /// <param name="listAreaRepOut">出库明细ModelList</param>
        /// <param name="listAreaRepIn">入库明细ModelList</param>
        /// <returns>是否成功</returns>
        public string InsertAreaRepAndTab(AreaRepModel areaRepModel, List<AreaRepOutModel> listAreaRepOut, List<AreaRepInModel> listAreaRepIn, List<SKUTabModel> listSKU)
        {
            //新增库区间调拨单
            areaRepModel.AREA_REP_ID = IBussFactory<WMS.Business.Base.BussDocumentTable>.Instance().GetDocumentStream("库区调拨单");
             DataProvider.Instance.AreaRep.InsertAreaRep(areaRepModel);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            ////删除所有明细
            //DataProvider.Instance.AreaRepOut.DeleteAreaRepOutByAreaRepID(AreaRepModel.AREA_REP_ID);
            //logList.Add(DataProvider.Instance.logData);

            //DataProvider.Instance.AreaRepIn.DeleteAreaRepInByAreaRepID(AreaRepModel.AREA_REP_ID);
            //logList.Add(DataProvider.Instance.logData);

            //增加明细
            foreach (AreaRepOutModel areaRepOutModel in listAreaRepOut)
            {
                if (!string.IsNullOrEmpty(areaRepModel.AREA_REP_ID))
                {
                    areaRepOutModel.AREA_REP_ID = areaRepModel.AREA_REP_ID;
                }

                DataProvider.Instance.AreaRepOut.InsertAreaRepOut(areaRepOutModel);
                logList.Add(DataProvider.Instance.logData);

                ////根据计划数修改已占用库存
                //MIStockModel mi = new MIStockModel();
                //mi.PUTIN_ID = areaRepOutModel.PUTIN_ID;
                //mi.GOODS_ID = areaRepOutModel.GOODS_ID;
                //mi.LOCATION_ID = areaRepOutModel.OUT_LOC_ID;
                //mi.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                //DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                //logList.Add(DataProvider.Instance.logData);

                ////写入库存占用记录表
                //MIStockModel mistock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(mi))[0];
                //MIStockOccupyModel occupy = new MIStockOccupyModel();
                //occupy.AREA_ID = mistock.AREA_ID;
                //occupy.DOCCTNUMBER = areaRepOutModel.AREA_REP_ID;
                //occupy.GOODS_ID = mistock.GOODS_ID;
                //occupy.LOCATION_ID = mistock.LOCATION_ID;
                //occupy.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                //occupy.PUTIN_ID = mistock.PUTIN_ID;
                //occupy.STOCK_ID = mistock.STOCK_ID;
                //occupy.STORAGE_ID = mistock.STORAGE_ID;
                //DataProvider.Instance.MIStockOccupy.InsertMIStockOccupy(occupy);
                //logList.Add(DataProvider.Instance.logData);
            }
            foreach (AreaRepInModel areaRepInModel in listAreaRepIn)
            {
                if (!string.IsNullOrEmpty(areaRepModel.AREA_REP_ID))
                {
                    areaRepInModel.AREA_REP_ID = areaRepModel.AREA_REP_ID;
                }

                DataProvider.Instance.AreaRepIn.InsertAreaRepIn(areaRepInModel);
                logList.Add(DataProvider.Instance.logData);
            }

            ////新增规格明细
            //if (listSKU != null && listSKU.Count > 0)
            //{
            //    //新增规格明细
            //    foreach (var item in listSKU)
            //    {
            //        item.DOCCTNUMBER = areaRepModel.AREA_REP_ID;
            //        DataProvider.Instance.SKUTab.AddSKUTab(item);
            //        logList.Add(DataProvider.Instance.logData);
            //    }
            //}

            TaCmtOrRak();

            #region 新增消息
            MessageModel messModel = new MessageModel();
            messModel.ID = "KQ" + DateTime.Now.ToString("yyyyMMddHHmmss") + DataProvider.Instance.Message.GetSerialNum();
            messModel.MENU_FORM = "FrmAreaRep";
            messModel.MESS_CONTENT = "新增库区补货单,单据编号:" + areaRepModel.AREA_REP_ID;
            messModel.MESS_DATE = DateTime.Now;
            messModel.MESS_DEP = areaRepModel.STORAGE_ID;
            messModel.MESS_FLAG = "0";
            messModel.MESS_STAR = areaRepModel.CREATE_PERSON;
            messModel.MESS_TO = areaRepModel.OUT_PERSON;
            messModel.MESS_STATUS = "0";
            messModel.WORK_TYPE = "worktype004";
            messModel.WORK_KIND = "0";
            messModel.MESS_TYPE = "6";
            messModel.RELATIVE_NUMBER = areaRepModel.AREA_REP_ID;
            messModel.STO_ID = areaRepModel.STORAGE_ID;
            DataProvider.Instance.Message.Add(messModel);
            logList.Add(DataProvider.Instance.logData);
            Transaction = DataProvider.Instance.TranOracle;
            TaCmtOrRak();
            #endregion
            return ErrText;
        }

        /// <summary>
        /// 修改库区间调拨单(包括明细)
        /// </summary>
        /// <param name="AreaRepModel">库区间调拨单Model</param>
        /// <param name="listAreaRepOut">出库明细ModelList</param>
        /// <param name="listAreaRepIn">入库明细ModelList</param>
        /// <returns>是否成功</returns>
        public string UpdateAreaRepAndTab(AreaRepModel areaRepModel, List<AreaRepOutModel> listAreaRepOut, List<AreaRepInModel> listAreaRepIn, List<SKUTabModel> listSKU)
        {
            //修改库区间调拨单
            DataProvider.Instance.AreaRep.UpdateAreaRep(areaRepModel);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            if (areaRepModel.STATE != "0") {
                //获取原来的所有明细,减去原来的已占用库存
                AreaRepOutModel tab = new AreaRepOutModel();
                tab.AREA_REP_ID = areaRepModel.AREA_REP_ID;
                DataTable table = DataProvider.Instance.AreaRepOut.GetAreaRepOutDT(tab);
                List<AreaRepOutModel> list = ConvertHelper<AreaRepOutModel>.ConvertToList(table);
                foreach (var item in list)
                {
                    MIStockModel mi = new MIStockModel();
                    mi.PUTIN_ID = item.PUTIN_ID;
                    mi.GOODS_ID = item.GOODS_ID;
                    mi.LOCATION_ID = item.OUT_LOC_ID;
                    mi.OCCUPY_NUM = -item.PLAN_COUNT;
                    DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                    logList.Add(DataProvider.Instance.logData);

                    try
                    {
                        //删除库存占用记录表相应记录
                        MIStockOccupyModel queryOccupy = new MIStockOccupyModel();
                        queryOccupy.GOODS_ID = mi.GOODS_ID;
                        queryOccupy.LOCATION_ID = mi.LOCATION_ID;
                        queryOccupy.PUTIN_ID = mi.PUTIN_ID;
                        List<MIStockOccupyModel> occupy = ConvertHelper<MIStockOccupyModel>.ConvertToList(DataProvider.Instance.MIStockOccupy.GetMIStockOccupyDT(queryOccupy));
                        DataProvider.Instance.MIStockOccupy.DeleteMIStockOccupy(occupy[0]);
                        logList.Add(DataProvider.Instance.logData);
                    }
                    catch (Exception)
                    {
                        
                    }
                }
            }

            //删除所有明细
            DataProvider.Instance.AreaRepOut.DeleteAreaRepOutByAreaRepID(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRepIn.DeleteAreaRepInByAreaRepID(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            //增加明细
            foreach (AreaRepOutModel areaRepOutModel in listAreaRepOut)
            {
                DataProvider.Instance.AreaRepOut.InsertAreaRepOut(areaRepOutModel);
                logList.Add(DataProvider.Instance.logData);

                //根据计划数修改已占用库存
                MIStockModel mi = new MIStockModel();
                mi.PUTIN_ID = areaRepOutModel.PUTIN_ID;
                mi.GOODS_ID = areaRepOutModel.GOODS_ID;
                mi.LOCATION_ID = areaRepOutModel.OUT_LOC_ID;
                mi.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                logList.Add(DataProvider.Instance.logData);

                //写入库存占用记录表
                MIStockModel mistock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(mi))[0];
                MIStockOccupyModel occupy = new MIStockOccupyModel();
                occupy.AREA_ID = mistock.AREA_ID;
                occupy.DOCCTNUMBER = areaRepOutModel.AREA_REP_ID;
                occupy.GOODS_ID = mistock.GOODS_ID;
                occupy.LOCATION_ID = mistock.LOCATION_ID;
                occupy.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                occupy.PUTIN_ID = mistock.PUTIN_ID;
                occupy.STOCK_ID = mistock.STOCK_ID;
                occupy.STORAGE_ID = mistock.STORAGE_ID;
                DataProvider.Instance.MIStockOccupy.InsertMIStockOccupy(occupy);
                logList.Add(DataProvider.Instance.logData);

            }
            foreach (AreaRepInModel areaRepInModel in listAreaRepIn)
            {
                DataProvider.Instance.AreaRepIn.InsertAreaRepIn(areaRepInModel);

                logList.Add(DataProvider.Instance.logData);
            }

            //修改规格明细
            //if (listSKU != null && listSKU.Count > 0)
            //{
            //    //删除规格明细
            //    SKUTabModel skuTab = new SKUTabModel();
            //    skuTab.DOCCTNUMBER = areaRepModel.AREA_REP_ID;
            //    DataProvider.Instance.SKUTab.DelSKUTab(skuTab);
            //    logList.Add(DataProvider.Instance.logData);

            //    //新增规格明细
            //    foreach (var item in listSKU)
            //    {
            //        item.DOCCTNUMBER = areaRepModel.AREA_REP_ID;
            //        DataProvider.Instance.SKUTab.AddSKUTab(item);
            //        logList.Add(DataProvider.Instance.logData);
            //    }
            //}
            
            if (areaRepModel.STATE == "2"){//状态为完成
                List<MIStockModel> hadUpdeteList = new List<MIStockModel>();//已经被修改过的库存记录

                List<AreaRepOutModel> listOut = new List<AreaRepOutModel>();

                foreach (AreaRepOutModel item in listAreaRepOut)
                {
                    for (int i = 0; i < item.REAL_COUNT; i++)
                    {
                        listOut.Add(item);
                    }

                    //根据实际数修改实际库存
                    MIStockModel mi = new MIStockModel();
                    mi.PUTIN_ID = item.PUTIN_ID;
                    mi.GOODS_ID = item.GOODS_ID;
                    mi.LOCATION_ID = item.OUT_LOC_ID;
                    mi.SHELVES_NUM = item.REAL_COUNT;
                    DataProvider.Instance.MIStock.UpdateMIStockNum(mi);
                    logList.Add(DataProvider.Instance.logData);

                    ////根据计划数修改已占用库存
                    //mi = new MIStockModel();
                    //mi.PUTIN_ID = item.PUTIN_ID;
                    //mi.GOODS_ID = item.GOODS_ID;
                    //mi.LOCATION_ID = item.OUT_LOC_ID;
                    //mi.OCCUPY_NUM = -item.PLAN_COUNT;
                    //DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                    //logList.Add(DataProvider.Instance.logData);

                    ////删除库存占用记录表相应记录
                    //MIStockOccupyModel queryOccupy = new MIStockOccupyModel();
                    //queryOccupy.GOODS_ID = mi.GOODS_ID;
                    //queryOccupy.LOCATION_ID = mi.LOCATION_ID;
                    //queryOccupy.PUTIN_ID = mi.PUTIN_ID;
                    //List<MIStockOccupyModel> occupy = ConvertHelper<MIStockOccupyModel>.ConvertToList(DataProvider.Instance.MIStockOccupy.GetMIStockOccupyDT(queryOccupy));
                    //DataProvider.Instance.MIStockOccupy.DeleteMIStockOccupy(occupy[0]);
                    //logList.Add(DataProvider.Instance.logData);
                }


                List<MIStockModel> listMI = new List<MIStockModel>();
                foreach (AreaRepOutModel outM in listOut)
                {
                    AreaRepInModel inM = listAreaRepIn.Find(p => p.REAL_COUNT != p.TEMP_COUNT && p.GOODS_ID == outM.GOODS_ID);
                    inM.TEMP_COUNT++;
                    MIStockModel model = listMI.Find(i => i.LOCATION_ID == inM.IN_LOC_ID && i.GOODS_ID == outM.GOODS_ID && i.PUTIN_ID == outM.PUTIN_ID && i.AREA_ID == areaRepModel.IN_AREA_ID);
                    if (model != null)
                    {
                        model.SHELVES_NUM++;
                    }
                    else
                    {
                        model = new MIStockModel();
                        model.PUTIN_ID = outM.PUTIN_ID;
                        model.AREA_ID = areaRepModel.OUT_AREA_ID;
                        model.LOCATION_ID = outM.OUT_LOC_ID;
                        model.GOODS_ID = outM.GOODS_ID;
                        model = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(model))[0];

                        model.OCCUPY_NUM = 0;
                        model.LOCATION_ID = inM.IN_LOC_ID;
                        model.SHELVES_NUM = 1;
                        model.AREA_ID = areaRepModel.IN_AREA_ID;
                        listMI.Add(model);
                    }
                }

                foreach (MIStockModel model in listMI)
                {
                    MIStockModel queryModel = new MIStockModel();
                    queryModel.PUTIN_ID = model.PUTIN_ID;
                    queryModel.AREA_ID = model.AREA_ID;
                    queryModel.LOCATION_ID = model.LOCATION_ID;
                    queryModel.GOODS_ID = model.GOODS_ID;
                    List<MIStockModel> queryList = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(queryModel));
                    if (queryList == null || queryList.Count == 0)
                    {
                        model.STOCK_ID = DataProvider.Instance.MIStock.InsertMIStock(model);
                    }
                    else
                    {
                        DataProvider.Instance.MIStock.UpdateMIStock(model);
                    }
                    logList.Add(DataProvider.Instance.logData);

                    //操作库存日志表
                    MIStockBackModel backModel = new MIStockBackModel();//入
                    backModel.AREA_ID = model.AREA_ID;
                    backModel.CHANGE_NUM = model.SHELVES_NUM;
                    backModel.GOODS_ID = model.GOODS_ID;
                    backModel.GOODS_NAME = model.GOODS_NAME;
                    backModel.GOODS_NUM = model.SHELVES_NUM;
                    backModel.GOODS_TYPEID = model.GOODS_TYPEID;
                    backModel.ID = DataProvider.Instance.MIStockBack.GetSerialNum();
                    backModel.LOCATION_ID = model.LOCATION_ID;
                    backModel.OPERATOR_MAN = areaRepModel.IN_PERSON;
                    backModel.OPERATOR_MAN_NAME = areaRepModel.IN_PERSON_NAME;
                    backModel.OPERATOR_TYPE = "0";
                    backModel.ORI_NUM = 0;
                    backModel.PUTIN_ID = model.PUTIN_ID;
                    backModel.PRODUCTION_DATE = model.PRODUCTION_DATE;
                    backModel.REMARK = model.REMARK;
                    backModel.STOCK_ID = model.STOCK_ID;
                    backModel.STORAGE_ID = model.STORAGE_ID;
                    backModel.STORAGE_NAME = model.STORAGE_NAME;
                    backModel.VERSION = model.VERSION;

                    DataProvider.Instance.MIStockBack.AddBMiStockack(backModel);
                    logList.Add(DataProvider.Instance.logData);


                    //修改库位已占用体积
                    GoodsInfoModel goods = new GoodsInfoModel();
                    Decimal perVo = Convert.ToDecimal(DataProvider.Instance.Goods.GetGoodsDataTable(model.GOODS_ID, "", "", "").Rows[0]["GVOLUME"].ToString());
                    Decimal allVo = 0;
                    allVo = model.SHELVES_NUM * perVo;
                    if (allVo != 0)
                    {
                        //新库位
                        StorageAreaLocationModel loc = new StorageAreaLocationModel();
                        loc.STORAGE_ID = areaRepModel.STORAGE_ID;
                        loc.LOCATION_ID = model.LOCATION_ID;
                        loc = ConvertHelper<StorageAreaLocationModel>.ConvertToList(DataProvider.Instance.StorageAreaLocation.GetLocationInfoDS(loc))[0];

                        loc.HASVOLUME += allVo;
                        loc.OPERATORID = areaRepModel.IN_PERSON;
                        DataProvider.Instance.StorageAreaLocation.UpdateLocHasVolume(loc);
                        logList.Add(DataProvider.Instance.logData);
                    }
                }

                //写工作量
                //WorkLoadModel workLoad = new WorkLoadModel();
                //workLoad.BILLS_ID = areaRepModel.AREA_REP_ID;
                //workLoad.USER_ID = areaRepModel.OUT_PERSON;
                //workLoad.WORK_DATE = System.DateTime.Now;
                //workLoad.WORK_DATE_STAR = System.DateTime.Now.Date;
                //workLoad.WORK_DATE_END = System.DateTime.Now.Date;
                //workLoad.WORK_NUM = areaRepModel.REAL_PLAN_NUM;
                //workLoad.WORK_TYPE = "3";
                ////workLoad.DEP_ID = 
                //if (listAreaRepOut != null && listAreaRepOut.Count > 0)
                //{
                //    workLoad.WORK_UNIT = listAreaRepOut[0].UNIT;
                //}
                //DataProvider.Instance.WorkLoad.Add(workLoad);
                //logList.Add(DataProvider.Instance.logData);

                //workLoad = new WorkLoadModel();
                //workLoad.BILLS_ID = areaRepModel.AREA_REP_ID;
              //  workLoad.USER_ID = areaRepModel.IN_PERSON;
                //workLoad.WORK_DATE = System.DateTime.Now;
                //workLoad.WORK_DATE_STAR = System.DateTime.Now.Date;
                //workLoad.WORK_DATE_END = System.DateTime.Now.Date;
                //workLoad.WORK_NUM = areaRepModel.REAL_PLAN_NUM;
                //workLoad.WORK_TYPE = "3";
                ////workLoad.DEP_ID = 
                //if (listAreaRepOut != null && listAreaRepOut.Count > 0)
                //{
                //    workLoad.WORK_UNIT = listAreaRepOut[0].UNIT;
                //}
             //   DataProvider.Instance.WorkLoad.Add(workLoad);
             //   logList.Add(DataProvider.Instance.logData);

                //foreach (AreaRepInModel item in listAreaRepIn)
                //{
                //    //操作库存表
                //    MIStockModel model = new MIStockModel();//入
                //    //model.LOCATION_ID = item.IN_LOC_ID;
                //    //model.GOODS_ID = item.GOODS_ID;

                //    ////得到库存记录
                //    //bool hadMIStock = false;
                //    //foreach (MIStockModel i in hadUpdeteList)
                //    //{
                //    //    if (i.LOCATION_ID == model.LOCATION_ID && i.GOODS_ID == model.GOODS_ID)
                //    //    {
                //    //        hadMIStock = true;
                //    //        model = i;
                //    //        break;
                //    //    }
                //    //}
                //    //if (!hadMIStock)
                //    //{
                //    //    List<MIStockModel> nowMIStock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(model));
                //    //    if (nowMIStock.Count > 0)//有该库存 修改
                //    //    {
                //    //        model = nowMIStock[0];
                //    //        model.SHELVES_NUM += item.REAL_COUNT;
                //    //        DataProvider.Instance.MIStock.UpdateMIStock(model);
                //    //        logList.Add(DataProvider.Instance.logData);
                //    //    }
                //    //    else//无该库存 新增
                //    //    {
                //    foreach (AreaRepOutModel i in listAreaRepOut)
                //    {
                //        if (i.GOODS_ID == item.GOODS_ID)
                //        {
                //            MIStockModel outModel = new MIStockModel();
                //            outModel.LOCATION_ID = i.OUT_LOC_ID;
                //            outModel.GOODS_ID = i.GOODS_ID;
                //            model = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(outModel))[0];
                //            break;
                //        }
                //    }
                //    model.LOCATION_ID = item.IN_LOC_ID;
                //    //StorageAreaLocationModel locModel = new StorageAreaLocationModel();
                //    //locModel.LOCATION_ID = model.LOCATION_ID;
                //    model.AREA_ID = areaRepModel.IN_AREA_ID;// IBussFactory<BussStorageAreaLocation>.Instance().GetLocationInfoDS(locModel)[0].STORAGE_AREA_ID;//入库库区编号
                //    model.GOODS_ID = item.GOODS_ID;
                //    model.SHELVES_NUM = item.REAL_COUNT;//原值是出库的 必须重新赋值
                //    model.WARE_DATE = System.DateTime.Now;
                //    model.AREA_NAME = areaRepModel.IN_AREA_NAME;
                //    model.DOCCTNUMBER = item.AREA_REP_ID;////////////////////////////////////////////

                //    model.STOCK_ID = DataProvider.Instance.MIStock.InsertMIStock(model);
                //    logList.Add(DataProvider.Instance.logData);
                //    //    }
                //    //}
                //    //else
                //    //{//已经改过
                //    //    model.SHELVES_NUM += item.REAL_COUNT;
                //    //    DataProvider.Instance.MIStock.UpdateMIStock(model);
                //    //    logList.Add(DataProvider.Instance.logData);
                //    //}

                //    //hadUpdeteList.Add(model);//保存修改过的库存记录


                //    //操作库存日志表
                //    MIStockBackModel backModel = new MIStockBackModel();//入
                //    backModel.AREA_ID = model.AREA_ID;
                //    backModel.CHANGE_NUM = model.SHELVES_NUM;
                //    backModel.GOODS_ID = model.GOODS_ID;
                //    backModel.GOODS_NAME = model.GOODS_NAME;
                //    backModel.GOODS_NUM = item.REAL_COUNT;
                //    backModel.GOODS_TYPEID = model.GOODS_TYPEID;
                //    backModel.ID = DataProvider.Instance.MIStockBack.GetSerialNum();
                //    backModel.LOCATION_ID = model.LOCATION_ID;
                //    backModel.OPERATOR_MAN = areaRepModel.IN_PERSON;
                //    backModel.OPERATOR_MAN_NAME = areaRepModel.IN_PERSON_NAME;
                //    backModel.OPERATOR_TYPE = "0";
                //    backModel.ORI_NUM = model.SHELVES_NUM - item.REAL_COUNT;
                //    backModel.PUTIN_ID = item.TAB_IN_ID;
                //    backModel.PRODUCTION_DATE = model.PRODUCTION_DATE;
                //    backModel.REMARK = model.REMARK;
                //    backModel.STOCK_ID = model.STOCK_ID;
                //    backModel.STORAGE_ID = model.STORAGE_ID;
                //    backModel.STORAGE_NAME = model.STORAGE_NAME;
                //    backModel.VERSION = model.VERSION;

                //    DataProvider.Instance.MIStockBack.Add(backModel);
                //    logList.Add(DataProvider.Instance.logData);


                //    //修改库位已占用体积
                //    GoodsInfoModel goods = new GoodsInfoModel();
                //    Decimal perVo = Convert.ToDecimal(DataProvider.Instance.Goods.GetGoodsDataTable(item.GOODS_ID, "", "", "").Rows[0]["GVOLUME"].ToString());
                //    Decimal allVo = 0;
                //    allVo = item.REAL_COUNT * perVo;
                //    if (allVo != 0)
                //    {
                //        //新库位
                //        StorageAreaLocationModel loc = new StorageAreaLocationModel();
                //        loc.STORAGE_ID = areaRepModel.STORAGE_ID;
                //        loc.LOCATION_ID = item.IN_LOC_ID;
                //        loc = ConvertHelper<StorageAreaLocationModel>.ConvertToList(DataProvider.Instance.StorageAreaLocation.GetLocationInfoDS(loc))[0];

                //        loc.HASVOLUME += allVo;
                //        loc.OPERATORID = areaRepModel.IN_PERSON;
                //        DataProvider.Instance.StorageAreaLocation.UpdateLocHasVolume(loc);
                //        logList.Add(DataProvider.Instance.logData);
                //    }

                //}

                //foreach (AreaRepOutModel item in listAreaRepOut)
                //{
                //    //操作库存表
                //    MIStockModel model = new MIStockModel();//出
                //    model.LOCATION_ID = item.OUT_LOC_ID;
                //    model.GOODS_ID = item.GOODS_ID;
                //    model.PUTIN_ID = item.PUTIN_ID;
                //    model.AREA_ID = areaRepModel.OUT_AREA_ID;

                //    //得到库存记录
                //    bool hadMIStock = false;
                //    foreach (MIStockModel i in hadUpdeteList)
                //    {
                //        if (i.LOCATION_ID == model.LOCATION_ID && i.GOODS_ID == model.GOODS_ID && i.PUTIN_ID == model.PUTIN_ID && i.AREA_ID == model.AREA_ID)
                //        {
                //            hadMIStock = true;
                //            model = i;
                //            break;
                //        }
                //    }
                //    if (!hadMIStock)
                //    {
                //        model = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(model))[0];
                //    }

                //    model.SHELVES_NUM -= item.REAL_COUNT;

                //    if (model.SHELVES_NUM == 0)
                //    { //删该条库存
                //        DataProvider.Instance.MIStock.DeleteMIStock(model);
                //        logList.Add(DataProvider.Instance.logData);
                //    }
                //    else
                //    {
                //        hadUpdeteList.Add(model);//保存修改过的库存记录

                //        DataProvider.Instance.MIStock.UpdateMIStock(model);
                //        logList.Add(DataProvider.Instance.logData);
                //    }


                //    //操作库存日志表
                //    MIStockBackModel backModel = new MIStockBackModel();//出
                //    backModel.AREA_ID = model.AREA_ID;
                //    backModel.CHANGE_NUM = model.SHELVES_NUM;
                //    backModel.GOODS_ID = model.GOODS_ID;
                //    backModel.GOODS_NAME = model.GOODS_NAME;
                //    backModel.GOODS_NUM = item.REAL_COUNT;
                //    backModel.GOODS_TYPEID = model.GOODS_TYPEID;
                //    backModel.ID = DataProvider.Instance.MIStockBack.GetSerialNum();
                //    backModel.LOCATION_ID = model.LOCATION_ID;
                //    backModel.OPERATOR_MAN = areaRepModel.OUT_PERSON;
                //    backModel.OPERATOR_MAN_NAME = areaRepModel.OUT_PERSON_NAME;
                //    backModel.OPERATOR_TYPE = "1";
                //    backModel.ORI_NUM = model.SHELVES_NUM + item.REAL_COUNT;
                //    backModel.OUT_ID = item.TAB_OUT_ID;
                //    backModel.PRODUCTION_DATE = model.PRODUCTION_DATE;
                //    backModel.REMARK = model.REMARK;
                //    backModel.STOCK_ID = model.STOCK_ID;
                //    backModel.STORAGE_ID = model.STORAGE_ID;
                //    backModel.STORAGE_NAME = model.STORAGE_NAME;
                //    backModel.VERSION = model.VERSION;
                //    DataProvider.Instance.MIStockBack.Add(backModel);
                //    logList.Add(DataProvider.Instance.logData);

                //    //修改库位已占用体积
                //    GoodsInfoModel goods = new GoodsInfoModel();
                //    Decimal perVo = Convert.ToDecimal(DataProvider.Instance.Goods.GetGoodsDataTable(item.GOODS_ID, "", "", "").Rows[0]["GVOLUME"].ToString());
                //    Decimal allVo = 0;
                //    allVo = item.REAL_COUNT * perVo;
                //    if (allVo != 0)
                //    {
                //        //原库位
                //        StorageAreaLocationModel loc = new StorageAreaLocationModel();
                //        loc.STORAGE_ID = areaRepModel.STORAGE_ID;
                //        loc.LOCATION_ID = item.OUT_LOC_ID;
                //        loc = ConvertHelper<StorageAreaLocationModel>.ConvertToList(DataProvider.Instance.StorageAreaLocation.GetLocationInfoDS(loc))[0];

                //        loc.HASVOLUME -= allVo;
                //        loc.OPERATORID = areaRepModel.OUT_PERSON;
                //        DataProvider.Instance.StorageAreaLocation.UpdateLocHasVolume(loc);
                //        logList.Add(DataProvider.Instance.logData);
                //    }

                //}
            }

            TaCmtOrRak();
            return ErrText;
        }

        /// <summary>
        /// 修改库区间调拨单状态
        /// </summary>
        /// <param name="AreaRepModel">库区间调拨单Model</param>
        /// <returns>是否成功</returns>
        public string UpdateAreaRepState(AreaRepModel AreaRepModel)
        {
            //修改库区间调拨单状态
            DataProvider.Instance.AreaRep.UpdateAreaRepState(AreaRepModel);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            if (AreaRepModel.STATE == "1") {
                AreaRepOutModel m = new AreaRepOutModel();
                m.AREA_REP_ID = AreaRepModel.AREA_REP_ID;
                DataTable table = DataProvider.Instance.AreaRepOut.GetAreaRepOutDT(m);
                List<AreaRepOutModel> AreaRepOutModel = ConvertHelper<AreaRepOutModel>.ConvertToList(table);

                foreach (var areaRepOutModel in AreaRepOutModel)
                {

                    //根据计划数修改已占用库存
                    MIStockModel mi = new MIStockModel();
                    mi.PUTIN_ID = areaRepOutModel.PUTIN_ID;
                    mi.GOODS_ID = areaRepOutModel.GOODS_ID;
                    mi.LOCATION_ID = areaRepOutModel.OUT_LOC_ID;
                    mi.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                    DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                    logList.Add(DataProvider.Instance.logData);

                    //写入库存占用记录表
                    MIStockModel mistock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(mi))[0];
                    MIStockOccupyModel occupy = new MIStockOccupyModel();
                    occupy.AREA_ID = mistock.AREA_ID;
                    occupy.DOCCTNUMBER = areaRepOutModel.AREA_REP_ID;
                    occupy.GOODS_ID = mistock.GOODS_ID;
                    occupy.LOCATION_ID = mistock.LOCATION_ID;
                    occupy.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                    occupy.PUTIN_ID = mistock.PUTIN_ID;
                    occupy.STOCK_ID = mistock.STOCK_ID;
                    occupy.STORAGE_ID = mistock.STORAGE_ID;
                    DataProvider.Instance.MIStockOccupy.InsertMIStockOccupy(occupy);
                    logList.Add(DataProvider.Instance.logData);
                }
            }

            TaCmtOrRak();
            return ErrText;
        }

        /// <summary>
        /// 将已完成的或已关闭的库区间调拨单与属于它的明细放到备份表中
        /// </summary>
        /// <param name="areaRepModel">库区间调拨单</param>
        /// <returns>是否成功</returns>
        public string MoveAreaRepAndTabIntoBack(AreaRepModel areaRepModel)
        {
            DataProvider.Instance.AreaRep.UpdateAreaRepState(areaRepModel);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            DataProvider.Instance.AreaRep.InsertAreaRepBack(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRepOut.InsertAreaRepOutBack(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRepIn.InsertAreaRepInBack(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRep.DeleteAreaRep(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            //获取原来的所有明细,减去原来的已占用库存
            AreaRepOutModel tab = new AreaRepOutModel();
            tab.AREA_REP_ID = areaRepModel.AREA_REP_ID;
            DataTable table = DataProvider.Instance.AreaRepOut.GetAreaRepOutDT(tab);
            List<AreaRepOutModel> list = ConvertHelper<AreaRepOutModel>.ConvertToList(table);
            foreach (var item in list)
            {
                try
                {
                    if (string.IsNullOrEmpty(item.PUTIN_ID)) {
                        continue;
                    }
                    if (string.IsNullOrEmpty(item.GOODS_ID))
                    {
                        continue;
                    }
                    if (string.IsNullOrEmpty(item.OUT_LOC_ID))
                    {
                        continue;
                    }

                    MIStockModel mi = new MIStockModel();
                    mi.PUTIN_ID = item.PUTIN_ID;
                    mi.GOODS_ID = item.GOODS_ID;
                    mi.LOCATION_ID = item.OUT_LOC_ID;
                    mi.OCCUPY_NUM = -item.PLAN_COUNT;
                    DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                    logList.Add(DataProvider.Instance.logData);

                    //删除库存占用记录表相应记录
                    MIStockOccupyModel queryOccupy = new MIStockOccupyModel();
                    queryOccupy.GOODS_ID = mi.GOODS_ID;
                    queryOccupy.LOCATION_ID = mi.LOCATION_ID;
                    queryOccupy.PUTIN_ID = mi.PUTIN_ID;
                    List<MIStockOccupyModel> occupy = ConvertHelper<MIStockOccupyModel>.ConvertToList(DataProvider.Instance.MIStockOccupy.GetMIStockOccupyDT(queryOccupy));
                    DataProvider.Instance.MIStockOccupy.DeleteMIStockOccupy(occupy[0]);
                    logList.Add(DataProvider.Instance.logData);
                }
                catch (Exception)
                {
                    
                }
            }

            DataProvider.Instance.AreaRepOut.DeleteAreaRepOut(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            DataProvider.Instance.AreaRepIn.DeleteAreaRepIn(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            //删除消息
            DataProvider.Instance.Message.DeleteMessByRelativeNumber(areaRepModel.AREA_REP_ID);
            logList.Add(DataProvider.Instance.logData);

            TaCmtOrRak();
            return ErrText;
        }

        /// <summary>
        /// 打印完成
        /// </summary>
        /// <param name="model">库区间调拨单</param>
        /// <returns>是否成功</returns>
        public string PrintOK(AreaRepModel model)
        {
            //修改拣货单打印次数
            model.PRINT_COUNT += 1;
            DataProvider.Instance.AreaRep.UpdateAreaRep(model);
            logList.Add(DataProvider.Instance.logData);

            Transaction = DataProvider.Instance.TranOracle;

            //新增打印记录
            PrintInfoModel printInfo = new PrintInfoModel();
            printInfo.Order_id = model.AREA_REP_ID;
            printInfo.PRINT_DATE = model.DOCUMENT_TIME;
            printInfo.PRINT_PER = model.DOCUMENT_PERSON_ID;
            printInfo.Print_per_name = model.DOCUMENT_PERSON;
            printInfo.PRINT_TYPE = "5";
            DataProvider.Instance.PrintInfo.UpdatePrintInfo(printInfo);
            logList.Add(DataProvider.Instance.logData);

            TaCmtOrRak();
            return ErrText;
        }

        #region 通过出库库区、商品、商品数量获取出库库位明细

        #region 变量

        /// <summary>
        /// 需要的商品、商品数量，用于判断商品是否充足、拣货
        /// </summary>
        private List<OrderDetailModel> listOrderGoods = new List<OrderDetailModel>();
        /// <summary>
        /// 发货仓库的所有库存
        /// </summary>
        private List<MIStockModel> listMIStock = new List<MIStockModel>();
        /// <summary>
        /// 有所需商品的库存->需要拣货的库存（某种商品的）
        /// </summary>
        private List<MIStockModel> listPackingMIStock = new List<MIStockModel>();
        /// <summary>
        /// 某商品在listPackingMIStock中的总数
        /// </summary>
        private decimal num = 0;
        /// <summary>
        /// 某商品在拣货后为空库位的库位中的总数
        /// </summary>
        private decimal numNew = 0;

        /// <summary>
        /// 生产日期 是否优先
        /// </summary>
        private bool byProduce = true;
        /// <summary>
        /// 上架日期 是否优先
        /// </summary>
        private bool byAdded = true;
        /// <summary>
        /// 捡空库位 是否优先
        /// </summary>
        private bool byNull = true;

        #endregion

        #region 筛选
        /// <summary>
        /// 通过生产日期筛选库存记录
        /// </summary>
        /// <returns>true:数量正好满足 无需再次筛选</returns>
        private bool GetMiStockByProductDate()
        {
            List<MIStockModel> newMIStockList = new List<MIStockModel>();

            //获取listPackingMIStock中的生产日期并从小到大排序
            List<DateTime> dtList = new List<DateTime>();
            foreach (MIStockModel oldMIStock in listPackingMIStock)
            {
                if (!dtList.Exists(p => p == oldMIStock.PRODUCTION_DATE))
                {
                    dtList.Add(oldMIStock.PRODUCTION_DATE);
                }
            }
            dtList.Sort();

            for (int i = 0; i < dtList.Count; i++)//遍历生产日期
            {
                //将与当前生产日期相同的库存记录
                foreach (MIStockModel oldMIStock in listPackingMIStock)
                {
                    if (oldMIStock.PRODUCTION_DATE == dtList[i])
                    {
                        newMIStockList.Add(oldMIStock);
                    }
                }

                //检查当前记录的库存能否满足拣货需求，若满足：跳出循环
                num = 0;
                foreach (MIStockModel newMIStock in newMIStockList)
                {
                    //foreach (OrderDetailModel item in listOrderGoods)
                    //{
                    //    if (item.GOOD_ID == newMIStock.GOODS_ID)
                    //    {
                    //        num += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区该商品总数
                    //    }
                    //}
                    if (listPackingMIStock[0].GOODS_ID == newMIStock.GOODS_ID)
                    {
                        num += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区该商品总数
                    }
                }
                foreach (OrderDetailModel item in listOrderGoods)
                {
                    if (item.GOOD_ID == newMIStockList[0].GOODS_ID)
                    {
                        if (num == item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return true;
                        }
                        else if (num > item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return false;
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 通过上架日期筛选库存记录
        /// </summary>
        /// <returns>true:数量正好满足 无需再次筛选</returns>
        private bool GetMiStockByWaveDate()
        {
            List<MIStockModel> newMIStockList = new List<MIStockModel>();

            //获取listPackingMIStock中的上架日期并从小到大排序
            List<DateTime> dtList = new List<DateTime>();
            foreach (MIStockModel oldMIStock in listPackingMIStock)
            {
                if (!dtList.Exists(p => p == oldMIStock.WARE_DATE))
                {
                    dtList.Add(oldMIStock.WARE_DATE);
                }
            }
            dtList.Sort();

            for (int i = 0; i < dtList.Count; i++)//遍历上架日期
            {
                //将与当前上架日期相同的库存记录
                foreach (MIStockModel oldMIStock in listPackingMIStock)
                {
                    if (oldMIStock.WARE_DATE == dtList[i])
                    {
                        newMIStockList.Add(oldMIStock);
                    }
                }

                //检查当前记录的库存能否满足拣货需求，若满足：跳出循环
                num = 0;
                foreach (MIStockModel newMIStock in newMIStockList)
                {
                    //foreach (OrderDetailModel item in listOrderGoods)
                    //{
                    //    if (item.GOOD_ID == newMIStock.GOODS_ID)
                    //    {
                    //        num += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区该商品总数
                    //    }
                    //}
                    if (listPackingMIStock[0].GOODS_ID == newMIStock.GOODS_ID)
                    {
                        num += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区该商品总数
                    }
                }
                foreach (OrderDetailModel item in listOrderGoods)
                {
                    if (item.GOOD_ID == newMIStockList[0].GOODS_ID)
                    {
                        if (num == item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return true;
                        }
                        else if (num > item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return false;
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 通过拣货后的已占用容积筛选库存记录
        /// </summary>
        /// <param name="newMIStockList">只存放所需商品的库位</param>
        /// <returns>false：数量不足</returns>
        private bool GetMiStockByOnlyOne(ref List<MIStockModel> newMIStockList)
        {
            numNew = 0;

            //获取listPackingMIStock中的所有库位
            List<string> locList = new List<string>();
            foreach (MIStockModel oldMIStock in listPackingMIStock)
            {
                if (!locList.Exists(p => p == oldMIStock.LOCATION_ID))
                {
                    locList.Add(oldMIStock.LOCATION_ID);
                }
            }
            locList.Sort();

            //遍历存在该商品的所有库位
            for (int i = 0; i < locList.Count; i++)
            {
                if (listMIStock.FindAll(p => p.LOCATION_ID == locList[i]).Count > 1)
                {
                    locList[i] = string.Empty;//所有不只存放该商品的库位移除
                }
            }

            //记录只存放一种商品的库存
            foreach (string i in locList)
            {
                if (i != string.Empty)
                {
                    foreach (MIStockModel item in listPackingMIStock)
                    {
                        if (i == item.LOCATION_ID)
                        {
                            newMIStockList.Add(item);
                        }
                    }
                }
            }

            if (newMIStockList.Count > 0)//只存放该商品的库存->拣货后已占用容积为0的库位
            {
                //检查当前记录的库存能否满足拣货需求
                foreach (MIStockModel newMIStock in newMIStockList)
                {
                    if (listPackingMIStock[0].GOODS_ID == newMIStock.GOODS_ID)
                    {
                        numNew += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区只有该商品的库位上该商品总数
                    }
                }
                foreach (OrderDetailModel item in listOrderGoods)
                {
                    if (item.GOOD_ID == newMIStockList[0].GOODS_ID)
                    {
                        if (numNew == item.GOODS_NUM || newMIStockList.Count == 1)
                        {
                            listPackingMIStock = newMIStockList;
                            return true;
                        }
                        else if (numNew > item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            newMIStockList = new List<MIStockModel>();
                            GetMiStockBySurplus(ref newMIStockList);
                            return true;
                            //newMIStockList.Sort((left, right) =>
                            //{
                            //    if ((left.ABLE_NUM) > (right.ABLE_NUM))
                            //        return -1;
                            //    else if ((left.ABLE_NUM) == (right.ABLE_NUM))
                            //        return 0;
                            //    else
                            //        return 1;
                            //});//排序 先移走库存最小的

                            //while ( (numNew - newMIStockList[newMIStockList.Count - 1].ABLE_NUM) > item.GOODS_NUM)//保证拣货库位不多余
                            //{
                            //    if ((numNew - newMIStockList[newMIStockList.Count - 1].ABLE_NUM) < item.GOODS_NUM)//保证商品不少于
                            //    {
                            //        break;
                            //    }
                            //    numNew -= newMIStockList[newMIStockList.Count - 1].ABLE_NUM;
                            //    newMIStockList.RemoveAt(newMIStockList.Count - 1);//移除最后一个
                            //}
                            //return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// 通过拣货后的剩余容积筛选库存记录
        /// </summary>
        /// <param name="newMIStockList">只存放所需商品的库位（必须拣货的库位）</param>
        private void GetMiStockBySurplus(ref List<MIStockModel> newMIStockList)
        {
            //int needNum = 0;//还需要的数量
            //foreach (OrderDetailModel item in listOrderGoods)
            //{
            //    if (item.GOOD_ID == newMIStockList[0].GOODS_ID)
            //    {
            //        needNum = Convert.ToDecimal(item.GOODS_NUM) - numNew;
            //    }
            //}

            ////通过商品ID得商品
            //DataTable table = DataProvider.Instance.Goods.GetGoodsDataTable(newMIStockList[0].GOODS_ID,"","","");
            //GoodsInfoModel goods = ConvertHelper<GoodsInfoModel>.ConvertToList(table)[0];

            if (newMIStockList.Count > 0)
            {
                //遍历必须拣货的库位（拣货后已占用容积为0的）
                foreach (MIStockModel newMIStock in newMIStockList)
                {
                    listPackingMIStock.RemoveAll(p => p.LOCATION_ID == newMIStock.LOCATION_ID);//移除重复库位
                }
            }

            //获取listPackingMIStock中的所有库位
            List<string> locList = new List<string>();
            foreach (MIStockModel oldMIStock in listPackingMIStock)
            {
                if (!locList.Exists(p => p == oldMIStock.LOCATION_ID))
                {
                    locList.Add(oldMIStock.LOCATION_ID);
                }
            }
            //locList.Sort();
            List<StorageAreaLocationModel> listLoc = new List<StorageAreaLocationModel>();
            foreach (string locID in locList)
            {
                StorageAreaLocationModel loc = new StorageAreaLocationModel();
                loc.STORAGE_ID = listPackingMIStock[0].STORAGE_ID;
                loc.LOCATION_ID = locID;

                DataTable table = DataProvider.Instance.StorageAreaLocation.GetLocationInfoDS(loc);
                loc = ConvertHelper<StorageAreaLocationModel>.ConvertToList(table)[0];
                loc.HASVOLUME = 0;
                listLoc.Add(loc);
            }

            //算各个库位拣货后的已占用体积
            foreach (StorageAreaLocationModel loc in listLoc)
            {
                foreach (MIStockModel miStock in listMIStock)
                {
                    if (miStock.LOCATION_ID == loc.LOCATION_ID && miStock.GOODS_ID != listPackingMIStock[0].GOODS_ID)
                    {
                        DataTable table = DataProvider.Instance.Goods.GetGoodsDataTable(miStock.GOODS_ID, "", "", "");
                        GoodsInfoModel otherGoods = ConvertHelper<GoodsInfoModel>.ConvertToList(table)[0];
                        loc.HASVOLUME += otherGoods.GVOLUME;
                    }
                }
            }
            //按剩余容积排序
            listLoc.Sort((left, right) =>
            {
                if ((left.VOLUME - left.HASVOLUME) > (right.VOLUME - right.HASVOLUME))
                    return 1;
                else if ((left.VOLUME - left.HASVOLUME) == (right.VOLUME - right.HASVOLUME))
                    return 0;
                else
                    return -1;
            });

            for (int i = 0; i < listLoc.Count; i++)//遍历
            {
                //将与当前编号相同的库存记录
                foreach (MIStockModel oldMIStock in listPackingMIStock)
                {
                    if (oldMIStock.LOCATION_ID == listLoc[i].LOCATION_ID)
                    {
                        newMIStockList.Add(oldMIStock);
                    }
                }

                //检查当前记录的库存能否满足拣货需求，若满足：跳出循环
                num = 0;
                foreach (MIStockModel newMIStock in newMIStockList)
                {
                    if (listPackingMIStock[0].GOODS_ID == newMIStock.GOODS_ID)
                    {
                        num += Convert.ToDecimal(newMIStock.ABLE_NUM);//记录拣货区该商品总数
                    }
                }
                foreach (OrderDetailModel item in listOrderGoods)
                {
                    if (item.GOOD_ID == newMIStockList[0].GOODS_ID)
                    {
                        if (num == item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return;
                        }
                        else if (num > item.GOODS_NUM)
                        {
                            listPackingMIStock = newMIStockList;
                            return;
                        }
                    }
                }
            }
        }

        #endregion

        /// <summary>
        /// 通过出库库区、商品、商品数量获取出库库位明细
        /// </summary>
        /// <param name="areaRepModel"></param>
        /// <param name="listOut"></param>
        /// <param name="haveStrategy"></param>
        /// <returns>是否成功/找不到策略的信息</returns>
        public string GetAreaRepOutLoc(AreaRepModel areaRepModel, ref List<AreaRepOutModel> listOut)
        {
            List<AreaRepOutModel> tempOut = new List<AreaRepOutModel>();//存放计划数量为0的
            tempOut = listOut.FindAll(p=>p.PLAN_COUNT == 0 || !string.IsNullOrEmpty(p.OUT_LOC_ID));
            listOut.RemoveAll(p => p.PLAN_COUNT == 0 || !string.IsNullOrEmpty(p.OUT_LOC_ID));

            #region 清空数据
            listOrderGoods = new List<OrderDetailModel>();
            listMIStock = new List<MIStockModel>();
            listPackingMIStock = new List<MIStockModel>();
            num = 0;
            numNew = 0;
            byProduce = true;
            byAdded = true;
            byNull = true;
            listPackingMIStock = new List<MIStockModel>();//有所需商品的库存->需要拣货的库存（某种商品的）
            #endregion

            #region 转成标准单位，数量一并改变

            foreach (AreaRepOutModel orderTab in listOut)
            {
                //获取商品标准单位
                DataTable dt = DataProvider.Instance.Goods.GetGoodsDataTable(orderTab.GOODS_ID, "", "", "");
                List<GoodsInfoModel> list = null;
                if (DataLogErrWrite(dt, "获取商品标准单位"))
                {
                    list = ConvertHelper<GoodsInfoModel>.ConvertToList(dt);
                }
                else
                {
                    return ErrText;
                }
                string standardUnit = list[0].UNIT;

                //如果不是标准单位 转换
                if (orderTab.UNIT != null && standardUnit != orderTab.UNIT)
                {
                    //获取商品可选单位、转换率
                    DataTable unitTable = DataProvider.Instance.Goods.GetGoodsUnit(orderTab.GOODS_ID);
                    if (!DataLogErrWrite(unitTable, "获取商品可选单位、转换率"))
                    {
                        return ErrText;
                    }
                    //获取转换率
                    decimal convert = 0;
                    foreach (DataRow unitRow in unitTable.Rows)
                    {
                        if (unitRow[0].ToString() == orderTab.UNIT)
                        {
                            convert = decimal.Parse(unitRow[2].ToString());
                            break;
                        }
                    }

                    if (convert == 0)
                    {
                        ErrText += "单位转换率不能为0,请检查商品资料 ";
                        return ErrText;
                    }

                    //转成标准单位，数量一并改变
                    if (orderTab.PLAN_COUNT > 0)
                    {
                        orderTab.PLAN_COUNT = orderTab.PLAN_COUNT / convert;
                    }
                    if (orderTab.REAL_COUNT > 0)
                    {
                        orderTab.REAL_COUNT = orderTab.REAL_COUNT / convert;
                    }
                    if (orderTab.MISTOCK_NUM > 0)
                    {
                        orderTab.MISTOCK_NUM = orderTab.MISTOCK_NUM / convert;
                    }
                    orderTab.UNIT = standardUnit;

                }
            }
            #endregion

            #region 获取需要拣货的商品
            foreach (var item in listOut)
            {
                OrderDetailModel tab = new OrderDetailModel();
                tab.GOOD_ID = item.GOODS_ID;
                tab.GOODS_NUM = item.PLAN_COUNT;
                tab.UNIT = item.UNIT;
                listOrderGoods.Add(tab);
            }
            #endregion

            #region 获取发货仓库的所有库存
            MIStockModel queryMIStock = new MIStockModel();
            queryMIStock.STORAGE_ID = areaRepModel.STORAGE_ID;
            DataTable tableMIStock = DataProvider.Instance.MIStock.GetMIStockDT(queryMIStock);
            listMIStock = ConvertHelper<MIStockModel>.ConvertToList(tableMIStock);//发货仓库的所有库存
            if (!DataLogErrWrite(tableMIStock, "获取发货仓库的所有库存"))
            {
                return ErrText;
            }
            listMIStock.RemoveAll(p => p.ABLE_NUM == 0);//移除所有数量为0的
            #endregion

            #region 根据拣货策略记录需要的商品在拣货区的数量
            DataTable downStrategy = DataProvider.Instance.DownStrategy.GetDownStrategyDTByStorage(areaRepModel.STORAGE_ID);
            bool haveStrategy = false;
            foreach (DataRow row in downStrategy.Rows)
            {
                if (areaRepModel.OUT_AREA_ID == row["STORAGE_AREA_ID"].ToString())
                {
                    haveStrategy = true;
                    foreach (MIStockModel MIStock in listMIStock)
                    {
                        if (MIStock.AREA_ID == row["STORAGE_AREA_ID"].ToString())
                        {
                            foreach (OrderDetailModel item in listOrderGoods)
                            {
                                if (item.GOOD_ID == MIStock.GOODS_ID)
                                {
                                    item.AREA_NUM += Convert.ToDecimal(MIStock.ABLE_NUM);//记录拣货区该商品总数
                                }
                            }
                        }
                    }
                }
            }
            if (!haveStrategy)
            {
                //ErrText = "找不到下架策略 ";
                return ErrText;
            }
            #endregion

            #region 获取对应库位
            foreach (OrderDetailModel item in listOrderGoods)//遍历需要拣货的商品
            {
                //获取有所需商品的库存集合
                listPackingMIStock = new List<MIStockModel>();
                foreach (DataRow row in downStrategy.Rows)
                {
                    if (areaRepModel.OUT_AREA_ID == row["STORAGE_AREA_ID"].ToString())
                    {

                        foreach (MIStockModel MIStock in listMIStock)
                        {
                            if (MIStock.AREA_ID == row["STORAGE_AREA_ID"].ToString())
                            {
                                if (item.GOOD_ID == MIStock.GOODS_ID)
                                {
                                    listPackingMIStock.Add(MIStock);
                                }
                            }
                        }

                        if (row["PRODUCE_FLAG"].ToString() == "0")
                        {
                            byProduce = false;
                        }
                        else
                        {
                            byProduce = true;
                        }
                        if (row["ADDED_FLAG"].ToString() == "0")
                        {
                            byAdded = false;
                        }
                        else
                        {
                            byAdded = true;
                        }
                        if (row["NULL_FLAG"].ToString() == "0")
                        {
                            byNull = false;
                        }
                        else
                        {
                            byNull = true;
                        }
                    }
                }

                //通过生产日期对listGoodsMIStock筛选
                if (byProduce && (GetMiStockByProductDate() || listPackingMIStock.Count == 1))//数量正好满足或只有1个库位可以满足
                {

                }
                else
                {
                    //通过上架日期对listGoodsMIStock筛选
                    if (byAdded && (GetMiStockByWaveDate() || listPackingMIStock.Count == 1))//数量正好满足或只有1个库位可以满足
                    {

                    }
                    else
                    {
                        List<MIStockModel> newMIList = new List<MIStockModel>();//拣货后已占用容积为0的所有库位（只有这一种商品的库位）

                        if (byNull && GetMiStockByOnlyOne(ref newMIList))
                        {

                        }
                        else//少
                        {
                            GetMiStockBySurplus(ref newMIList);//取拣货后剩余容积大的
                        }
                    }
                }

                List<AreaRepOutModel> tempOutList = new List<AreaRepOutModel>();
                foreach (var outModel in listOut)
                {
                    decimal tempCount = outModel.PLAN_COUNT;

                    List<MIStockModel> tempList = listPackingMIStock.FindAll(p => p.GOODS_ID == outModel.GOODS_ID);

                    if (tempList.Count == 0) {
                        continue;
                    }

                    //outModel.OUT_LOC_ID = tempList[0].LOCATION_ID;
                    
                    
                    //if (tempList.Count > 1)
                    //{
                    //    outModel.PLAN_COUNT = tempList[0].ABLE_NUM;

                        for (int i = 0; i < tempList.Count; i++)
                        {
                            AreaRepOutModel tempOutModel = new AreaRepOutModel();
                            tempOutModel.AREA_REP_ID = outModel.AREA_REP_ID;
                            tempOutModel.GOODS_ID = outModel.GOODS_ID;
                            tempOutModel.GOODS_NAME = outModel.GOODS_NAME;
                            tempOutModel.MISTOCK_NUM = outModel.MISTOCK_NUM;
                            tempOutModel.PRICE = outModel.PRICE;
                            tempOutModel.REAL_COUNT = outModel.REAL_COUNT;
                            tempOutModel.SCALE_UNIT = outModel.SCALE_UNIT;
                            tempOutModel.SORT = outModel.SORT;
                            tempOutModel.TAB_OUT_ID = outModel.TAB_OUT_ID;
                            tempOutModel.UNIT = outModel.UNIT;
                            tempOutModel.UNIT_NAME = outModel.UNIT_NAME;
                            tempOutModel.OUT_LOC_ID = tempList[i].LOCATION_ID;
                            tempOutModel.LOC_NUM = tempList[i].ABLE_NUM;

                            tempOutModel.DOCCTNUMBER = tempList[i].DOCCTNUMBER;
                            tempOutModel.PUTIN_ID = tempList[i].PUTIN_ID;
                            tempOutModel.PRODUCTION_DATE = tempList[i].PRODUCTION_DATE;
                            tempOutModel.WARE_DATE = tempList[i].WARE_DATE;
                            tempOutModel.PROVIDER_ID = tempList[i].PROVIDER_ID;

                            if (tempList.Count - 1 == i)
                            {
                                tempOutModel.PLAN_COUNT = tempCount - tempOutList.FindAll(p => p.GOODS_ID == outModel.GOODS_ID).Sum(p => p.PLAN_COUNT);
                            }
                            else {

                                tempOutModel.PLAN_COUNT = tempList[i].ABLE_NUM;
                            }

                            tempOutList.Add(tempOutModel);
                        }
                    //}
                }
                listOut.AddRange(tempOutList);

                //单位转换回去

            }
            #endregion

            listOut.RemoveAll(p=>p.PLAN_COUNT > 0 && string.IsNullOrEmpty(p.OUT_LOC_ID));

            ////根据库位 商品 汇总
            //List<AreaRepOutModel> newOutList = new List<AreaRepOutModel>();
            //foreach (var item in listOut)
            //{
            //    if (newOutList.Exists(p => p.OUT_LOC_ID == item.OUT_LOC_ID && p.GOODS_ID == item.GOODS_ID))
            //    {
            //        AreaRepOutModel tempOutModel = newOutList.Find(p => p.OUT_LOC_ID == item.OUT_LOC_ID && p.GOODS_ID == item.GOODS_ID);
            //        tempOutModel.PLAN_COUNT += item.PLAN_COUNT;
            //        tempOutModel.LOC_NUM += item.LOC_NUM;
            //    }
            //    else {
            //        newOutList.Add(item);
            //    }
            //}
            //listOut.Clear();
            //listOut.AddRange(newOutList);
            listOut.AddRange(tempOut);

            listOut.OrderBy(p => p.GOODS_ID);
            return ErrText;
            
        }

        /// <summary>
        /// 通过库区名称得到库区ID（仓库编号指定为发货仓库ID）
        /// </summary>
        /// <param name="areaName"></param>
        /// <returns></returns>
        private string getAreaID(string areaName)
        {
            StorageAreaModel queryArea = new StorageAreaModel();
            queryArea.STORAGE_AREA_NAME = areaName;
            queryArea.STORAGE_ID = storageID;
            DataTable table = DataProvider.Instance.StorageArea.GetAreaInfoDS(queryArea, string.Empty);
            string areaID = string.Empty;
            if (table.Rows.Count == 0)
            {
                queryArea = new StorageAreaModel();
                queryArea.STORAGE_ID = storageID;
                table = DataProvider.Instance.StorageArea.GetAreaInfoDS(queryArea, string.Empty);
                areaID = ConvertHelper<StorageAreaModel>.ConvertToList(table)[0].STORAGE_AREA_ID;
            }
            else
            {
                areaID = ConvertHelper<StorageAreaModel>.ConvertToList(table)[0].STORAGE_AREA_ID;
                //if (DataLogErrWrite(table, "获取发货仓库拣货区库区编号"))
                //{
                //}
                //else
                //{
                //    return string.Empty;
                //}
            }
            return areaID;
        }

        #endregion

        private void getAreaGoodsType(ref List<AreaGoodsTypeModel> areaGoodsTypeList, string GOODS_TYPE_ID)
        {
            if (!string.IsNullOrEmpty(GOODS_TYPE_ID))
            {

                AreaGoodsTypeModel m = new AreaGoodsTypeModel();
                m.GOODS_TYPE_ID = GOODS_TYPE_ID;
                DataTable table2 = DataProvider.Instance.AreaGoodsType.GetAreaGoodsTypeDT(m);
                areaGoodsTypeList = ConvertHelper<AreaGoodsTypeModel>.ConvertToList(table2);

                if (areaGoodsTypeList == null || areaGoodsTypeList.Count == 0)
                {
                    GoodsTypeModel goodsType = new GoodsTypeModel();
                    goodsType.GOODS_TYPE_ID = m.GOODS_TYPE_ID;
                    List<GoodsTypeModel> gtList = ConvertHelper<GoodsTypeModel>.ConvertToList(DataProvider.Instance.GoodsType.GetGoodsTypeDataTable(goodsType));
                    if (gtList != null && gtList.Count > 0 && !string.IsNullOrEmpty(gtList[0].PARENT_ID))
                    {
                        m.GOODS_TYPE_ID = gtList[0].PARENT_ID;
                        table2 = DataProvider.Instance.AreaGoodsType.GetAreaGoodsTypeDT(m);
                        areaGoodsTypeList = ConvertHelper<AreaGoodsTypeModel>.ConvertToList(table2);

                        if (areaGoodsTypeList == null || areaGoodsTypeList.Count == 0)
                        {
                            goodsType = new GoodsTypeModel();
                            goodsType.GOODS_TYPE_ID = m.GOODS_TYPE_ID;
                            gtList = ConvertHelper<GoodsTypeModel>.ConvertToList(DataProvider.Instance.GoodsType.GetGoodsTypeDataTable(goodsType));
                            if (gtList != null && gtList.Count > 0 && !string.IsNullOrEmpty(gtList[0].PARENT_ID))
                            {
                                m.GOODS_TYPE_ID = gtList[0].PARENT_ID;
                                table2 = DataProvider.Instance.AreaGoodsType.GetAreaGoodsTypeDT(m);
                                areaGoodsTypeList = ConvertHelper<AreaGoodsTypeModel>.ConvertToList(table2);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 仓库编号
        /// </summary>
        string storageID;
        /// <summary>
        /// 线上订单占用库存
        /// </summary>
        /// <param name="province"></param>
        /// <param name="city"></param>
        /// <param name="district"></param>
        /// <param name="id"></param>
        /// <param name="listD"></param>
        /// <returns></returns>
        public string OccupyMIStock(string province, string city, string district,string id, Dictionary<string, decimal> listD)
        {
            StorageOrderModel storOrderModel = new StorageOrderModel();
            storOrderModel.TOWN_ID = DataProvider.Instance.AddressArea.GetAddressArea(province, city, district).Rows[0][0].ToString();
            DataTable table = DataProvider.Instance.StorageOrder.GetStorOrderDT(storOrderModel);
            List<StorageOrderModel> storOrderList = ConvertHelper<StorageOrderModel>.ConvertToList(table);
            if (storOrderList == null || storOrderList.Count == 0) { return "找不到配送仓库"; }
            storageID = storOrderList[0].STORAGE_ID;
            List<AreaRepOutModel> listOut = new List<AreaRepOutModel>();
            foreach (var item in listD)
            {
                AreaRepOutModel areaRepOut = new AreaRepOutModel();
                areaRepOut.GOODS_ID = item.Key;
                areaRepOut.PLAN_COUNT = item.Value;
                listOut.Add(areaRepOut);
            }

            List<AreaRepOutModel> tempOut = new List<AreaRepOutModel>();//存放计划数量为0的
            tempOut = listOut.FindAll(p => p.PLAN_COUNT == 0 || !string.IsNullOrEmpty(p.OUT_LOC_ID));
            listOut.RemoveAll(p => p.PLAN_COUNT == 0 || !string.IsNullOrEmpty(p.OUT_LOC_ID));


            #region 清空数据
            listOrderGoods = new List<OrderDetailModel>();
            listMIStock = new List<MIStockModel>();
            listPackingMIStock = new List<MIStockModel>();
            num = 0;
            numNew = 0;
            byProduce = true;
            byAdded = true;
            byNull = true;
            listPackingMIStock = new List<MIStockModel>();//有所需商品的库存->需要拣货的库存（某种商品的）
            #endregion
            listPackingMIStock = new List<MIStockModel>();//有所需商品的库存->需要拣货的库存（某种商品的）

            DataTable downStrategy = DataProvider.Instance.DownStrategy.GetDownStrategyDTByStorage(storageID);

            StorageAreaModel tempArea = new StorageAreaModel();
            tempArea.STORAGE_ID = storageID;
            List<StorageAreaModel> listJianHuo = ConvertHelper<StorageAreaModel>.ConvertToList(DataProvider.Instance.StorageArea.GetAreaInfoDS(tempArea, "拣配区"));
            List<StorageAreaModel> listShangJia = ConvertHelper<StorageAreaModel>.ConvertToList(DataProvider.Instance.StorageArea.GetAreaInfoDS(tempArea, "整箱区"));
            foreach (DataRow row in downStrategy.Rows)
            {
                if (!listJianHuo.Exists(p => p.STORAGE_AREA_ID == row["STORAGE_AREA_ID"].ToString()))
                {
                    row["STORAGE_AREA_ID"] = string.Empty;
                }
            }

            #region 获取需要拣货的商品
            foreach (var item in listOut)
            {
                OrderDetailModel tab = new OrderDetailModel();
                tab.GOOD_ID = item.GOODS_ID;
                tab.GOODS_NUM = item.PLAN_COUNT;
                tab.UNIT = item.UNIT;
                listOrderGoods.Add(tab);
            }
            #endregion

            #region 获取发货仓库的所有库存
            MIStockModel queryMIStock = new MIStockModel();
            queryMIStock.STORAGE_ID = storageID;
            DataTable tableMIStock = DataProvider.Instance.MIStock.GetMIStockDT(queryMIStock);
            listMIStock = ConvertHelper<MIStockModel>.ConvertToList(tableMIStock);//发货仓库的所有库存
            if (!DataLogErrWrite(tableMIStock, "获取发货仓库的所有库存"))
            {
                return ErrText;
            }
            listMIStock.RemoveAll(p => p.ABLE_NUM == 0);//移除所有数量为0的
            #endregion

            #region 根据拣货策略记录需要的商品在拣货区的数量
            int te = 0;
            List<MIStockModel> areaList = new List<MIStockModel>();
            foreach (DataRow row in downStrategy.Rows)
            {
                if (row["STORAGE_AREA_ID"].ToString() == string.Empty)
                {
                    continue;
                }
                te++;
            }
            if (te == 0)
            {
                foreach (var item in listOrderGoods)
                {
                    string areaID = string.Empty;
                    List<AreaGoodsTypeModel> areaGoodsTypeList = new List<AreaGoodsTypeModel>();
                    getAreaGoodsType(ref areaGoodsTypeList, item.GOODS_TYPE_ID);

                    if (areaGoodsTypeList != null && areaGoodsTypeList.Count > 0)
                    {

                        foreach (var jh in listJianHuo)
                        {
                            if (areaGoodsTypeList.Exists(p => p.AREA_ID == jh.STORAGE_AREA_ID))
                            {
                                areaID = jh.STORAGE_AREA_ID;
                                break;
                            }
                        }
                    }

                    if (areaID == string.Empty)
                    {
                        areaID = getAreaID("拣配区");
                    }
                    MIStockModel m = new MIStockModel();
                    m.AREA_ID = areaID;
                    m.GOODS_ID = item.GOOD_ID;
                    areaList.Add(m);

                }

                foreach (var area in areaList)
                {
                    foreach (MIStockModel MIStock in listMIStock)
                    {
                        if (area.GOODS_ID == MIStock.GOODS_ID && MIStock.AREA_ID == area.AREA_ID)
                        {

                            foreach (OrderDetailModel item in listOrderGoods)
                            {
                                if (item.GOOD_ID == MIStock.GOODS_ID)
                                {
                                    item.AREA_NUM += Convert.ToDecimal(MIStock.ABLE_NUM);//记录拣货区该商品总数
                                }
                            }

                        }
                    }
                }
                //ErrText += "找不到该仓库的下架策略或该仓库的下架策略已被禁用 ";
                //return ErrText;
            }
            else
            {
                foreach (DataRow row in downStrategy.Rows)
                {
                    if (row["STORAGE_AREA_ID"].ToString() == string.Empty)
                    {
                        continue;
                    }

                    foreach (MIStockModel MIStock in listMIStock)
                    {
                        if (MIStock.AREA_ID == row["STORAGE_AREA_ID"].ToString())
                        {
                            foreach (OrderDetailModel item in listOrderGoods)
                            {
                                if (item.GOOD_ID == MIStock.GOODS_ID)
                                {
                                    item.AREA_NUM += Convert.ToDecimal(MIStock.ABLE_NUM);//记录拣货区该商品总数
                                }
                            }
                        }
                    }

                }
            }
            #endregion

            //判断库存是否充足，如果不足调拨
            bool have = true;
            List<OrderDetailModel> listAddGoods = new List<OrderDetailModel>();
            foreach (OrderDetailModel item in listOrderGoods)
            {
                if (item.AREA_NUM < item.GOODS_NUM)
                {
                    have = false;
                    if (listAddGoods.Exists(p => p.GOOD_ID == item.GOOD_ID))
                    {
                        listAddGoods.Find(p => p.GOOD_ID == item.GOOD_ID).GOODS_NUM += (item.GOODS_NUM - item.AREA_NUM);
                    }
                    else
                    {
                        OrderDetailModel t = new OrderDetailModel();
                        t.GOOD_ID = item.GOOD_ID;
                        t.GOODS_NUM = (item.GOODS_NUM - item.AREA_NUM);
                        t.GOODS_TYPE_ID = item.GOODS_TYPE_ID;
                        if (t.GOODS_NUM <= 0)
                        {
                            break;
                        }
                        listAddGoods.Add(t);
                    }
                }
            }
            if (!have) {

                List<AreaRepModel> listAreaRep = new List<AreaRepModel>();
                List<AreaRepInModel> listInGoods = new List<AreaRepInModel>();
                List<AreaRepOutModel> listOutGoods = new List<AreaRepOutModel>();


                Transaction = DataProvider.Instance.TranOracle;

                foreach (OrderDetailModel item in listAddGoods)
                {
                    #region 通过商品找商品分类找存放该商品分类的捡货区、上架区
                    string inAreaID = string.Empty;
                    string outAreaID = string.Empty;
                    List<AreaGoodsTypeModel> areaGoodsTypeList = new List<AreaGoodsTypeModel>();

                    getAreaGoodsType(ref areaGoodsTypeList, item.GOODS_TYPE_ID);

                    if (areaGoodsTypeList != null && areaGoodsTypeList.Count > 0)
                    {

                        foreach (var jh in listJianHuo)
                        {
                            if (areaGoodsTypeList.Exists(p => p.AREA_ID == jh.STORAGE_AREA_ID))
                            {
                                inAreaID = jh.STORAGE_AREA_ID;
                                break;
                            }
                        }
                        foreach (var sj in listShangJia)
                        {
                            if (areaGoodsTypeList.Exists(p => p.AREA_ID == sj.STORAGE_AREA_ID))
                            {
                                outAreaID = sj.STORAGE_AREA_ID;
                                break;
                            }
                        }
                    }

                    if (inAreaID == string.Empty)
                    {
                        inAreaID = getAreaID("拣配区");
                    }
                    if (outAreaID == string.Empty)
                    {
                        outAreaID = getAreaID("整箱区");
                    }

                    AreaRepModel areaRepGoods;
                    if (!listAreaRep.Exists(p => p.IN_AREA_ID == inAreaID && p.OUT_AREA_ID == outAreaID))
                    {
                        areaRepGoods = new AreaRepModel();//商品调拨单
                        areaRepGoods.CREATE_METHOD = "0";
                        //areaRepGoods.CREATE_PERSON = listOrders[0].CREATE_MAN;
                        areaRepGoods.IN_AREA_ID = inAreaID;
                        areaRepGoods.OUT_AREA_ID = outAreaID;
                        areaRepGoods.STATE = "0";
                        areaRepGoods.STORAGE_ID = storageID;
                        areaRepGoods.REASON = "0";
                        areaRepGoods.TOTAL_PLAN_NUM = 0;//计划出库总数

                        areaRepGoods.AREA_REP_ID = DataProvider.Instance.AreaRep.InsertAreaRep(areaRepGoods);
                        logList.Add(DataProvider.Instance.logData);

                        listAreaRep.Add(areaRepGoods);
                    }
                    else
                    {
                        areaRepGoods = listAreaRep.Find(p => p.IN_AREA_ID == inAreaID && p.OUT_AREA_ID == outAreaID);
                    }
                    #endregion

                    AreaRepInModel inGoods = new AreaRepInModel();
                    inGoods.GOODS_ID = item.GOOD_ID;
                    inGoods.AREA_REP_ID = areaRepGoods.AREA_REP_ID;
                    //上架区商品数
                    inGoods.MISTOCK_NUM = 0;
                    foreach (MIStockModel MIStock in listMIStock)
                    {
                        if (MIStock.AREA_ID == outAreaID)
                        {
                            if (inGoods.GOODS_ID == MIStock.GOODS_ID)
                            {
                                inGoods.MISTOCK_NUM += Convert.ToDecimal(MIStock.ABLE_NUM);
                            }

                        }
                    }

                    inGoods.PLAN_COUNT = item.GOODS_NUM;// num + repGoodsNum;////////////////////////////////???????????????????????????????

                    listInGoods.Add(inGoods);

                    AreaRepOutModel outGoods = new AreaRepOutModel();
                    outGoods.AREA_REP_ID = areaRepGoods.AREA_REP_ID;
                    outGoods.GOODS_ID = item.GOOD_ID;
                    outGoods.MISTOCK_NUM = inGoods.MISTOCK_NUM;
                    outGoods.PLAN_COUNT = inGoods.PLAN_COUNT;

                    listOutGoods.Add(outGoods);

                    //areaRepGoods.TOTAL_PLAN_NUM += inGoods.PLAN_COUNT;


                    //decimal nu = item.AREA_NUM - Convert.ToDecimal(item.GOODS_NUM);

                    //if (nu < addGoodsNum)//调拨商品
                    //{
                    //    AreaRepInModel inGoods = new AreaRepInModel();
                    //    inGoods.GOODS_ID = item.GOOD_ID;

                    //    //上架区商品数
                    //    inGoods.MISTOCK_NUM = 0;
                    //    foreach (MIStockModel MIStock in listMIStock)
                    //    {
                    //        if (MIStock.AREA_NAME == "上架区")
                    //        {
                    //            if (inGoods.GOODS_ID == MIStock.GOODS_ID)
                    //            {
                    //                inGoods.MISTOCK_NUM += Convert.ToDecimal(MIStock.ABLE_NUM);
                    //            }

                    //        }
                    //    }

                    //    inGoods.PLAN_COUNT = 0;// num + repGoodsNum;

                    //    listInGoods.Add(inGoods);

                    //    AreaRepOutModel outGoods = new AreaRepOutModel();
                    //    outGoods.GOODS_ID = item.GOOD_ID;
                    //    outGoods.MISTOCK_NUM = inGoods.MISTOCK_NUM;
                    //    outGoods.PLAN_COUNT = 0;// num + repGoodsNum;

                    //    listOutGoods.Add(outGoods);

                    //    areaRepGoods.TOTAL_PLAN_NUM += inGoods.PLAN_COUNT;
                    //}
                }

                foreach (var areaRepModel in listAreaRep)
                {
                    List<AreaRepOutModel> listO = listOutGoods.FindAll(p => p.AREA_REP_ID == areaRepModel.AREA_REP_ID);
                    //ErrText += IBussFactory<BussAreaRep>.Instance().GetAreaRepOutLoc(areaRepModel, ref listO);
                }

                //增加明细
                foreach (AreaRepOutModel areaRepOutModel in listOutGoods)
                {
                    DataProvider.Instance.AreaRepOut.InsertAreaRepOut(areaRepOutModel);
                    logList.Add(DataProvider.Instance.logData);

                    ////根据计划数修改已占用库存
                    //MIStockModel mi = new MIStockModel();
                    //mi.PUTIN_ID = areaRepOutModel.PUTIN_ID;
                    //mi.GOODS_ID = areaRepOutModel.GOODS_ID;
                    //mi.LOCATION_ID = areaRepOutModel.OUT_LOC_ID;
                    //mi.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                    //DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                    //logList.Add(DataProvider.Instance.logData);

                    ////写入库存占用记录表
                    //MIStockModel mistock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(mi))[0];
                    //MIStockOccupyModel occupy = new MIStockOccupyModel();
                    //occupy.AREA_ID = mistock.AREA_ID;
                    //occupy.DOCCTNUMBER = areaRepOutModel.AREA_REP_ID;
                    //occupy.GOODS_ID = mistock.GOODS_ID;
                    //occupy.LOCATION_ID = mistock.LOCATION_ID;
                    //occupy.OCCUPY_NUM = areaRepOutModel.PLAN_COUNT;
                    //occupy.PUTIN_ID = mistock.PUTIN_ID;
                    //occupy.STOCK_ID = mistock.STOCK_ID;
                    //occupy.STORAGE_ID = mistock.STORAGE_ID;
                    //DataProvider.Instance.MIStockOccupy.InsertMIStockOccupy(occupy);
                    //logList.Add(DataProvider.Instance.logData);

                    listAreaRep.Find(p => p.AREA_REP_ID == areaRepOutModel.AREA_REP_ID).TOTAL_PLAN_NUM += areaRepOutModel.PLAN_COUNT;
                }
                foreach (AreaRepInModel areaRepInModel in listInGoods)
                {
                    DataProvider.Instance.AreaRepIn.InsertAreaRepIn(areaRepInModel);
                    logList.Add(DataProvider.Instance.logData);
                }

                foreach (var item in listAreaRep)//修改计划总数
                {
                    DataProvider.Instance.AreaRep.UpdateAreaRep(item);
                    logList.Add(DataProvider.Instance.logData);
                }

                TaCmtOrRak();//提交事务

                return "库存不足";
            }

            #region 获取对应库位
            foreach (OrderDetailModel item in listOrderGoods)//遍历需要拣货的商品
            {
                //获取有所需商品的库存集合
                listPackingMIStock = new List<MIStockModel>();
                if (te == 0) {
                    foreach (var area in areaList)
                    {
                        foreach (MIStockModel MIStock in listMIStock)
                        {
                            if (area.GOODS_ID == MIStock.GOODS_ID && MIStock.AREA_ID == area.AREA_ID)
                            {

                                foreach (OrderDetailModel ite in listOrderGoods)
                                {
                                    if (ite.GOOD_ID == MIStock.GOODS_ID)
                                    {
                                        listPackingMIStock.Add(MIStock);
                                    }
                                }

                            }
                        }
                    }
                }
                else
                {
                    foreach (DataRow row in downStrategy.Rows)
                    {

                        if (row["STORAGE_AREA_ID"].ToString() == string.Empty)
                        {
                            continue;
                        }

                        foreach (MIStockModel MIStock in listMIStock)
                        {
                            if (MIStock.AREA_ID == row["STORAGE_AREA_ID"].ToString())
                            {
                                if (item.GOOD_ID == MIStock.GOODS_ID)
                                {
                                    listPackingMIStock.Add(MIStock);
                                }
                            }
                        }

                        if (row["PRODUCE_FLAG"].ToString() == "0")
                        {
                            byProduce = false;
                        }
                        else
                        {
                            byProduce = true;
                        }
                        if (row["ADDED_FLAG"].ToString() == "0")
                        {
                            byAdded = false;
                        }
                        else
                        {
                            byAdded = true;
                        }
                        if (row["NULL_FLAG"].ToString() == "0")
                        {
                            byNull = false;
                        }
                        else
                        {
                            byNull = true;
                        }

                    }
                }
                //通过生产日期对listGoodsMIStock筛选
                if (byProduce && (GetMiStockByProductDate() || listPackingMIStock.Count == 1))//数量正好满足或只有1个库位可以满足
                {

                }
                else
                {
                    //通过上架日期对listGoodsMIStock筛选
                    if (byAdded && (GetMiStockByWaveDate() || listPackingMIStock.Count == 1))//数量正好满足或只有1个库位可以满足
                    {

                    }
                    else
                    {
                        List<MIStockModel> newMIList = new List<MIStockModel>();//拣货后已占用容积为0的所有库位（只有这一种商品的库位）

                        if (byNull && GetMiStockByOnlyOne(ref newMIList))
                        {

                        }
                        else//少
                        {
                            GetMiStockBySurplus(ref newMIList);//取拣货后剩余容积大的
                        }
                    }
                }

                List<AreaRepOutModel> tempOutList = new List<AreaRepOutModel>();
                foreach (var outModel in listOut)
                {
                    decimal tempCount = outModel.PLAN_COUNT;

                    List<MIStockModel> tempList = listPackingMIStock.FindAll(p => p.GOODS_ID == outModel.GOODS_ID);

                    if (tempList.Count == 0)
                    {
                        continue;
                    }

                    for (int i = 0; i < tempList.Count; i++)
                    {
                        AreaRepOutModel tempOutModel = new AreaRepOutModel();
                        tempOutModel.AREA_REP_ID = outModel.AREA_REP_ID;
                        tempOutModel.GOODS_ID = outModel.GOODS_ID;
                        tempOutModel.GOODS_NAME = outModel.GOODS_NAME;
                        tempOutModel.MISTOCK_NUM = outModel.MISTOCK_NUM;
                        tempOutModel.PRICE = outModel.PRICE;
                        tempOutModel.REAL_COUNT = outModel.REAL_COUNT;
                        tempOutModel.SCALE_UNIT = outModel.SCALE_UNIT;
                        tempOutModel.SORT = outModel.SORT;
                        tempOutModel.TAB_OUT_ID = outModel.TAB_OUT_ID;
                        tempOutModel.UNIT = outModel.UNIT;
                        tempOutModel.UNIT_NAME = outModel.UNIT_NAME;
                        tempOutModel.OUT_LOC_ID = tempList[i].LOCATION_ID;
                        tempOutModel.LOC_NUM = tempList[i].ABLE_NUM;

                        tempOutModel.DOCCTNUMBER = tempList[i].DOCCTNUMBER;
                        tempOutModel.PUTIN_ID = tempList[i].PUTIN_ID;
                        tempOutModel.PRODUCTION_DATE = tempList[i].PRODUCTION_DATE;
                        tempOutModel.WARE_DATE = tempList[i].WARE_DATE;
                        tempOutModel.PROVIDER_ID = tempList[i].PROVIDER_ID;

                        if (tempList.Count - 1 == i)
                        {
                            tempOutModel.PLAN_COUNT = tempCount - tempOutList.FindAll(p => p.GOODS_ID == outModel.GOODS_ID).Sum(p => p.PLAN_COUNT);
                        }
                        else
                        {

                            tempOutModel.PLAN_COUNT = tempList[i].ABLE_NUM;
                        }

                        tempOutList.Add(tempOutModel);
                    }
                    //}
                }
                listOut.AddRange(tempOutList);


            }
            #endregion

            listOut.RemoveAll(p => p.PLAN_COUNT > 0 && string.IsNullOrEmpty(p.OUT_LOC_ID));

            listOut.AddRange(tempOut);

            Transaction = DataProvider.Instance.TranOracle;
            //减库存
            foreach (var i in listOut)
            {
                //查询数据库里面有没有该商品，如果没有则插入该商品(商品编号,商品名称)
                foreach (var or_de_Model in listOut)
                {
                    if (DataProvider.Instance.Goods.GetGoodsDataTable(or_de_Model.GOODS_ID, or_de_Model.GOODS_NAME, "", "").Rows.Count <= 0)
                    {
                        GoodsInfoModel goods = new GoodsInfoModel();
                        goods.GOODS_ID = or_de_Model.GOODS_ID;
                        goods.GOODS_NAME = or_de_Model.GOODS_NAME;
                        //DataProvider.Instance.Goods.AddGoodsInfo(goods);
                    }
                }

                //根据计划数修改已占用库存
                MIStockModel mi = new MIStockModel();
                mi.PUTIN_ID = i.PUTIN_ID;
                mi.GOODS_ID = i.GOODS_ID;
                mi.LOCATION_ID = i.OUT_LOC_ID;
                mi.OCCUPY_NUM = i.PLAN_COUNT;
                DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                logList.Add(DataProvider.Instance.logData);


                //写入库存占用记录表
                MIStockModel mistock = ConvertHelper<MIStockModel>.ConvertToList(DataProvider.Instance.MIStock.GetMIStockDT(mi))[0];
                MIStockOccupyModel occupy = new MIStockOccupyModel();
                occupy.AREA_ID = mistock.AREA_ID;
                occupy.DOCCTNUMBER = id;
                occupy.GOODS_ID = mistock.GOODS_ID;
                occupy.LOCATION_ID = mistock.LOCATION_ID;
                occupy.OCCUPY_NUM = i.PLAN_COUNT;
                occupy.PUTIN_ID = mistock.PUTIN_ID;
                occupy.STOCK_ID = mistock.STOCK_ID;
                occupy.STORAGE_ID = mistock.STORAGE_ID;
                DataProvider.Instance.MIStockOccupy.InsertMIStockOccupy(occupy);
                logList.Add(DataProvider.Instance.logData);
            }
            TaCmtOrRak();
            return ErrText;
            
        }

        /// <summary>
        /// ERP线上订单取消库存占用
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string CancelOccupyMIStock(string id) {

            MIStockOccupyModel queryOccupy = new MIStockOccupyModel();
            queryOccupy.DOCCTNUMBER = id;
            List<MIStockOccupyModel> occupy = ConvertHelper<MIStockOccupyModel>.ConvertToList(DataProvider.Instance.MIStockOccupy.GetMIStockOccupyDT(queryOccupy));

            Transaction = DataProvider.Instance.TranOracle;

            foreach (var i in occupy)
            {
                MIStockModel mi = new MIStockModel();
                mi.PUTIN_ID = i.PUTIN_ID;
                mi.GOODS_ID = i.GOODS_ID;
                mi.LOCATION_ID = i.LOCATION_ID;
                mi.AREA_ID = i.AREA_ID;
                mi.STOCK_ID = i.STOCK_ID;
                mi.STORAGE_ID = i.STORAGE_ID;
                mi.OCCUPY_NUM = -i.OCCUPY_NUM;

                DataProvider.Instance.MIStock.UpdateMIStockOccupyNum(mi);
                logList.Add(DataProvider.Instance.logData);

                DataProvider.Instance.MIStockOccupy.DeleteMIStockOccupy(i);
                logList.Add(DataProvider.Instance.logData);
            }

            TaCmtOrRak();
            return ErrText;
        }
    }
}