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.
udi-wms-java/src/main/java/com/glxp/api/service/inout/IoAddInoutService.java

1205 lines
61 KiB
Java

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

package com.glxp.api.service.inout;
import cn.hutool.core.bean.BeanUtil;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.service.basic.*;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inv.impl.InvProductService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.vo.basic.InvProductNewVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.inout.IoOrderDetailCodeDao;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.req.basic.FilterCompanyProductRelevanceRequest;
import com.glxp.api.req.inout.PdaPostOrderRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.inv.InvPreProductDetailService;
import com.glxp.api.service.inv.InvPreinProductDetailService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.*;
import com.glxp.api.util.udi.FilterUdiUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import static com.glxp.api.constant.ConstantStatus.ORDER_STATUS_CHECK_PROCESS;
@Slf4j
@Service
public class IoAddInoutService {
@Resource
private IBasicBussinessTypeService basicBussinessTypeService;
@Resource
private IoOrderService orderService;
@Resource
GennerOrderUtils gennerOrderUtils;
@Resource
IoCodeService codeService;
@Resource
IoCodeTempService codeTempService;
@Resource
UdiRlSupService udiRlSupService;
@Resource
IoOrderDetailCodeService orderDetailCodeService;
@Resource
UdiRelevanceService udiRelevanceService;
@Resource
InvProductServiceNew invProductServiceNew;
@Resource
BasicCorpService basicCorpService;
@Resource
IoCheckInoutService ioCheckInoutService;
@Resource
SystemParamConfigService systemParamConfigService;
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
private IoOrderDetailCodeDao orderDetailCodeDao;
@Resource
InvWarehouseService invWarehouseService;
@Resource
InvProductService invProductService;
@Resource
IoCheckInvService checkInvService;
//新增扫码单据处理
public BaseResponse dealProcess(IoOrderEntity orderEntity) {
orderEntity.setErrMsg("正在处理!");
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESSING);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
List<IoOrderEntity> orderEntities = orderService.isExitRepeat(orderEntity.getCorpOrderId(), orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderEntities)) {
orderEntity.setErrMsg("单据重复上传");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (bussinessTypeEntity == null) {
orderEntity.setErrMsg("单据类型不存在");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
if (StrUtil.isEmpty(orderEntity.getFromCorp()) && StrUtil.isEmpty(orderEntity.getFromInvCode())) {
orderEntity.setErrMsg("未选择往来单位");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
} else if (StrUtil.isNotEmpty(orderEntity.getFromCorp())) {
updateCorp(bussinessTypeEntity, orderEntity.getFromCorp(), orderEntity.getSickerAdNum());
}
if (StrUtil.isEmpty(orderEntity.getInvCode())) {
orderEntity.setErrMsg("未选择当前仓库信息");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
List<IoCodeTempEntity> filterList = codeTempService.findByOrderId(orderEntity.getBillNo());
List<IoCodeTempEntity> insertList = new ArrayList<>();
for (int j = 0; j < filterList.size(); j++) {
IoCodeTempEntity warehouseEntity = filterList.get(j);
String result = checkOrderRepeatCode(warehouseEntity, filterList);
if (result == null) {
insertList.add(warehouseEntity);
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg(result);
orderService.update(orderEntity);
insertList.clear();
return ResultVOUtils.error(orderEntity.getErrMsg());
}
if (bussinessTypeEntity.isCodeFillCheck()) {
//三期校验
String checkOriginMsg = checkOriginCode(warehouseEntity);
if (StrUtil.isNotEmpty(checkOriginMsg)) {
orderEntity.setErrMsg(checkOriginMsg);
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
insertList.clear();
return ResultVOUtils.error(orderEntity.getErrMsg());
}
}
//产品是否已维护已关联
if ((warehouseEntity.getRelId() == null)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("udi码" + warehouseEntity.getCode() + "上传时对照数据丢失!");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
//产品是否指定供应商
if (!(bussinessTypeEntity.getAction().equals(ConstantType.SPLIT_RETURN) || bussinessTypeEntity.getAction().equals(ConstantType.SPLIT_OUT))) {
if (StrUtil.isEmpty(warehouseEntity.getSupId())) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("udi码" + warehouseEntity.getCode() + "未指定供应商!");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
//校验是否是当前供应商
if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
UdiRlSupEntity udiRlSupEntity = udiRlSupService.findByUdiRlIdUnitFk(warehouseEntity.getRelId() + "", orderEntity.getFromCorp());
if (udiRlSupEntity == null) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("udi码" + warehouseEntity.getCode() + "当前供应商不存在此配送产品");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
}
}
//产品是否可以以使用单元入库
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectGroupById(warehouseEntity.getRelId());
if (udiRelevanceResponse == null) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("udi码" + warehouseEntity.getCode() + "该产品信息未维护");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
} else if (!udiRelevanceResponse.getUseDy() && udiRelevanceResponse.getDiType() == ConstantStatus.DITYPE_SYDY) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("udi码" + warehouseEntity.getCode() + "该产品不允许以使用单元入库");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
BaseResponse baseResponse = checkInvService.check(bussinessTypeEntity, warehouseEntity, udiRelevanceResponse);
if (baseResponse != null) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg(baseResponse.getMessage());
orderService.update(orderEntity);
return baseResponse;
}
}
if (CollUtil.isNotEmpty(insertList)) {
//生成扫码单据详情
if (!orderDetailCodeService.isExit(orderEntity.getBillNo())) {
for (IoCodeTempEntity codeTempEntity : insertList) {
genOrderDetailCode(orderEntity, codeTempEntity);
}
}
if (orderEntity.getFromType().equals(ConstantStatus.FROM_UDISP)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_REW);
orderEntity.setDealStatus(ConstantStatus.ORDER_STATUS_CHECK);
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
}
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("");
orderService.update(orderEntity);
return null;
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("未添加UDI码");
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
}
//新增业务单据处理
public BaseResponse dealBusProcess(IoOrderEntity orderEntity, BasicBussinessTypeEntity bussinessTypeEntity) {
orderEntity.setErrMsg("正在处理!");
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESSING);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
List<IoOrderEntity> orderEntities = orderService.isExitRepeat(orderEntity.getCorpOrderId(), orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderEntities)) {
return updateErrMsg(orderEntity, "单据重复上传");
}
if (StrUtil.isEmpty(orderEntity.getFromCorp()) && StrUtil.isEmpty(orderEntity.getFromInvCode())) {
return updateErrMsg(orderEntity, "未选择往来单位");
}
if (StrUtil.isEmpty(orderEntity.getInvCode())) {
return updateErrMsg(orderEntity, "未选择当前仓库信息");
}
String errMsg = "";
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
if (StrUtil.isEmpty(orderDetailBizEntity.getSupId())) {
errMsg = errMsg + orderDetailBizEntity.getCoName() + "未绑定供应商;";
}
if (orderDetailBizEntity.getBindRlFk() == null) {
errMsg = errMsg + orderDetailBizEntity.getCoName() + "未绑定耗材字典编码;";
}
if (orderDetailBizEntity.getBindRlFk() == null) {
errMsg = errMsg + orderDetailBizEntity.getCoName() + "该产品未指定唯一耗材编码;";
}
if (StrUtil.isEmpty(orderDetailBizEntity.getSupId())) {
errMsg = errMsg + orderDetailBizEntity.getCoName() + "该产品未指定供应商;";
}
if (IntUtil.value(orderDetailBizEntity.getCount()) == 0) {
errMsg = errMsg + orderDetailBizEntity.getCoName() + "产品数量不能为0;";
}
if (bussinessTypeEntity.getCheckWebNew() == 1 || bussinessTypeEntity.getCheckWebNew() == 3) {
if (StrUtil.isEmpty(orderDetailBizEntity.getBatchNo())
&& StrUtil.isEmpty(orderDetailBizEntity.getProductDate())
&& StrUtil.isEmpty(orderDetailBizEntity.getExpireDate())) {
return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "三期不能全为空!");
}
}
}
}
if (StrUtil.isNotEmpty(errMsg)) {
return updateErrMsg(orderEntity, errMsg);
}
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
//业务单直接生成扫码单
if (bussinessTypeEntity.getCheckWebNew() == 4) {
boolean exit = codeTempService.isExit(orderEntity.getBillNo());
if (!exit) {
stockGenScan(orderEntity);
}
}
return ResultVOUtils.success();
}
BaseResponse updateErrMsg(IoOrderEntity orderEntity, String errMsg) {
orderEntity.setErrMsg(errMsg);
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return ResultVOUtils.error(orderEntity.getErrMsg());
}
/**
* 业务单生成扫码单
*/
public void stockGenScan(IoOrderEntity orderEntity) {
List<IoOrderDetailBizEntity> bizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
List<IoOrderDetailBizEntity> newBizList = new ArrayList<>();
if (IntUtil.value(bussinessTypeEntity.getVailInvBatchNo())) {
//校验库存
for (IoOrderDetailBizEntity bizEntity : bizEntities) {
if (StrUtil.isNotEmpty(bizEntity.getBatchNo())) {
List<InvProductEntity> invProductEntities = invProductService.selectByRelId(bizEntity.getBindRlFk(), bizEntity.getSupId(), null, orderEntity.getInvCode());
if (CollUtil.isNotEmpty(invProductEntities)) {
int count = 0;
for (InvProductEntity invProductEntity : invProductEntities) {
if (invProductEntity.getReCount() + count > IntUtil.value(bizEntity.getCount())) {
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(bizEntity, orderDetailBizEntity);
orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());
newBizList.add(orderDetailBizEntity);
break;
} else {
count = invProductEntity.getReCount();
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(bizEntity, orderDetailBizEntity);
orderDetailBizEntity.setCount(count);
orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());
newBizList.add(orderDetailBizEntity);
}
}
} else {
newBizList.add(bizEntity);
}
} else if (StrUtil.isEmpty(bizEntity.getBatchNo())) {
List<InvProductEntity> invProductEntities = invProductService.selectByRelId(bizEntity.getBindRlFk(), bizEntity.getSupId(), null, orderEntity.getInvCode());
if (CollUtil.isNotEmpty(invProductEntities)) {
int count = 0;
for (InvProductEntity invProductEntity : invProductEntities) {
if (invProductEntity.getReCount() + count > IntUtil.value(bizEntity.getCount())) {
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(bizEntity, orderDetailBizEntity);
orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());
orderDetailBizEntity.setBatchNo(invProductEntity.getBatchNo());
newBizList.add(orderDetailBizEntity);
break;
} else {
count = invProductEntity.getReCount();
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(bizEntity, orderDetailBizEntity);
orderDetailBizEntity.setCount(count);
orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());
orderDetailBizEntity.setBatchNo(invProductEntity.getBatchNo());
newBizList.add(orderDetailBizEntity);
}
}
} else {
newBizList.add(bizEntity);
}
}
}
orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
orderDetailBizService.batchInsertBizs(newBizList);
} else {
newBizList = bizEntities;
}
List<IoCodeTempEntity> codeTempEntities = new ArrayList<>();
for (IoOrderDetailBizEntity bizEntity : newBizList) {
IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
String udiCode = "#" + bizEntity.getNameCode()
+ "#" + StrUtil.trimToEmpty(bizEntity.getProductDate())
+ "#" + StrUtil.trimToEmpty(bizEntity.getExpireDate()) +
"#" + StrUtil.trimToEmpty(bizEntity.getBatchNo()) + "#" + "#" + "#";
codeTempEntity.setCode(udiCode);
codeTempEntity.setMainAction(orderEntity.getMainAction());
codeTempEntity.setAction(orderEntity.getAction());
codeTempEntity.setOrderId(orderEntity.getBillNo());
codeTempEntity.setCorpOrderId(orderEntity.getCorpOrderId());
codeTempEntity.setNameCode(bizEntity.getNameCode());
codeTempEntity.setBatchNo(bizEntity.getBatchNo());
codeTempEntity.setProduceDate(bizEntity.getProductDate());
codeTempEntity.setExpireDate(bizEntity.getExpireDate());
codeTempEntity.setSupId(bizEntity.getSupId());
codeTempEntity.setRelId(bizEntity.getBindRlFk());
codeTempEntity.setCount(bizEntity.getCount());
codeTempEntity.setReCount(bizEntity.getCount());
codeTempEntity.setDeptCode(orderEntity.getDeptCode());
codeTempEntity.setInvCode(orderEntity.getInvCode());
codeTempEntity.setUpdateTime(new Date());
codeTempEntity.setCreateTime(new Date());
codeTempEntity.setPrice(bizEntity.getPrice());
if (orderEntity.getBillNo() != null && orderEntity.getBillNo().length() >= 12) {
codeTempEntity.setInBatchNo(orderEntity.getBillNo().substring(orderEntity.getBillNo().length() - 12));
}
codeTempEntities.add(codeTempEntity);
}
codeTempService.insertBatch(codeTempEntities);
newBizList.forEach(orderDetailBizEntity -> {
IoOrderDetailCodeEntity orderDetailCodeEntity = new IoOrderDetailCodeEntity();
BeanUtils.copyProperties(orderDetailBizEntity, orderDetailCodeEntity);
orderDetailCodeEntity.setId(null);
orderDetailCodeEntity.setReCount(orderDetailBizEntity.getCount());
orderDetailCodeEntity.setCount(orderDetailBizEntity.getCount());
orderDetailCodeService.insert(orderDetailCodeEntity);
});
ioCheckInoutService.check(orderEntity.getBillNo());
}
//生成扫码单据详情
@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.READ_COMMITTED,
timeout = 30,
rollbackFor = Exception.class
)
public List<IoOrderDetailCodeEntity> genOrderDetailCode(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity) {
List<IoOrderDetailCodeEntity> ioOrderDetailCodeEntities = orderDetailCodeDao.selectList(new QueryWrapper<IoOrderDetailCodeEntity>().select("id", "count", "reCount", "bindRlFk", "batchNo", "price").eq("orderIdFk", orderEntity.getBillNo()));
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectSupGroupById(codeTempEntity.getRelId(), codeTempEntity.getSupId());
if (codeTempEntity.getPrice() == null && udiRelevanceResponse.getPrice() != null) {
codeTempService.updateById(IoCodeTempEntity.builder().id(codeTempEntity.getId()).price(udiRelevanceResponse.getPrice()).build());
}
if (CollUtil.isEmpty(ioOrderDetailCodeEntities)) {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
ioOrderDetailCodeEntities = orderDetailCodeDao.selectList(new QueryWrapper<IoOrderDetailCodeEntity>().select("id", "count", "reCount", "bindRlFk", "batchNo", "price").eq("orderIdFk", orderEntity.getBillNo()));
} else {
// && BigDecimalUtil.equalTo(IntUtil.value(orderDetailCodeEntity.getPrice()), IntUtil.value(codeTempEntity.getPrice())
boolean isUpdate = false;
for (IoOrderDetailCodeEntity orderDetailCodeEntity : ioOrderDetailCodeEntities) {
if (orderDetailCodeEntity.getBindRlFk().longValue() == udiRelevanceResponse.getId().longValue()
&& StrUtil.trimToEmpty(orderDetailCodeEntity.getBatchNo()).equals(StrUtil.trimToEmpty(codeTempEntity.getBatchNo())
)
) {
orderDetailCodeEntity.setCount(orderDetailCodeEntity.getCount() + codeTempEntity.getMyCount());
orderDetailCodeEntity.setReCount(orderDetailCodeEntity.getReCount() + codeTempEntity.getMyReCount());
UpdateWrapper<IoOrderDetailCodeEntity> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("count", orderDetailCodeEntity.getCount()).set("reCount", orderDetailCodeEntity.getReCount());
orderDetailCodeEntity.setUpdateTime(new Date());
orderDetailCodeDao.updateCount(orderDetailCodeEntity);
isUpdate = true;
break;
}
}
if (!isUpdate) {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
}
}
return ioOrderDetailCodeEntities;
}
//平衡补单
public BaseResponse supplementOrder(String orderId) {
IoOrderEntity order = orderService.findByBillNo(orderId);
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(order.getAction());
if (StrUtil.isBlank(bussinessTypeEntity.getSupplementOrderType())) {
return ResultVOUtils.error(500, "此类型单据不可补单");
}
IoOrderEntity supplementOrder = new IoOrderEntity();
BeanUtils.copyProperties(order, supplementOrder);
//生成补单单号,互填单号
String supplementOrderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
supplementOrder.setSupplementNo(orderId);
order.setSupplementNo(supplementOrderNo);
supplementOrder.setBillNo(supplementOrderNo);
supplementOrder.setCorpOrderId(CustomUtil.getId() + "x");
//修改状态
SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("additional_auto_submit");
if ("1".equals(systemParamConfigEntity.getParamValue())) {
supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS); //设置状态为补录单据
} else {
supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_ADDITIONAL); //设置状态为补录单据
}
//交换往来信息
supplementOrder.setFromDeptCode(order.getDeptCode());
supplementOrder.setFromInvCode(order.getInvCode());
supplementOrder.setInvCode(order.getFromInvCode());
supplementOrder.setDeptCode(order.getFromDeptCode());
supplementOrder.setFromType(ConstantStatus.FROM_PEACE_CHANGE);
//设置往来信息
BasicBussinessTypeEntity supplementType = basicBussinessTypeService.findByAction(bussinessTypeEntity.getSupplementOrderType());
supplementOrder.setMainAction(supplementType.getMainAction());
supplementOrder.setAction(supplementType.getAction());
supplementOrder.setBusType(supplementType.getBusType());
//复制码表
List<IoCodeEntity> codes = codeService.findByOrderId(orderId);
List<IoCodeTempEntity> supplementCodes = new ArrayList<>();
codes.forEach(
code -> {
IoCodeTempEntity supplementCode = new IoCodeTempEntity();
BeanUtils.copyProperties(code, supplementCode);
supplementCode.setId(null);
supplementCode.setInvCode(order.getFromInvCode());
supplementCode.setDeptCode(order.getFromDeptCode());
supplementCode.setOrderId(supplementOrderNo);
supplementCode.setAction(supplementType.getAction());
supplementCode.setWarehouseCode(null);
supplementCode.setPreInSpaceCode(null);
supplementCode.setPreSpaceCode(null);
supplementCode.setMainAction(supplementType.getMainAction());
supplementCodes.add(supplementCode);
}
);
//更新数据
orderService.insertOrder(supplementOrder);
orderService.update(order);
codeTempService.insertBatch(supplementCodes);
dealProcess(supplementOrder);
if (!ioCheckInoutService.checkManual(supplementOrder.getBillNo())) {
ioCheckInoutService.check(supplementOrder.getBillNo());
}
return ResultVOUtils.success();
}
/**
* 手持终端-----新增出入库单据
*
* @param pdaPostOrderRequest
* @return
*/
public BaseResponse creatOrderByPda(PdaPostOrderRequest pdaPostOrderRequest) {
IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
IoOrderEntity tempEntity = orderService.findByBillNo(orderEntity.getBillNo());
if (tempEntity != null) {
return ResultVOUtils.error(500, "单据已存在,请勿重复提交");
}
tempEntity = orderService.findByCorpOrderId(orderEntity.getCorpOrderId());
if (tempEntity != null) {
return ResultVOUtils.error(500, "单据已存在,请勿重复提交");
}
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
BaseResponse baseResponse = checkInv(bussinessTypeEntity, pdaPostOrderRequest.getOrderDetailBizEntities(), orderEntity, pdaPostOrderRequest.getCodeTempEntities());
if (baseResponse != null)
return baseResponse;
List<IoCodeTempEntity> codeTempEntities = BeanUtil.copyToList(pdaPostOrderRequest.getCodeTempEntities(), IoCodeTempEntity.class);
String priceFifo = systemParamConfigService.selectValueByParamKey("price_fifo");
if (IntUtil.value(priceFifo) > 0 && bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
List<IoCodeTempEntity> resultList = new ArrayList<>();
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
resultList = checkPrice(codeTempEntity, bussinessTypeEntity, resultList);
}
}
String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
orderEntity.setBillNo(orderNo);
orderService.insertOrder(orderEntity);
if (CollUtil.isNotEmpty(pdaPostOrderRequest.getCodeTempEntities())) {
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
codeTempEntity.setOrderId(orderNo);
}
codeTempService.insertBatch(codeTempEntities);
}
dealProcess(orderEntity);
if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
ioCheckInoutService.check(orderEntity.getBillNo());
}
return ResultVOUtils.success("单据上传成功!");
}
/**
* 手持终端-----待配货(无三期,有三期)单据提交
*
* @return
*/
@Transactional(rollbackFor = Exception.class)
public BaseResponse waitOrderByPda(PdaPostOrderRequest pdaPostOrderRequest) {
IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
IoOrderEntity temp = orderService.findByBillNo(orderEntity.getBillNo());
BaseResponse tempResponse = checkSubmitEnable(temp);
if (tempResponse != null)
return tempResponse;
List<IoOrderDetailBizEntity> orderDetailBizEntities = pdaPostOrderRequest.getOrderDetailBizEntities();
List<IoCodeTempEntity> codeTempEntities = pdaPostOrderRequest.getCodeTempEntities();
orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
orderDetailCodeService.deleteByOrderId(orderEntity.getBillNo());
codeTempService.deleteByBillNo(orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
orderDetailBizEntities.forEach(orderDetailBizEntity -> {
orderDetailBizService.insert(orderDetailBizEntity);
IoOrderDetailCodeEntity orderDetailCodeEntity = new IoOrderDetailCodeEntity();
BeanUtils.copyProperties(orderDetailBizEntity, orderDetailCodeEntity);
orderDetailCodeEntity.setReCount(orderDetailBizEntity.getScanCount());
orderDetailCodeEntity.setCount(orderDetailBizEntity.getCodeCount());
orderDetailCodeService.insert(orderDetailCodeEntity);
});
}
if (CollUtil.isNotEmpty(codeTempEntities)) {
codeTempEntities.forEach(codeTempEntity -> {
codeTempService.insert(codeTempEntity);
});
}
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
if (bussinessTypeEntity.getCheckWebNew() == 1) {
String errMsg = ioCheckInoutService.bizOrderCheck(orderDetailBizEntities, orderDetailCodeEntities);
if (StrUtil.isNotEmpty(errMsg)) {
return ResultVOUtils.error(500, errMsg);
}
errMsg = ioCheckInoutService.codeOrderCheck(orderDetailCodeEntities, orderDetailBizEntities);
if (StrUtil.isNotEmpty(errMsg)) {
return ResultVOUtils.error(500, errMsg);
}
// saveOrderWeb(addOrderRequest);
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderService.update(orderEntity);
ioCheckInoutService.check(orderEntity.getBillNo());
} else {
String errMsg = ioCheckInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
if (StrUtil.isNotEmpty(errMsg)) {
return ResultVOUtils.error(500, errMsg);
}
orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
orderDetailBizEntity.setId(null);
orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
ioCheckInoutService.getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
orderDetailBizService.insert(orderDetailBizEntity);
}
// saveOrderWeb(addOrderRequest);
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderService.update(orderEntity);
dealProcess(orderEntity);
ioCheckInoutService.check(orderEntity.getBillNo());
}
} else {
return ResultVOUtils.error(500, "单据校验提交失败,请先录入业务单据!");
}
} else {
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
dealProcess(orderEntity);
ioCheckInoutService.check(orderEntity.getBillNo());
return ResultVOUtils.success("提交成功!");
}
return ResultVOUtils.success("提交成功!");
}
/**
* 手持终端------扫码结果提交
*
* @return
*/
@Transactional(rollbackFor = Exception.class)
public BaseResponse checkCodeResultByPda(Integer checkWebNewType, PdaPostOrderRequest pdaPostOrderRequest) {
IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
IoOrderEntity temp = orderService.findByBillNo(orderEntity.getBillNo());
BaseResponse tempResponse = checkSubmitEnable(temp);
if (tempResponse != null)
return tempResponse;
List<IoOrderDetailBizEntity> orderDetailBizEntities = pdaPostOrderRequest.getOrderDetailBizEntities();
List<IoCodeTempEntity> codeTempEntities = pdaPostOrderRequest.getCodeTempEntities();
orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
orderDetailCodeService.deleteByOrderId(orderEntity.getBillNo());
codeTempService.deleteByBillNo(orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
orderDetailBizEntities.forEach(orderDetailBizEntity -> {
orderDetailBizService.insert(orderDetailBizEntity);
IoOrderDetailCodeEntity orderDetailCodeEntity = new IoOrderDetailCodeEntity();
BeanUtils.copyProperties(orderDetailBizEntity, orderDetailCodeEntity);
orderDetailCodeEntity.setReCount(orderDetailBizEntity.getScanCount());
orderDetailCodeEntity.setCount(orderDetailBizEntity.getCodeCount());
orderDetailCodeService.insert(orderDetailCodeEntity);
});
}
if (CollUtil.isNotEmpty(codeTempEntities)) {
codeTempEntities.forEach(codeTempEntity -> {
codeTempService.insert(codeTempEntity);
});
}
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
orderService.update(orderEntity);
ioCheckInoutService.checkCodeResult(orderEntity.getBillNo());
// if (checkWebNewType == 0) {
//
// } else {
// dealProcess(orderEntity);
// ioCheckInoutService.checkRightResult(orderEntity.getBillNo());
// }
return ResultVOUtils.success("提交成功!");
}
//校验条码关联供应商
public String checkExitSup(IoCodeTempEntity ioCodeTempEntity) {
Long relId = ioCodeTempEntity.getRelId();
String batchNo = ioCodeTempEntity.getBatchNo();
FilterCompanyProductRelevanceRequest filterCompanyProductRelevanceRequest = new FilterCompanyProductRelevanceRequest();
filterCompanyProductRelevanceRequest.setUdiRlIdFk(relId + "");
List<UdiRlSupEntity> companyProductRelevanceEntities = udiRlSupService.filterCompanyProductRelevance(filterCompanyProductRelevanceRequest);
if (companyProductRelevanceEntities != null && companyProductRelevanceEntities.size() == 1) {
UdiRlSupEntity udiRlSupEntity = companyProductRelevanceEntities.get(0);
return udiRlSupEntity.getUnitFk();
} else if (companyProductRelevanceEntities != null && companyProductRelevanceEntities.size() > 1) {
//携带供应商号列表
List<String> unitFks = new ArrayList<>(companyProductRelevanceEntities.size());
String unitFk = companyProductRelevanceEntities.get(0).getUnitFk();
boolean isMuti = false;
for (UdiRlSupEntity udiRlSupEntity : companyProductRelevanceEntities) {
unitFks.add(udiRlSupEntity.getUnitFk());
if (!unitFk.equals(udiRlSupEntity.getUnitFk())) {
isMuti = true;
break;
}
}
if (isMuti) {
//过滤掉库存数量为0的供应商
if (relId != null && StrUtil.isNotEmpty(batchNo)) {
unitFks = invProductService.filterReCount(relId, batchNo, unitFks);
if (unitFks != null && unitFks.size() == 1) {
return unitFks.get(0);
}
}
return "MUTI"; //绑定多个供应商
} else return unitFk;
}
return null;
}
public String checkInvExitSup(IoCodeEntity codeEnttity) {
String supId = checkNorInv(codeEnttity);
if (supId == null) {
return checkPreInv(codeEnttity);
}
return supId;
}
//查普通库存 todo
public String checkNorInv(IoCodeEntity codeEnttity) {
// FilterInvWarehouseRequest filterInvWarehouseRequest = new FilterInvWarehouseRequest();
// filterInvWarehouseRequest.setLevel(1);
// filterInvWarehouseRequest.setAdvanceType(false);
// List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.filterInvWarehouse(filterInvWarehouseRequest);
// List<String> codes = new ArrayList<>();
// if (!invWarehouseEntities.isEmpty()) {
// for (InvWarehouseEntity invWarehouseEntity : invWarehouseEntities) {
// codes.add(invWarehouseEntity.getCode());
// }
// }
// FilterInvProductRequest filterInvProductDetailRequest = new FilterInvProductRequest();
// filterInvProductDetailRequest.setRelIdFk(codeEnttity.getRelId());
// filterInvProductDetailRequest.setBatchNo(codeEnttity.getBatchNo());
// filterInvProductDetailRequest.setInvCodes(codes);
// List<InvProductEntity> invProductEntities = invProductService.filterInvProduct(filterInvProductDetailRequest);
// if (invProductEntities.size() > 0) {
// String supId = invProductEntities.get(0).getSupId();
// int count = 0;
// for (InvProductEntity invProductEntity : invProductEntities) {
// if (!supId.equals(invProductEntity.getSupId())) {
// return null;
// }
// count = count + (invProductEntity.getInCount() - invProductEntity.getOutCount());
// }
// if (count > 0)
// return supId;
// }
return null;
}
//查寄售库存 todo
public String checkPreInv(IoCodeEntity codeEnttity) {
// FilterInvWarehouseRequest filterInvWarehouseRequest = new FilterInvWarehouseRequest();
// filterInvWarehouseRequest.setLevel(1);
// filterInvWarehouseRequest.setAdvanceType(true);
// List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.filterInvWarehouse(filterInvWarehouseRequest);
// List<String> codes = new ArrayList<>();
// if (!invWarehouseEntities.isEmpty()) {
// for (InvWarehouseEntity invWarehouseEntity : invWarehouseEntities) {
// codes.add(invWarehouseEntity.getCode());
// }
// }
// FilterInvProductRequest filterInvProductDetailRequest = new FilterInvProductRequest();
// filterInvProductDetailRequest.setRelIdFk(codeEnttity.getRelId());
// filterInvProductDetailRequest.setBatchNo(codeEnttity.getBatchNo());
// filterInvProductDetailRequest.setInvCodes(codes);
// List<InvProductEntity> invProductEntities = invPreProductService.filterInvProduct(filterInvProductDetailRequest);
// if (invProductEntities.size() > 0) {
// String supId = invProductEntities.get(0).getSupId();
// int count = 0;
// for (InvProductEntity invProductEntity : invProductEntities) {
// if (!supId.equals(invProductEntity.getSupId())) {
// return null;
// }
// count = count + (invProductEntity.getInCount() - invProductEntity.getOutCount());
// }
// if (count > 0)
// return supId;
// }
return null;
}
//查询本单是否有重复条码
public String checkOrderRepeatCode(IoCodeTempEntity codeEntity, List<IoCodeTempEntity> filterList) {
int count = 0;
if (filterList != null) {
for (IoCodeTempEntity temp : filterList) {
if (temp.getCode().equals(codeEntity.getCode())
&& StrUtil.trimToEmpty(temp.getSerialNo()).equals(StrUtil.trimToEmpty(codeEntity.getSerialNo()))
&& StrUtil.trimToEmpty(temp.getInBatchNo()).equals(StrUtil.trimToEmpty(codeEntity.getInBatchNo()))
&& BigDecimalUtil.equalTo(temp.getPrice(), codeEntity.getPrice())
) {
count = count + 1;
}
}
}
if (count > 1) {
return codeEntity.getCode() + "条码重复";
} else
return null;
}
@Resource
IoCodeLostService codeLostService;
public String checkOriginCode(IoCodeTempEntity warehouseEntity) {
UdiEntity udiEntity = FilterUdiUtils.getUdi(warehouseEntity.getCode());
//校验条码的完整性
String errMsg = "";
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
if (udiRelevanceResponse == null) {
return "耗材字典不存在此产品";
}
IoCodeLostEntity codeLostEntity = codeLostService.findByCode(warehouseEntity.getCode());
if (codeLostEntity != null) {
if (StrUtil.isEmpty(warehouseEntity.getBatchNo())) {
warehouseEntity.setBatchNo(codeLostEntity.getBatchNo());
}
if (StrUtil.isEmpty(warehouseEntity.getProduceDate())) {
warehouseEntity.setProduceDate(codeLostEntity.getProduceDate());
}
if (StrUtil.isEmpty(warehouseEntity.getExpireDate())) {
warehouseEntity.setExpireDate(codeLostEntity.getExpireDate());
}
}
if (StrUtil.isEmpty(warehouseEntity.getBatchNo()) && !udiRelevanceResponse.getAllowNoBatch()) {
errMsg = errMsg + ",批次号";
}
if (StrUtil.isEmpty(warehouseEntity.getProduceDate()) && !udiRelevanceResponse.getAllowNoProduct()) {
errMsg = errMsg + ",生产日期";
}
if (StrUtil.isEmpty(warehouseEntity.getExpireDate()) && !udiRelevanceResponse.getAllowNoExpire()) {
errMsg = errMsg + ",失效日期";
}
if (StrUtil.isNotEmpty(errMsg)) {
return "UDI码" + warehouseEntity.getCode() + "产品三期缺失请补齐" + errMsg.substring(1) + "";
}
return null;
}
IoOrderDetailCodeEntity buildEntity(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity, UdiRelevanceResponse udiRelevanceResponse) {
IoOrderDetailCodeEntity ioOrderDetailCodeEntity = new IoOrderDetailCodeEntity();
ioOrderDetailCodeEntity.setOrderIdFk(orderEntity.getBillNo());
ioOrderDetailCodeEntity.setBindRlFk(udiRelevanceResponse.getId());
ioOrderDetailCodeEntity.setUuidFk(udiRelevanceResponse.getUuid());
ioOrderDetailCodeEntity.setBatchNo(codeTempEntity.getBatchNo());
ioOrderDetailCodeEntity.setNameCode(codeTempEntity.getNameCode());
ioOrderDetailCodeEntity.setProductDate(codeTempEntity.getProduceDate());
ioOrderDetailCodeEntity.setExpireDate(codeTempEntity.getExpireDate());
ioOrderDetailCodeEntity.setCoName(udiRelevanceResponse.getCpmctymc());
ioOrderDetailCodeEntity.setCertCode(udiRelevanceResponse.getZczbhhzbapzbh());
ioOrderDetailCodeEntity.setYlqxzcrbarmc(udiRelevanceResponse.getYlqxzcrbarmc());
ioOrderDetailCodeEntity.setManufacturer(udiRelevanceResponse.getManufactory());
ioOrderDetailCodeEntity.setMeasname(udiRelevanceResponse.getMeasname());
if (StrUtil.isEmpty(udiRelevanceResponse.getGgxh())) {
ioOrderDetailCodeEntity.setSpec(udiRelevanceResponse.getBzgg());
} else
ioOrderDetailCodeEntity.setSpec(udiRelevanceResponse.getGgxh());
if (StrUtil.isEmpty(udiRelevanceResponse.getMeasname())) {
ioOrderDetailCodeEntity.setMeasname(udiRelevanceResponse.getUseLevelUnit());
}
ioOrderDetailCodeEntity.setSupId(codeTempEntity.getSupId());
ioOrderDetailCodeEntity.setProductType(codeTempEntity.getProductType());
if (codeTempEntity.getPrice() == null) {
ioOrderDetailCodeEntity.setPrice(udiRelevanceResponse.getPrice());
codeTempEntity.setPrice(udiRelevanceResponse.getPrice());
codeTempService.updateById(codeTempEntity);
} else {
ioOrderDetailCodeEntity.setPrice(codeTempEntity.getPrice());
}
ioOrderDetailCodeEntity.setCount(codeTempEntity.getCount());
ioOrderDetailCodeEntity.setReCount(codeTempEntity.getMyReCount());
ioOrderDetailCodeEntity.setUpdateTime(new Date());
return ioOrderDetailCodeEntity;
}
@Resource
BasicSkSickerService basicSkSickerService;
/**
* 临床出库时更新往来单位信息
*/
public String updateCorp(BasicBussinessTypeEntity bussinessTypeEntity, String fromCorp, String adNum) {
BasicCorpEntity basicCorpEntity;
BasicSkSickerEntity basicSkSickerEntity;
//要是特殊往来信息没有就创建
if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_INPUT && bussinessTypeEntity.isGenUnit()) {
if (StrUtil.isNotEmpty(adNum)) {
basicCorpEntity = basicCorpService.findBySickAdNum(adNum);
if (basicCorpEntity == null) {
basicSkSickerEntity = basicSkSickerService.findByAdNum(adNum);
if (basicSkSickerEntity != null) {
basicCorpEntity = new BasicCorpEntity();
basicCorpEntity.setName(basicSkSickerEntity.getName() + " " + basicSkSickerEntity.getAdNum());
basicCorpEntity.setAdSickNum(basicSkSickerEntity.getAdNum());
String erpId = genBasicCorp(basicCorpEntity);
basicCorpEntity.setErpId(erpId);
}
}
} else {
basicCorpEntity = basicCorpService.selectByName(fromCorp);
if (basicCorpEntity == null)
basicCorpEntity = basicCorpService.selectByErpId(fromCorp + " ");
}
if (basicCorpEntity == null) {
basicCorpEntity = new BasicCorpEntity();
basicCorpEntity.setName(fromCorp);
String erpId = genBasicCorp(basicCorpEntity);
basicCorpEntity.setErpId(erpId);
}
return basicCorpEntity.getErpId();
} else {
return fromCorp;
}
}
public String genBasicCorp(BasicCorpEntity basicCorpEntity) {
basicCorpEntity.setErpId(CustomUtil.getUnitId());
basicCorpEntity.setCorpType(ConstantStatus.CORP_SICK);
basicCorpEntity.setOutType(ConstantStatus.CORP_SICK_SICK);
basicCorpEntity.setId(IdUtil.getSnowflakeNextId());
basicCorpService.insert(basicCorpEntity);
return basicCorpEntity.getErpId();
}
public BaseResponse checkSubmitEnable(IoOrderEntity orderEntity) {
if (orderEntity == null) {
return ResultVOUtils.error(500, "请先录入单据信息!");
}
if (orderEntity.getStatus() == ORDER_STATUS_CHECK_PROCESS || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESS
|| orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESSING) {
return ResultVOUtils.error(500, "提交失败,单据正在处理,请稍后刷新查看!");
}
if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6) {
return ResultVOUtils.error(500, "提交失败,单据已提交,请稍后刷新查看!");
}
return null;
}
@Resource
InvPreProductDetailService invPreProductDetailService;
@Resource
InvPreinProductDetailService invPreinProductDetailService;
/**
* 手持终端上传校验库存
*/
public BaseResponse checkInv(BasicBussinessTypeEntity bussinessTypeEntity, List<IoOrderDetailBizEntity> orderDetailBizEntities, IoOrderEntity orderEntity, List<IoCodeTempEntity> codeTempEntities) {
if (bussinessTypeEntity.isScanPreIn()) { //校验预验收库存
InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_PREIN);
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
if (checkDiAttribute(bussinessTypeEntity, codeTempEntity.getRelId(), 2)) {
int count = 0;
if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
if (StrUtil.isNotEmpty(codeTempEntity.getSerialNo())) {
count = invPreinProductDetailService.vailStockCountByCode(null, invWarehouseEntity.getCode(), null, codeTempEntity.getCode());
} else
count = invPreinProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
} else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
if (StrUtil.isNotEmpty(codeTempEntity.getSerialNo())) {
count = invPreinProductDetailService.vailStockCountByCode(null, invWarehouseEntity.getCode(), codeTempEntity.getPreInSpaceCode(), codeTempEntity.getCode());
} else
count = invPreinProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), null, invWarehouseEntity.getCode(), codeTempEntity.getPreInSpaceCode());
}
if (count < IntUtil.value(codeTempEntity.getReCount())) {
return ResultVOUtils.error(500, "UDI码" + codeTempEntity.getCode() + "预验收库存数量不足!");
}
}
}
} else if (bussinessTypeEntity.isAdvancePreIn()) { //校验寄售库存
InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_ADVANCE);
for (IoOrderDetailBizEntity orderDetailCodeEntity : orderDetailBizEntities) {
if (checkDiAttribute(bussinessTypeEntity, orderDetailCodeEntity.getBindRlFk(), 3)) {
int count = 0;
if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
count = invPreProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
} else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
count = invPreProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), null, invWarehouseEntity.getCode(), orderEntity.getPreCurSpaceCode());
}
if (count < orderDetailCodeEntity.getScanCount()) {
return ResultVOUtils.error(500, "提交失败," + orderDetailCodeEntity.getCoName() + "库存数量不足!");
}
}
}
} else { //校验普通库存
if (bussinessTypeEntity.isVailInv() && bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
String outInvCode = orderEntity.getInvCode();
InvWarehouseEntity invWarehouseEntity = invWarehouseService.findNoInvTypeInv(bussinessTypeEntity.getDeptNoInvType(), outInvCode);
if (invWarehouseEntity != null) {
outInvCode = invWarehouseEntity.getCode();
}
for (IoOrderDetailBizEntity orderDetailCodeEntity : orderDetailBizEntities) {
if (checkDiAttribute(bussinessTypeEntity, orderDetailCodeEntity.getBindRlFk(), 1)) {
int count = 0;
if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
count = invProductServiceNew.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), null, outInvCode, null, true);
} else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
count = invProductServiceNew.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), orderEntity.getDeptCode(), orderEntity.getInvCode(), orderEntity.getCurSpaceCode(), true);
}
if (count < orderDetailCodeEntity.getScanCount()) {
return ResultVOUtils.error(500, "提交失败," + orderDetailCodeEntity.getCoName() + "库存数量不足!");
}
}
}
}
}
return null;
}
/**
*
*/
public boolean checkDiAttribute(BasicBussinessTypeEntity bussinessTypeEntity, Long relId, Integer purType) {
if (bussinessTypeEntity.getUseDyCount() == 2) {
if (udiRelevanceService.findPurType(relId) == IntUtil.value(purType)) {
return true;
} else
return false;
}
return true;
}
/**
* 手持终端上传校验价格
*/
public List<IoCodeTempEntity> checkPrice(IoCodeTempEntity codeTempEntity, BasicBussinessTypeEntity bussinessTypeEntity, List<IoCodeTempEntity> codeTempEntities) {
List<IoCodeTempEntity> filteredAndSorted = codeTempEntities.stream()
.filter(person -> IntUtil.value(person.getRelId()) == IntUtil.value(codeTempEntity.getRelId())
&& StrUtil.trimToEmpty(person.getBatchNo()).equals(StrUtil.trimToEmpty(codeTempEntity.getBatchNo()))
)
.sorted(Comparator.comparing(IoCodeTempEntity::getInBatchNo, Comparator.nullsLast(Comparator.naturalOrder())))
.collect(Collectors.toList());
Map<String, List<IoCodeTempEntity>> stringListMap = null;
if (CollUtil.isNotEmpty(filteredAndSorted)) {
stringListMap = filteredAndSorted.stream()
.collect(Collectors.groupingBy(person -> StrUtil.trimToEmpty(person.getInBatchNo()))
);
}
List<IoCodeTempEntity> lastList = null;
if (stringListMap != null) {
lastList = stringListMap.entrySet().stream().findFirst().get().getValue();
}
int exitCount = 0;
int extiReCount = 0;
if (CollUtil.isNotEmpty(lastList)) {
for (IoCodeTempEntity ioCodeTempEntity : lastList) {
exitCount = exitCount + ioCodeTempEntity.getCount();
extiReCount = extiReCount + ioCodeTempEntity.getReCount();
}
}
//出库时填写价格与入库批次
//1.获取出库最新批次
String lastInBatch = null;
if (exitCount > 0) {
lastInBatch = lastList.get(0).getInBatchNo();
} else {
InvProductNewVo invProductDetailEntity = invProductServiceNew.selectLastInBatch(bussinessTypeEntity, codeTempEntity.getRelId() + "", codeTempEntity.getBatchNo(), codeTempEntity.getInvCode(), codeTempEntity.getMainAction());
if (invProductDetailEntity != null) {
lastInBatch = invProductDetailEntity.getInBatchNo();
codeTempEntity.setPrice(invProductDetailEntity.getPrice());
codeTempEntity.setInBatchNo(invProductDetailEntity.getInBatchNo());
}
}
if (lastInBatch == null && exitCount == 0) {
//首次出库,获取入库最早批次
InvProductNewVo inProductDetail = invProductServiceNew.selectFirstInBatch(bussinessTypeEntity, codeTempEntity.getRelId() + "", codeTempEntity.getBatchNo(), codeTempEntity.getInvCode(), ConstantType.TYPE_PUT);
if (inProductDetail != null) {
codeTempEntity.setPrice(inProductDetail.getPrice());
codeTempEntity.setInBatchNo(inProductDetail.getInBatchNo());
}
} else {
//非首次出库
//1.获取当前批次已出库数量
Integer outCount = IntUtil.value(invProductServiceNew.selectCountByInBatch(codeTempEntity.getRelId() + "", codeTempEntity.getBatchNo(), bussinessTypeEntity, lastInBatch, codeTempEntity.getInvCode(), ConstantType.TYPE_OUT));
//2.获取当前批次入库数量
Integer inCount = IntUtil.value(invProductServiceNew.selectCountByInBatch(codeTempEntity.getRelId() + "", codeTempEntity.getBatchNo(), bussinessTypeEntity, lastInBatch, codeTempEntity.getInvCode(), ConstantType.TYPE_PUT));
//3.若数量还有剩,则此次出库为当前批次
if (inCount >= (outCount + extiReCount + codeTempEntity.getReCount())) {
if (lastList != null) {
codeTempEntity.setPrice(lastList.get(0).getPrice());
codeTempEntity.setInBatchNo(lastList.get(0).getInBatchNo());
} else {
}
} else {
// 4.若数量不足,则出下一批次
InvProductNewVo nextInvProduct = invProductServiceNew.selectNextInBatch(bussinessTypeEntity, codeTempEntity.getRelId() + "", codeTempEntity.getBatchNo(), codeTempEntity.getInvCode(), ConstantType.TYPE_PUT, lastInBatch);
if (nextInvProduct != null) {
codeTempEntity.setPrice(nextInvProduct.getPrice());
codeTempEntity.setInBatchNo(nextInvProduct.getInBatchNo());
}
}
}
codeTempEntities.add(codeTempEntity);
return codeTempEntities;
}
}