|
|
package com.glxp.api.service.inout;
|
|
|
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
|
import cn.hutool.core.util.StrUtil;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
|
import com.github.pagehelper.PageHelper;
|
|
|
import com.github.pagehelper.PageInfo;
|
|
|
import com.glxp.api.common.res.BaseResponse;
|
|
|
import com.glxp.api.common.util.ResultVOUtils;
|
|
|
import com.glxp.api.constant.Constant;
|
|
|
import com.glxp.api.dao.inout.IoCodeTempDao;
|
|
|
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
|
|
|
import com.glxp.api.entity.basic.UdiEntity;
|
|
|
import com.glxp.api.entity.basic.UdiProductEntity;
|
|
|
import com.glxp.api.entity.inout.IoCodeTempEntity;
|
|
|
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
|
|
|
import com.glxp.api.entity.inout.IoOrderEntity;
|
|
|
import com.glxp.api.req.inout.AddEnterCodeRequest;
|
|
|
import com.glxp.api.req.inout.FilterCodeRequest;
|
|
|
import com.glxp.api.res.PageSimpleResponse;
|
|
|
import com.glxp.api.res.basic.UdiRelevanceResponse;
|
|
|
import com.glxp.api.res.collect.RelCodeDetailResponse;
|
|
|
import com.glxp.api.res.inout.AddEnterCodeResponse;
|
|
|
import com.glxp.api.res.inout.IoCodeResponse;
|
|
|
import com.glxp.api.res.inout.IoCodeTempResponse;
|
|
|
import com.glxp.api.service.basic.IBasicBussinessTypeService;
|
|
|
import com.glxp.api.service.basic.UdiProductService;
|
|
|
import com.glxp.api.service.basic.UdiRelevanceService;
|
|
|
import com.glxp.api.service.collect.RelCodeDetailService;
|
|
|
import com.glxp.api.service.inout.impl.IoCodeService;
|
|
|
import com.glxp.api.service.system.SystemParamConfigService;
|
|
|
import com.glxp.api.util.BeanCopyUtils;
|
|
|
import com.glxp.api.util.IntUtil;
|
|
|
import com.glxp.api.util.page.PageQuery;
|
|
|
import com.glxp.api.util.page.TableDataInfo;
|
|
|
import com.glxp.api.util.udi.FilterUdiUtils;
|
|
|
import com.glxp.api.util.udi.UdiCalCountUtil;
|
|
|
import lombok.extern.slf4j.Slf4j;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
|
|
import javax.annotation.Resource;
|
|
|
import java.util.Date;
|
|
|
import java.util.List;
|
|
|
import java.util.Map;
|
|
|
import java.util.HashMap;
|
|
|
|
|
|
@Service
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
@Slf4j
|
|
|
public class IoCodeTempService {
|
|
|
|
|
|
@Resource
|
|
|
IoCodeTempDao ioCodeTempDao;
|
|
|
|
|
|
|
|
|
public IoCodeTempEntity selectById(Integer id) {
|
|
|
return ioCodeTempDao.selectById(id);
|
|
|
}
|
|
|
|
|
|
|
|
|
public int insert(IoCodeTempEntity codeEnttity) {
|
|
|
codeEnttity.setId(null);
|
|
|
return ioCodeTempDao.insert(codeEnttity);
|
|
|
}
|
|
|
|
|
|
|
|
|
public int deleteById(Integer id) {
|
|
|
return ioCodeTempDao.deleteById(id);
|
|
|
}
|
|
|
|
|
|
|
|
|
public boolean insertBatch(List<IoCodeTempEntity> codeEnttities) {
|
|
|
return ioCodeTempDao.insertBatch(codeEnttities);
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCodeTempEntity> findByOrderId(String billNo) {
|
|
|
return ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", billNo));
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCodeResponse> findJoinByOrderId(String billNo) {
|
|
|
if (StrUtil.isEmpty(billNo))
|
|
|
return null;
|
|
|
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
|
|
|
filterCodeRequest.setOrderId(billNo);
|
|
|
return ioCodeTempDao.filterJoinProduct(filterCodeRequest);
|
|
|
}
|
|
|
|
|
|
public List<IoCodeResponse> findJoinByBizId(Long bizId) {
|
|
|
if (bizId == null)
|
|
|
return null;
|
|
|
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
|
|
|
filterCodeRequest.setBizId(bizId);
|
|
|
return ioCodeTempDao.filterJoinProduct(filterCodeRequest);
|
|
|
}
|
|
|
|
|
|
|
|
|
public int updateById(IoCodeTempEntity codeEnttity) {
|
|
|
return ioCodeTempDao.updateById(codeEnttity);
|
|
|
}
|
|
|
|
|
|
|
|
|
public int updateByOrderId(IoCodeTempEntity codeTempEntity) {
|
|
|
return ioCodeTempDao.update(codeTempEntity, new QueryWrapper<IoCodeTempEntity>().eq("orderId", codeTempEntity.getOrderId()));
|
|
|
}
|
|
|
|
|
|
|
|
|
public IoCodeTempEntity findByUnique(String orderId, String code) {
|
|
|
List<IoCodeTempEntity> codeTempEntities = ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId).eq("code", code));
|
|
|
if (CollUtil.isNotEmpty(codeTempEntities)) {
|
|
|
IoCodeTempEntity codeTempEntity = codeTempEntities.get(0);
|
|
|
if (codeTempEntities.size() > 1) {
|
|
|
for (int i = 1; i < codeTempEntities.size(); i++) {
|
|
|
codeTempEntity.setCount(codeTempEntity.getCount() + codeTempEntities.get(i).getCount());
|
|
|
codeTempEntity.setReCount(codeTempEntity.getReCount() + codeTempEntities.get(i).getReCount());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return codeTempEntity;
|
|
|
|
|
|
}
|
|
|
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
|
|
|
public TableDataInfo<IoCodeTempEntity> findByOrderId(FilterCodeRequest filterCodeRequest) {
|
|
|
PageQuery pageQuery = new PageQuery();
|
|
|
BeanCopyUtils.copy(filterCodeRequest, pageQuery);
|
|
|
Page<IoCodeTempEntity> page = ioCodeTempDao.selectPage(pageQuery.build(), new QueryWrapper<IoCodeTempEntity>().eq("orderId", filterCodeRequest.getOrderId()));
|
|
|
return TableDataInfo.build(page);
|
|
|
}
|
|
|
|
|
|
|
|
|
public int deleteByBillNo(String orderId) {
|
|
|
return ioCodeTempDao.delete(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCodeTempResponse> findCodeList(FilterCodeRequest filterCodeRequest) {
|
|
|
if (null != filterCodeRequest && null != filterCodeRequest.getPage() && null != filterCodeRequest.getLimit()) {
|
|
|
PageHelper.offsetPage((filterCodeRequest.getPage() - 1) * filterCodeRequest.getLimit(), filterCodeRequest.getLimit());
|
|
|
}
|
|
|
return ioCodeTempDao.selectCodeList(filterCodeRequest);
|
|
|
}
|
|
|
|
|
|
|
|
|
public boolean isExit(String orderId) {
|
|
|
return ioCodeTempDao.exists(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
|
|
|
}
|
|
|
|
|
|
|
|
|
public Integer selectExitCount(String orderId, String bacthNo, Long relId, String supId) {
|
|
|
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
|
|
|
filterCodeRequest.setOrderId(orderId);
|
|
|
filterCodeRequest.setBatchNo(bacthNo);
|
|
|
filterCodeRequest.setRelId(relId + "");
|
|
|
filterCodeRequest.setSupId(supId);
|
|
|
return ioCodeTempDao.selectExitCount(filterCodeRequest);
|
|
|
}
|
|
|
|
|
|
|
|
|
public Integer selectExitCount(String orderId, String code) {
|
|
|
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
|
|
|
filterCodeRequest.setOrderId(orderId);
|
|
|
filterCodeRequest.setCode(code);
|
|
|
return ioCodeTempDao.selectExitCount(filterCodeRequest);
|
|
|
}
|
|
|
|
|
|
|
|
|
public Boolean checkTempCode(IoCodeTempEntity ioCodeTempEntity) {
|
|
|
|
|
|
QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
|
|
|
ew.eq("code", ioCodeTempEntity.getCode());
|
|
|
ew.eq("corpOrderId", ioCodeTempEntity.getCorpOrderId());
|
|
|
ew.eq("batchNo", ioCodeTempEntity.getBatchNo());
|
|
|
ew.eq("produceDate", ioCodeTempEntity.getProduceDate());
|
|
|
ew.eq("expireDate", ioCodeTempEntity.getExpireDate());
|
|
|
ew.eq("serialNo", ioCodeTempEntity.getSerialNo());
|
|
|
Long count = ioCodeTempDao.selectCount(ew);
|
|
|
if (count > 0) {
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
public IoCodeTempEntity selectByCode(String code, String batchNo, String action) {
|
|
|
QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
|
|
|
ew.eq("code", code);
|
|
|
ew.eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo);
|
|
|
ew.eq(StrUtil.isNotEmpty(action), "action", action);
|
|
|
return ioCodeTempDao.selectOne(ew);
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCodeTempEntity> selectByCodes(List<String> codeList, String orderId) {
|
|
|
QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
|
|
|
ew.eq("orderId", orderId);
|
|
|
ew.in("code", codeList);
|
|
|
return ioCodeTempDao.selectList(ew);
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
private IoOrderService orderService;
|
|
|
@Resource
|
|
|
private IBasicBussinessTypeService basicBussinessTypeService;
|
|
|
@Resource
|
|
|
UdiRelevanceService udiRelevanceService;
|
|
|
@Resource
|
|
|
UdiCalCountUtil udiCalCountUtil;
|
|
|
@Resource
|
|
|
IoOrderDetailCodeService ioOrderDetailCodeService;
|
|
|
@Resource
|
|
|
IoOrderDetailBizService orderDetailBizService;
|
|
|
|
|
|
|
|
|
public Boolean removeCodeById(IoCodeTempEntity codeTempEntity) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(codeTempEntity.getOrderId());
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
|
|
|
UdiRelevanceResponse udiRelevanceResponses = udiRelevanceService.selectByNameCode(codeTempEntity.getNameCode());
|
|
|
|
|
|
if (codeTempEntity.getMyCount() > 1) {
|
|
|
codeTempEntity.setCount(codeTempEntity.getMyCount() - 1);
|
|
|
if (bussinessTypeEntity.isUse()) {
|
|
|
codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
|
|
|
} else {
|
|
|
codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
|
|
|
}
|
|
|
updateById(codeTempEntity);
|
|
|
} else {
|
|
|
deleteById(codeTempEntity.getId());
|
|
|
}
|
|
|
|
|
|
//更新扫码详情
|
|
|
IoOrderDetailCodeEntity orderDetailCodeEntity = ioOrderDetailCodeService.findByUnique(orderEntity.getBillNo(), codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getPrice());
|
|
|
if (orderDetailCodeEntity != null) {
|
|
|
//扫码数量-1
|
|
|
int orderCount = IntUtil.value(orderDetailCodeEntity.getCount());
|
|
|
int orderReCount = IntUtil.value(orderDetailCodeEntity.getReCount());
|
|
|
if (orderCount > 1) {
|
|
|
orderDetailCodeEntity.setCount(orderCount - 1);
|
|
|
|
|
|
|
|
|
if (bussinessTypeEntity.isUse()) {
|
|
|
orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
|
|
|
// codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses);
|
|
|
} else {
|
|
|
orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
|
|
|
// codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses);
|
|
|
}
|
|
|
|
|
|
ioOrderDetailCodeService.update(orderDetailCodeEntity);
|
|
|
} else {
|
|
|
ioOrderDetailCodeService.deleteById(orderDetailCodeEntity.getId());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
boolean r1 = orderDetailBizService.isExit(orderEntity.getBillNo());
|
|
|
boolean r2 = ioOrderDetailCodeService.isExit(orderEntity.getBillNo());
|
|
|
if (!r1 && !r2) {
|
|
|
if (StrUtil.isNotEmpty(orderDetailCodeEntity.getOrderIdFk()))
|
|
|
orderService.deleteByBillNo(orderDetailCodeEntity.getOrderIdFk());
|
|
|
}
|
|
|
|
|
|
orderEntity.setUpdateTime(new Date());
|
|
|
orderService.update(orderEntity);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
RelCodeDetailService relCodeDetailService;
|
|
|
|
|
|
public boolean ieExitRel(String code, String orderId) {
|
|
|
boolean ret = false;
|
|
|
RelCodeDetailResponse relCodeDetail = relCodeDetailService.findByCode(code);
|
|
|
if (relCodeDetail != null) {
|
|
|
//判断是否存在关联关系：1.先判断当前单号是否存在父码，若存在则表示存在关联关系重复扫码
|
|
|
if (StrUtil.isNotEmpty(relCodeDetail.getParentCode())) {
|
|
|
ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
|
|
|
if (!ret) {
|
|
|
relCodeDetail = relCodeDetailService.findByCode(relCodeDetail.getParentCode());
|
|
|
ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
|
|
|
}
|
|
|
}
|
|
|
if (ret)
|
|
|
return true;
|
|
|
//若父码不存在，判断当前单号是否存在当前码的子码，若存在则表示存在关联关系重复扫码
|
|
|
ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getParentCode, code));
|
|
|
if (!ret) {
|
|
|
ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getGrantPaCode, code));
|
|
|
}
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
IoCodeService ioCodeService;
|
|
|
|
|
|
public BaseResponse findCodes(FilterCodeRequest filterCodeRequest) {
|
|
|
List<IoCodeResponse> ioCodeResponses = ioCodeService.filterList(filterCodeRequest);
|
|
|
PageInfo<IoCodeResponse> pageInfo = new PageInfo<>(ioCodeResponses);
|
|
|
PageSimpleResponse<IoCodeResponse> pageSimpleResponse = new PageSimpleResponse<>();
|
|
|
pageSimpleResponse.setTotal(pageInfo.getTotal());
|
|
|
pageSimpleResponse.setList(pageInfo.getList());
|
|
|
return ResultVOUtils.success(pageSimpleResponse);
|
|
|
}
|
|
|
|
|
|
public Integer selectMaxGroupNumber() {
|
|
|
return ioCodeTempDao.selectMaxGroupNumber();
|
|
|
}
|
|
|
|
|
|
public IoCodeTempEntity selectOone(FilterCodeRequest filterCodeRequest) {
|
|
|
return ioCodeTempDao.selectOne(new LambdaQueryWrapper<IoCodeTempEntity>()
|
|
|
.eq(IoCodeTempEntity::getCode,filterCodeRequest.getCode())
|
|
|
.eq(IoCodeTempEntity::getQueueCode,filterCodeRequest.getQueueCode())
|
|
|
.eq(IoCodeTempEntity::getAction,"SC72197936495755")
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public List<IoCodeTempEntity> selectListByGroupNumber(Integer groupNumber) {
|
|
|
return ioCodeTempDao.selectList(new LambdaQueryWrapper<IoCodeTempEntity>()
|
|
|
.eq(IoCodeTempEntity::getGroupNumber,groupNumber)
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public BaseResponse checkRedundant(AddEnterCodeRequest addEnterCodeRequest,String newCode,String originCode) {
|
|
|
String tempOriginCode = addEnterCodeRequest.getOriginCode();
|
|
|
if (tempOriginCode.endsWith("\u001D")) {
|
|
|
tempOriginCode = tempOriginCode.replace("\u001D", "");
|
|
|
}
|
|
|
UdiEntity originUdiEntity = FilterUdiUtils.getUdi(tempOriginCode);
|
|
|
if (StrUtil.isNotEmpty(newCode)) {
|
|
|
if (newCode.startsWith("10")) {
|
|
|
if (StrUtil.isNotEmpty(originUdiEntity.getBatchNo())) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "批次号重复添加");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
} else {
|
|
|
String msg = checkNewCode(originUdiEntity, newCode);
|
|
|
if (msg != null) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, msg);
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
} else if (newCode.startsWith("17")) {
|
|
|
if (StrUtil.isNotEmpty(originUdiEntity.getExpireDate())) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "失效日期重复添加");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
} else {
|
|
|
String msg = checkNewCode(originUdiEntity, newCode);
|
|
|
if (msg != null) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, msg);
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
} else if (newCode.startsWith("11")) {
|
|
|
if (StrUtil.isNotEmpty(originUdiEntity.getProduceDate())) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "生产日期重复添加");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
} else {
|
|
|
String msg = checkNewCode(originUdiEntity, newCode);
|
|
|
if (msg != null) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, msg);
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
} else if (newCode.startsWith("21")) {
|
|
|
if (StrUtil.isNotEmpty(originUdiEntity.getSerialNo())) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "序列号重复添加");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
} else {
|
|
|
String msg = checkNewCode(originUdiEntity, newCode);
|
|
|
if (msg != null) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, msg);
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "格式错误");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
|
|
|
public String checkNewCode(UdiEntity originEnity, String newCode) {
|
|
|
UdiEntity newEntity = FilterUdiUtils.getUdi(originEnity.getUdi() + newCode);
|
|
|
if (newEntity == null || originEnity == null) {
|
|
|
return null;
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(originEnity.getBatchNo()) && StrUtil.isNotEmpty(newEntity.getBatchNo())) {
|
|
|
return "批次号重复添加！";
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(originEnity.getProduceDate()) && StrUtil.isNotEmpty(newEntity.getProduceDate())) {
|
|
|
return "生产日期重复添加！";
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(originEnity.getExpireDate()) && StrUtil.isNotEmpty(newEntity.getExpireDate())) {
|
|
|
return "失效日期重复添加！";
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(originEnity.getSerialNo()) && StrUtil.isNotEmpty(newEntity.getSerialNo())) {
|
|
|
return "序列号重复添加！";
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
|
|
|
@Autowired
|
|
|
private SystemParamConfigService systemParamConfigService;
|
|
|
|
|
|
@Autowired
|
|
|
UdiProductService udiProductService;
|
|
|
public BaseResponse checkFormat(String code,String originCode) {
|
|
|
// TODO: 2024/9/13 首次无单进入的时候报错提示，不需要执行校验
|
|
|
UdiEntity udiEntity = FilterUdiUtils.getUdi(code);
|
|
|
if (udiEntity == null) {
|
|
|
String sptmtodi = systemParamConfigService.selectValueByParamKey(Constant.SPTM_TO_DI);
|
|
|
if (sptmtodi.equals("1")) {
|
|
|
if (code.length() == 13) {
|
|
|
UdiProductEntity udiProductEntity = udiProductService.findBySptm(code);
|
|
|
if (udiProductEntity != null) {
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(508, "追溯码格式错误");
|
|
|
baseResponse.setData(udiProductEntity);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(501, "追溯码格式错误");
|
|
|
baseResponse.setData(originCode);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
return ResultVOUtils.success(udiEntity);
|
|
|
}
|
|
|
|
|
|
public BaseResponse checkCode(UdiEntity udiEntity,String code,UdiRelevanceResponse checkUdi,String newCode) {
|
|
|
boolean checkSuccess = true;
|
|
|
String lostMsg = "";
|
|
|
//校验条码完整性
|
|
|
if ("是".equals(checkUdi.getScbssfbhph()) && StrUtil.isEmpty(udiEntity.getBatchNo())) {
|
|
|
checkSuccess = false;
|
|
|
lostMsg = lostMsg + ",批次号";
|
|
|
}
|
|
|
if ("是".equals(checkUdi.getScbssfbhscrq()) && StrUtil.isEmpty(udiEntity.getProduceDate())) {
|
|
|
checkSuccess = false;
|
|
|
lostMsg = lostMsg + ",生产日期";
|
|
|
}
|
|
|
|
|
|
if ("是".equals(checkUdi.getScbssfbhsxrq()) && StrUtil.isEmpty(udiEntity.getExpireDate())) {
|
|
|
checkSuccess = false;
|
|
|
lostMsg = lostMsg + ",失效日期";
|
|
|
}
|
|
|
if (checkUdi.getAllowNoSerial() != null && !checkUdi.getAllowNoSerial() && StrUtil.isEmpty(udiEntity.getSerialNo())
|
|
|
) {
|
|
|
checkSuccess = false;
|
|
|
lostMsg = lostMsg + ",序列号";
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(udiEntity.getSerialNo()) && udiEntity.getSerialNo().length() > 20) {
|
|
|
return ResultVOUtils.error(504, "序列号超出20位！");
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(udiEntity.getBatchNo()) && udiEntity.getBatchNo().length() > 20) {
|
|
|
return ResultVOUtils.error(504, "批次号超出20位！");
|
|
|
}
|
|
|
if (StrUtil.isEmpty(udiEntity.getSerialNo()) && StrUtil.isEmpty(udiEntity.getBatchNo())) {
|
|
|
checkSuccess = false;
|
|
|
}
|
|
|
if (checkSuccess) {
|
|
|
if (code.endsWith("\u001D")) {
|
|
|
code = code.substring(0, code.length() - "\u001D".length());
|
|
|
}
|
|
|
udiEntity.setCode(code);
|
|
|
AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
|
|
|
return ResultVOUtils.success(addEnterCodeResponse);
|
|
|
} else {
|
|
|
if (newCode.startsWith("21") || (StrUtil.isNotEmpty(udiEntity.getSerialNo()) && newCode.contains("21" + udiEntity.getSerialNo()))) {
|
|
|
if (StrUtil.isEmpty(lostMsg)) {
|
|
|
lostMsg = ",";
|
|
|
}
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(503, "条码完整性错误,缺少" + lostMsg.substring(1) + "是否继续添加？");
|
|
|
udiEntity.setCode(code);
|
|
|
AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
|
|
|
baseResponse.setData(addEnterCodeResponse);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
}
|
|
|
BaseResponse baseResponse = ResultVOUtils.error(502, "校验未完成,缺少" + lostMsg.substring(1));
|
|
|
udiEntity.setCode(code);
|
|
|
AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
|
|
|
baseResponse.setData(addEnterCodeResponse);
|
|
|
return baseResponse;
|
|
|
}
|
|
|
|
|
|
public AddEnterCodeResponse setAddEnterCodeResponse(UdiEntity udiEntity, UdiRelevanceResponse checkUdi) {
|
|
|
AddEnterCodeResponse addEnterCodeResponse = new AddEnterCodeResponse();
|
|
|
BeanUtils.copyProperties(udiEntity, addEnterCodeResponse);
|
|
|
addEnterCodeResponse.setBzgg(checkUdi.getBzgg());
|
|
|
addEnterCodeResponse.setCpmctymc(checkUdi.getCpmctymc());
|
|
|
addEnterCodeResponse.setPrepnSpec(checkUdi.getPrepnSpec());
|
|
|
addEnterCodeResponse.setPrepnUnit(checkUdi.getPrepnUnit());
|
|
|
addEnterCodeResponse.setPackUnit(checkUdi.getPackUnit());
|
|
|
addEnterCodeResponse.setGgxh(checkUdi.getGgxh());
|
|
|
return addEnterCodeResponse;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 批量插入码信息
|
|
|
* @param entities 码信息实体列表
|
|
|
* @return 是否成功
|
|
|
*/
|
|
|
public boolean batchInsert(List<IoCodeTempEntity> entities) {
|
|
|
if (CollUtil.isEmpty(entities)) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// 分批插入，每批最多500条
|
|
|
int batchSize = 500;
|
|
|
int totalSize = entities.size();
|
|
|
boolean result = true;
|
|
|
|
|
|
for (int i = 0; i < totalSize; i += batchSize) {
|
|
|
int end = Math.min(i + batchSize, totalSize);
|
|
|
List<IoCodeTempEntity> batch = entities.subList(i, end);
|
|
|
result = result && ioCodeTempDao.insertBatch(batch);
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 批量更新码信息
|
|
|
* @param entities 码信息实体列表
|
|
|
* @return 受影响的行数
|
|
|
*/
|
|
|
public int batchUpdate(List<IoCodeTempEntity> entities) {
|
|
|
if (CollUtil.isEmpty(entities)) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int updatedRows = 0;
|
|
|
for (IoCodeTempEntity entity : entities) {
|
|
|
updatedRows += ioCodeTempDao.updateById(entity);
|
|
|
}
|
|
|
|
|
|
return updatedRows;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 批量检查码是否存在
|
|
|
* @param codes 码列表
|
|
|
* @param orderId 订单ID
|
|
|
* @return 存在的码实体映射
|
|
|
*/
|
|
|
public Map<String, IoCodeTempEntity> batchCheckCodesExistence(List<String> codes, String orderId) {
|
|
|
if (CollUtil.isEmpty(codes) || StrUtil.isEmpty(orderId)) {
|
|
|
return new HashMap<>();
|
|
|
}
|
|
|
|
|
|
List<IoCodeTempEntity> existingEntities = selectByCodes(codes, orderId);
|
|
|
if (CollUtil.isEmpty(existingEntities)) {
|
|
|
return new HashMap<>();
|
|
|
}
|
|
|
|
|
|
Map<String, IoCodeTempEntity> codeToEntityMap = new HashMap<>();
|
|
|
for (IoCodeTempEntity entity : existingEntities) {
|
|
|
codeToEntityMap.put(entity.getCode(), entity);
|
|
|
}
|
|
|
|
|
|
return codeToEntityMap;
|
|
|
}
|
|
|
}
|
