wanghaiming/BaoKai_202508-Wms-Jingwang.ChenPin-Jiangxi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
03bbd92115
BaoKai_202508-Wms-Jingwang..../WMS.Business/Stock/BussAreaRep.cs

2263 lines
99 KiB
C#
Raw Normal View History

景旺成品仓wms
2025-08-24 09:35:55 +08:00
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;
}
}
}
Reference in New Issue Copy Permalink