package zy.cloud.wms.manager.service.impl;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.core.common.*;
|
import com.core.exception.CoolException;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import zy.cloud.wms.common.config.CodeCoolException;
|
import zy.cloud.wms.common.model.BillDto;
|
import zy.cloud.wms.common.model.MatnrDto;
|
import zy.cloud.wms.common.model.OrderStoDto;
|
import zy.cloud.wms.common.service.MainService;
|
import zy.cloud.wms.common.service.asrs.AsrsService;
|
import zy.cloud.wms.common.service.asrs.entity.Result1;
|
import zy.cloud.wms.common.service.erp.ErpService;
|
import zy.cloud.wms.common.utils.VersionUtils;
|
import zy.cloud.wms.manager.entity.*;
|
import zy.cloud.wms.manager.entity.param.*;
|
import zy.cloud.wms.manager.entity.result.StoPrintVo;
|
import zy.cloud.wms.manager.service.*;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.Iterator;
|
import java.util.List;
|
|
/**
|
* Created by vincent on 2021/2/25
|
*/
|
@Service("workService")
|
public class WorkServiceImpl implements WorkService {
|
|
@Autowired
|
private MainService mainService;
|
@Autowired
|
private NodeService nodeService;
|
@Autowired
|
private CombService combService;
|
@Autowired
|
private LocDetlService locDetlService;
|
@Autowired
|
private CustOrderService custOrderService;
|
@Autowired
|
private PakoutService pakoutService;
|
@Autowired
|
private SnowflakeIdWorker snowflakeIdWorker;
|
@Autowired
|
private MatService matService;
|
@Autowired
|
private AsrsService asrsService;
|
@Autowired
|
private ErpService erpService;
|
@Autowired
|
private CheckService checkService;
|
|
@Override
|
@Transactional
|
public R stockPakin(PakinParam param, Long userId) {
|
Node node = nodeService.selectByUuid(param.getNodeId());
|
if (node == null) {
|
return R.error("货位不存在");
|
}
|
if (Cools.isEmpty(param.getMats())) {
|
return R.error("入库物料不能为空");
|
}
|
Date now = new Date();
|
for (MatnrDto dto : param.getMats()) {
|
Mat mat = matService.selectByMatnr(dto.getMatnr());
|
if (mat == null) {
|
throw new CoolException("物料数据错误，请联系管理员");
|
}
|
LocDetl locDetl = locDetlService.getLocDetl(node.getId(), dto.getMatnr());
|
if (locDetl == null) {
|
// 更新货位库存明细
|
locDetl = new LocDetl();
|
locDetl.setLocNo(node.getName());
|
locDetl.setNodeId(node.getId());
|
locDetl.setZpallet("");
|
locDetl.setAnfme(dto.getCount());
|
VersionUtils.setLocDetl(locDetl, mat);
|
// locDetl.setDocId(param.getDocType().longValue());
|
// locDetl.setDocNum(docNum);
|
locDetl.setStatus(1);
|
locDetl.setCreateBy(userId);
|
locDetl.setCreateTime(now);
|
locDetl.setUpdateBy(userId);
|
locDetl.setUpdateTime(now);
|
boolean insert = locDetlService.insert(locDetl);
|
if (!insert) {
|
throw new CoolException("新增库存明细档失败");
|
}
|
} else {
|
if (!locDetlService.incrementStock(node.getId(), dto.getMatnr(), dto.getCount())) {
|
throw new CoolException("新增库存明细档失败");
|
}
|
}
|
}
|
return R.ok("入库成功");
|
}
|
|
@Override
|
@Transactional
|
public R stockIn(StockInParam param, Long userId) {
|
Node node = nodeService.selectByUuid(param.getNodeId());
|
if (node == null) {
|
return R.error("货位不存在");
|
}
|
List<Comb> combs = combService.selectList(new EntityWrapper<Comb>().eq("zpallet", param.getZpallet()).eq("io_status", 1));
|
if (Cools.isEmpty(combs)) {
|
return R.error("物料不存在");
|
}
|
Date now = new Date();
|
String docNum = String.valueOf(snowflakeIdWorker.nextId());
|
switch (param.getDocType()) {
|
case 34: // 采购单
|
docNum = "PU-" + String.valueOf(snowflakeIdWorker.nextId()).substring(0, 15);
|
break;
|
case 45: // 销售退货单
|
docNum = "SR-" + String.valueOf(snowflakeIdWorker.nextId()).substring(0, 15);
|
break;
|
default:
|
break;
|
}
|
for (Comb comb : combs) {
|
// 改变组托档状态
|
comb.setIoStatus(4);
|
comb.setUpdateBy(userId);
|
comb.setUpdateTime(now);
|
boolean update = combService.update(comb, new EntityWrapper<Comb>().eq("zpallet", param.getZpallet()).eq("matnr", comb.getMatnr()));
|
if (!update) {
|
throw new CoolException("修改托盘资料档失败");
|
}
|
LocDetl locDetl = locDetlService.getLocDetl(node.getId(), comb.getMatnr());
|
if (locDetl == null) {
|
// 更新货位库存明细
|
locDetl = new LocDetl();
|
locDetl.setLocNo(node.getName());
|
locDetl.setNodeId(node.getId());
|
locDetl.setZpallet(param.getZpallet());
|
locDetl.setAnfme(comb.getAnfme());
|
VersionUtils.setLocDetl(locDetl, comb);
|
locDetl.setDocId(param.getDocType().longValue());
|
locDetl.setDocNum(docNum);
|
locDetl.setStatus(1);
|
locDetl.setCreateBy(userId);
|
locDetl.setCreateTime(now);
|
locDetl.setUpdateBy(userId);
|
locDetl.setUpdateTime(now);
|
boolean insert = locDetlService.insert(locDetl);
|
if (!insert) {
|
throw new CoolException("新增库存明细档失败");
|
}
|
} else {
|
if (!locDetlService.incrementStock(node.getId(), comb.getMatnr(), comb.getAnfme())) {
|
throw new CoolException("新增库存明细档失败");
|
}
|
|
}
|
|
}
|
|
// 上报给erp
|
List<BillDto> dtos = new ArrayList<>();
|
for (Comb comb : combs) {
|
BillDto billDto = new BillDto();
|
billDto.setMatnr(comb.getMatnr());
|
billDto.setQty(comb.getAnfme());
|
dtos.add(billDto);
|
}
|
if (!erpService.uploadBill(dtos, param.getDocType(), docNum)) {
|
throw new CoolException("无法上报至erp");
|
}
|
|
return R.ok();
|
}
|
|
@Override
|
public R stockOutCheck(String number, Long userId) {
|
return null;
|
}
|
|
@Override
|
public R stockOutPrint(StockOutParam param, Long userId) {
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", param.getNumber()));
|
Double total = 0.0D;
|
String custName = "";
|
for (Pakout pakout : pakouts) {
|
total = pakout.getAnfme() + total;
|
custName = pakout.getCustName();
|
}
|
StoPrintVo vo = new StoPrintVo();
|
vo.setDocNum(param.getNumber());
|
vo.setList(pakouts);
|
vo.setTotal(total);
|
vo.setCustName("浙江中扬立库技术有限公司");
|
vo.setWorkerName("陆晓涛");
|
return R.ok().add(vo);
|
}
|
|
@Override
|
public R stockOutPreview(StockOutParam param, Long userId) {
|
List<CustOrder> custOrders = custOrderService.selectList(new EntityWrapper<CustOrder>()
|
.eq("number", param.getNumber())
|
.eq("status", 1)
|
);
|
OrderStoDto dto = new OrderStoDto();
|
dto.setNumber(param.getNumber());
|
dto.setCustOrders(custOrders);
|
return R.ok().add(mainService.stockOutPreview(dto));
|
}
|
|
@Override
|
public R stockOut(StockOutParam param, Long userId) {
|
List<CustOrder> custOrders = custOrderService.selectList(new EntityWrapper<CustOrder>()
|
.eq("number", param.getNumber())
|
.eq("status", 1)
|
);
|
OrderStoDto dto = new OrderStoDto();
|
dto.setNumber(param.getNumber());
|
dto.setCustOrders(custOrders);
|
// 开始整理出库数据
|
mainService.stockOutProcess(dto);
|
return R.ok("生成拣货单成功");
|
}
|
|
@Override
|
@Transactional
|
public R stockOutComplete(StockConfirmParam param, Long userId) {
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>()
|
.eq("doc_num", param.getNumber())
|
.in("wrk_sts", 1, 2));
|
// 修改库存数量
|
for (Pakout pakout : pakouts) {
|
LocDetl locDetl = locDetlService.getLocDetl(pakout.getNodeId(), pakout.getMatnr());
|
if (pakout.getAnfme()>=locDetl.getAnfme()) {
|
// 删除库存明细
|
if (!locDetlService.removeStock(locDetl.getNodeId(), pakout.getMatnr())) {
|
throw new CoolException("删除库存明细失败");
|
}
|
} else {
|
// 修改库存明细数量
|
if (!locDetlService.reduceStock(locDetl.getNodeId(), pakout.getMatnr(), pakout.getAnfme())) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
}
|
}
|
// 修改出库单状态
|
if (!pakoutService.stockOutComplete(param.getWrkNo(), param.getNumber(), userId)) {
|
return R.error("保存数据失败");
|
}
|
// 修改单据状态
|
if (!custOrderService.updateStatus(param.getNumber(), 4)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
// 采购退货单
|
// if (param.getNumber().startsWith("PR-")) {
|
// erp单据上传 todo
|
// Long docId = pakouts.get(0).getDocId();
|
// if (null != docId) {
|
// List<BillDto> dtos = new ArrayList<>();
|
// for (Pakout pakout : pakouts) {
|
// BillDto billDto = new BillDto();
|
// billDto.setMatnr(pakout.getMatnr());
|
// billDto.setQty(pakout.getAnfme());
|
// dtos.add(billDto);
|
// }
|
// if (!erpService.uploadBill(dtos, docId.intValue() , pakouts.get(0).getDocNum())) {
|
// throw new CoolException("无法上报至erp");
|
// }
|
// }
|
|
// }
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R initPakout(List<InitPakoutParam> params, Long userId) {
|
if (!Cools.isEmpty(params)) {
|
Date now = new Date();
|
for (InitPakoutParam param : params) {
|
LocDetl locDetl = locDetlService.getLocDetl(param.getNodeId(), param.getMatnr());
|
// 保存出库通知单
|
Pakout pakout = new Pakout();
|
pakout.setWrkSts(1L);
|
pakout.setAnfme(param.getCount());
|
pakout.setWrkNo(String.valueOf(snowflakeIdWorker.nextId()));
|
VersionUtils.setPakout(pakout, locDetl);
|
pakout.setCreateTime(now);
|
pakout.setCreateBy(userId);
|
pakout.setUpdateTime(now);
|
pakout.setUpdateBy(userId);
|
pakout.setStatus(1);
|
if (!pakoutService.insert(pakout)) {
|
throw new CoolException("生成拣货单失败");
|
}
|
if (param.getCount() > locDetl.getAnfme()) {
|
throw new CoolException("库存不足");
|
} else if (param.getCount()<locDetl.getAnfme()) {
|
// 修改库存明细数量
|
if (!locDetlService.reduceStock(locDetl.getNodeId(), param.getMatnr(), param.getCount())) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
} else {
|
// 删除库存明细
|
if (!locDetlService.removeStock(locDetl.getNodeId(), param.getMatnr())) {
|
throw new CoolException("删除库存明细失败");
|
}
|
}
|
}
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R completePakout(String wrkNo, Long userId) {
|
Pakout pakout = pakoutService.selectOne(new EntityWrapper<Pakout>().eq("wrk_no", wrkNo));
|
if (null != pakout) {
|
// 修改库存数量
|
LocDetl locDetl = locDetlService.getLocDetl(pakout.getNodeId(), pakout.getMatnr());
|
if (pakout.getAnfme()>=locDetl.getAnfme()) {
|
// 删除库存明细
|
if (!locDetlService.removeStock(locDetl.getNodeId(), pakout.getMatnr())) {
|
throw new CoolException("删除库存明细失败");
|
}
|
} else {
|
// 修改库存明细数量
|
if (!locDetlService.reduceStock(locDetl.getNodeId(), pakout.getMatnr(), pakout.getAnfme())) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
}
|
// 修改拣货单状态
|
if (pakoutService.stockOutComplete(wrkNo, null, userId)) {
|
|
boolean complete = true;
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", pakout.getDocNum()));
|
for (Pakout item : pakouts) {
|
if (item.getWrkSts() != 3) {
|
complete = false;
|
break;
|
}
|
}
|
if (complete) {
|
// 修改单据状态
|
if (!custOrderService.updateStatus(pakout.getDocNum(), 4)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
}
|
|
return R.ok("拣货单已完成");
|
}
|
}
|
return R.error();
|
}
|
|
@Override
|
@Transactional
|
public R cancelPakout(String wrkNo, Long userId) {
|
Pakout pakout = pakoutService.selectOne(new EntityWrapper<Pakout>().eq("wrk_no", wrkNo));
|
// if (null != pakout) {
|
// LocDetl locDetl = locDetlService.getLocDetl(pakout.getNodeId(), pakout.getMatnr());
|
// if (locDetl == null) {
|
// LocDetl oldLocDetl = new LocDetl();
|
// VersionUtils.setLocDetl(oldLocDetl, pakout);
|
// oldLocDetl.setCreateTime(new Date());
|
// oldLocDetl.setCreateBy(userId);
|
// oldLocDetl.setUpdateTime(new Date());
|
// oldLocDetl.setUpdateBy(userId);
|
// if (!locDetlService.insert(oldLocDetl)) {
|
// throw new CoolException("恢复库存明细失败");
|
// }
|
// } else {
|
// if (!locDetlService.incrementStock(locDetl.getNodeId(), locDetl.getMatnr(), pakout.getAnfme())) {
|
// throw new CoolException("恢复库存明细失败");
|
// }
|
// }
|
// } else {
|
// return R.error("拣货单已失效，取消失败！");
|
// }
|
if (!pakoutService.delete(new EntityWrapper<Pakout>().eq("wrk_no", pakout.getWrkNo()))) {
|
throw new CoolException("删除拣货单失败");
|
}
|
|
// 取消销售订单
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", pakout.getDocNum()));
|
if (Cools.isEmpty(pakouts)){
|
// 修改单据状态
|
if (!custOrderService.updateStatus(pakout.getDocNum(), 3)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
}
|
return R.ok("拣货单已取消");
|
}
|
|
@Override
|
@Transactional
|
public R initOrder(InitOrderParam param, Long userId) {
|
if (custOrderService.selectCount(new EntityWrapper<CustOrder>().eq("number", param.getNumber()).ne("bType_id", param.getCustomerTypeId())) > 0) {
|
return R.error("抱歉单号已存在，请修改单号");
|
}
|
Date now = new Date();
|
for (PakinMatDto dto : param.getList()){
|
Mat mat = matService.selectByMatnr(dto.getMatnr());
|
if (mat == null) {
|
continue;
|
}
|
CustOrder custOrder = new CustOrder(
|
param.getNumber(), // 销售单号
|
DateUtils.convert(now), // 单据日期[非空]
|
param.getCustomerTypeId(), // 客户编号
|
null, // 经手人编号[空]
|
null,
|
dto.getMatnr(), // 商品编号
|
dto.getCount(), // 商品数量
|
dto.getCount(), // 总数量
|
Cools.isEmpty(mat.getName())?0.0D:Double.parseDouble(mat.getName()), // 商品单价
|
null, // 商品明细行号
|
null, // 商品备注[空]
|
1, // 状态
|
now, // 添加时间
|
now, // 修改时间
|
null // 备注
|
);
|
if (!custOrderService.insert(custOrder)) {
|
throw new CoolException("保存销售订单失败");
|
}
|
}
|
return R.ok("生成销售订单" + param.getNumber() + "成功");
|
}
|
|
@Override
|
@Transactional
|
public R stockTransfer(String number, Long userId) {
|
List<CustOrder> custOrders = custOrderService.selectList(new EntityWrapper<CustOrder>().eq("number", number).eq("status", 1));
|
boolean asrs = false;
|
List<StockTransferParam> params = new ArrayList<>();
|
for (CustOrder custOrder : custOrders) {
|
Double count = locDetlService.selectCountByMatnr(custOrder.getUserCode());
|
if (count == null) {
|
count = 0.0D;
|
}
|
if (count < custOrder.getQty()) {
|
if (!asrs) { asrs = true; }
|
StockTransferParam param = new StockTransferParam();
|
param.setMatnr(custOrder.getUserCode());
|
param.setAnfme(custOrder.getQty() - count);
|
params.add(param);
|
}
|
}
|
if (asrs) {
|
// if (asrsService.stockTransfer(params)) {
|
// for (StockTransferParam param : params) {
|
// // 修改销售订单待出数量
|
// if (!custOrderService.updateQty(number, param.getMatnr(), param.getAnfme())) {
|
// throw new CoolException("修改销售订单待出数量失败");
|
// }
|
// }
|
// return R.ok("库存调拨成功");
|
// } else {
|
// return R.error("立库调拨失败，请联系管理员");
|
// }
|
}
|
return R.error("暂不缺货，不需要立库调拨");
|
}
|
|
@Override
|
public R asrsStockTransfer(AsrsTransferParam param, Long userId) {
|
if (Cools.isEmpty(param.getNode_id(), param.getMatnr(), param.getSafe_qua(), param.getAmount())) {
|
return R.error("数量错误");
|
}
|
List<StockTransferParam> params = new ArrayList<>();
|
StockTransferParam transferParam = new StockTransferParam();
|
transferParam.setMatnr(param.getMatnr());
|
transferParam.setAnfme(Arith.subtract(2, param.getSafe_qua(), param.getAmount()));
|
transferParam.setAllotNo(param.getNode_id()+ "_" +param.getMatnr());
|
params.add(transferParam);
|
Result1 result = asrsService.stockTransfer(params);
|
if (result.getCode() == 500) {
|
if (Cools.isEmpty(result.getData())) {
|
throw new CoolException(result.getMsg());
|
} else {
|
throw new CodeCoolException("20001-" + result.getData());
|
}
|
}
|
return R.ok("补仓成功，等待立库调拨");
|
}
|
|
@Override
|
public R stockCheck(StoCheckParam param, Long userId) {
|
if (Cools.isEmpty(param.getLocNo())) {
|
return R.error("请选择货位");
|
}
|
Node node = nodeService.selectByUuid(param.getLocNo());
|
if (Cools.isEmpty(node)) {
|
return R.error("货位异常,请联系管理员");
|
}
|
// 准备数据
|
Date now = new Date();
|
List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("node_id", node.getId()));
|
List<String> locDetlMatnrs = new ArrayList<>();
|
locDetls.forEach(locDetl -> locDetlMatnrs.add(locDetl.getMatnr()));
|
Iterator<LocDetl> detlIterator = locDetls.iterator();
|
List<PakinMatDto> dtos = param.getDtos();
|
|
// 1.盈亏 修改数量
|
while (detlIterator.hasNext()){
|
LocDetl locDetl = detlIterator.next();
|
for (PakinMatDto dto : dtos) {
|
if (locDetl.getMatnr().equals(dto.getMatnr())) {
|
if (!locDetl.getAnfme().equals(dto.getCount())) {
|
Check check = new Check(
|
String.valueOf(snowflakeIdWorker.nextId()), // 盘点编号
|
node.getId(), // 盘点货位
|
node.getUuid(), // 货位编号
|
node.getName(), // 货位名称
|
locDetl.getMatnr(), // 商品编号
|
locDetl.getMaktx(), // 商品名称
|
locDetl.getUnit(), // 单位
|
null, // 单据类型
|
null, // 单据编号
|
locDetl.getAnfme(), // 账面数量
|
dto.getCount(), // 实盘数量
|
dto.getCount() - locDetl.getAnfme(), // 差值
|
locDetl.getAnfme() < dto.getCount() ? 1 : 2, // 盈亏
|
1, // 状态
|
userId, // 添加人员
|
now, // 添加时间
|
userId, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!checkService.insert(check)) {
|
throw new CoolException("保存盘点记录失败");
|
}
|
}
|
detlIterator.remove();
|
break;
|
}
|
}
|
}
|
|
// 2.盘亏 删除库存
|
for (LocDetl locDetl : locDetls) {
|
Check check = new Check(
|
String.valueOf(snowflakeIdWorker.nextId()), // 盘点编号
|
node.getId(), // 盘点货位
|
node.getUuid(), // 货位编号
|
node.getName(), // 货位名称
|
locDetl.getMatnr(), // 商品编号
|
locDetl.getMaktx(), // 商品名称
|
locDetl.getUnit(), // 单位
|
null, // 单据类型
|
null, // 单据编号
|
locDetl.getAnfme(), // 账面数量
|
0D, // 实盘数量
|
0D - locDetl.getAnfme(), // 差值
|
2, // 盈亏
|
1, // 状态
|
userId, // 添加人员
|
now, // 添加时间
|
userId, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!checkService.insert(check)) {
|
throw new CoolException("保存盘点记录失败");
|
}
|
|
}
|
|
// 3.盘盈 新增库存
|
for (PakinMatDto dto : dtos) {
|
if (!locDetlMatnrs.contains(dto.getMatnr())) {
|
Mat mat = matService.selectByMatnr(dto.getMatnr());
|
Check check = new Check(
|
String.valueOf(snowflakeIdWorker.nextId()), // 盘点编号
|
node.getId(), // 盘点货位
|
node.getUuid(), // 货位编号
|
node.getName(), // 货位名称
|
mat.getMatnr(), // 商品编号
|
mat.getMaktx(), // 商品名称
|
mat.getUnit(), // 单位
|
null, // 单据类型
|
null, // 单据编号
|
0D, // 账面数量
|
dto.getCount(), // 实盘数量
|
dto.getCount() - 0D, // 差值
|
1, // 盈亏
|
1, // 状态
|
userId, // 添加人员
|
now, // 添加时间
|
userId, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!checkService.insert(check)) {
|
throw new CoolException("保存盘点记录失败");
|
}
|
|
}
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R stockCheckAuditing(Long checkId, Long userId) {
|
Check check = checkService.selectById(checkId);
|
if (null == check) {
|
return R.error("盘点记录已失效");
|
}
|
Date now = new Date();
|
// 1.修改库存数量
|
if (check.getOriQty() != 0 && check.getCekQty() != 0) {
|
// 更新库存明细
|
if (check.getSettle() == 1) {
|
if (!locDetlService.incrementStock(check.getNodeId(), check.getMatnr(), Math.abs(check.getDiffQty()))) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
} else if (check.getSettle() == 2) {
|
if (!locDetlService.reduceStock(check.getNodeId(), check.getMatnr(), Math.abs(check.getDiffQty()))) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
}
|
}
|
|
// 2.删除库存
|
if (check.getOriQty() != 0 && check.getCekQty() == 0) {
|
if (!locDetlService.delete(new EntityWrapper<LocDetl>().eq("node_id", check.getNodeId()).eq("matnr", check.getMatnr()))) {
|
throw new CoolException("删除库存明细数量失败");
|
}
|
}
|
|
// 3.新增库存
|
if (check.getOriQty() == 0 && check.getCekQty() != 0) {
|
Mat mat = matService.selectByMatnr(check.getMatnr());
|
if (mat == null) {
|
throw new CoolException("商品数据异常，请联系管理员");
|
}
|
// 更新货位库存明细
|
LocDetl locDetl = new LocDetl();
|
locDetl.setLocNo(check.getLocNo());
|
locDetl.setNodeId(check.getNodeId());
|
// locDetl.setZpallet(param.getZpallet());
|
locDetl.setAnfme(check.getCekQty());
|
VersionUtils.setLocDetl(locDetl, mat);
|
locDetl.setStatus(1);
|
locDetl.setCreateBy(userId);
|
locDetl.setCreateTime(now);
|
locDetl.setUpdateBy(userId);
|
locDetl.setUpdateTime(now);
|
if (!locDetlService.insert(locDetl)) {
|
throw new CoolException("新增库存明细失败");
|
}
|
}
|
|
// 修改盘点记录
|
String docNum = null;
|
Long docId = null;
|
switch (check.getSettle()) {
|
case 1: // 盘盈
|
docNum = "CS-" + String.valueOf(snowflakeIdWorker.nextId()).substring(0, 15);
|
docId = 14L; // 报溢单
|
break;
|
case 2: // 盘亏
|
docNum = "CD-" + String.valueOf(snowflakeIdWorker.nextId()).substring(0, 15);
|
docId = 9L; // 报损单
|
break;
|
default:
|
throw new CoolException("盘点记录盈亏情况异常");
|
}
|
check.setStatus(2);
|
check.setDocId(docId);
|
check.setDocNum(docNum);
|
check.setUpdateBy(userId);
|
check.setUpdateTime(now);
|
if (!checkService.updateById(check)) {
|
throw new CoolException("修改盘点记录状态失败");
|
}
|
|
// 上报给erp
|
List<BillDto> dtos = new ArrayList<>();
|
BillDto billDto = new BillDto();
|
billDto.setMatnr(check.getMatnr());
|
billDto.setQty(Math.abs(check.getDiffQty()));
|
dtos.add(billDto);
|
if (!erpService.uploadBill(dtos, docId.intValue(), docNum)) {
|
throw new CoolException("无法上报至erp");
|
}
|
|
return R.ok();
|
}
|
|
}
|
