UDI
/
udi-spms-java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
dev_ksck
dev_drug_dmyh250207
dev_drug_dm
dev_ksck_axxyy
dev_drug
lh_dev_ksck
dev_unify
dev_test1.0
dev_price
20231126-yw
dengbao
test
dev2.0
dev
pro
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '83dcc7bded'
${ noResults }
udi-spms-java/src/main/java/com/glxp/api/service/inout/IoCheckInoutService.java

984 lines
47 KiB
Java
Raw Normal View History Unescape Escape

first commit
2 years ago
package com.glxp.api.service.inout;
import cn.hutool.core.collection.CollUtil;
单据流转设置关联UUID，方便后续关联查询（单据编辑)
2 years ago
import cn.hutool.core.lang.UUID;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import cn.hutool.core.thread.ThreadUtil;
first commit
2 years ago
import cn.hutool.core.util.StrUtil;
import com.glxp.api.common.util.ResultVOUtils;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import com.glxp.api.constant.Constant;
first commit
2 years ago
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
UDI码缺失补齐相关问题
2 years ago
import com.glxp.api.entity.basic.UdiEntity;
first commit
2 years ago
import com.glxp.api.entity.inout.*;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import com.glxp.api.entity.inv.InvInnerOrderPdfTempEntity;
first commit
2 years ago
import com.glxp.api.entity.inv.InvPreinDetailEntity;
import com.glxp.api.res.inout.IoOrderCheckResultResponse;
import com.glxp.api.res.inout.IoOrderDetailBizResponse;
import com.glxp.api.res.inout.IoOrderDetailCodeResponse;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inv.InvPreinDetailService;
import com.glxp.api.service.inv.InvPreinOrderService;
新增预验收单据字段,预验收库存查询接口
2 years ago
import com.glxp.api.service.inv.InvPreinProductDetailService;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.JasperUtils;
import com.glxp.api.util.OrderNoTypeBean;
first commit
2 years ago
import com.glxp.api.util.udi.FilterUdiUtils;
新增预验收单据字段,预验收库存查询接口
2 years ago
import com.glxp.api.util.udi.UdiCalCountUtil;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import net.sf.jasperreports.engine.JRException;
first commit
2 years ago
import org.springframework.beans.BeanUtils;
UDI码缺失补齐相关问题
2 years ago
import org.springframework.scheduling.annotation.Async;
first commit
2 years ago
import org.springframework.stereotype.Service;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import org.springframework.transaction.annotation.Transactional;
first commit
2 years ago
import javax.annotation.Resource;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
import java.io.IOException;
first commit
2 years ago
import java.util.*;
/**
* 校验出入库服务
*/
@Service
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
@Transactional(rollbackFor = Exception.class)
first commit
2 years ago
public class IoCheckInoutService {
@Resource
IoOrderService orderService;
@Resource
IoCodeService codeService;
@Resource
IoCodeTempService codeTempService;
@Resource
IBasicBussinessTypeService basicBussinessTypeService;
@Resource
IoOrderDetailCodeService orderDetailCodeService;
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoOrderDetailResultService orderDetailResultService;
@Resource
InvPreinDetailService invPreinDetailService;
@Resource
IoGenInvService genInvService;
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
@Resource
IoAddInoutService addInoutService;
first commit
2 years ago
//判断是否需要手动校验
public boolean checkManual(String billNo) {
IoOrderEntity orderEntity = orderService.findByBillNo(billNo);
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (!bussinessTypeEntity.isCheckEnable()) {
return false;
} else {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isCheckUdims()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isCheckWebNew()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isCheckPdaEd()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isCheckPdaUn()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isCheckPc()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isCheckChange()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isCheckBalance()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDISP) {
if (!bussinessTypeEntity.isCheckSp()) {
return false;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isCheckCopy()) {
return false;
}
}
return true;
}
}
业务流程,资质证书,单据类型等相关修改
2 years ago
//校验流程 //一次校验
first commit
2 years ago
public void check(String orderId) {
IoOrderEntity orderEntity = orderService.findByBillNo(orderId);
//过滤非未校验或校验异常
if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_CHECK && orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_CHECK_FAIL)
return;
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (!bussinessTypeEntity.isCheckEnable()) {
unCheckFirstFinish(orderEntity);
} else {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isCheckUdims()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isCheckWebNew()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isCheckPdaEd()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isCheckPdaUn()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isCheckPc()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isCheckChange()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isCheckBalance()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDISP) {
if (!bussinessTypeEntity.isCheckSp()) {
unCheckFirstFinish(orderEntity);
return;
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isCheckCopy()) {
unCheckFirstFinish(orderEntity);
return;
}
}
checkFirstFinish(orderEntity);
}
}
UDI码缺失补齐相关问题
2 years ago
@Resource
IoCodeLostService codeLostService;
@Async
public void genLostCode(String orderId) {
List<IoCodeEntity> ioCodeEntities = codeService.findByOrderId(orderId);
for (IoCodeEntity codeEntity : ioCodeEntities) {
UdiEntity udiEntity = FilterUdiUtils.getUdi(codeEntity.getCode());
IoCodeLostEntity codeLostEntity = codeLostService.findByCode(codeEntity.getCode());
if (codeLostEntity == null)
codeLostEntity = new IoCodeLostEntity();
//校验是否写入缺失表
boolean isTrue = false;
if (udiEntity != null) {
if (!StrUtil.trimToEmpty(codeEntity.getBatchNo()).equals(StrUtil.trimToEmpty(udiEntity.getBatchNo()))) {
if (StrUtil.isNotEmpty(codeEntity.getBatchNo())) {
codeLostEntity.setBatchNo(codeEntity.getBatchNo());
isTrue = true;
}
}
if (!StrUtil.trimToEmpty(codeEntity.getProduceDate()).equals(StrUtil.trimToEmpty(udiEntity.getProduceDate()))) {
if (StrUtil.isNotEmpty(codeEntity.getProduceDate())) {
codeLostEntity.setProduceDate(codeEntity.getProduceDate());
isTrue = true;
}
}
if (!StrUtil.trimToEmpty(codeEntity.getExpireDate()).equals(StrUtil.trimToEmpty(udiEntity.getExpireDate()))) {
if (StrUtil.isNotEmpty(codeEntity.getExpireDate())) {
codeLostEntity.setExpireDate(codeEntity.getExpireDate());
isTrue = true;
}
}
if (isTrue)
codeLostService.insertOrUpdate(codeLostEntity);
}
}
}
first commit
2 years ago
public String checkCode(IoCodeTempEntity codeEntity) {
boolean isBillExit = orderDetailBizService.isExit(codeEntity.getOrderId());
if (!isBillExit) {
return "请先录入业务详情";
}
单据校验相关修改
2 years ago
IoOrderDetailBizEntity bizEntity = orderDetailBizService.findByUnique(codeEntity.getOrderId(), codeEntity.getRelId(), codeEntity.getBatchNo(), codeEntity.getProduceDate(), codeEntity.getExpireDate());
first commit
2 years ago
if (bizEntity == null) {
return "非此单产品!";
}
IoOrderDetailCodeEntity orderDetailCodeEntity = orderDetailCodeService.findByUnique(codeEntity.getOrderId(), codeEntity.getRelId(), codeEntity.getBatchNo());
int curCount = 0;
if (orderDetailCodeEntity != null) {
curCount = orderDetailCodeEntity.getReCount() + codeEntity.getMyReCount();
} else {
curCount = codeEntity.getMyReCount();
}
if (curCount > bizEntity.getCount()) {
return "当前产品数量超出！";
}
return null;
}
//一次校验（无需校验）完成
public void unCheckFirstFinish(IoOrderEntity orderEntity) {
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_FAIL);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("校验失败，扫码详情为空！");
orderService.update(orderEntity);
return;
}
orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
orderDetailResultService.deleteByOrderId(orderEntity.getBillNo());
orderDetailCodeEntities.forEach(orderDetailCodeEntity ->
{
//生成业务单据
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
orderDetailBizEntity.setCount(orderDetailCodeEntity.getReCount());
orderDetailBizEntity.setId(null);
orderDetailBizService.insert(orderDetailBizEntity);
//生成单据结果
IoOrderDetailResultEntity orderDetailResultEntity = new IoOrderDetailResultEntity();
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailResultEntity);
orderDetailResultEntity.setCount(orderDetailCodeEntity.getReCount());
orderDetailResultEntity.setReCount(orderDetailCodeEntity.getReCount());
orderDetailResultEntity.setId(null);
orderDetailResultService.insert(orderDetailResultEntity);
});
//临时表转正式表
List<IoCodeTempEntity> codeTempEntities = codeTempService.findByOrderId(orderEntity.getBillNo());
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
IoCodeEntity codeEnttity = new IoCodeEntity();
BeanUtils.copyProperties(codeTempEntity, codeEnttity);
codeEnttity.setId(null);
codeService.insert(codeEnttity);
}
codeTempService.deleteByBillNo(orderEntity.getBillNo());
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_SUCCESS);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
UDI码缺失补齐相关问题
2 years ago
genLostCode(orderEntity.getBillNo());
业务流程,资质证书,单据类型等相关修改
2 years ago
checkThird(orderEntity);
first commit
2 years ago
}
业务流程,资质证书,单据类型等相关修改
2 years ago
first commit
2 years ago
//一次校验完成
public void checkFirstFinish(IoOrderEntity orderEntity) {
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("校验失败，扫码详情为空！");
orderService.update(orderEntity);
return;
}
if (CollUtil.isEmpty(orderDetailBizEntities)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("校验失败，业务详情为空！");
orderService.update(orderEntity);
return;
}
String errMsg = "";
//正向校验
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
单据校验相关修改
2 years ago
String msg = "";
first commit
2 years ago
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
&& checkProductDate(bizEntity, codeEntity) == null
&& checkExpireDate(bizEntity, codeEntity) == null
) {
if (checkCount(bizEntity, codeEntity) == null) {
bizEntity.setCheckSuccess(true);
bizEntity.setScanCount(codeEntity.getReCount());
codeEntity.setCheckSuccess(true);
单据校验相关修改
2 years ago
} else {
bizEntity.setScanCount(codeEntity.getReCount());
bizEntity.setCheckSuccess(false);
msg = "数量不匹配";
first commit
2 years ago
}
break;
}
}
单据校验相关修改
2 years ago
if (StrUtil.isEmpty(msg) && !bizEntity.isCheckSuccess()) {
msg = "三期不匹配";
}
bizEntity.setErrMsg(msg);
first commit
2 years ago
}
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess()) {
单据校验相关修改
2 years ago
errMsg = errMsg + bizEntity.getCoName() + bizEntity.getErrMsg() + ";";
first commit
2 years ago
}
}
//反向校验
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
&& checkProductDate(bizEntity, codeEntity) == null
&& checkExpireDate(bizEntity, codeEntity) == null
) {
if (checkCount(bizEntity, codeEntity) == null) {
bizEntity.setCheckSuccess(true);
codeEntity.setCheckSuccess(true);
}
break;
}
}
}
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!codeEntity.isCheckSuccess()) {
errMsg = errMsg + codeEntity.getCoName() + ";";
}
}
if (StrUtil.isNotEmpty(errMsg)) {
orderEntity.setErrMsg(errMsg + "校验失败");
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_FAIL);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
} else {
//生成单据结果
orderDetailResultService.deleteByOrderId(orderEntity.getBillNo());
for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
IoOrderDetailResultEntity orderDetailResultEntity = new IoOrderDetailResultEntity();
BeanUtils.copyProperties(orderDetailBizEntity, orderDetailResultEntity);
orderDetailResultEntity.setId(null);
orderDetailResultEntity.setReCount(orderDetailBizEntity.getScanCount());
orderDetailResultService.insert(orderDetailResultEntity);
}
//临时表转正式表
List<IoCodeTempEntity> codeTempEntities = codeTempService.findByOrderId(orderEntity.getBillNo());
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
IoCodeEntity codeEnttity = new IoCodeEntity();
BeanUtils.copyProperties(codeTempEntity, codeEnttity);
codeService.insert(codeEnttity);
}
codeTempService.deleteByBillNo(orderEntity.getBillNo());
orderEntity.setErrMsg("校验成功！");
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_SUCCESS);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
UDI码缺失补齐相关问题
2 years ago
//生成缺失码
genLostCode(orderEntity.getBillNo());
业务流程,资质证书,单据类型等相关修改
2 years ago
checkThird(orderEntity);
UDI码缺失补齐相关问题
2 years ago
first commit
2 years ago
}
}
//业务单正向校验
public String bizOrderCheck(List<IoOrderDetailBizEntity> orderDetailBizEntities, List<IoOrderDetailCodeEntity> orderDetailCodeEntities) {
String errMsg = "";
//初始化默认值
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
codeEntity.setCheckSuccess(false);
}
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
bizEntity.setCheckSuccess(false);
}
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
单据校验相关修改
2 years ago
String msg = "";
first commit
2 years ago
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
单据校验相关修改
2 years ago
&& checkProductDate(bizEntity, codeEntity) == null
&& checkExpireDate(bizEntity, codeEntity) == null
first commit
2 years ago
) {
if (checkCount(bizEntity, codeEntity) == null) {
单据校验相关修改
2 years ago
first commit
2 years ago
bizEntity.setCheckSuccess(true);
codeEntity.setCheckSuccess(true);
bizEntity.setScanCount(codeEntity.getReCount());
} else {
单据校验相关修改
2 years ago
msg = "数量不匹配";
first commit
2 years ago
bizEntity.setScanCount(codeEntity.getReCount());
bizEntity.setCheckSuccess(false);
}
break;
}
}
单据校验相关修改
2 years ago
if (StrUtil.isEmpty(msg) && !bizEntity.isCheckSuccess()) {
msg = "三期不匹配";
}
bizEntity.setErrMsg(msg);
first commit
2 years ago
}
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess()) {
单据校验相关修改
2 years ago
errMsg = errMsg + bizEntity.getCoName() + bizEntity.getErrMsg() + ";";
first commit
2 years ago
}
}
return errMsg;
}
//业务单正向校验
public String bizOrderCheck2(List<IoOrderDetailBizResponse> orderDetailBizEntities, List<IoOrderDetailCodeEntity> orderDetailCodeEntities) {
String errMsg = "";
//初始化默认值
for (IoOrderDetailBizResponse bizResponse : orderDetailBizEntities) {
IoOrderDetailBizEntity bizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(bizResponse, bizEntity);
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
) {
if (checkCount(bizEntity, codeEntity) == null) {
bizResponse.setCheckSuccess(true);
codeEntity.setCheckSuccess(true);
bizResponse.setScanCount(codeEntity.getReCount());
} else {
bizResponse.setScanCount(codeEntity.getReCount());
bizResponse.setCheckSuccess(false);
}
break;
}
}
}
for (IoOrderDetailBizResponse bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess()) {
errMsg = errMsg + bizEntity.getCoName() + ";";
}
}
return errMsg;
}
//单据合并校验
public List<IoOrderCheckResultResponse> combineCheck(List<IoOrderDetailBizEntity> orderDetailBizEntities, List<IoOrderDetailCodeEntity> orderDetailCodeEntities) {
List<IoOrderCheckResultResponse> orderCheckResultResponses = new ArrayList<>();
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
boolean isPass = false;
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
) {
//将产品ID,批次号匹配的合并，添加到列表
IoOrderCheckResultResponse ioOrderCheckResultResponse = new IoOrderCheckResultResponse();
BeanUtils.copyProperties(bizEntity, ioOrderCheckResultResponse);
ioOrderCheckResultResponse.setBBatchNo(bizEntity.getBatchNo());
ioOrderCheckResultResponse.setBProductDate(bizEntity.getProductDate());
ioOrderCheckResultResponse.setBExpireDate(bizEntity.getExpireDate());
ioOrderCheckResultResponse.setSBatchNo(codeEntity.getBatchNo());
ioOrderCheckResultResponse.setSProductDate(codeEntity.getProductDate());
ioOrderCheckResultResponse.setSExpireDate(codeEntity.getExpireDate());
bizEntity.setCheckSuccess(true);
codeEntity.setCheckSuccess(true);
bizEntity.setScanCount(codeEntity.getReCount());
相关业务流程调整
2 years ago
ioOrderCheckResultResponse.setScanCount(bizEntity.getScanCount());
ioOrderCheckResultResponse.setCheckSuccess(true);
first commit
2 years ago
isPass = true;
orderCheckResultResponses.add(ioOrderCheckResultResponse);
break;
}
}
if (!isPass) {
//将未与扫码单
IoOrderCheckResultResponse ioOrderCheckResultResponse = new IoOrderCheckResultResponse();
BeanUtils.copyProperties(bizEntity, ioOrderCheckResultResponse);
ioOrderCheckResultResponse.setBBatchNo(bizEntity.getBatchNo());
ioOrderCheckResultResponse.setBProductDate(bizEntity.getProductDate());
ioOrderCheckResultResponse.setBExpireDate(bizEntity.getExpireDate());
bizEntity.setScanCount(0);
ioOrderCheckResultResponse.setCheckSuccess(false);
orderCheckResultResponses.add(ioOrderCheckResultResponse);
}
}
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!codeEntity.isCheckSuccess()) {
IoOrderCheckResultResponse ioOrderCheckResultResponse = new IoOrderCheckResultResponse();
BeanUtils.copyProperties(codeEntity, ioOrderCheckResultResponse);
ioOrderCheckResultResponse.setSBatchNo(codeEntity.getBatchNo());
ioOrderCheckResultResponse.setSProductDate(codeEntity.getProductDate());
ioOrderCheckResultResponse.setSExpireDate(codeEntity.getExpireDate());
ioOrderCheckResultResponse.setCount(0);
相关业务流程调整
2 years ago
ioOrderCheckResultResponse.setScanCount(codeEntity.getReCount());
first commit
2 years ago
orderCheckResultResponses.add(ioOrderCheckResultResponse);
}
}
return orderCheckResultResponses;
}
//扫码单反向校验
public String codeOrderCheck(List<IoOrderDetailCodeEntity> orderDetailCodeEntities, List<IoOrderDetailBizEntity> orderDetailBizEntities) {
//初始化默认值
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
codeEntity.setCheckSuccess(false);
}
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
bizEntity.setCheckSuccess(false);
}
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
单据校验相关修改
2 years ago
String msg = "";
first commit
2 years ago
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess()
&& checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
单据校验相关修改
2 years ago
&& checkProductDate(bizEntity, codeEntity) == null
&& checkExpireDate(bizEntity, codeEntity) == null
first commit
2 years ago
) {
if (checkCount(bizEntity, codeEntity) == null) {
单据校验相关修改
2 years ago
first commit
2 years ago
bizEntity.setCheckSuccess(true);
codeEntity.setCheckSuccess(true);
codeEntity.setOrderCount(bizEntity.getCount());
} else {
单据校验相关修改
2 years ago
msg = "数量不匹配";
first commit
2 years ago
codeEntity.setCheckSuccess(false);
codeEntity.setOrderCount(bizEntity.getCount());
}
break;
} else {
codeEntity.setCheckSuccess(false);
}
}
单据校验相关修改
2 years ago
if (StrUtil.isEmpty(msg) && !codeEntity.isCheckSuccess()) {
msg = "三期不匹配";
}
codeEntity.setErrMsg(msg);
first commit
2 years ago
}
String errMsg = "";
for (IoOrderDetailCodeEntity codeEntity : orderDetailCodeEntities) {
if (!codeEntity.isCheckSuccess()) {
单据校验相关修改
2 years ago
errMsg = errMsg + codeEntity.getCoName() + codeEntity.getErrMsg() + ";";
first commit
2 years ago
}
}
return errMsg;
}
public void codeOrderCheck2(List<IoOrderDetailCodeResponse> orderDetailCodeEntities, List<IoOrderDetailBizEntity> orderDetailBizEntities) {
for (IoOrderDetailCodeResponse codeResponse : orderDetailCodeEntities) {
IoOrderDetailCodeEntity codeEntity = new IoOrderDetailCodeEntity();
BeanUtils.copyProperties(codeResponse, codeEntity);
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
if (!bizEntity.isCheckSuccess() && !codeEntity.isCheckSuccess() && checkId(bizEntity, codeEntity) == null
&& checkBatchNo(bizEntity, codeEntity) == null
) {
if (checkCount(bizEntity, codeEntity) == null) {
bizEntity.setCheckSuccess(true);
codeResponse.setCheckSuccess(true);
codeResponse.setOrderCount(bizEntity.getCount());
} else {
codeResponse.setCheckSuccess(false);
codeResponse.setOrderCount(bizEntity.getCount());
}
break;
} else {
codeResponse.setCheckSuccess(false);
}
}
}
}
业务流程,资质证书,单据类型等相关修改
2 years ago
//三次校验(中间层）
public void checkThird(IoOrderEntity orderEntity) {
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_AUDITED && orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_CHECK_REW) {
if (bussinessTypeEntity.isThrCheckEnable()) {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isThrCheckUdims()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isThrCheckWebNew()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isThrCheckPdaEd()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isThrCheckPdaUn()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isThrCheckPc()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isThrCheckChange()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isThrCheckBalance()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isThrCheckCopy()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
}
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
}
}
if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_REW) {
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_REW);
orderEntity.setUpdateTime(new Date());
切换部门，验收时间等问题
2 years ago
orderEntity.setCheckTime(new Date());
业务流程,资质证书,单据类型等相关修改
2 years ago
orderService.update(orderEntity);
checkSecond(orderEntity);
}
}
first commit
2 years ago
//二次校验
public void checkSecond(IoOrderEntity orderEntity) {
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_AUDITED) {
if (bussinessTypeEntity.isSecCheckEnable()) {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isSecCheckUdims()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isSecCheckWebNew()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isSecCheckPdaEd()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isSecCheckPdaUn()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isSecCheckPc()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isSecCheckChange()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isSecCheckBalance()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isSecCheckCopy()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
}
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
}
if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_CHECK);
orderEntity.setUpdateTime(new Date());
相关业务流程调整
2 years ago
orderEntity.setAuditTime(new Date());
first commit
2 years ago
orderService.update(orderEntity);
genInv(orderEntity, bussinessTypeEntity);
}
}
单据类型转换，耗材字典新增问题
2 years ago
@Resource
IoChangeInoutService changeInoutService;
新增预验收单据字段,预验收库存查询接口
2 years ago
@Resource
InvPreinProductDetailService invPreinProductDetailService;
@Resource
UdiCalCountUtil udiCalCountUtil;
单据类型转换，耗材字典新增问题
2 years ago
first commit
2 years ago
//校验完成后生成库存
public void genInv(IoOrderEntity orderEntity, BasicBussinessTypeEntity bussinessTypeEntity) {
if (bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT) && bussinessTypeEntity.isScanPreIn()) {
预验收重新调整
2 years ago
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
ThreadUtil.execAsync(() -> {
新增预验收单据字段,预验收库存查询接口
2 years ago
List<IoCodeEntity> backCodeList = new ArrayList<>();
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
List<IoCodeEntity> codeList = codeService.findByOrderId(orderEntity.getBillNo());
新增预验收单据字段,预验收库存查询接口
2 years ago
for (IoCodeEntity codeEntity : codeList) {
int count = invPreinProductDetailService.findCountByCode(codeEntity.getCode());
if (count > 0) {
codeEntity.setCount(count);
codeEntity.setReCount(udiCalCountUtil.getActCount(codeEntity.getNameCode()));
backCodeList.add(codeEntity);
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
}
first commit
2 years ago
}
新增预验收单据字段,预验收库存查询接口
2 years ago
BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (StrUtil.isNotEmpty(basicBussinessTypeEntity.getPreInBackAction())) {
IoOrderEntity outOrder = new IoOrderEntity();
// BeanUtils.copyProperties(orderEntity, outOrder);
outOrder.setId(null);
outOrder.setMainAction(ConstantType.TYPE_OUT);
outOrder.setAction(basicBussinessTypeEntity.getAction());
outOrder.setCreateTime(new Date());
outOrder.setFromType(ConstantStatus.FROM_CHANGE);
String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(basicBussinessTypeEntity.getPrefix()), "yyyyMMdd"));
outOrder.setBillNo(orderNo);
outOrder.setCustomerId(Constant.SYSTEM_CUSTOMER_ID);
outOrder.setCorpOrderId(CustomUtil.getId() + "x");
outOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);
orderEntity.setUllageSupNo(outOrder.getBillNo());
orderEntity.setUpdateTime(new Date());
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
orderService.update(orderEntity);
新增预验收单据字段,预验收库存查询接口
2 years ago
outOrder.setOriginUllageSupNo(orderEntity.getBillNo());
outOrder.setCreateUser(null);
outOrder.setReviewUser(null);
orderService.insertOrder(outOrder);
//生成条码
List<IoCodeTempEntity> codeTempEntities = new ArrayList<>();
for (IoCodeEntity warehouseEntity : backCodeList) {
IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
BeanUtils.copyProperties(warehouseEntity, codeTempEntity);
codeTempEntity.setId(null);
codeTempEntity.setOrderId(outOrder.getBillNo());
codeTempEntity.setAction(outOrder.getAction());
codeTempEntity.setMainAction(outOrder.getMainAction());
codeTempEntity.setCreateTime(new Date());
codeTempEntity.setUpdateTime(new Date());
codeTempEntities.add(codeTempEntity);
}
codeTempService.insertBatch(codeTempEntities);
addInoutService.dealProcess(outOrder);
if (!checkManual(outOrder.getBillNo())) {
check(outOrder.getBillNo());
}
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
单据相关bug修改
2 years ago
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
}
first commit
2 years ago
新增预验收单据字段,预验收库存查询接口
2 years ago
// //找出UDI码对应的预验收入库单号
// Map<String, String> preInOrder = new HashMap<>();
// for (IoCodeEntity warehouseEntity : codeList) {
// List<InvPreinDetailEntity> invProductDetailEntities = invPreinDetailService.findByCode(warehouseEntity.getCode());
// if (invProductDetailEntities.size() > 0) {
// for (InvPreinDetailEntity invPreinDetailEntity : invProductDetailEntities)
// preInOrder.put(invPreinDetailEntity.getOrderId(), invPreinDetailEntity.getOrderId());
// }
// }
// if (preInOrder.size() > 0) {
// String preInBillNo = "";
// boolean isBreak = false;
//
// for (String key : preInOrder.keySet()) {
// if (!isBreak) {
// preInBillNo = preInBillNo + "," + key;
// IoOrderEntity preInEntity = orderService.findByBillNo(key);
// preInEntity.setPreOutBillNo(orderEntity.getBillNo());
// orderService.update(preInEntity);
// BasicBussinessTypeEntity preBusType = basicBussinessTypeService.findByAction(preInEntity.getAction());
// //预验收不删除单号，方便后续查询
// if (preBusType.isPreInBack()) { //预验收如果带回，则清空相关预验收库存；
// invPreinDetailService.deleteByOrderId(preInEntity.getBillNo());
// //剩余UDI码生成退货单 todo
// List<IoCodeEntity> codeEntities = codeService.findByOrderId(key);
// backCodeList.addAll(codeEntities);
// } else { //预验收如果不带回，则清除已出库相关库存
// for (IoCodeEntity codeEntity : codeList) {
// if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
// InvPreinDetailEntity invPreinDetailEntity = invPreinDetailService.findByCode(key, codeEntity.getCode());
// if (invPreinDetailEntity != null) {
// int count = 0;
// if (invPreinDetailEntity.getCount() < codeEntity.getCount()) {
// count = 0;
// } else {
// count = invPreinDetailEntity.getCount() - codeEntity.getCount();
// }
// if (count >= 0) {
// isBreak = true;
// if (count == 0) {
// invPreinDetailService.deleteByCode(key, codeEntity.getCode());
// } else {
// invPreinDetailEntity.setCount(count);
// invPreinDetailService.update(invPreinDetailEntity);
// }
// int reCount = invPreinDetailEntity.getReCount() - codeEntity.getMyReCount();
// if (reCount == 0) {
// invPreinDetailService.deleteByCode(key, codeEntity.getCode());
// } else {
// invPreinDetailEntity.setReCount(reCount);
// invPreinDetailService.update(invPreinDetailEntity);
// }
// }
// }
// } else {
// invPreinDetailService.deleteByCode(key, codeEntity.getCode());
// }
// }
//
// }
// }
//
//
// }
// orderEntity.setPreInBillNo(preInBillNo.substring(1));
// orderService.update(orderEntity);
//
//
// //生成退货单 1.查出所有关联的单据条码，2.扣减当前出库数量；3.生成单据类型对应绑定的出库单
// if (CollUtil.isNotEmpty(backCodeList)) {
// List<IoCodeEntity> realBackCodeList = new ArrayList<>();
// for (IoCodeEntity backCodeEntity : backCodeList) {
// for (IoCodeEntity codeEntity : codeList) {
// if (codeEntity.getCount() != 0 && backCodeEntity.getCode().equals(codeEntity.getCode())) {
// int count = backCodeEntity.getCount() - codeEntity.getCount();
// int reCount = backCodeEntity.getReCount() - codeEntity.getReCount();
// if (count > 0) {
// codeEntity.setCount(0);
// codeEntity.setReCount(0);
// backCodeEntity.setCount(count);
// backCodeEntity.setReCount(reCount);
// realBackCodeList.add(backCodeEntity);
// } else if (count == 0) {
// codeEntity.setCount(0);
// codeEntity.setReCount(0);
// } else if (count < 0) {
// codeEntity.setCount(-count);
// codeEntity.setReCount(-reCount);
// }
// }
// }
//
// }
// if (CollUtil.isNotEmpty(realBackCodeList)) {
// Map<String, List<IoCodeEntity>> backPreInOrder = new HashMap<>();
// for (IoCodeEntity codeEntity : codeList) {
// List<IoCodeEntity> codeEntities = backPreInOrder.get(codeEntity.getOrderId());
// if (CollUtil.isEmpty(codeEntities)) {
// codeEntities = new ArrayList<>();
// }
// codeEntities.add(codeEntity);
// backPreInOrder.put(codeEntity.getOrderId(), codeEntities);
// }
//
// for (String key : backPreInOrder.keySet()) {
// IoOrderEntity originOrder = orderService.findByBillNo(key);
// BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(originOrder.getAction());
//
// }
// }
// }
// }
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
});
first commit
2 years ago
}
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
单据类型转换，耗材字典新增问题
2 years ago
//校验是否是不入库存单据
相关业务流程调整
2 years ago
if (bussinessTypeEntity.isInStock()) {
单据类型转换，耗材字典新增问题
2 years ago
//生成库存
单据类型字段合并等相关修改
2 years ago
if (bussinessTypeEntity.getActionType() == ConstantStatus.ACTION_TYPE_PREIN) {
单据类型转换，耗材字典新增问题
2 years ago
genInvService.genPreInInv(orderEntity.getBillNo());
单据类型字段合并等相关修改
2 years ago
} else if (bussinessTypeEntity.getActionType() == ConstantStatus.ACTION_TYPE_ADVANCE) {
单据类型转换，耗材字典新增问题
2 years ago
genInvService.genPreInv(orderEntity.getBillNo());
} else {
genInvService.genNorInv(orderEntity.getBillNo());
}
first commit
2 years ago
} else {
单据类型转换，耗材字典新增问题
2 years ago
//不入库存，直接进行单据流转
changeInoutService.changeOrder(orderEntity);
first commit
2 years ago
}
单据类型转换，耗材字典新增问题
2 years ago
first commit
2 years ago
}
1.新增预验收库存产品信息，库存产品信息详情； 2.更改预验收出库扫码校验流程； 3.更改预验收生成库存流程； 4.新增预验收出库后生成退货单； 5.更改预验收出库后扣减数量流程
2 years ago
// 预验收使用出库处理1.不带回扣库存;2.带回时生成退货出库单
@Resource
GennerOrderUtils gennerOrderUtils;
first commit
2 years ago
public String checkId(IoOrderDetailBizEntity bizEntity, IoOrderDetailCodeEntity codeEntity) {
if (bizEntity.getBindRlFk().longValue() == codeEntity.getBindRlFk().longValue()) {
return null;
} else {
return "产品ID不匹配";
}
}
public String checkBatchNo(IoOrderDetailBizEntity bizEntity, IoOrderDetailCodeEntity codeEntity) {
if (StrUtil.nullToEmpty(bizEntity.getBatchNo()).equals(StrUtil.nullToEmpty(codeEntity.getBatchNo()))) {
return null;
} else {
return bizEntity.getCoName() + "批次号不匹配";
}
}
public String checkProductDate(IoOrderDetailBizEntity bizEntity, IoOrderDetailCodeEntity codeEntity) {
if (StrUtil.nullToEmpty(bizEntity.getProductDate()).equals(StrUtil.nullToEmpty(codeEntity.getProductDate()))) {
return null;
} else {
return bizEntity.getCoName() + "生产日期不匹配";
}
}
public String checkExpireDate(IoOrderDetailBizEntity bizEntity, IoOrderDetailCodeEntity codeEntity) {
if (StrUtil.nullToEmpty(bizEntity.getExpireDate()).equals(StrUtil.nullToEmpty(codeEntity.getExpireDate()))) {
return null;
} else {
return bizEntity.getCoName() + "失效日期不匹配";
}
}
public String checkCount(IoOrderDetailBizEntity bizEntity, IoOrderDetailCodeEntity codeEntity) {
if (bizEntity.getCount() == codeEntity.getReCount()) {
return null;
}
return bizEntity.getCoName() + "数量不匹配！";
}
}