package com.zy.asrs.wms.asrs.manage;
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.zy.asrs.framework.exception.CoolException;
|
import com.zy.asrs.wms.asrs.entity.dto.*;
|
import com.zy.asrs.wms.asrs.entity.dto.OrderOutMergeDto;
|
import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;
|
import com.zy.asrs.wms.asrs.entity.enums.LocStsType;
|
import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType;
|
import com.zy.asrs.wms.asrs.entity.enums.WaveStatusType;
|
import com.zy.asrs.wms.asrs.entity.param.*;
|
import com.zy.asrs.wms.asrs.entity.*;
|
import com.zy.asrs.wms.asrs.service.*;
|
import com.zy.asrs.wms.utils.OrderUtils;
|
import com.zy.asrs.wms.utils.OutUtils;
|
import com.zy.asrs.wms.utils.Utils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
/**
|
* 出库管理
|
*/
|
@Service
|
public class OutManage {
|
|
private static Logger logger = LoggerFactory.getLogger(LocManage.class);
|
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private TaskDetlService taskDetlService;
|
@Autowired
|
private TaskDetlFieldService taskDetlFieldService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private LocDetlService locDetlService;
|
@Autowired
|
private LocDetlFieldService locDetlFieldService;
|
@Autowired
|
private WorkService workService;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private OrderDetlService orderDetlService;
|
@Autowired
|
private OutUtils outUtils;
|
@Autowired
|
private OperationPortService operationPortService;
|
@Autowired
|
private OrderUtils orderUtils;
|
@Autowired
|
private OrderNoRuleService orderNoRuleService;
|
@Autowired
|
private WaveService waveService;
|
@Autowired
|
private WaveDetlService waveDetlService;
|
@Autowired
|
private CacheSiteService cacheSiteService;
|
@Autowired
|
private WaveSeedService waveSeedService;
|
|
/**
|
* 出库
|
*/
|
@Transactional
|
public void out(OutParam outParam) {
|
if (outParam.getOperationPort() == null) {
|
throw new CoolException("作业口不存在");
|
}
|
|
List<OutLocDto> list = outUtils.merge(outParam);
|
processTask(list);
|
}
|
|
private void processTask(List<OutLocDto> list) {
|
for (OutLocDto locDto : list) {
|
long taskType = locDto.getAll() ? 101L : 103L;
|
|
Loc loc = locService.getById(locDto.getLocId());
|
if(loc == null) {
|
throw new CoolException("库位不存在");
|
}
|
|
if (!loc.getLocStsId().equals(LocStsType.F.val())) {
|
throw new CoolException("库位状态不在库");
|
}
|
|
Task task = new Task();
|
task.setTaskNo(workService.generateTaskNo(1L));
|
task.setTaskSts(101L);
|
task.setTaskType(taskType);
|
task.setIoPri(workService.generateIoPri(taskType));
|
task.setOriginLoc(loc.getLocNo());
|
task.setTargetSite(locDto.getOperationPort());
|
task.setBarcode(loc.getBarcode());
|
boolean res = taskService.save(task);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 工作档明细保存
|
for (OutDetlDto detl : locDto.getDetls()) {
|
LocDetl locDetl = locDetlService.getById(detl.getDetlId());
|
if(locDetl == null) {
|
throw new CoolException("明细不存在");
|
}
|
|
TaskDetl taskDetl = new TaskDetl();
|
taskDetl.sync(locDetl);
|
taskDetl.setTaskId(task.getId());
|
taskDetl.setTaskNo(task.getTaskNo());
|
taskDetl.setAnfme(detl.getAnfme());
|
taskDetl.setStock(detl.getStock());
|
taskDetl.setOrderId(null);
|
taskDetl.setOrderNo(null);
|
if (!taskDetlService.save(taskDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
|
List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
|
for (LocDetlField locDetlField : locDetlFields) {
|
TaskDetlField taskDetlField = new TaskDetlField();
|
taskDetlField.sync(locDetlField);
|
taskDetlField.setDetlId(taskDetl.getId());
|
boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
|
if(!taskDetlFieldSave){
|
throw new CoolException("明细扩展生成失败");
|
}
|
}
|
}
|
|
//库位F => R
|
loc.setLocStsId(LocStsType.R.val());
|
loc.setUpdateTime(new Date());
|
boolean locUpdate = locService.updateById(loc);
|
if(!locUpdate){
|
throw new CoolException("库位状态更新失败");
|
}
|
}
|
}
|
|
public List<OrderOutBatchPreviewDto> orderOutBatchPreview(OrderOutBatchPreviewParam param) {
|
List<Long> orderDetlIds = param.getOrderDetlIds();
|
if (orderDetlIds.isEmpty()) {
|
throw new CoolException("订单明细不能为空");
|
}
|
|
List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getId, orderDetlIds).orderByAsc(OrderDetl::getOrderNo, OrderDetl::getCreateTime));
|
if (orderDetls.isEmpty()) {
|
throw new CoolException("订单明细不存在");
|
}
|
orderDetls = orderDetlService.parseDetl(orderDetls);
|
|
HashMap<Long, List<LocDetl>> orderDetlLocMap = new HashMap<>();
|
List<OutDetlDto> detlDtos = new ArrayList<>();
|
|
for (OrderDetl orderDetl : orderDetls) {
|
double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
|
if (issued <= 0.0D) { continue; }
|
List<LocDetl> locDetls = locDetlService.queryStock(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
|
orderDetlLocMap.put(orderDetl.getId(), locDetls);
|
for (LocDetl locDetl : locDetls) {
|
if (issued > 0) {
|
OutDetlDto outDetlDto = new OutDetlDto();
|
outDetlDto.setDetlId(locDetl.getId());
|
outDetlDto.setAnfme(issued >= locDetl.getAnfme() ? locDetl.getAnfme() : issued);
|
outDetlDto.setStock(locDetl.getAnfme());
|
outDetlDto.setOrderDetlId(orderDetl.getId());
|
detlDtos.add(outDetlDto);
|
issued = issued - outDetlDto.getAnfme();
|
}else {
|
break;
|
}
|
}
|
}
|
|
HashMap<Long, List<OutDetlDto>> map = new HashMap<>();
|
for (OutDetlDto detlDto : detlDtos) {
|
LocDetl locDetl = locDetlService.getById(detlDto.getDetlId());
|
List<OutDetlDto> dtos = map.get(locDetl.getLocId());
|
if (dtos == null) {
|
dtos = new ArrayList<>();
|
dtos.add(detlDto);
|
}else {
|
dtos.add(detlDto);
|
}
|
map.put(locDetl.getLocId(), dtos);
|
}
|
|
List<Long> orderDetlIdsTmp = param.getOrderDetlIds();
|
List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
|
for (Map.Entry<Long, List<OutDetlDto>> entry : map.entrySet()) {
|
Long locId = entry.getKey();
|
Loc loc = locService.getById(locId);
|
|
List<OutDetlDto> outDetlDtos = entry.getValue();
|
for (OutDetlDto outDetlDto : outDetlDtos) {
|
orderDetlIdsTmp.remove(outDetlDto.getOrderDetlId());
|
}
|
Boolean all = outUtils.isAllForOut(locId, outDetlDtos);
|
|
for (OutDetlDto outDetlDto : outDetlDtos) {
|
OrderOutBatchPreviewDto previewDto = new OrderOutBatchPreviewDto();
|
previewDto.setLocId(locId);
|
previewDto.setLocNo(loc.getLocNo());
|
previewDto.setLocDetlId(outDetlDto.getDetlId());
|
previewDto.setAll(all);
|
previewDto.setAnfme(outDetlDto.getAnfme());
|
previewDto.setStock(outDetlDto.getStock());
|
previewDto.setOrderDetlId(outDetlDto.getOrderDetlId());
|
previewDtos.add(previewDto);
|
|
|
List<BatchPreviewOtherLocDto> otherLocs = new ArrayList<>();
|
previewDto.setOtherLoc(otherLocs);
|
|
List<LocDetl> locDetls = orderDetlLocMap.get(outDetlDto.getOrderDetlId());
|
for (LocDetl locDetl : locDetls) {
|
BatchPreviewOtherLocDto otherLocDto = new BatchPreviewOtherLocDto();
|
otherLocDto.setLocId(locDetl.getLocId());
|
otherLocDto.setLocNo(locDetl.getLocNo());
|
otherLocDto.setStock(locDetl.getAnfme());
|
otherLocDto.setLocDetlId(locDetl.getId());
|
|
if (locDetl.getLocId().equals(locId)) {
|
otherLocs.add(0, otherLocDto);
|
continue;
|
}
|
|
if (otherLocs.isEmpty()) {
|
otherLocs.add(otherLocDto);
|
}
|
|
for (int i = 0; i < otherLocs.size(); i++) {
|
BatchPreviewOtherLocDto locDto = otherLocs.get(i);
|
if (locDto.getLocId().equals(locDetl.getLocId())) {
|
break;
|
}
|
otherLocs.add(otherLocDto);
|
}
|
}
|
}
|
|
}
|
|
for (Long id : orderDetlIdsTmp) {
|
OrderDetl orderDetl = orderDetlService.getById(id);
|
double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
|
|
OrderOutBatchPreviewDto previewDto = new OrderOutBatchPreviewDto();
|
previewDto.setLocId(null);
|
previewDto.setLocNo(null);
|
previewDto.setLocDetlId(null);
|
previewDto.setAll(null);
|
previewDto.setAnfme(issued);
|
previewDto.setStock(0D);
|
previewDto.setOrderDetlId(orderDetl.getId());
|
|
previewDtos.add(previewDto);
|
}
|
|
return previewDtos;
|
}
|
|
@Transactional
|
public void orderOutBatch(List<OrderOutBatchPreviewDto> param) {
|
if (param == null) {
|
throw new CoolException("参数不能为空");
|
}
|
|
if (param.isEmpty()) {
|
throw new CoolException("参数不能为空");
|
}
|
|
boolean noStock = true;
|
for (OrderOutBatchPreviewDto dto : param) {
|
if (dto.getStock() > 0) {
|
noStock = false;
|
break;
|
}
|
}
|
if (noStock) {
|
throw new CoolException("库存不足");
|
}
|
|
|
HashMap<Long, List<OrderOutBatchPreviewDto>> detlMap = new HashMap<>();
|
for (OrderOutBatchPreviewDto previewDto : param) {
|
if (previewDto.getLocId() == null) {
|
continue;
|
}
|
|
if(detlMap.containsKey(previewDto.getLocDetlId())) {
|
List<OrderOutBatchPreviewDto> previewDtos = detlMap.get(previewDto.getLocDetlId());
|
previewDtos.add(previewDto);
|
detlMap.put(previewDto.getLocDetlId(), previewDtos);
|
}else {
|
List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
|
previewDtos.add(previewDto);
|
detlMap.put(previewDto.getLocDetlId(), previewDtos);
|
}
|
}
|
|
List<OrderOutBatchPreviewDto> dtos = new ArrayList<>();
|
for (Map.Entry<Long, List<OrderOutBatchPreviewDto>> entry : detlMap.entrySet()) {
|
Long locDetlId = entry.getKey();
|
LocDetl locDetl = locDetlService.getById(locDetlId);
|
if (locDetl == null) {
|
continue;
|
}
|
|
Double stock = locDetl.getAnfme();
|
for (OrderOutBatchPreviewDto dto : entry.getValue()) {
|
stock = stock - dto.getAnfme();
|
if (stock >= 0) {
|
dtos.add(dto);
|
}
|
}
|
}
|
|
|
HashMap<Long, List<OrderOutBatchPreviewDto>> map = new HashMap<>();
|
|
for (OrderOutBatchPreviewDto previewDto : dtos) {
|
if(map.containsKey(previewDto.getLocId())) {
|
List<OrderOutBatchPreviewDto> previewDtos = map.get(previewDto.getLocId());
|
previewDtos.add(previewDto);
|
map.put(previewDto.getLocId(), previewDtos);
|
}else {
|
List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
|
previewDtos.add(previewDto);
|
map.put(previewDto.getLocId(), previewDtos);
|
}
|
}
|
|
for (Map.Entry<Long, List<OrderOutBatchPreviewDto>> entry : map.entrySet()) {
|
Long locId = entry.getKey();
|
List<OrderOutBatchPreviewDto> previewDtos = entry.getValue();
|
Boolean all = outUtils.isAllForPreview(locId, previewDtos);
|
OrderOutBatchPreviewDto previewDto = previewDtos.get(0);
|
Long operationPortId = previewDto.getOperationPort();
|
|
Loc loc = locService.getById(locId);
|
if (loc == null) {
|
continue;
|
}
|
|
if (!loc.getLocStsId().equals(LocStsType.F.val())) {
|
continue;
|
}
|
|
OperationPort operationPort = operationPortService.getById(operationPortId);
|
if (operationPort == null) {
|
throw new CoolException("作业口不存在");
|
}
|
|
|
long taskType = all ? 101L : 103L;
|
|
Task task = new Task();
|
task.setTaskNo(workService.generateTaskNo(taskType));
|
task.setTaskSts(101L);
|
task.setTaskType(taskType);
|
task.setIoPri(workService.generateIoPri(taskType));
|
task.setOriginLoc(loc.getLocNo());
|
task.setTargetSite(operationPort.getFlag());
|
task.setBarcode(loc.getBarcode());
|
boolean res = taskService.save(task);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
for (OrderOutBatchPreviewDto dto : previewDtos) {
|
LocDetl locDetl = locDetlService.getById(dto.getLocDetlId());
|
if(locDetl == null) {
|
throw new CoolException("明细不存在");
|
}
|
|
OrderDetl orderDetl = orderDetlService.getById(dto.getOrderDetlId());
|
if(orderDetl == null) {
|
throw new CoolException("订单明细不存在");
|
}
|
orderUtils.updateWorkQty(dto.getOrderDetlId(), dto.getAnfme());
|
|
TaskDetl taskDetl = new TaskDetl();
|
taskDetl.sync(locDetl);
|
taskDetl.setId(null);
|
taskDetl.setTaskId(task.getId());
|
taskDetl.setTaskNo(task.getTaskNo());
|
taskDetl.setAnfme(dto.getAnfme());
|
taskDetl.setStock(locDetl.getAnfme());
|
taskDetl.setOrderId(orderDetl.getOrderId());
|
taskDetl.setOrderNo(orderDetl.getOrderNo());
|
taskDetl.setDetlId(orderDetl.getId());
|
if (!taskDetlService.save(taskDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
|
List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
|
for (LocDetlField locDetlField : locDetlFields) {
|
TaskDetlField taskDetlField = new TaskDetlField();
|
taskDetlField.sync(locDetlField);
|
taskDetlField.setId(null);
|
taskDetlField.setDetlId(taskDetl.getId());
|
boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
|
if(!taskDetlFieldSave){
|
throw new CoolException("明细扩展生成失败");
|
}
|
}
|
}
|
|
//库位F => R
|
loc.setLocStsId(LocStsType.R.val());
|
loc.setUpdateTime(new Date());
|
boolean locUpdate = locService.updateById(loc);
|
if(!locUpdate){
|
throw new CoolException("库位状态更新失败");
|
}
|
|
}
|
|
}
|
|
@Transactional
|
public List<MergePreviewDto> orderOutMergePreview(OrderOutMergePreviewParam param) {
|
if (param == null) {
|
throw new CoolException("参数不能为空");
|
}
|
|
List<Long> orderIds = param.getOrderIds();
|
if (orderIds.isEmpty()) {
|
throw new CoolException("订单不能为空");
|
}
|
|
List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getId, orderIds));
|
if (orders.isEmpty()) {
|
throw new CoolException("订单不存在");
|
}
|
|
List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, orderIds));
|
if(orderDetls.isEmpty()){
|
throw new CoolException("订单明细不存在");
|
}
|
orderDetls = orderDetlService.parseDetl(orderDetls);
|
|
HashMap<String, Double> locDetlStockMap = new HashMap<>();
|
for (OrderDetl orderDetl : orderDetls) {
|
String matUniqueKey = Utils.getMatUniqueKey(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
|
double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
|
if (locDetlStockMap.containsKey(matUniqueKey)) {
|
Double anfme = locDetlStockMap.get(matUniqueKey);
|
anfme += issued;
|
locDetlStockMap.put(matUniqueKey, anfme);
|
}else {
|
locDetlStockMap.put(matUniqueKey, issued);
|
}
|
}
|
|
List<MergePreviewDto> mergePreviewDtos = new ArrayList<>();
|
for (Map.Entry<String, Double> entry : locDetlStockMap.entrySet()) {
|
String matUniqueKey = entry.getKey();
|
Double anfme = entry.getValue();
|
|
MatUniqueObjDto matUniqueObj = Utils.getMatUniqueObj(matUniqueKey);
|
HashMap<String, Object> dynamicFields = new HashMap<>();
|
for (FieldParam fieldParam : matUniqueObj.getParams()) {
|
dynamicFields.put(fieldParam.getName(), fieldParam.getValue());
|
}
|
|
MergePreviewDto dto = new MergePreviewDto();
|
dto.setMatnr(matUniqueObj.getMatnr());
|
dto.setBatch(matUniqueObj.getBatch());
|
dto.setAnfme(anfme);
|
dto.setOrderIds(orderIds);
|
dto.setFieldParamsEncode(JSON.toJSONString(matUniqueObj.getParams()));
|
dto.setDynamicFields(dynamicFields);
|
mergePreviewDtos.add(dto);
|
}
|
|
|
return mergePreviewDtos;
|
}
|
|
@Transactional
|
public List<MergePreviewResultDto> orderOutMergeLocPreview(List<MergePreviewDto> param) {
|
if (param == null) {
|
throw new CoolException("参数不能为空");
|
}
|
|
if (param.isEmpty()) {
|
throw new CoolException("参数不能为空");
|
}
|
|
for (MergePreviewDto dto : param) {
|
List<FieldParam> fieldParams = JSON.parseArray(dto.getFieldParamsEncode(), FieldParam.class);
|
dto.setFieldParams(fieldParams);
|
}
|
|
FieldSortParam sortParam = new FieldSortParam("anfme","desc");
|
List<FieldSortParam> sortParams = new ArrayList<>();
|
sortParams.add(sortParam);
|
|
List<MergePreviewResultDto> resultDtos = new ArrayList<>();
|
for (MergePreviewDto dto : param) {
|
List<LocDetl> locDetls = locDetlService.queryStock(dto.getMatnr(), dto.getBatch(), dto.getFieldParams(), sortParams);
|
if(locDetls.isEmpty()){
|
MergePreviewResultDto resultDto = new MergePreviewResultDto();
|
resultDto.sync(dto);
|
resultDto.setLocs(new ArrayList<>());
|
resultDto.setOrderIds(dto.getOrderIds());
|
resultDto.setAnfme(dto.getAnfme());
|
resultDtos.add(resultDto);
|
continue;
|
}
|
|
List<MergePreviewResultLocDto> locDtos = new ArrayList<>();
|
|
MergePreviewResultDto resultDto = new MergePreviewResultDto();
|
resultDto.sync(dto);
|
resultDto.setLocs(locDtos);
|
resultDto.setOrderIds(dto.getOrderIds());
|
|
Double anfme = dto.getAnfme();
|
for (LocDetl locDetl : locDetls) {
|
Loc loc = locService.getById(locDetl.getLocId());
|
if (loc == null) {
|
throw new CoolException("库位数据不存在");
|
}
|
|
if (loc.getLocStsId() != LocStsType.F.val()) {
|
continue;
|
}
|
|
MergePreviewResultLocDto locDto = new MergePreviewResultLocDto();
|
locDto.setLocId(locDetl.getLocId());
|
locDto.setLocNo(locDetl.getLocNo());
|
locDto.setLocDetlId(locDetl.getId());
|
|
locDtos.add(locDto);
|
if (anfme - locDetl.getAnfme() < 0) {
|
locDto.setAnfme(anfme);
|
break;
|
}
|
locDto.setAnfme(locDetl.getAnfme());
|
anfme -= locDetl.getAnfme();
|
}
|
|
List<MergePreviewResultLocDto> otherLocDtos = new ArrayList<>();
|
for (LocDetl locDetl : locDetls) {
|
Loc loc = locService.getById(locDetl.getLocId());
|
if (loc == null) {
|
throw new CoolException("库位数据不存在");
|
}
|
|
if (loc.getLocStsId() != LocStsType.F.val()) {
|
continue;
|
}
|
|
MergePreviewResultLocDto locDto = new MergePreviewResultLocDto();
|
locDto.setLocId(locDetl.getLocId());
|
locDto.setLocNo(locDetl.getLocNo());
|
locDto.setLocDetlId(locDetl.getId());
|
locDto.setAnfme(locDetl.getAnfme());
|
otherLocDtos.add(locDto);
|
}
|
resultDto.setOtherLocs(otherLocDtos);
|
|
resultDto.setAnfme(dto.getAnfme());
|
|
resultDtos.add(resultDto);
|
}
|
|
return resultDtos;
|
}
|
|
@Transactional
|
public void orderOutMerge(OrderOutMergeParamDto dto) {
|
if(dto == null){
|
throw new CoolException("参数不能为空");
|
}
|
|
List<OrderOutMergeParam> params = dto.getList();
|
|
if (params.isEmpty()) {
|
throw new CoolException("参数不能为空");
|
}
|
|
List<Long> orderIds = null;
|
|
List<OrderOutMergeParam> filterParam = new ArrayList<>();
|
HashMap<String, OrderOutMergeParam> paramMap = new HashMap<>();
|
for (OrderOutMergeParam param : params) {
|
if (param.getLocId() == null) {
|
continue;
|
}
|
|
filterParam.add(param);
|
|
String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
|
paramMap.put(matUniqueKey, param);
|
|
if (orderIds == null) {
|
orderIds = param.getOrderIds();
|
}
|
}
|
|
if (orderIds == null) {
|
throw new CoolException("订单不存在");
|
}
|
|
List<Order> orderList = orderService.listByIds(orderIds);
|
if (orderList.isEmpty()) {
|
throw new CoolException("订单不存在");
|
}
|
|
List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, orderIds));
|
if (orderDetls.isEmpty()) {
|
throw new CoolException("订单明细不存在");
|
}
|
|
HashMap<String, List<OrderDetl>> detlMap = new HashMap<>();
|
for (OrderDetl orderDetl : orderDetls) {
|
String matUniqueKey = Utils.getMatUniqueKey(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
|
if (detlMap.containsKey(matUniqueKey)) {
|
List<OrderDetl> detls = detlMap.get(matUniqueKey);
|
detls.add(orderDetl);
|
detlMap.put(matUniqueKey, detls);
|
}else {
|
List<OrderDetl> detls = new ArrayList<>();
|
detls.add(orderDetl);
|
detlMap.put(matUniqueKey, detls);
|
}
|
}
|
|
List<OrderOutMergeDto> orderOutMergeDtos = new ArrayList<>();
|
for (OrderOutMergeParam param : filterParam) {
|
String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
|
if (!detlMap.containsKey(matUniqueKey)) {
|
continue;
|
}
|
|
Double requireAnfme = param.getAnfme();
|
|
List<OrderDetl> orderDetlList = detlMap.get(matUniqueKey);
|
for (OrderDetl orderDetl : orderDetlList) {
|
orderDetl = orderDetlService.getById(orderDetl);
|
double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
|
if (issued <= 0D) {
|
continue;
|
}
|
|
OrderOutMergeDto orderOutMergeDto = new OrderOutMergeDto();
|
orderOutMergeDto.sync(param);
|
orderOutMergeDto.setOrderDetlId(orderDetl.getId());
|
|
Double updateWorkQty = null;
|
|
if (requireAnfme > issued) {
|
orderOutMergeDto.setAnfme(issued);
|
updateWorkQty = issued;
|
requireAnfme -= issued;
|
}else {
|
orderOutMergeDto.setAnfme(requireAnfme);
|
updateWorkQty = requireAnfme;
|
requireAnfme -= requireAnfme;
|
}
|
|
orderOutMergeDtos.add(orderOutMergeDto);
|
|
orderUtils.updateWorkQty(orderDetl.getId(), updateWorkQty);
|
if (requireAnfme <= 0) {
|
break;
|
}
|
}
|
}
|
|
HashMap<Long, List<OrderOutMergeDto>> map = new HashMap<>();
|
for (OrderOutMergeDto orderOutMergeDto : orderOutMergeDtos) {
|
List<OrderOutMergeDto> list = null;
|
if (map.containsKey(orderOutMergeDto.getLocId())) {
|
list = map.get(orderOutMergeDto.getLocId());
|
}else {
|
list = new ArrayList<>();
|
}
|
list.add(orderOutMergeDto);
|
map.put(orderOutMergeDto.getLocId(), list);
|
}
|
|
List<TaskDetl> taskDetls = new ArrayList<>();
|
for (Map.Entry<Long, List<OrderOutMergeDto>> entry : map.entrySet()) {
|
Long locId = entry.getKey();
|
List<OrderOutMergeDto> list = entry.getValue();
|
Boolean all = outUtils.isAllForMerge(locId, list);
|
OrderOutMergeDto param = list.get(0);
|
Long operationPortId = param.getOperationPort();
|
|
Loc loc = locService.getById(locId);
|
if (loc == null) {
|
throw new CoolException("库位不存在");
|
}
|
|
if (!loc.getLocStsId().equals(LocStsType.F.val())) {
|
throw new CoolException(loc.getLocNo() + "库位状态异常");
|
}
|
|
OperationPort operationPort = operationPortService.getById(operationPortId);
|
if (operationPort == null) {
|
throw new CoolException("作业口不存在");
|
}
|
|
long taskType = all ? 101L : 103L;
|
|
Task task = new Task();
|
task.setTaskNo(workService.generateTaskNo(taskType));
|
task.setTaskSts(101L);
|
task.setTaskType(taskType);
|
task.setIoPri(workService.generateIoPri(taskType));
|
task.setOriginLoc(loc.getLocNo());
|
task.setTargetSite(operationPort.getFlag());
|
task.setBarcode(loc.getBarcode());
|
boolean res = taskService.save(task);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
for (OrderOutMergeDto merge : list) {
|
LocDetl locDetl = locDetlService.getById(merge.getLocDetlId());
|
if(locDetl == null) {
|
throw new CoolException("明细不存在");
|
}
|
|
OrderDetl orderDetl = orderDetlService.getById(merge.getOrderDetlId());
|
if(orderDetl == null) {
|
throw new CoolException("订单明细不存在");
|
}
|
|
TaskDetl taskDetl = new TaskDetl();
|
taskDetl.sync(locDetl);
|
taskDetl.setId(null);
|
taskDetl.setTaskId(task.getId());
|
taskDetl.setTaskNo(task.getTaskNo());
|
taskDetl.setAnfme(merge.getAnfme());
|
taskDetl.setStock(locDetl.getAnfme());
|
taskDetl.setOrderId(orderDetl.getOrderId());
|
taskDetl.setOrderNo(orderDetl.getOrderNo());
|
taskDetl.setDetlId(orderDetl.getId());
|
if (!taskDetlService.save(taskDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
|
List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
|
for (LocDetlField locDetlField : locDetlFields) {
|
TaskDetlField taskDetlField = new TaskDetlField();
|
taskDetlField.sync(locDetlField);
|
taskDetlField.setId(null);
|
taskDetlField.setDetlId(taskDetl.getId());
|
boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
|
if(!taskDetlFieldSave){
|
throw new CoolException("明细扩展生成失败");
|
}
|
}
|
|
taskDetls.add(taskDetl);
|
}
|
|
//库位F => R
|
loc.setLocStsId(LocStsType.R.val());
|
loc.setUpdateTime(new Date());
|
boolean locUpdate = locService.updateById(loc);
|
if(!locUpdate){
|
throw new CoolException("库位状态更新失败");
|
}
|
|
}
|
|
}
|
|
@Transactional
|
public void orderOutMergeWave(OrderOutMergeParamDto dto) {
|
if(dto == null){
|
throw new CoolException("参数不能为空");
|
}
|
|
if (dto.getWaveId() == null) {
|
throw new CoolException("未生成波次");
|
}
|
|
List<OrderOutMergeParam> params = dto.getList();
|
|
if (params.isEmpty()) {
|
throw new CoolException("参数不能为空");
|
}
|
|
Long waveId = dto.getWaveId();
|
|
List<Long> filterParamsList = new ArrayList<>();
|
List<OrderOutMergeParam> filterParams = new ArrayList<>();
|
for (OrderOutMergeParam param : params) {
|
if (param.getLocId() == null) {
|
continue;
|
}
|
|
if(!filterParamsList.contains(param.getLocId())){
|
filterParamsList.add(param.getLocId());
|
filterParams.add(param);
|
}
|
}
|
|
HashMap<String, Double> stockMap = new HashMap<>();
|
for (OrderOutMergeParam param : filterParams) {
|
String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
|
WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));
|
if(waveDetl == null){
|
throw new CoolException("波次数据不存在");
|
}
|
|
double issued = Optional.of(waveDetl.getAnfme() - waveDetl.getWorkQty()).orElse(0.0D);
|
if(!stockMap.containsKey(matUniqueKey)){
|
stockMap.put(matUniqueKey, issued);
|
}
|
}
|
|
HashMap<Long, List<OrderOutMergeDto>> map = new HashMap<>();
|
for (OrderOutMergeParam param : filterParams) {
|
LocDetl locDetl = locDetlService.getById(param.getLocDetlId());
|
if(locDetl == null) {
|
continue;
|
}
|
|
if (locDetl.getAnfme() - param.getAnfme() < 0) {
|
continue;
|
}
|
|
OrderOutMergeDto orderOutMergeDto = new OrderOutMergeDto();
|
orderOutMergeDto.sync(param);
|
|
String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
|
Double issued = stockMap.get(matUniqueKey);
|
if (issued - orderOutMergeDto.getAnfme() < 0) {
|
orderOutMergeDto.setAnfme(issued);
|
issued = 0D;
|
}else {
|
issued -= orderOutMergeDto.getAnfme();
|
}
|
stockMap.put(matUniqueKey, issued);
|
|
List<OrderOutMergeDto> list = null;
|
if (map.containsKey(orderOutMergeDto.getLocId())) {
|
list = map.get(orderOutMergeDto.getLocId());
|
}else {
|
list = new ArrayList<>();
|
}
|
list.add(orderOutMergeDto);
|
map.put(orderOutMergeDto.getLocId(), list);
|
}
|
|
for (Map.Entry<Long, List<OrderOutMergeDto>> entry : map.entrySet()) {
|
Long locId = entry.getKey();
|
List<OrderOutMergeDto> list = entry.getValue();
|
Boolean all = outUtils.isAllForMerge(locId, list);
|
OrderOutMergeDto param = list.get(0);
|
Long operationPortId = param.getOperationPort();
|
|
Loc loc = locService.getById(locId);
|
if (loc == null) {
|
throw new CoolException("库位不存在");
|
}
|
|
if (!loc.getLocStsId().equals(LocStsType.F.val())) {
|
throw new CoolException(loc.getLocNo() + "库位状态异常");
|
}
|
|
OperationPort operationPort = operationPortService.getById(operationPortId);
|
if (operationPort == null) {
|
throw new CoolException("作业口不存在");
|
}
|
|
long taskType = all ? 101L : 103L;
|
|
Task task = new Task();
|
task.setTaskNo(workService.generateTaskNo(taskType));
|
task.setTaskSts(101L);
|
task.setTaskType(taskType);
|
task.setIoPri(workService.generateIoPri(taskType));
|
task.setOriginLoc(loc.getLocNo());
|
task.setTargetSite(operationPort.getFlag());
|
task.setBarcode(loc.getBarcode());
|
boolean res = taskService.save(task);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
for (OrderOutMergeDto merge : list) {
|
LocDetl locDetl = locDetlService.getById(merge.getLocDetlId());
|
if(locDetl == null) {
|
throw new CoolException("明细不存在");
|
}
|
|
TaskDetl taskDetl = new TaskDetl();
|
taskDetl.sync(locDetl);
|
taskDetl.setId(null);
|
taskDetl.setTaskId(task.getId());
|
taskDetl.setTaskNo(task.getTaskNo());
|
taskDetl.setAnfme(merge.getAnfme());
|
taskDetl.setStock(locDetl.getAnfme());
|
taskDetl.setWaveId(waveId);
|
taskDetl.setOrderId(null);
|
taskDetl.setOrderNo(null);
|
if (!taskDetlService.save(taskDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
|
List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
|
for (LocDetlField locDetlField : locDetlFields) {
|
TaskDetlField taskDetlField = new TaskDetlField();
|
taskDetlField.sync(locDetlField);
|
taskDetlField.setId(null);
|
taskDetlField.setDetlId(taskDetl.getId());
|
boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
|
if(!taskDetlFieldSave){
|
throw new CoolException("明细扩展生成失败");
|
}
|
}
|
|
String matUniqueKey = Utils.getMatUniqueKey(taskDetl.getMatnr(), taskDetl.getBatch(), taskDetl.getUniqueField());
|
WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));
|
if (waveDetl == null) {
|
throw new CoolException("波次数据不存在");
|
}
|
waveDetl.setWorkQty(waveDetl.getWorkQty() + taskDetl.getAnfme());
|
waveDetl.setUpdateTime(new Date());
|
if (!waveDetlService.updateById(waveDetl)) {
|
throw new CoolException("波次数据更新失败");
|
}
|
|
}
|
|
//库位F => R
|
loc.setLocStsId(LocStsType.R.val());
|
loc.setUpdateTime(new Date());
|
boolean locUpdate = locService.updateById(loc);
|
if(!locUpdate){
|
throw new CoolException("库位状态更新失败");
|
}
|
|
}
|
|
Wave wave = waveService.getById(waveId);
|
if (wave == null) {
|
throw new CoolException("波次不存在");
|
}
|
|
wave.setWaveStatus(WaveStatusType.GENERATE.id);
|
wave.setUpdateTime(new Date());
|
if (!waveService.updateById(wave)) {
|
throw new CoolException("波次更新失败");
|
}
|
}
|
|
@Transactional
|
public void generateWave(GenerateWaveParam param) {
|
if (param == null) {
|
throw new CoolException("参数不能为空");
|
}
|
|
List<String> channels = param.getChannels();
|
if (channels == null) {
|
throw new CoolException("通道参数不能为空");
|
}
|
|
if (channels.isEmpty()) {
|
throw new CoolException("通道参数不能为空");
|
}
|
|
for (String channel : channels) {
|
long count = cacheSiteService.count(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getChannel, channel).ne(CacheSite::getSiteStatus, 0));
|
if (count > 0) {
|
throw new CoolException(channel + "通道已经分配波次");
|
}
|
}
|
|
|
List<Long> orderIds = param.getOrderIds();
|
if (orderIds == null) {
|
throw new CoolException("订单参数不能为空");
|
}
|
|
if (orderIds.isEmpty()) {
|
throw new CoolException("订单参数不能为空");
|
}
|
|
List<Order> orderList = orderService.listByIds(orderIds);
|
if (orderList.isEmpty()) {
|
throw new CoolException("订单不存在");
|
}
|
|
for (Order order : orderList) {
|
if (order.getWaveId() != null) {
|
throw new CoolException("当前订单中已经生成波次");
|
}
|
}
|
|
String waveNo = orderNoRuleService.getOrderNo(3);
|
Wave wave = new Wave();
|
wave.setWaveNo(waveNo);
|
wave.setWaveType(0);
|
wave.setWaveStatus(WaveStatusType.INIT.id);
|
if (!waveService.save(wave)) {
|
throw new CoolException("波次生成失败");
|
}
|
|
HashMap<String, List<OrderDetl>> map = new HashMap<>();
|
for (Order order : orderList) {
|
List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, order.getId()));
|
for (OrderDetl orderDetl : orderDetls) {
|
List<OrderDetl> list = map.get(orderDetl.getStockIndex());
|
if (list == null) {
|
list = new ArrayList<>();
|
}
|
list.add(orderDetl);
|
map.put(orderDetl.getStockIndex(), list);
|
}
|
|
order.setOrderSettle(OrderSettleType.WAVE.val());
|
order.setWaveId(wave.getId());
|
order.setWaveNo(waveNo);
|
order.setHasWave(1);
|
order.setUpdateTime(new Date());
|
if (!orderService.updateById(order)) {
|
throw new CoolException("订单反写波次失败");
|
}
|
|
List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getSiteStatus, CacheSiteStatusType.O.id).in(CacheSite::getChannel, channels).orderBy(true, true, CacheSite::getChannel));
|
if (cacheSites.isEmpty()) {
|
throw new CoolException("缓存站空间不足，请稍后再试");
|
}
|
|
CacheSite cacheSite = cacheSites.get(0);
|
cacheSite.setOrderId(order.getId());
|
cacheSite.setOrderNo(order.getOrderNo());
|
cacheSite.setSiteStatus(CacheSiteStatusType.R.id);
|
cacheSite.setUpdateTime(new Date());
|
if (!cacheSiteService.updateById(cacheSite)) {
|
throw new CoolException("缓存站更新失败");
|
}
|
}
|
|
for (Map.Entry<String, List<OrderDetl>> entry : map.entrySet()) {
|
String stockIndex = entry.getKey();
|
List<OrderDetl> orderDetls = entry.getValue();
|
Double anfme = 0D;
|
Long matId = null;
|
String matnr = null;
|
String batch = null;
|
List<FieldParam> uniqueField = null;
|
for (OrderDetl orderDetl : orderDetls) {
|
anfme += orderDetl.getAnfme();
|
matId = orderDetl.getMatId();
|
matnr = orderDetl.getMat$().getMatnr();
|
batch = orderDetl.getBatch();
|
uniqueField = orderDetl.getUniqueField();
|
}
|
|
WaveDetl waveDetl = new WaveDetl();
|
waveDetl.setWaveNo(waveNo);
|
waveDetl.setWaveId(wave.getId());
|
waveDetl.setStockIndex(stockIndex);
|
waveDetl.setMatId(matId);
|
waveDetl.setMatnr(matnr);
|
waveDetl.setBatch(batch);
|
waveDetl.setAnfme(anfme);
|
waveDetl.setWorkQty(0D);
|
waveDetl.setFieldParams(JSON.toJSONString(uniqueField));
|
if (!waveDetlService.save(waveDetl)) {
|
throw new CoolException("波次明细生成失败");
|
}
|
|
}
|
|
}
|
|
@Transactional
|
public void cancelWave(List<Long> waveIds) {
|
if (waveIds == null) {
|
throw new CoolException("参数不能为空");
|
}
|
|
if (waveIds.isEmpty()) {
|
throw new CoolException("参数不能为空");
|
}
|
|
List<Wave> waves = waveService.listByIds(waveIds);
|
if (waves.isEmpty()) {
|
throw new CoolException("波次不存在");
|
}
|
|
for (Wave wave : waves) {
|
List<WaveDetl> waveDetls = waveDetlService.list(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, wave.getId()));
|
for (WaveDetl waveDetl : waveDetls) {
|
long count = taskDetlService.count(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getWaveId, wave.getId()));
|
if (count > 0) {
|
throw new CoolException("已存在任务，禁止取消波次");
|
}
|
|
List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().eq(Order::getWaveId, wave.getId()));
|
for (Order order : orders) {
|
order.setWaveId(null);
|
order.setWaveNo(null);
|
order.setHasWave(0);
|
if(order.getOrderSettle().equals(OrderSettleType.WAVE.val())){
|
order.setOrderSettle(OrderSettleType.WAIT.val());
|
}
|
if (!orderService.updateById(order)) {
|
throw new CoolException("订单反写失败");
|
}
|
|
CacheSite cacheSite = cacheSiteService.getOne(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderId, order.getId()));
|
if (cacheSite == null) {
|
throw new CoolException("缓存站不存在");
|
}
|
cacheSite.setSiteStatus(CacheSiteStatusType.O.id);
|
cacheSite.setOrderId(null);
|
cacheSite.setOrderNo(null);
|
cacheSite.setUpdateTime(new Date());
|
if (!cacheSiteService.updateById(cacheSite)) {
|
throw new CoolException("缓存站清空失败");
|
}
|
}
|
|
waveDetlService.removeById(waveDetl.getId());
|
}
|
|
waveService.removeById(wave.getId());
|
}
|
|
}
|
|
}
|
