/// <summary>
/// 审核销售出库单
/// </summary>
/// <param name="id"></param>
/// <param name="userid"></param>
/// <returns></returns>
internal static int CKInDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
using (var tx = db.Database.BeginTransaction())
{
try
{
SaleDepot co = db.SaleDepot.FirstOrDefault(p => p.SDID.Equals(id));
co.SDState = 1;
ObjectParameter para = new ObjectParameter("DD", "");
db.pro_order("InOutDepot", "IODNum", "RK", para);
string IODNum = para.Value.ToString();
//添加入库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = co.DepotID, IODType = 2, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = co.SDDesc
});
db.SaveChanges();
int inod = db.InOutDepot.Max(i => i.IODID);
List <SaleDepotDetail> list = db.SaleDepotDetail.Where(p => p.SDID.Equals(id)).ToList(); //销售出库详单
List <CustomerOrderDetail> cuslist = db.CustomerOrderDetail.Where(p => p.COID.Equals(co.COID)).ToList(); //客户订单详单
foreach (SaleDepotDetail item in list)
{
//修改客户订单已销数量
foreach (CustomerOrderDetail cus in cuslist)
{
if (cus.ProID == item.ProID)
{
cus.CODSale = item.SDDAmount;
}
}
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(co.DepotID) && p.ProID == item.ProID) == null)
{//如果指定的仓库中不存在该商品
throw new Exception("不存在该商品，操作失败！");
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == co.DepotID);
ds.DSAmount = ds.DSAmount - item.SDDAmount;
}
//添加入库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = inod, ProID = item.ProID, IODDAmount = item.SDDAmount, IODDPrice = item.SDDPrice
});
}
db.SaveChanges();
tx.Commit();
}
catch (Exception ex)
{
fg = 0;
tx.Rollback();
throw new Exception(ex.Message);
}
}
return(fg);
}
public void BatchDeleteTest()
{
DepotStock v1 = new DepotStock();
DepotStock v2 = new DepotStock();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v1.DepotsID = AddDepots();
v1.ProductsID = AddProducts();
v1.DSAmount = 18;
v1.DSPrice = 23;
v2.DepotsID = v1.DepotsID;
v2.ProductsID = v1.ProductsID;
v2.DSAmount = 10;
v2.DSPrice = 33;
context.Set <DepotStock>().Add(v1);
context.Set <DepotStock>().Add(v2);
context.SaveChanges();
}
var rv = _controller.BatchDelete(new string[] { v1.ID.ToString(), v2.ID.ToString() });
Assert.IsInstanceOfType(rv, typeof(OkObjectResult));
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
var data1 = context.Set <DepotStock>().Find(v1.ID);
var data2 = context.Set <DepotStock>().Find(v2.ID);
Assert.AreEqual(data1.IsValid, false);
Assert.AreEqual(data2.IsValid, false);
}
rv = _controller.BatchDelete(new string[] {});
Assert.IsInstanceOfType(rv, typeof(OkResult));
}
/// <summary>
/// 审核订单【修改后不可修改，直接影响库存数据】
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int CKDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
///以下开始事务操作
using (var tx = db.Database.BeginTransaction())
{
try
{
/*
* --------------------------------------- 【库存盘点】-------------------------------------------------
* 1、将盘点状态改为1
* 2、直接修改对应仓库中的商品库存为拆分商品后的实际库存
*/
Splits st = db.Splits.FirstOrDefault(s => s.SplitID.Equals(id));
st.SplitState = 1;
List <SplitDetail> list = db.SplitDetail.Where(p => p.SplitID.Equals(id)).ToList();//销售出库详单
DepotStock ds = db.DepotStock.FirstOrDefault(s => s.DepotID == st.DepotID && s.ProID == st.ProID);
if (ds == null)
{
throw new Exception("拆分商品未在当前仓库中！！！");
}
if (ds.DSAmount < st.SplitAmount)//判断库存是否充足
{
throw new Exception("拆分数量超出当前商品的库存数量！！");
}
else
{
ds.DSAmount -= st.SplitAmount;//减少被拆分商品的库存
}
foreach (SplitDetail item in list)
{
//如果拆分后的商品在当前仓库中不存在
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DepotID) && p.ProID == item.ProID) == null)
{
//添加新的商品库存
db.DepotStock.Add(new DepotStock()
{
DepotID = st.DepotID, ProID = item.ProID, DSAmount = item.SDAmount, DSPrice = item.SDPrice
});
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock dss = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == st.DepotID);
dss.DSAmount += item.SDAmount;
}
}
db.SaveChanges();
tx.Commit();
}
catch (Exception e)
{
tx.Rollback();
throw new Exception(e.Message);
}
}
return(fg);
}
/// <summary>
/// 审核入库单【---事务处理---】
/// </summary>
/// <param name="id">入库单ID</param>
/// <returns>是否成功【0失败、1成功】</returns>
public static int CKStockIn(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
using (var tx = db.Database.BeginTransaction())
{
try
{ //------------------------------------------------【入库审核】-------------------------------------------------
List <StockInDepotDetail> prolist = db.StockInDepotDetail.Where(s => s.SIDID.Equals(id)).ToList(); //根据入库单ID找到采购入库订单详单集合
StockInDepot st = db.StockInDepot.FirstOrDefault(s => s.SIDID.Equals(id)); //根据入库单ID找到采购入库订单
ObjectParameter para = new ObjectParameter("DD", ""); //生产入库记录单号
db.pro_order("InOutDepot", "IODNum", "RK", para);
string IODNum = para.Value.ToString();
//添加入库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = st.DepotID, IODType = 1, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = st.SIDDesc
});
db.SaveChanges(); //保存
int inod = db.InOutDepot.Max(i => i.IODID); //再获取出刚刚出入库记录编号【循环添加出入库详单的时候需要出入库记录编号，所有要先保存】
// db.InOutDepot.
foreach (StockInDepotDetail item in prolist) //遍历出库单详单
{
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DepotID) && p.ProID == item.ProID) == null)
{//如果指定的仓库中不存在该商品
//【为这个仓库添加一个新商品】
db.DepotStock.Add(new DepotStock()
{
DepotID = st.DepotID, ProID = item.ProID, DSAmount = item.SIDAmount, DSPrice = item.SIDPrice
});
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == st.DepotID);
ds.DSAmount = item.SIDAmount + ds.DSAmount;
}
//添加入库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = inod, ProID = item.ProID, IODDAmount = item.SIDAmount, IODDPrice = item.SIDPrice
});
}
st.SIDData = 1;//修改入库表状态
db.SaveChanges();
tx.Commit();
}
catch (Exception ex)
{
fg = 0;
tx.Rollback();
throw new Exception(ex.Message);
}
}
return(fg);
}
/// <summary>
/// 审核采购订单
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int CKInDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
///以下开始事务操作
using (var tx = db.Database.BeginTransaction())
{
try
{
List <OtherInDepotDetail> prolist = db.OtherInDepotDetail.Where(s => s.OIDID.Equals(id)).ToList();
OtherInDepot st = db.OtherInDepot.FirstOrDefault(s => s.OIDID.Equals(id));
ObjectParameter para = new ObjectParameter("DD", "");
db.pro_order("InOutDepot", "IODNum", "RK", para);
string IODNum = para.Value.ToString();
//添加入库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = st.DepotID, IODType = 1, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = st.OIDDesc
});
db.SaveChanges();
int inod = db.InOutDepot.Max(i => i.IODID);
// db.InOutDepot.
foreach (OtherInDepotDetail item in prolist)
{
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DepotID) && p.ProID == item.ProID) == null)
{//如果指定的仓库中不存在该商品
//【为这个仓库添加一个新商品】
db.DepotStock.Add(new DepotStock()
{
DepotID = st.DepotID, ProID = item.ProID, DSAmount = item.OIDDAmount, DSPrice = item.OIDDPrice
});
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID);
ds.DSAmount = item.OIDDAmount + ds.DSAmount;
}
//添加入库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = inod, ProID = item.ProID, IODDAmount = item.OIDDAmount, IODDPrice = item.OIDDPrice
});
}
st.OIDState = 1;
db.SaveChanges();
tx.Commit();
}
catch (Exception e)
{
tx.Rollback();
throw new Exception(e.Message);
}
}
return(fg);
}
/// <summary>
/// 审核报损单
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int CKInDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
///以下开始事务操作
using (var tx = db.Database.BeginTransaction())
{
try
{
Losts st = db.Losts.FirstOrDefault(s => s.LostID.Equals(id));
st.LostState = 1;
ObjectParameter para = new ObjectParameter("DD", "");
db.pro_order("InOutDepot", "IODNum", "RK", para);
string IODNum = para.Value.ToString();
//添加出库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = st.DepotID, IODType = 2, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = st.LostDesc
});
db.SaveChanges();
int inod = db.InOutDepot.Max(i => i.IODID);
List <LostDetail> list = db.LostDetail.Where(p => p.LostID.Equals(id)).ToList();//销售出库详单
foreach (LostDetail item in list)
{
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DepotID) && p.ProID == item.ProID) == null)
{//如果指定的仓库中不存在该商品
throw new Exception("报损仓库不存在该商品，操作失败！");
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID);
if (ds.DSAmount < item.LDAmount)
{
throw new Exception("商品库存小于报损数量，操作失败！");
}
ds.DSAmount = ds.DSAmount - item.LDAmount;
}
//添加入库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = inod, ProID = item.ProID, IODDAmount = item.LDAmount, IODDPrice = item.LDPrice
});
}
db.SaveChanges();
tx.Commit();
}
catch (Exception e)
{
tx.Rollback();
throw new Exception(e.Message);
}
}
return(fg);
}
public void GetTest()
{
DepotStock v = new DepotStock();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v.DepotsID = AddDepots();
v.ProductsID = AddProducts();
v.DSAmount = 18;
v.DSPrice = 23;
context.Set <DepotStock>().Add(v);
context.SaveChanges();
}
var rv = _controller.Get(v.ID.ToString());
Assert.IsNotNull(rv);
}
public void EditTest()
{
DepotStock v = new DepotStock();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v.DepotsID = AddDepots();
v.ProductsID = AddProducts();
v.DSAmount = 18;
v.DSPrice = 23;
context.Set <DepotStock>().Add(v);
context.SaveChanges();
}
DepotStockVM vm = _controller.Wtm.CreateVM <DepotStockVM>();
var oldID = v.ID;
v = new DepotStock();
v.ID = oldID;
v.DSAmount = 10;
v.DSPrice = 33;
vm.Entity = v;
vm.FC = new Dictionary <string, object>();
vm.FC.Add("Entity.DepotsID", "");
vm.FC.Add("Entity.ProductsID", "");
vm.FC.Add("Entity.DSAmount", "");
vm.FC.Add("Entity.DSPrice", "");
var rv = _controller.Edit(vm);
Assert.IsInstanceOfType(rv, typeof(OkObjectResult));
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
var data = context.Set <DepotStock>().Find(v.ID);
Assert.AreEqual(data.DSAmount, 10);
Assert.AreEqual(data.DSPrice, 33);
Assert.AreEqual(data.UpdateBy, "user");
Assert.IsTrue(DateTime.Now.Subtract(data.UpdateTime.Value).Seconds < 10);
}
}
/// <summary>
/// 审核订单【修改后不可修改，直接影响库存数据】
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int CKDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
///以下开始事务操作
using (var tx = db.Database.BeginTransaction())
{
try
{
/*
* --------------------------------------- 【库存盘点】-------------------------------------------------
* 1、将盘点状态改为3
* 2、直接修改对应仓库中的商品库存为盘点后的实际库存
*/
CheckDepot st = db.CheckDepot.FirstOrDefault(s => s.CDID.Equals(id));
st.CDState = 2;
List <CheckDepotDetail> list = db.CheckDepotDetail.Where(p => p.CDID.Equals(id)).ToList();//销售出库详单
foreach (CheckDepotDetail item in list)
{
//如果盘点的仓库中不存在该商品
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DepotID) && p.ProID == item.ProID) == null)
{
throw new Exception("商品不存在该仓库中！");
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存为盘点后的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == st.DepotID);
ds.DSAmount = item.CDDAmount1;
}
}
db.SaveChanges();
tx.Commit();
}
catch (Exception e)
{
tx.Rollback();
throw new Exception(e.Message);
}
}
return(fg);
}
public void CreateTest()
{
DepotStockVM vm = _controller.Wtm.CreateVM <DepotStockVM>();
DepotStock v = new DepotStock();
v.DepotsID = AddDepots();
v.ProductsID = AddProducts();
v.DSAmount = 18;
v.DSPrice = 23;
vm.Entity = v;
var rv = _controller.Add(vm);
Assert.IsInstanceOfType(rv, typeof(OkObjectResult));
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
var data = context.Set <DepotStock>().Find(v.ID);
Assert.AreEqual(data.DSAmount, 18);
Assert.AreEqual(data.DSPrice, 23);
Assert.AreEqual(data.CreateBy, "user");
Assert.IsTrue(DateTime.Now.Subtract(data.CreateTime.Value).Seconds < 10);
}
}
/// <summary>
/// 审核报损单
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int CKInDepot(string id, int userid)
{
PSSEntities db = new PSSEntities();
int fg = 1;
///以下开始事务操作
using (var tx = db.Database.BeginTransaction())
{
try
{
/*
* --------------------------------------- 【库存调拨】-------------------------------------------------
*
* 1、将仓库A中的商品调入到仓库里B中去
* 2、修改A、B仓库中调拨商品的商品数量，
* 3、分别为A、B仓库添加对应的出入库记录与详情
*
*/
Devolves st = db.Devolves.FirstOrDefault(s => s.DevID.Equals(id));
st.DevState = 1;
ObjectParameter para = new ObjectParameter("DD", "");
db.pro_order("InOutDepot", "IODNum", "RK", para);
string IODNum = para.Value.ToString();
//为A仓库添加出库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = st.DevOutID, IODType = 2, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = st.DevDesc
});
db.SaveChanges();
int outinod = db.InOutDepot.Max(i => i.IODID);
//为B仓库添加入库记录
db.InOutDepot.Add(new InOutDepot()
{
DepotID = st.DevInID, IODType = 1, IODNum = IODNum, IODDate = DateTime.Now, IODUser = userid, IODDesc = st.DevDesc
});
db.SaveChanges();
int ininod = db.InOutDepot.Max(i => i.IODID);
List <DevolveDetail> list = db.DevolveDetail.Where(p => p.DevID.Equals(id)).ToList();//销售出库详单
foreach (DevolveDetail item in list)
{
//如果调出的仓库中不存在该商品
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DevOutID) && p.ProID == item.ProID) == null)
{
throw new Exception("调出商品不存在仓库中！");
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == st.DevOutID);
ds.DSAmount = ds.DSAmount - item.DevDAmount;
}
//如果调入仓库中不存在该商品
if (db.DepotStock.FirstOrDefault(p => p.DepotID.Equals(st.DevOutID) && p.ProID == item.ProID) == null)
{
//为调入仓库添加新的商品库存
db.DepotStock.Add(new DepotStock()
{
DepotID = st.DevInID, ProID = item.ProID, DSAmount = item.DevDAmount
});
}
else
{//如果指定仓库存在这个商品，修改这个商品的库存
DepotStock ds = db.DepotStock.FirstOrDefault(d => d.ProID == item.ProID && d.DepotID == st.DevOutID);
ds.DSAmount = ds.DSAmount + item.DevDAmount;
}
//添加出库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = outinod, ProID = item.ProID, IODDAmount = item.DevDAmount
});
//添加入库记录详情
db.InOutDepotDetail.Add(new InOutDepotDetail()
{
IODID = ininod, ProID = item.ProID, IODDAmount = item.DevDAmount
});
}
db.SaveChanges();
tx.Commit();
}
catch (Exception e)
{
tx.Rollback();
throw new Exception(e.Message);
}
}
return(fg);
}
