package zy.cloud.wms.manager.service.impl;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.core.common.BaseRes;
|
import com.core.common.Cools;
|
import com.core.common.R;
|
import com.core.common.SnowflakeIdWorker;
|
import com.core.exception.CoolException;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import zy.cloud.wms.common.model.MatnrDto;
|
import zy.cloud.wms.common.model.OrderStoDto;
|
import zy.cloud.wms.common.model.ReceiveStoDto;
|
import zy.cloud.wms.common.model.WaveStoDto;
|
import zy.cloud.wms.common.service.MainService;
|
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.*;
|
|
/**
|
* Created by vincent on 2021/2/25
|
*/
|
@Slf4j
|
@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 PakoutService pakoutService;
|
@Autowired
|
private SnowflakeIdWorker snowflakeIdWorker;
|
@Autowired
|
private MatService matService;
|
@Autowired
|
private CheckService checkService;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private OrderDetlService orderDetlService;
|
@Autowired
|
private ItemService itemService;
|
@Autowired
|
private CstmrService cstmrService;
|
@Autowired
|
private PakinService pakinService;
|
@Autowired
|
private ReceiveService receiveService;
|
@Autowired
|
private ReceiveDetlService receiveDetlService;
|
@Autowired
|
ReceiveLogService receiveLogService;
|
@Autowired
|
private WaveService waveService;
|
@Autowired
|
private WaveDetlService waveDetlService;
|
|
|
@Override
|
@Transactional
|
public R stockPakin(PakinParam param, Long userId, Long hostId) {
|
Node node = nodeService.selectByUuid(param.getNodeId(), hostId);
|
if (node == null) {
|
node = nodeService.selectById(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(hostId, dto.getMatnr());
|
if (mat == null) {
|
throw new CoolException("物料数据错误，请联系管理员");
|
}
|
// 保存入库记录
|
Pakin pakin = new Pakin(
|
hostId,
|
"I" + String.valueOf(snowflakeIdWorker.nextId()), // 任务号[非空]
|
null, // 工作状态
|
null, // 托盘号
|
dto.getCount(), // 入库数量
|
node.getId(), // 关联货位[非空]
|
node.getUuid(), // 货位[非空]
|
mat.getMatnr(), // 商品编码[非空]
|
null, // 商品名称
|
null, // 名称
|
null, // 规格
|
null, // 型号
|
null, // 批号
|
null, // 单位
|
null, // SKC
|
null, // 单据类型
|
null, // 单据编号
|
null, // 客户名称
|
null, // 品项数
|
null, // 数量
|
null, // 重量
|
1, // 状态
|
userId, // 添加人员
|
now, // 添加时间
|
userId, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
VersionUtils.setPakin(pakin, mat);
|
if (!pakinService.insert(pakin)) {
|
throw new CoolException("保存入库记录失败");
|
}
|
|
/**
|
* 上架完成之后,存放数据至上架统计表 man_receive_log
|
*/
|
ReceiveLog receiveLog = new ReceiveLog();
|
receiveLog.setOrderNo("");//单号
|
receiveLog.setNodeId(node.getId());//库位号id
|
receiveLog.setNodeName(node.getName());//库位名称
|
receiveLog.setMatnr(dto.getMatnr());//物料编码
|
receiveLog.setAnfme(dto.getCount());//数量
|
receiveLog.setBatch(dto.getBatch());//批号
|
receiveLog.setCreateBy(userId);//添加人员
|
receiveLog.setUpdateBy(userId);//修改人员
|
receiveLog.setCreateTime(now);
|
receiveLog.setUpdateTime(now);
|
receiveLog.setIoType(1);
|
receiveLogService.insert(receiveLog);
|
// 修改库存
|
LocDetl locDetl = locDetlService.getLocDetl(node.getId(), dto.getMatnr());
|
if (locDetl == null) {
|
// 更新货位库存明细
|
locDetl = new LocDetl();
|
locDetl.setHostId(hostId);
|
locDetl.setLocNo(node.getName());
|
locDetl.setNodeId(node.getId());
|
locDetl.setZpallet("");
|
locDetl.setAnfme(dto.getCount());
|
VersionUtils.setLocDetl(locDetl, mat);
|
locDetl.setBatch(dto.getBatch());
|
// 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 stockPakout(PakoutParam param, Long userId, Long hostId) {
|
Mat mat = matService.selectByMatnr(hostId, param.getMatnr());
|
Node node = nodeService.selectByUuid(param.getNodeUuid(), hostId);
|
LocDetl locDetl = locDetlService.getLocDetl(node.getId(), mat.getMatnr());
|
if (locDetl == null || locDetl.getAnfme() < param.getCount()) {
|
return R.error(mat.getMaktx() + "库存不足");
|
}
|
Pakout pakout = new Pakout(
|
hostId,
|
String.valueOf(snowflakeIdWorker.nextId()), // 任务号[非空]
|
3L, // 工作状态
|
null, // 托盘号
|
param.getCount(), // 出库数量
|
node.getId(), // 关联货位[非空]
|
node.getUuid(), // 货位[非空]
|
mat.getMatnr(), // 商品编码[非空]
|
null, // 商品名称
|
null, // 名称
|
null, // 规格
|
null, // 型号
|
null, // 批号
|
null, // 单位
|
null, // SKC
|
null, // 单据类型
|
null, // 单据编号
|
null, // 客户名称
|
null, // 品项数
|
null, // 数量
|
null, // 重量
|
1, // 状态
|
userId, // 添加人员
|
new Date(), // 添加时间
|
userId, // 修改人员
|
new Date(), // 修改时间
|
null // 备注
|
);
|
VersionUtils.setPakout(pakout, mat);
|
// 保存出库通知单
|
if (!pakoutService.insert(pakout)) {
|
throw new CoolException("保存出库通知单失败");
|
}
|
if (param.getCount()>=locDetl.getAnfme()) {
|
// 删除库存明细
|
if (!locDetlService.removeStock(node.getId(), mat.getMatnr())) {
|
throw new CoolException("删除库存明细失败");
|
}
|
} else {
|
// 修改库存明细数量
|
if (!locDetlService.reduceStock(node.getId(), mat.getMatnr(), param.getCount())) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R stockIn(StockInParam param, Long userId, Long hostId) {
|
Node node = nodeService.selectByUuid(param.getNodeId(), hostId);
|
if (node == null) {
|
return R.error("货位不存在");
|
}
|
List<Comb> combs = combService.selectList(new EntityWrapper<Comb>().eq("host_id", hostId).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.setHostId(hostId);
|
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("新增库存明细档失败");
|
}
|
|
}
|
|
}
|
return R.ok();
|
}
|
|
@Override
|
public R stockOutCheck(String number, Long userId) {
|
return null;
|
}
|
|
@Override
|
public R stockOutPreview(StockOutParam param, Long userId, Long hostId) {
|
Wrapper<Order> wrapper = new EntityWrapper<Order>()
|
.eq("order_no", param.getOrderNo());
|
if (hostId != null) {
|
wrapper.eq("host_id", hostId);
|
}
|
Order order_no = orderService.selectOne(wrapper);
|
|
if (order_no.getSettle() != 1){
|
return R.error("此单据无法生成拣货单");
|
}
|
// Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
// if (order.getSettle() != 1) {
|
// return R.error("此单据无法生成拣货单");
|
// }
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order_no.getOrderNo(), hostId);
|
if (Cools.isEmpty(orderDetls)) {
|
return R.error("此单据已失效，请联系管理员");
|
}
|
// List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order.getOrderNo(), hostId);
|
// if (Cools.isEmpty(orderDetls)) {
|
// return R.error("此单据已失效，请联系管理员");
|
// }
|
|
OrderStoDto orderStoDto = new OrderStoDto().create(order_no.getOrderNo(), orderDetls);
|
// OrderStoDto dto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
|
return R.ok().add(mainService.orderOutPreview(orderStoDto, hostId));
|
}
|
|
@Override
|
public R stockOutCreate(StockOutParam param, Long userId, Long hostId) {
|
// Receive receive = receiveService.selectByOrderNo(param.getOrderNo(), hostId);
|
Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (order.getSettle() != 1) {
|
return R.error("此单据无法生成拣货单");
|
}
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(param.getOrderNo(), hostId);
|
// List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (Cools.isEmpty(orderDetls)) {
|
return R.error("此单据已失效，请联系管理员");
|
}
|
OrderStoDto orderStoDto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
|
// OrderStoDto dto = new OrderStoDto().create(receive.getOrderNo(), receiveDetls);
|
// 开始整理出库数据
|
mainService.orderStockOutProcess(orderStoDto,hostId,userId);
|
return R.ok("生成拣货单成功");
|
}
|
|
|
@Override
|
public R stockOutPrint(StockOutParam param, Long userId, Long hostId) {
|
|
Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (order == null) {
|
return R.error("此单据已失效");
|
}
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", order.getOrderNo()).eq("host_id", hostId));
|
Double total = 0.0D;
|
for (Pakout pakout : pakouts) {
|
total = pakout.getAnfme() + total;
|
}
|
StoPrintVo vo = new StoPrintVo();
|
vo.setDocNum(param.getOrderNo());
|
vo.setList(pakouts);
|
vo.setTotal(total);
|
vo.setCstmrName(order.getCstmrName());
|
vo.setWorkerName(Cools.isEmpty(order.getOperMemb())? "" : order.getOperMemb());
|
return R.ok().add(vo);
|
}
|
|
@Override
|
public R stockInPrint(StockOutParam param, Long userId, Long hostId) {
|
Receive receive = receiveService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (receive == null) {
|
return R.error("此单据已失效");
|
}
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", receive.getOrderNo()).eq("host_id", hostId));
|
Double total = 0.0D;
|
for (Pakout pakout : pakouts) {
|
total = pakout.getAnfme() + total;
|
}
|
StoPrintVo vo = new StoPrintVo();
|
vo.setDocNum(param.getOrderNo());
|
vo.setList(pakouts);
|
vo.setTotal(total);
|
vo.setCstmrName(receive.getCstmrName());
|
vo.setWorkerName(Cools.isEmpty(receive.getOperMemb())? "" : receive.getOperMemb());
|
return R.ok().add(vo);
|
|
}
|
|
@Override
|
public R pakoutComplete(StockConfirmParam param, Long userId) {
|
if (Cools.isEmpty(param.getMatnr(), param.getAnfme())) {
|
return R.parse(BaseRes.PARAM);
|
}
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>()
|
.eq("doc_num", param.getOrderNo())
|
.in("wrk_sts", 1, 2));
|
for (Pakout pakout : pakouts) {
|
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R stockOutComplete(StockConfirmParam param, Long userId, Long hostId) {
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>()
|
.eq("doc_num", param.getOrderNo())
|
.in("wrk_sts", 1, 2));
|
for (Pakout pakout : pakouts) {
|
LocDetl locDetl = locDetlService.getLocDetl(pakout.getNodeId(), pakout.getMatnr());
|
// 缺货 or 立库
|
if (locDetl == null) {
|
// 缺货
|
if (pakout.getLocNo().equals("缺货")) {
|
Double count = Optional.ofNullable(locDetlService.selectCountByMatnr(pakout.getMatnr(), hostId)).orElse(0.0D);
|
if (count < pakout.getAnfme()) {
|
throw new CoolException(pakout.getMaktx()+"缺货");
|
}
|
Date now = new Date();
|
// 查找推荐货位是否库存足够
|
List<LocDetl> locDetls = locDetlService.findOfSort(hostId, pakout.getMatnr());
|
double issued = Optional.ofNullable(pakout.getAnfme()).orElse(0.0D) ;
|
for (LocDetl locDetl1 : locDetls) {
|
if (issued > 0) {
|
// 保存出库通知单
|
Pakout newPakout = new Pakout();
|
newPakout.setHostId(hostId);
|
newPakout.setWrkSts(3L);
|
newPakout.setAnfme(issued>=locDetl1.getAnfme()?locDetl1.getAnfme():issued);
|
newPakout.setZpallet(locDetl1.getZpallet());
|
newPakout.setLocNo(locDetl1.getLocNo());
|
newPakout.setNodeId(locDetl1.getNodeId());
|
newPakout.setWrkNo(String.valueOf(snowflakeIdWorker.nextId()));
|
VersionUtils.setPakout(newPakout, locDetl1);
|
newPakout.setDocId(pakout.getDocId()); // 单据类型
|
newPakout.setDocNum(pakout.getDocNum()); // 单据编号
|
newPakout.setCreateTime(now);
|
newPakout.setUpdateTime(now);
|
newPakout.setStatus(1);
|
if (!pakoutService.insert(newPakout)) {
|
throw new CoolException("保存出库通知单失败");
|
}
|
if (issued>=locDetl1.getAnfme()) {
|
// 删除库存明细
|
if (!locDetlService.removeStock(locDetl1.getNodeId(), newPakout.getMatnr())) {
|
throw new CoolException("删除库存明细失败");
|
}
|
} else {
|
// 修改库存明细数量
|
if (!locDetlService.reduceStock(locDetl1.getNodeId(), newPakout.getMatnr(), issued)) {
|
throw new CoolException("修改库存明细数量失败");
|
}
|
}
|
// 剩余待出数量递减
|
issued = issued - locDetl1.getAnfme();
|
}
|
}
|
|
}
|
continue;
|
}
|
// 修改库存数量
|
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.getOrderNo(), userId, hostId)) {
|
return R.error("保存数据失败");
|
}
|
// 修改单据状态
|
if (!orderService.updateSettle(param.getOrderNo(), 4L, hostId)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public R initPakout(List<InitPakoutParam> params, Long userId, Long hostId) {
|
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.setHostId(hostId);
|
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, Long hostId) {
|
Pakout pakout = pakoutService.selectOne(new EntityWrapper<Pakout>().eq("wrk_no", wrkNo).eq("host_id", hostId));
|
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, hostId)) {
|
|
boolean complete = true;
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", pakout.getDocNum()).eq("host_id", hostId));
|
for (Pakout item : pakouts) {
|
if (item.getWrkSts() != 3) {
|
complete = false;
|
break;
|
}
|
}
|
if (complete) {
|
// 修改单据状态
|
if (!orderService.updateSettle(pakout.getDocNum(), 4L, hostId)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
}
|
|
return R.ok("拣货单已完成");
|
}
|
}
|
return R.error();
|
}
|
|
@Override
|
@Transactional
|
public R cancelPakout(String wrkNo, Long userId, Long hostId) {
|
Pakout pakout = pakoutService.selectOne(new EntityWrapper<Pakout>().eq("wrk_no", wrkNo).eq("host_id", hostId));
|
if (!pakoutService.delete(new EntityWrapper<Pakout>().eq("wrk_no", pakout.getWrkNo()).eq("host_id", hostId))) {
|
throw new CoolException("删除拣货单失败");
|
}
|
// 取消销售订单
|
List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", pakout.getDocNum()).eq("host_id", hostId));
|
if (Cools.isEmpty(pakouts)){
|
// 修改单据状态
|
if (!orderService.updateSettle(pakout.getDocNum(), 3L, hostId)) {
|
throw new CoolException("修改单据状态失败");
|
}
|
}
|
return R.ok("拣货单已取消");
|
}
|
@Override
|
@Transactional
|
public R initReceive(InitOrderParam param, Long userId, Long hostId){
|
Receive order_no = receiveService.selectOne(new EntityWrapper<Receive>()
|
.eq("order_no", param.getOrderNo()));
|
if (order_no != null) {
|
return R.error("抱歉单号已存在，请修改单号");
|
}
|
Date now = new Date();
|
Item item = itemService.selectByName(param.getItem());
|
Cstmr cstmr = cstmrService.selectByName(param.getCstmr());
|
// 新增订单表头
|
order_no = new Receive(
|
hostId,
|
String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
|
param.getOrderNo(), // 订单编号
|
param.getOrderTime(), // 单据日期
|
param.getDocType(), // 单据类型
|
item==null?null:item.getId(), // 项目编号
|
param.getItem(), // 项目名称
|
null, // 调拨项目编号
|
null, // 初始票据号
|
null, // 票据号
|
cstmr==null?null:cstmr.getId(), // 客户编号
|
param.getCstmr(), // 客户
|
null, // 联系方式
|
null, // 操作人员
|
null, // 合计金额
|
null, // 优惠率
|
null, // 优惠金额
|
null, // 销售或采购费用合计
|
null, // 实付金额
|
null, // 付款类型
|
null, // 业务员
|
null, // 结算天数
|
null, // 邮费支付类型
|
null, // 邮费
|
null, // 付款时间
|
null, // 发货时间
|
null, // 物流名称
|
null, // 物流单号
|
1L, // 订单状态
|
1, // 状态
|
userId, // 添加人员
|
now, // 添加时间
|
userId, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!receiveService.insert(order_no)) {
|
throw new CoolException("保存订单表头失败！");
|
}
|
|
// 遍历商品数量并保存
|
for (MatnrDto dto : param.getList()){
|
Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
|
if (mat == null) {
|
log.error("{}商品不存在。", dto.getMatnr());
|
continue;
|
}
|
ReceiveDetl receiveDetl = new ReceiveDetl();
|
receiveDetl.setHostId(hostId);
|
receiveDetl.setOrderId(order_no.getId());
|
receiveDetl.setAnfme(dto.getCount());
|
receiveDetl.setCreateTime(now);
|
receiveDetl.setCreateBy(userId);
|
receiveDetl.setUpdateBy(userId);
|
receiveDetl.setUpdateTime(now);
|
receiveDetl.setStatus(1);
|
receiveDetl.setMatnr(mat.getMatnr());
|
receiveDetl.setMaktx(mat.getMaktx());
|
receiveDetl.setName(mat.getName());
|
receiveDetl.setSpecs(mat.getSpecs());
|
receiveDetl.setModel(mat.getModel());
|
receiveDetl.setBatch(mat.getBatch());
|
receiveDetl.setUnit(mat.getUnit());
|
receiveDetl.setBarcode(mat.getBarcode());
|
receiveDetl.setItemNum(mat.getItemNum());
|
receiveDetl.setCount(dto.getCount());
|
receiveDetl.setUnitPrice(mat.getPrice());
|
receiveDetl.setWeight(mat.getWeight());
|
if (!receiveDetlService.insert(receiveDetl)) {
|
throw new CoolException("保存订单明细失败");
|
}
|
}
|
return R.ok("创建订单成功");
|
}
|
|
@Override
|
@Transactional
|
public R initOrder(InitOrderParam param, Long userId, Long hostId) {
|
// Receive order_no = receiveService.selectOne(new EntityWrapper<Receive>()
|
// .eq("order_no", param.getOrderNo()));
|
Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (order != null) {
|
return R.error("抱歉单号已存在，请修改单号");
|
}
|
Date now = new Date();
|
Item item = itemService.selectByName(param.getItem());
|
Cstmr cstmr = cstmrService.selectByName(param.getCstmr());
|
// 新增订单表头
|
Order order1 = new Order();
|
order1.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
order1.setHostId(hostId);
|
order1.setOrderNo(param.getOrderNo());
|
order1.setOrderTime(param.getOrderTime());
|
order1.setDocType(param.getDocType());
|
order1.setItemId(item == null? null : item.getId());
|
order1.setItemName(param.getItem());
|
order1.setCstmr(cstmr == null? null : cstmr.getId());
|
order1.setCstmrName(param.getCstmr());
|
order1.setSettle(1L);
|
order1.setStatus(1);
|
order1.setCreateBy(userId);
|
order1.setCreateTime(now);
|
order1.setUpdateBy(userId);
|
order1.setUpdateTime(now);
|
// order_no = new Receive(
|
// hostId,
|
// String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
|
// param.getOrderNo(), // 订单编号
|
// param.getOrderTime(), // 单据日期
|
// param.getDocType(), // 单据类型
|
// item==null?null:item.getId(), // 项目编号
|
// param.getItem(), // 项目名称
|
// null, // 调拨项目编号
|
// null, // 初始票据号
|
// null, // 票据号
|
// cstmr==null?null:cstmr.getId(), // 客户编号
|
// param.getCstmr(), // 客户
|
// null, // 联系方式
|
// null, // 操作人员
|
// null, // 合计金额
|
// null, // 优惠率
|
// null, // 优惠金额
|
// null, // 销售或采购费用合计
|
// null, // 实付金额
|
// null, // 付款类型
|
// null, // 业务员
|
// null, // 结算天数
|
// null, // 邮费支付类型
|
// null, // 邮费
|
// null, // 付款时间
|
// null, // 发货时间
|
// null, // 物流名称
|
// null, // 物流单号
|
// 1L, // 订单状态
|
// 1, // 状态
|
// userId, // 添加人员
|
// now, // 添加时间
|
// userId, // 修改人员
|
// now, // 修改时间
|
// null // 备注
|
// );
|
// if (!orderService.insert(order)) {
|
// throw new CoolException("保存订单表头失败！");
|
// }
|
if (!orderService.insert(order1)) {
|
throw new CoolException("保存订单表头失败！");
|
}
|
|
// // 遍历商品数量并保存
|
// for (MatnrDto dto : param.getList()){
|
// Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
|
// if (mat == null) {
|
// log.error("{}商品不存在。", dto.getMatnr());
|
// continue;
|
// }
|
// OrderDetl orderDetl = new OrderDetl();
|
// orderDetl.setHostId(hostId);
|
// orderDetl.setOrderId(order.getId()); // 订单内码
|
// orderDetl.setAnfme(dto.getCount()); // 数量
|
// orderDetl.setCreateBy(userId);
|
// orderDetl.setCreateTime(now);
|
// orderDetl.setUpdateBy(userId);
|
// orderDetl.setUpdateTime(now);
|
// orderDetl.setStatus(1);
|
// VersionUtils.setOrderDetl(orderDetl, mat);
|
// if (!orderDetlService.insert(orderDetl)) {
|
// throw new CoolException("保存订单明细失败");
|
// }
|
// }
|
// 遍历商品数量并保存
|
for (MatnrDto dto : param.getList()){
|
Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
|
if (mat == null) {
|
log.error("{}商品不存在。", dto.getMatnr());
|
continue;
|
}
|
OrderDetl orderDetl = new OrderDetl();
|
orderDetl.setHostId(hostId);
|
orderDetl.setOrderId(order1.getId());
|
orderDetl.setAnfme(dto.getCount());
|
orderDetl.setCreateTime(now);
|
orderDetl.setCreateBy(userId);
|
orderDetl.setUpdateBy(userId);
|
orderDetl.setUpdateTime(now);
|
orderDetl.setStatus(1);
|
orderDetl.setMatnr(mat.getMatnr());
|
orderDetl.setMaktx(mat.getMaktx());
|
orderDetl.setName(mat.getName());
|
orderDetl.setSpecs(mat.getSpecs());
|
orderDetl.setModel(mat.getModel());
|
orderDetl.setBatch(mat.getBatch());
|
orderDetl.setUnit(mat.getUnit());
|
orderDetl.setBarcode(mat.getBarcode());
|
orderDetl.setItemNum(mat.getItemNum());
|
orderDetl.setCount(mat.getCount() == null ? 0 : mat.getCount());
|
orderDetl.setUnitPrice(mat.getPrice());
|
orderDetl.setWeight(mat.getWeight());
|
if (!orderDetlService.insert(orderDetl)) {
|
throw new CoolException("保存订单明细失败");
|
}
|
}
|
return R.ok("创建订单成功");
|
}
|
|
@Override
|
public R stockCheck(StoCheckParam param, Long userId, Long hostId) {
|
if (Cools.isEmpty(param.getLocNo())) {
|
return R.error("请选择货位");
|
}
|
Node node = nodeService.selectByUuid(param.getLocNo(), hostId);
|
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(
|
hostId,
|
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(
|
hostId,
|
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(hostId, dto.getMatnr());
|
Check check = new Check(
|
hostId,
|
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, Long hostId) {
|
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(hostId, check.getMatnr());
|
if (mat == null) {
|
throw new CoolException("商品数据异常，请联系管理员");
|
}
|
// 更新货位库存明细
|
LocDetl locDetl = new LocDetl();
|
locDetl.setHostId(hostId);
|
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("修改盘点记录状态失败");
|
}
|
return R.ok();
|
}
|
|
@Override
|
// @Transactional
|
public R initOutOrder(InitOrderParam param, Long userId, Long hostId) {
|
Order order_no = orderService.selectOne(new EntityWrapper<Order>()
|
.eq("order_no", param.getOrderNo()));
|
// Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
if (order_no != null) {
|
return R.error("抱歉单号已存在，请修改单号");
|
}
|
Date now = new Date();
|
Item item = itemService.selectByName(param.getItem());
|
Cstmr cstmr = cstmrService.selectByName(param.getCstmr());
|
|
// 新增订单表头
|
order_no = new Order();
|
order_no.setHostId(hostId);
|
order_no.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
order_no.setOrderNo(param.getOrderNo());
|
order_no.setOrderTime(param.getOrderTime());
|
order_no.setDocType(param.getDocType());
|
order_no.setItemId(item==null?null:item.getId());
|
order_no.setItemName(param.getItem());
|
order_no.setCstmr(cstmr==null?null:cstmr.getId());
|
order_no.setCstmrName(param.getCstmr());
|
order_no.setSettle(1L);
|
order_no.setStatus(1);
|
order_no.setCreateTime(now);
|
order_no.setCreateBy(userId);
|
order_no.setUpdateTime(now);
|
order_no.setUpdateBy(userId);
|
|
// if (!orderService.insert(order)) {
|
// throw new CoolException("保存订单表头失败！");
|
// }
|
if (!orderService.insert(order_no)) {
|
throw new CoolException("保存订单表头失败！");
|
}
|
|
// // 遍历商品数量并保存
|
// for (MatnrDto dto : param.getList()){
|
// Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
|
// if (mat == null) {
|
// log.error("{}商品不存在。", dto.getMatnr());
|
// continue;
|
// }
|
// OrderDetl orderDetl = new OrderDetl();
|
// orderDetl.setHostId(hostId);
|
// orderDetl.setOrderId(order.getId()); // 订单内码
|
// orderDetl.setAnfme(dto.getCount()); // 数量
|
// orderDetl.setCreateBy(userId);
|
// orderDetl.setCreateTime(now);
|
// orderDetl.setUpdateBy(userId);
|
// orderDetl.setUpdateTime(now);
|
// orderDetl.setStatus(1);
|
// VersionUtils.setOrderDetl(orderDetl, mat);
|
// if (!orderDetlService.insert(orderDetl)) {
|
// throw new CoolException("保存订单明细失败");
|
// }
|
// }
|
// 遍历商品数量并保存
|
for (MatnrDto dto : param.getList()){
|
Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
|
if (mat == null) {
|
log.error("{}商品不存在。", dto.getMatnr());
|
continue;
|
}
|
OrderDetl orderDtel = new OrderDetl();
|
orderDtel.setHostId(hostId);
|
orderDtel.setOrderId(order_no.getId());
|
orderDtel.setAnfme(dto.getCount());
|
orderDtel.setCreateTime(now);
|
orderDtel.setCreateBy(userId);
|
orderDtel.setUpdateBy(userId);
|
orderDtel.setUpdateTime(now);
|
orderDtel.setStatus(1);
|
orderDtel.setMatnr(mat.getMatnr());
|
orderDtel.setMaktx(mat.getMaktx());
|
orderDtel.setName(mat.getName());
|
orderDtel.setSpecs(mat.getSpecs());
|
orderDtel.setModel(mat.getModel());
|
orderDtel.setBatch(mat.getBatch());
|
orderDtel.setUnit(mat.getUnit());
|
orderDtel.setBarcode(mat.getBarcode());
|
orderDtel.setItemNum(mat.getItemNum());
|
orderDtel.setCount(mat.getCount() == null ? 0 : mat.getCount());
|
orderDtel.setUnitPrice(mat.getPrice());
|
orderDtel.setWeight(mat.getWeight());
|
if (!orderDetlService.insert(orderDtel)) {
|
throw new CoolException("保存订单明细失败");
|
}
|
}
|
return R.ok("创建订单成功");
|
}
|
|
@Override
|
public R wavePreview(StockOutParam stockOutParam, Long userId, Long hostId) {
|
Wrapper<Wave> wrapper = new EntityWrapper<Wave>()
|
.eq("id", stockOutParam.getOrderNo());
|
|
if (hostId != null) {
|
wrapper.eq("host_id", hostId);
|
}
|
Wave wave = waveService.selectOne(wrapper);
|
|
if (wave.getStatus() != 0){
|
return R.error("此单据无法生成拣货单");
|
}
|
// Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
|
// if (order.getSettle() != 1) {
|
// return R.error("此单据无法生成拣货单");
|
// }
|
List<WaveDetl> waveDetls = waveDetlService.selectList(new EntityWrapper<WaveDetl>()
|
.eq("wave_id", stockOutParam.getOrderNo()));
|
if (Cools.isEmpty(waveDetls)) {
|
return R.error("此单据已失效，请联系管理员");
|
}
|
// List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order.getOrderNo(), hostId);
|
// if (Cools.isEmpty(orderDetls)) {
|
// return R.error("此单据已失效，请联系管理员");
|
// }
|
|
WaveStoDto waveStoDto = new WaveStoDto().create(stockOutParam.getOrderNo(),waveDetls);
|
// OrderStoDto dto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
|
return R.ok().add(mainService.waveOutPreview(waveStoDto, hostId));
|
}
|
|
}
|
