|
|
package com.glxp.api.service.inout;
|
|
|
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
|
import cn.hutool.core.thread.ThreadUtil;
|
|
|
import cn.hutool.core.util.IdUtil;
|
|
|
import cn.hutool.core.util.StrUtil;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
|
|
import com.github.pagehelper.PageHelper;
|
|
|
import com.glxp.api.constant.Constant;
|
|
|
import com.glxp.api.dao.inout.IoSplitCodeMapper;
|
|
|
import com.glxp.api.entity.basic.SysWorkplacePutRel;
|
|
|
import com.glxp.api.entity.basic.UdiRelevanceEntity;
|
|
|
import com.glxp.api.entity.collect.*;
|
|
|
import com.glxp.api.entity.inout.IoSplitCodeEntity;
|
|
|
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
|
|
|
import com.glxp.api.entity.inout.IoSplitFifoInv;
|
|
|
import com.glxp.api.exception.JsonException;
|
|
|
import com.glxp.api.req.basic.FilterUdiRelRequest;
|
|
|
import com.glxp.api.req.collect.AddInvDesDetaiRequest;
|
|
|
import com.glxp.api.req.collect.CollectOrderRequest;
|
|
|
import com.glxp.api.req.inout.IoSplitCodeRequest;
|
|
|
import com.glxp.api.res.basic.UdiRelevanceResponse;
|
|
|
import com.glxp.api.res.collect.ConfirmResponse;
|
|
|
import com.glxp.api.service.basic.UdiRelevanceService;
|
|
|
import com.glxp.api.service.collect.*;
|
|
|
import com.glxp.api.service.thrsys.SysWorkplacePutRelService;
|
|
|
import com.glxp.api.util.GennerOrderUtils;
|
|
|
import com.glxp.api.util.IntUtil;
|
|
|
import com.glxp.api.util.OrderNoTypeBean;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
|
|
import javax.annotation.Resource;
|
|
|
import java.util.*;
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
/**
|
|
|
* 拆零码明细
|
|
|
*/
|
|
|
@Service
|
|
|
public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCodeEntity> {
|
|
|
|
|
|
@Resource
|
|
|
IoSplitCodeMapper splitCodeMapper;
|
|
|
@Resource
|
|
|
IoSplitFifoCodeService splitFifoCodeService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizService collectOrderBizService;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeAutoService collectOrderCodeAutoService;
|
|
|
@Resource
|
|
|
IoSplitDesOrderService splitDesOrderService;
|
|
|
@Resource
|
|
|
IoSplitDesOrderDetailService splitDesOrderDetailService;
|
|
|
@Resource
|
|
|
GennerOrderUtils gennerOrderUtils;
|
|
|
|
|
|
@Resource
|
|
|
UdiRelevanceService udiRelevanceService;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeManService collectOrderCodeManService;
|
|
|
@Resource
|
|
|
IoSplitCodeService splitCodeService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
|
|
|
@Resource
|
|
|
IoSplitFifoInvService splitFifoInvService;
|
|
|
|
|
|
@Resource
|
|
|
IoCollectLedGroupService ioCollectLedGroupService;
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
SysWorkplacePutRelService workplacePutRelService;
|
|
|
|
|
|
public List<IoSplitCodeEntity> filterList(IoSplitCodeRequest splitCodeRequest) {
|
|
|
if (splitCodeRequest == null) {
|
|
|
return Collections.emptyList();
|
|
|
}
|
|
|
if (splitCodeRequest.getPage() != null) {
|
|
|
int offset = (splitCodeRequest.getPage() - 1) * splitCodeRequest.getLimit();
|
|
|
PageHelper.offsetPage(offset, splitCodeRequest.getLimit());
|
|
|
}
|
|
|
return super.baseMapper.filterList(splitCodeRequest);
|
|
|
|
|
|
}
|
|
|
|
|
|
public List<IoSplitCodeEntity> findSplitCodes(Long relId, String batchNo, Long workPlaceCode) {
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
|
|
|
.eq(IoSplitCodeEntity::getRelId, relId)
|
|
|
.eq(StrUtil.isNotEmpty(batchNo), IoSplitCodeEntity::getBatchNo, batchNo)
|
|
|
.eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
|
|
|
.gt(IoSplitCodeEntity::getRemainCount, 0)
|
|
|
.in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
|
|
|
return ioSplitCodeEntities;
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoSplitCodeEntity> findSplitCodes(String ybbm, String batchNo, Long workPlaceCode) {
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
|
|
|
.eq(StrUtil.isNotEmpty(batchNo), IoSplitCodeEntity::getBatchNo, batchNo)
|
|
|
.eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
|
|
|
.gt(IoSplitCodeEntity::getRemainCount, 0)
|
|
|
.in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
|
|
|
return ioSplitCodeEntities;
|
|
|
}
|
|
|
|
|
|
public IoSplitCodeEntity findByCode(String code, Long workPlaceCode) {
|
|
|
if (workPlaceCode == null) {
|
|
|
return null;
|
|
|
}
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
|
|
|
.eq(IoSplitCodeEntity::getCode, code)
|
|
|
.eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
|
|
|
.in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
|
|
|
if (CollUtil.isNotEmpty(ioSplitCodeEntities))
|
|
|
return ioSplitCodeEntities.get(0);
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
public IoSplitCodeEntity findByCode(String code) {
|
|
|
return splitCodeMapper.selectOne(new LambdaQueryWrapper<IoSplitCodeEntity>()
|
|
|
.eq(IoSplitCodeEntity::getCode, code).last("limit 1"));
|
|
|
}
|
|
|
|
|
|
public void splitRemove(IoCollectOrderBiz collectOrderBiz, IoCollectOrder collectOrder, Long putWorkPlaceCode, Boolean isAuto, String confirmSplitCode) {
|
|
|
//1.按照先进先出原则，查询拆零表，获取拆零表ID
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
|
|
|
//2.如果拆零表为空，则自动从预出库队列中获拉取数据
|
|
|
if (CollUtil.isEmpty(ioSplitCodeEntities)) {
|
|
|
addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), IntUtil.value(collectOrderBiz.getUnTagCount()), putWorkPlaceCode, confirmSplitCode);
|
|
|
ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
}
|
|
|
//3.如果拆零表不为空，则开始扣除数量
|
|
|
int count = 0;
|
|
|
int unCount = 0; //剩余未扣减数量
|
|
|
unCount = IntUtil.value(collectOrderBiz.getUnTagCount());
|
|
|
for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
|
|
|
count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
|
|
|
collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
|
|
|
.codeIdFk(ioSplitCodeEntity.getId())
|
|
|
.udiCode(ioSplitCodeEntity.getCode())
|
|
|
.orderIdFk(collectOrder.getBillNo())
|
|
|
.batchNo(ioSplitCodeEntity.getBatchNo())
|
|
|
.productDate(ioSplitCodeEntity.getProduceDate())
|
|
|
.expireDate(ioSplitCodeEntity.getExpireDate())
|
|
|
.serialNo(ioSplitCodeEntity.getSerialNo())
|
|
|
.relId(collectOrderBiz.getRelId())
|
|
|
.bizIdFk(collectOrderBiz.getId())
|
|
|
.fifoSplit(1)
|
|
|
.createTime(new Date())
|
|
|
.updateTime(new Date())
|
|
|
.build());
|
|
|
if (count > 0) {
|
|
|
ioSplitCodeEntity.setRemainCount(count);
|
|
|
unCount = 0;
|
|
|
splitCodeMapper.updateById(ioSplitCodeEntity);
|
|
|
break;
|
|
|
} else if (count == 0) {
|
|
|
ioSplitCodeEntity.setRemainCount(0);
|
|
|
unCount = 0;
|
|
|
} else {
|
|
|
ioSplitCodeEntity.setRemainCount(0);
|
|
|
unCount = -count;
|
|
|
}
|
|
|
splitCodeMapper.updateById(ioSplitCodeEntity);
|
|
|
}
|
|
|
|
|
|
if (unCount > 0) {
|
|
|
//4.拆零表数量不足，则从预出库队列中获取数据
|
|
|
Integer fifoCount = addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), unCount, putWorkPlaceCode, confirmSplitCode);
|
|
|
if (fifoCount == 0) {
|
|
|
//预出库队列数量不足
|
|
|
collectOrderBiz.setTagStatus(2);
|
|
|
collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
|
|
|
if (isAuto)
|
|
|
throw new JsonException(500, "提交失败，工位库存数量不足！");
|
|
|
else return;
|
|
|
|
|
|
} else {
|
|
|
//再次执行赋码
|
|
|
ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
|
|
|
if (IntUtil.value(ioSplitCodeEntity.getRemainCount()) > 0) {
|
|
|
count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
|
|
|
collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
|
|
|
.codeIdFk(ioSplitCodeEntity.getId())
|
|
|
.udiCode(ioSplitCodeEntity.getCode())
|
|
|
.orderIdFk(collectOrder.getBillNo())
|
|
|
.batchNo(ioSplitCodeEntity.getBatchNo())
|
|
|
.productDate(ioSplitCodeEntity.getProduceDate())
|
|
|
.expireDate(ioSplitCodeEntity.getExpireDate())
|
|
|
.serialNo(ioSplitCodeEntity.getSerialNo())
|
|
|
.relId(collectOrderBiz.getRelId())
|
|
|
.bizIdFk(collectOrderBiz.getId())
|
|
|
.fifoSplit(1)
|
|
|
.createTime(new Date())
|
|
|
.updateTime(new Date())
|
|
|
.build());
|
|
|
if (count > 0) {
|
|
|
ioSplitCodeEntity.setRemainCount(count);
|
|
|
splitCodeMapper.updateById(ioSplitCodeEntity);
|
|
|
unCount = 0;
|
|
|
break;
|
|
|
} else if (count == 0) {
|
|
|
ioSplitCodeEntity.setRemainCount(0);
|
|
|
unCount = 0;
|
|
|
splitCodeMapper.updateById(ioSplitCodeEntity);
|
|
|
} else {
|
|
|
ioSplitCodeEntity.setRemainCount(0);
|
|
|
splitCodeMapper.updateById(ioSplitCodeEntity);
|
|
|
unCount = -count;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (unCount > 0) {
|
|
|
collectOrderBiz.setTagStatus(2);
|
|
|
collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
|
|
|
if (isAuto)
|
|
|
throw new JsonException(500, "工位库存数量不足！");
|
|
|
else return;
|
|
|
} else {
|
|
|
collectOrderBiz.setTagStatus(3);
|
|
|
collectOrderBiz.setTagMsg("赋码完成！");
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
collectOrderBiz.setTagStatus(3);
|
|
|
collectOrderBiz.setTagMsg("赋码完成！");
|
|
|
}
|
|
|
collectOrderBiz.setUnTagCount(unCount);
|
|
|
collectOrderBizService.updateById(collectOrderBiz);
|
|
|
}
|
|
|
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void finishAutoTagCode(IoCollectOrder collectOrder, Boolean isAuto, String queueCode) {
|
|
|
|
|
|
SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
Long putWorkPlaceCode = null;
|
|
|
if (sysWorkplacePutRel != null)
|
|
|
putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
|
|
|
//如果手动扫码判断该码是否在队列里，如果已在队列，则队列里剔除
|
|
|
List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
|
|
|
if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
|
|
|
for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodeMEN) {
|
|
|
IoSplitFifoCodeEntity splitFifoCodeEntity = splitFifoCodeService.findByCode(collectOrderCodeMan.getUdiCode(), putWorkPlaceCode);
|
|
|
if (splitFifoCodeEntity != null) {
|
|
|
collectOrderCodeMan.setRemoveFlag(true);
|
|
|
if (IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()) <= 0) {
|
|
|
splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
|
|
|
IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
|
|
|
if (splitFifoInv != null) {
|
|
|
splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
|
|
|
splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(splitFifoCodeEntity.getScanCount()));
|
|
|
int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
|
|
|
splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
|
|
|
splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
|
|
|
splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInvService.updateById(splitFifoInv);
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
//队列码数量大于扫码数量更新数量（一般指无序列号）
|
|
|
// UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderCodeMan.getRelId());
|
|
|
FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
|
|
|
filterUdiRelRequest.setId(collectOrderCodeMan.getRelId());
|
|
|
filterUdiRelRequest.setPackLevel("1");
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
|
|
|
int removeCount = IntUtil.value(collectOrderCodeMan.getScanCount()) * udiRelevanceResponse.getBhxjsl();
|
|
|
splitFifoCodeService.updateById(IoSplitFifoCodeEntity.builder()
|
|
|
.id(splitFifoCodeEntity.getId())
|
|
|
.scanCount(IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()))
|
|
|
.totalCount(IntUtil.value(splitFifoCodeEntity.getTotalCount()) - removeCount)
|
|
|
.build());
|
|
|
|
|
|
IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
|
|
|
if (splitFifoInv != null) {
|
|
|
splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + removeCount);
|
|
|
splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(collectOrderCodeMan.getScanCount()));
|
|
|
int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - removeCount;
|
|
|
splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
|
|
|
splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
|
|
|
splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInvService.updateById(splitFifoInv);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//判断拆零表里是否存在，如果存在则剔除
|
|
|
IoSplitCodeEntity splitCodeEntity = splitCodeService.findByCode(collectOrderCodeMan.getUdiCode(), putWorkPlaceCode);
|
|
|
if (splitCodeEntity != null && IntUtil.value(splitCodeEntity.getRemainCount()) > 0) {
|
|
|
if (IntUtil.value(splitCodeEntity.getRemainCount()) > IntUtil.value(collectOrderCodeMan.getScanActCount())) {
|
|
|
splitCodeEntity.setRemainCount(IntUtil.value(splitCodeEntity.getRemainCount()) - IntUtil.value(collectOrderCodeMan.getScanActCount()));
|
|
|
} else {
|
|
|
splitCodeEntity.setRemainCount(0);
|
|
|
}
|
|
|
collectOrderCodeMan.setSplitFlag(true);
|
|
|
splitCodeService.updateById(splitCodeEntity);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
|
|
|
// UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderBiz.getRelId());
|
|
|
FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
|
|
|
filterUdiRelRequest.setId(collectOrderBiz.getRelId());
|
|
|
filterUdiRelRequest.setPackLevel("1");
|
|
|
//todo 后面可以 没有搜索到层级为1的
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
|
|
|
//去除掉已经手动扫码的数据，找出需要自动扫码的明细，执行上述的拆零或整取
|
|
|
int unTagCount = collectOrderBiz.getCount() - IntUtil.value(collectOrderBiz.getScanActCount());
|
|
|
if (unTagCount > 0) {
|
|
|
collectOrderBiz.setUnTagCount(unTagCount);
|
|
|
} else {
|
|
|
collectOrderBiz.setTagStatus(3);
|
|
|
//手动扫码时涉及到拆零时，把拆零剩余数量插入至拆零表里
|
|
|
if (unTagCount < 0) {
|
|
|
List<IoCollectOrderCodeMan> newList = filterCode(collectOrderCodeMEN, collectOrderBiz, udiRelevanceResponse);
|
|
|
if (CollUtil.isNotEmpty(newList)) {
|
|
|
for (IoCollectOrderCodeMan item : newList) {
|
|
|
if (IntUtil.value(item.getSplitFlag())) {
|
|
|
IoSplitCodeEntity splitCodeEntity = splitCodeService.findByCode(item.getUdiCode(), putWorkPlaceCode);
|
|
|
splitCodeEntity.setRemainCount(-unTagCount);
|
|
|
splitCodeService.updateById(splitCodeEntity);
|
|
|
} else {
|
|
|
IoSplitCodeEntity ioSplitCodeEntity = IoSplitCodeEntity.builder().code(item.getUdiCode())
|
|
|
.errUdiCode(item.getUdiCode())
|
|
|
.orderId(item.getOrderIdFk())
|
|
|
.action(collectOrder.getBusType())
|
|
|
.relId(item.getRelId())
|
|
|
.nameCode(item.getNameCode())
|
|
|
.batchNo(item.getBatchNo())
|
|
|
.produceDate(item.getProductDate())
|
|
|
.expireDate(item.getExpireDate())
|
|
|
.serialNo(item.getSerialNo())
|
|
|
.scanCount(item.getScanCount())
|
|
|
.totalCount(item.getScanCount())
|
|
|
.workPlaceCode(putWorkPlaceCode)
|
|
|
.status(2)
|
|
|
.fifoSplit(1)
|
|
|
.createTime(new Date()).updateTime(new Date())
|
|
|
.remainCount(item.getRemainCount()).build();
|
|
|
this.decorateUnpackExpireTime(ioSplitCodeEntity);
|
|
|
splitCodeService.save(ioSplitCodeEntity);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
int quotient = 0;
|
|
|
int remainder = 0;
|
|
|
if (IntUtil.value(udiRelevanceResponse.getBhxjsl()) != 0) {
|
|
|
quotient = collectOrderBiz.getUnTagCount() / IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
remainder = collectOrderBiz.getUnTagCount() % IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
}
|
|
|
//2.如果整盒，从工位队列扣除 默认最后一个追溯码拆零
|
|
|
if (quotient > 0) {
|
|
|
List<IoSplitFifoCodeEntity> ioSplitFifoCodeEntities = splitFifoCodeService.findByRelId(putWorkPlaceCode, collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
|
|
|
if (ioSplitFifoCodeEntities.size() < quotient) {
|
|
|
if (isAuto)
|
|
|
throw new JsonException(500, "提交失败，工位库存数量不足！");
|
|
|
// else return;
|
|
|
}
|
|
|
if (ioSplitFifoCodeEntities.size() > 0) {
|
|
|
Integer indexFlag = ioSplitFifoCodeEntities.size() < quotient ?ioSplitFifoCodeEntities.size():quotient;
|
|
|
for (int i = 0; i < indexFlag; i++) {
|
|
|
IoSplitFifoCodeEntity splitFifoCodeEntity = ioSplitFifoCodeEntities.get(i);
|
|
|
collectOrderBiz.setUnTagCount(IntUtil.value(collectOrderBiz.getUnTagCount()) - IntUtil.value(udiRelevanceResponse.getBhxjsl()));
|
|
|
collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
|
|
|
.codeIdFk(splitFifoCodeEntity.getId())
|
|
|
.udiCode(splitFifoCodeEntity.getCode())
|
|
|
.orderIdFk(collectOrder.getBillNo())
|
|
|
.batchNo(splitFifoCodeEntity.getBatchNo())
|
|
|
.productDate(splitFifoCodeEntity.getProduceDate())
|
|
|
.expireDate(splitFifoCodeEntity.getExpireDate())
|
|
|
.serialNo(splitFifoCodeEntity.getSerialNo())
|
|
|
.relId(collectOrderBiz.getRelId())
|
|
|
.bizIdFk(collectOrderBiz.getId())
|
|
|
.fifoSplit(2)
|
|
|
.createTime(new Date())
|
|
|
.updateTime(new Date())
|
|
|
.build());
|
|
|
splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
|
|
|
IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
|
|
|
if (splitFifoInv != null) {
|
|
|
splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
|
|
|
splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(splitFifoCodeEntity.getScanCount()));
|
|
|
int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
|
|
|
splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
|
|
|
splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
|
|
|
splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInvService.updateById(splitFifoInv);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
//.如果拆零，拆零表扣除
|
|
|
if (remainder > 0) {
|
|
|
splitRemove(collectOrderBiz, collectOrder, putWorkPlaceCode, isAuto, null);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
|
|
|
for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs) {
|
|
|
IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
|
|
|
BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
|
|
|
ioCollectOrderBizBackup.setId(IdUtil.getSnowflake().nextId());
|
|
|
ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
|
|
|
}
|
|
|
ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderService collectOrderService;
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public ConfirmResponse confirmBizAutiTagCode(IoCollectOrderBiz collectOrderBiz, String queueCode, String confirmSplitCode, Boolean skipSplitConfirm) {
|
|
|
ConfirmResponse confirmResponse = new ConfirmResponse();
|
|
|
IoCollectOrder collectOrder = collectOrderService.getByBillNo(collectOrderBiz.getOrderIdFk());
|
|
|
if (collectOrder == null) {
|
|
|
throw new JsonException(500, "提交失败，未找到对应的单据！");
|
|
|
}
|
|
|
SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
Long putWorkPlaceCode = null;
|
|
|
if (sysWorkplacePutRel != null)
|
|
|
putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
|
|
|
FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
|
|
|
filterUdiRelRequest.setId(collectOrderBiz.getRelId());
|
|
|
filterUdiRelRequest.setPackLevel("1");
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
|
|
|
//去除掉已经手动扫码的数据，找出需要自动扫码的明细，执行上述的拆零或整取
|
|
|
int unTagCount = collectOrderBiz.getCount() - IntUtil.value(collectOrderBiz.getScanActCount());
|
|
|
if (unTagCount > 0) {
|
|
|
collectOrderBiz.setUnTagCount(unTagCount);
|
|
|
}
|
|
|
int quotient = 0;
|
|
|
int remainder = 0;
|
|
|
if (IntUtil.value(udiRelevanceResponse.getBhxjsl()) != 0) {
|
|
|
quotient = collectOrderBiz.getUnTagCount() / IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
remainder = collectOrderBiz.getUnTagCount() % IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
}
|
|
|
|
|
|
// 获取所有可用的码列表
|
|
|
List<IoSplitFifoCodeEntity> availableCodes = splitFifoCodeService.findByRelId(putWorkPlaceCode, collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
|
|
|
|
|
|
IoSplitFifoCodeEntity confirmSplitCodeEntity = null;
|
|
|
if (CollUtil.isNotEmpty(availableCodes) && StrUtil.isNotEmpty(confirmSplitCode)) {
|
|
|
// 如果有确认的拆零码，直接使用
|
|
|
String finalConfirmSplitCode = confirmSplitCode;
|
|
|
confirmSplitCodeEntity = availableCodes.stream().filter(code -> StrUtil.equals(code.getCode(), finalConfirmSplitCode)).findFirst().orElse(null);
|
|
|
if (confirmSplitCodeEntity == null) {
|
|
|
throw new JsonException(500, "找不到指定的拆零码");
|
|
|
} else {
|
|
|
availableCodes.remove(confirmSplitCodeEntity);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 检查是否有足够的拆零数量
|
|
|
boolean hasEnoughSplitCount = false;
|
|
|
if (remainder > 0 && CollUtil.isNotEmpty(availableCodes)) {
|
|
|
// 获取第一个码的可用数量
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
|
|
|
int firstCodeAvailableCount = IntUtil.value(ioSplitCodeEntities.get(0).getRemainCount());
|
|
|
hasEnoughSplitCount = firstCodeAvailableCount >= remainder;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 判断是否需要拆零确认：整箱数量大于1且有拆零数量且没有足够的拆零数量
|
|
|
boolean needSplitConfirm = quotient > 0 && remainder > 0 && !hasEnoughSplitCount;
|
|
|
|
|
|
// 如果是第一次调用（confirmSplitCode为空）且需要拆零确认且不跳过拆零确认，只返回拆零信息
|
|
|
if (StrUtil.isEmpty(confirmSplitCode) && needSplitConfirm && !IntUtil.value(skipSplitConfirm)) {
|
|
|
if (CollUtil.isNotEmpty(availableCodes)) {
|
|
|
// 需要的总数量：整箱数量 + 拆零数量
|
|
|
int totalNeededCount = quotient + (remainder > 0 ? 1 : 0);
|
|
|
|
|
|
// 如果可用码数量小于需要的数量，直接报错
|
|
|
if (availableCodes.size() < totalNeededCount) {
|
|
|
throw new JsonException(500, "可用码数量不足！需要" + totalNeededCount + "个码，但只有" + availableCodes.size() + "个可用码。");
|
|
|
}
|
|
|
|
|
|
// 只返回需要的码数量
|
|
|
List<String> codeInfoList = availableCodes.stream()
|
|
|
// .limit(totalNeededCount) // 只取需要的数量
|
|
|
.map(code -> {
|
|
|
return code.getCode();
|
|
|
})
|
|
|
.collect(Collectors.toList());
|
|
|
if (CollUtil.isNotEmpty(codeInfoList)) {
|
|
|
confirmResponse.setNeedSplitConfirm(true);
|
|
|
confirmResponse.setNeedSplitCodes(codeInfoList);
|
|
|
return confirmResponse;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 执行实际的确认操作
|
|
|
//2.如果整盒，从工位队列扣除 默认最后一个追溯码拆零
|
|
|
if (quotient > 0) {
|
|
|
if (availableCodes.size() < quotient) {
|
|
|
throw new JsonException(500, "确认失败，工位库存数量不足！");
|
|
|
}
|
|
|
for (int i = 0; i < quotient; i++) {
|
|
|
IoSplitFifoCodeEntity splitFifoCodeEntity = availableCodes.get(i);
|
|
|
collectOrderBiz.setUnTagCount(IntUtil.value(collectOrderBiz.getUnTagCount()) - IntUtil.value(udiRelevanceResponse.getBhxjsl()));
|
|
|
collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
|
|
|
.codeIdFk(splitFifoCodeEntity.getId())
|
|
|
.udiCode(splitFifoCodeEntity.getCode())
|
|
|
.orderIdFk(collectOrder.getBillNo())
|
|
|
.batchNo(splitFifoCodeEntity.getBatchNo())
|
|
|
.productDate(splitFifoCodeEntity.getProduceDate())
|
|
|
.expireDate(splitFifoCodeEntity.getExpireDate())
|
|
|
.serialNo(splitFifoCodeEntity.getSerialNo())
|
|
|
.relId(collectOrderBiz.getRelId())
|
|
|
.bizIdFk(collectOrderBiz.getId())
|
|
|
.fifoSplit(2)
|
|
|
.createTime(new Date())
|
|
|
.updateTime(new Date())
|
|
|
.build());
|
|
|
splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
|
|
|
IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
|
|
|
if (splitFifoInv != null) {
|
|
|
splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
|
|
|
splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(splitFifoCodeEntity.getScanCount()));
|
|
|
int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
|
|
|
splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
|
|
|
splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
|
|
|
splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInvService.updateById(splitFifoInv);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//.如果拆零，拆零表扣除
|
|
|
if (remainder > 0) {
|
|
|
if (confirmSplitCode == null && (IntUtil.value(skipSplitConfirm) || !needSplitConfirm)) {
|
|
|
// 如果跳过拆零确认或不需要拆零确认，直接使用第一个可用的拆零码
|
|
|
if (CollUtil.isEmpty(availableCodes)) {
|
|
|
throw new JsonException(500, "没有可用的拆零码！");
|
|
|
}
|
|
|
confirmSplitCode = availableCodes.get(quotient).getCode(); // 使用整箱之后的下一个码
|
|
|
}
|
|
|
splitRemove(collectOrderBiz, collectOrder, putWorkPlaceCode, true, confirmSplitCode);
|
|
|
}
|
|
|
|
|
|
if (collectOrderBiz.getTagStatus() == 2) {
|
|
|
throw new JsonException(500, "确认失败，工位库存数量不足！");
|
|
|
} else {
|
|
|
collectOrderBiz.setGetConfirm(true);
|
|
|
collectOrderBizService.updateById(collectOrderBiz);
|
|
|
}
|
|
|
// 返回确认后的信息
|
|
|
confirmResponse.setConfirmed(true);
|
|
|
if (confirmSplitCode != null) {
|
|
|
confirmResponse.setUsedSplitCode(confirmSplitCode);
|
|
|
}
|
|
|
return confirmResponse;
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
IoSplitFifoInvRelService splitFifoInvRelService;
|
|
|
|
|
|
public List<Long> findInvIdFk(IoCollectOrder collectOrder) {
|
|
|
List<IoSplitFifoInvRel> ioSplitFifoInvRels = splitFifoInvRelService.findInvIdFk(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
if (CollUtil.isNotEmpty(ioSplitFifoInvRels)) {
|
|
|
return ioSplitFifoInvRels.stream()
|
|
|
.map(IoSplitFifoInvRel::getInvIdFk)
|
|
|
.collect(Collectors.toList());
|
|
|
} else
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
public List<IoCollectOrderCodeMan> filterCode(List<IoCollectOrderCodeMan> collectOrderCodes, IoCollectOrderBiz collectOrderBiz, UdiRelevanceResponse udiRelevanceResponse) {
|
|
|
int unTagCount = IntUtil.value(collectOrderBiz.getScanActCount()) - collectOrderBiz.getCount();
|
|
|
List<IoCollectOrderCodeMan> newList = new ArrayList<IoCollectOrderCodeMan>();
|
|
|
int count = 0;
|
|
|
boolean first = true;
|
|
|
for (IoCollectOrderCodeMan collectOrderCode : collectOrderCodes) {
|
|
|
if (collectOrderCode.getBizIdFk().equals(collectOrderBiz.getId())) {
|
|
|
if (IntUtil.value(collectOrderCode.getIsSplitCode())) {
|
|
|
if (first) {
|
|
|
int remainder = unTagCount % IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
collectOrderCode.setRemainCount(remainder);
|
|
|
first = false;
|
|
|
} else {
|
|
|
collectOrderCode.setRemainCount(collectOrderCode.getScanActCount());
|
|
|
}
|
|
|
newList.add(collectOrderCode);
|
|
|
} else {
|
|
|
count = count + collectOrderCode.getScanActCount();
|
|
|
if (!IntUtil.value(collectOrderCode.getRemoveFlag())) {
|
|
|
if (count > collectOrderBiz.getCount()) {
|
|
|
if (first) {
|
|
|
int remainder = unTagCount % IntUtil.value(udiRelevanceResponse.getBhxjsl());
|
|
|
collectOrderCode.setRemainCount(remainder);
|
|
|
first = false;
|
|
|
} else {
|
|
|
collectOrderCode.setRemainCount(collectOrderCode.getScanActCount());
|
|
|
}
|
|
|
newList.add(collectOrderCode);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
return newList;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 单据预赋码
|
|
|
*
|
|
|
* @param collectOrder
|
|
|
*/
|
|
|
public void preAutoTagCode(IoCollectOrder collectOrder, String queueCode) {
|
|
|
Long putWorkPlaceCode = null;
|
|
|
//获取上货工位
|
|
|
SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
if (sysWorkplacePutRel != null)
|
|
|
putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
|
|
|
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
|
|
|
List<IoSplitFifoCodeEntity> splitFifoCodeEntities =
|
|
|
splitFifoCodeService.findByRelId(putWorkPlaceCode,
|
|
|
collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
|
|
|
int total = splitFifoCodeEntities.stream()
|
|
|
.mapToInt(IoSplitFifoCodeEntity::getTotalCount)
|
|
|
.sum();
|
|
|
collectOrderBiz.setTempWorkPlaceCount(total);
|
|
|
List<IoSplitCodeEntity> splitCodeEntities = splitCodeService.findSplitCodes(collectOrderBiz.getRelId()
|
|
|
, collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
int splitTotal = splitCodeEntities.stream()
|
|
|
.mapToInt(IoSplitCodeEntity::getRemainCount)
|
|
|
.sum();
|
|
|
collectOrderBiz.setTempSplitCount(splitTotal);
|
|
|
total = total + splitTotal;
|
|
|
if (total >= IntUtil.value(collectOrderBiz.getCount())) {
|
|
|
collectOrderBiz.setAutoTagStatus(2);
|
|
|
} else if (total > 0) {
|
|
|
collectOrderBiz.setAutoTagStatus(3);
|
|
|
} else
|
|
|
collectOrderBiz.setAutoTagStatus(1);
|
|
|
}
|
|
|
ThreadUtil.execAsync(() -> {
|
|
|
ioCollectLedGroupService.openLed(collectOrderBizs);
|
|
|
}
|
|
|
);
|
|
|
collectOrderBizService.updateBatchById(collectOrderBizs);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 单据预赋码
|
|
|
*
|
|
|
* @param collectOrder
|
|
|
*/
|
|
|
public void preQxAutoTagCode(IoCollectOrder collectOrder, String queueCode) {
|
|
|
Long putWorkPlaceCode = null;
|
|
|
//获取上货工位
|
|
|
SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
if (sysWorkplacePutRel != null)
|
|
|
putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
|
|
|
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
|
|
|
List<IoSplitFifoCodeEntity> splitFifoCodeEntities =
|
|
|
splitFifoCodeService.findByCheckCode(putWorkPlaceCode,
|
|
|
collectOrderBiz.getYbbm(), collectOrderBiz.getBatchNo(), queueCode);
|
|
|
int total = splitFifoCodeEntities.stream()
|
|
|
.mapToInt(IoSplitFifoCodeEntity::getTotalCount)
|
|
|
.sum();
|
|
|
collectOrderBiz.setTempWorkPlaceCount(total);
|
|
|
List<IoSplitCodeEntity> splitCodeEntities = splitCodeService.findSplitCodes(collectOrderBiz.getRelId()
|
|
|
, collectOrderBiz.getBatchNo(), putWorkPlaceCode);
|
|
|
int splitTotal = splitCodeEntities.stream()
|
|
|
.mapToInt(IoSplitCodeEntity::getRemainCount)
|
|
|
.sum();
|
|
|
collectOrderBiz.setTempSplitCount(splitTotal);
|
|
|
total = total + splitTotal;
|
|
|
if (total >= IntUtil.value(collectOrderBiz.getCount())) {
|
|
|
collectOrderBiz.setAutoTagStatus(2);
|
|
|
} else if (total > 0) {
|
|
|
collectOrderBiz.setAutoTagStatus(3);
|
|
|
} else
|
|
|
collectOrderBiz.setAutoTagStatus(1);
|
|
|
}
|
|
|
collectOrderBizService.updateBatchById(collectOrderBizs);
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 拆零单据撤回，则将拆零表剩余数量加回预出库队列
|
|
|
*
|
|
|
* @param collectOrder
|
|
|
*/
|
|
|
public void backSplit(IoCollectOrder collectOrder) {
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), collectOrder.getWorkPlaceCode());
|
|
|
if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
|
|
|
IoSplitCodeEntity splitCodeEntity = ioSplitCodeEntities.get(0);
|
|
|
splitCodeEntity.setRemainCount(IntUtil.value(splitCodeEntity.getRemainCount()) + (IntUtil.value(collectOrderBiz.getCount()) - IntUtil.value(collectOrderBiz.getUnTagCount())));
|
|
|
splitCodeMapper.updateById(splitCodeEntity);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 从预出库队列里面取出数据，添加至拆零表
|
|
|
*/
|
|
|
public Integer addFifoCode(Long relId, String batchNo, Integer needCount, Long putWorkPlaceCode, String confirmSplitCode) {
|
|
|
|
|
|
List<IoSplitFifoCodeEntity> splitFifoCodeEntities;
|
|
|
|
|
|
if (StrUtil.isNotEmpty(confirmSplitCode)) {
|
|
|
splitFifoCodeEntities = splitFifoCodeService
|
|
|
.list(new LambdaQueryWrapper<IoSplitFifoCodeEntity>()
|
|
|
.eq(IoSplitFifoCodeEntity::getCode, confirmSplitCode)
|
|
|
.eq(putWorkPlaceCode != null, IoSplitFifoCodeEntity::getWorkPlaceCode, putWorkPlaceCode)
|
|
|
.orderByAsc(IoSplitFifoCodeEntity::getInBactchNo)
|
|
|
);
|
|
|
} else {
|
|
|
splitFifoCodeEntities = splitFifoCodeService
|
|
|
.list(new LambdaQueryWrapper<IoSplitFifoCodeEntity>()
|
|
|
.eq(IoSplitFifoCodeEntity::getRelId, relId)
|
|
|
.eq(StrUtil.isNotEmpty(batchNo), IoSplitFifoCodeEntity::getBatchNo, batchNo)
|
|
|
.eq(putWorkPlaceCode != null, IoSplitFifoCodeEntity::getWorkPlaceCode, putWorkPlaceCode)
|
|
|
.orderByAsc(IoSplitFifoCodeEntity::getInBactchNo)
|
|
|
);
|
|
|
}
|
|
|
|
|
|
Integer count = 0;
|
|
|
List<IoSplitCodeEntity> addSplitCodeEntities = new ArrayList<>();
|
|
|
List<Long> removeIds = new ArrayList<>();
|
|
|
for (IoSplitFifoCodeEntity splitFifoCodeEntity : splitFifoCodeEntities) {
|
|
|
IoSplitCodeEntity splitCodeEntity = new IoSplitCodeEntity();
|
|
|
BeanUtils.copyProperties(splitFifoCodeEntity, splitCodeEntity);
|
|
|
|
|
|
count = IntUtil.value(splitFifoCodeEntity.getTotalCount()) + count;
|
|
|
splitCodeEntity.setRemainCount(splitCodeEntity.getTotalCount());
|
|
|
|
|
|
splitCodeEntity.setStatus(1);
|
|
|
splitCodeEntity.setFifoSplit(splitFifoCodeEntity.getFifoSplit());
|
|
|
splitCodeEntity.setId(null);
|
|
|
this.decorateUnpackExpireTime(splitCodeEntity);
|
|
|
addSplitCodeEntities.add(splitCodeEntity);
|
|
|
removeIds.add(splitFifoCodeEntity.getId());
|
|
|
IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
|
|
|
if (splitFifoInv != null) {
|
|
|
splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
|
|
|
splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(splitFifoCodeEntity.getScanCount()));
|
|
|
int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
|
|
|
splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
|
|
|
splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
|
|
|
splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
|
|
|
splitFifoInvService.updateById(splitFifoInv);
|
|
|
}
|
|
|
if (count >= needCount) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (removeIds.size() > 0) {
|
|
|
splitFifoCodeService.removeByIds(removeIds);
|
|
|
}
|
|
|
if (addSplitCodeEntities.size() > 0) {
|
|
|
splitCodeMapper.insertBatch(addSplitCodeEntities);
|
|
|
}
|
|
|
return count;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
public int checkStatus(List<IoCollectOrderBiz> list) {
|
|
|
boolean hasTwo = false;
|
|
|
boolean hasOne = false;
|
|
|
boolean hasNone = true;
|
|
|
for (IoCollectOrderBiz di : list) {
|
|
|
int tagStatus = di.getTagStatus();
|
|
|
if (tagStatus == 2) {
|
|
|
hasTwo = true;
|
|
|
} else if (tagStatus == 1) {
|
|
|
hasOne = true;
|
|
|
} else if (tagStatus != 3) {
|
|
|
throw new IllegalArgumentException("Invalid tagStatus value: " + tagStatus);
|
|
|
}
|
|
|
}
|
|
|
for (IoCollectOrderBiz di : list) {
|
|
|
if (IntUtil.value(di.getCount()) != IntUtil.value(di.getUnTagCount())) {
|
|
|
hasNone = false;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (hasNone) {
|
|
|
return 1;
|
|
|
}
|
|
|
if (hasTwo) {
|
|
|
return 2;
|
|
|
} else if (hasOne) {
|
|
|
return 1;
|
|
|
} else {
|
|
|
return 3;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
//包装拆包失效时间
|
|
|
void decorateUnpackExpireTime(IoSplitCodeEntity ioSplitCodeEntity) {
|
|
|
Long relId = ioSplitCodeEntity.getRelId();
|
|
|
UdiRelevanceEntity relevanceEntity = udiRelevanceService.getById(relId);
|
|
|
int n = IntUtil.value(relevanceEntity.getUnpackUseTime());
|
|
|
// 获取当前时间
|
|
|
Calendar calendar = Calendar.getInstance();
|
|
|
Date unpackTime = calendar.getTime();
|
|
|
// 加上n小时
|
|
|
calendar.add(Calendar.HOUR_OF_DAY, n);
|
|
|
// 转换为Date对象
|
|
|
Date unpackExpireTime = calendar.getTime();
|
|
|
ioSplitCodeEntity.setUnpackTime(unpackTime);
|
|
|
ioSplitCodeEntity.setUnpackExpireTime(unpackExpireTime);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 扫描拆包过期进行处理损耗出库
|
|
|
*/
|
|
|
public void asyncUnpackExpireTask() {
|
|
|
LambdaQueryWrapper<IoSplitCodeEntity> lqw = new LambdaQueryWrapper<>();
|
|
|
Date now = new Date();
|
|
|
lqw.lt(IoSplitCodeEntity::getUnpackExpireTime, now);
|
|
|
|
|
|
List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(lqw);
|
|
|
if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
|
|
|
//进行损耗出库
|
|
|
IoSplitDesOrder collectOrder;
|
|
|
List<IoSplitDesOrderDetail> splitDesOrderDetails = new ArrayList<>();
|
|
|
List<Long> removeByIds = new ArrayList<>();
|
|
|
collectOrder = IoSplitDesOrder.builder()
|
|
|
.id(IdUtil.getSnowflakeNextId())
|
|
|
.billNo(gennerOrderUtils.createWdOrderNo(new OrderNoTypeBean(Constant.SPLIT_DES_ORDER, "yyyyMMdd")))
|
|
|
.busType(null)
|
|
|
.workPlaceCode(null)
|
|
|
.createTime(new Date())
|
|
|
.billTime(new Date())
|
|
|
.remark(null)
|
|
|
.status(2)
|
|
|
.createUser("1")
|
|
|
.updateTime(new Date())
|
|
|
.updateUser("1")
|
|
|
.build();
|
|
|
splitDesOrderService.save(collectOrder);
|
|
|
|
|
|
ioSplitCodeEntities.forEach(splitCodeEntity -> {
|
|
|
//损耗详细表
|
|
|
IoSplitDesOrderDetail splitDesOrderDetail = IoSplitDesOrderDetail.builder()
|
|
|
.id(IdUtil.getSnowflakeNextId())
|
|
|
.workPlaceCode(collectOrder.getWorkPlaceCode())
|
|
|
.orderIdFk(collectOrder.getBillNo())
|
|
|
.relId(splitCodeEntity.getRelId())
|
|
|
.batchNo(splitCodeEntity.getBatchNo())
|
|
|
.produceDate(splitCodeEntity.getProduceDate())
|
|
|
.expireDate(splitCodeEntity.getExpireDate())
|
|
|
.supId(splitCodeEntity.getSupId())
|
|
|
.count(splitCodeEntity.getRemainCount())
|
|
|
.reCount(splitCodeEntity.getRemainCount())
|
|
|
.createTime(new Date())
|
|
|
.updateTime(new Date())
|
|
|
.remark("").build();
|
|
|
splitDesOrderDetails.add(splitDesOrderDetail);
|
|
|
removeByIds.add(splitCodeEntity.getId());
|
|
|
});
|
|
|
|
|
|
if (removeByIds.size() > 0) {
|
|
|
this.removeByIds(removeByIds);
|
|
|
}
|
|
|
if (splitDesOrderDetails.size() > 0) {
|
|
|
splitDesOrderDetailService.saveBatch(splitDesOrderDetails);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
