package com.vincent.rsf.server.api.service.impl;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.cfg.CoercionAction;
|
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.config.RemotesInfoProperties;
|
import com.vincent.rsf.server.api.entity.CommonResponse;
|
import com.vincent.rsf.server.api.entity.constant.RcsConstant;
|
import com.vincent.rsf.server.api.entity.dto.InTaskMsgDto;
|
import com.vincent.rsf.server.api.entity.dto.LocTypeDto;
|
import com.vincent.rsf.server.api.controller.erp.params.TaskInParam;
|
import com.vincent.rsf.server.api.entity.dto.SyncLocsDto;
|
import com.vincent.rsf.server.api.entity.enums.CallBackEvent;
|
import com.vincent.rsf.server.api.entity.params.CommonRequest;
|
import com.vincent.rsf.server.api.entity.params.ExMsgParams;
|
import com.vincent.rsf.server.api.entity.params.WcsTaskParams;
|
import com.vincent.rsf.server.manager.enums.*;
|
import com.vincent.rsf.server.api.service.WcsService;
|
import com.vincent.rsf.server.api.utils.LocUtils;
|
import com.vincent.rsf.server.api.utils.SlaveProperties;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.manager.service.impl.LocServiceImpl;
|
import com.vincent.rsf.server.system.constant.SerialRuleCode;
|
import com.vincent.rsf.server.manager.enums.LocStsType;
|
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.http.HttpEntity;
|
import org.springframework.http.HttpHeaders;
|
import org.springframework.http.HttpMethod;
|
import org.springframework.http.ResponseEntity;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.client.RestTemplate;
|
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Random;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.ScheduledExecutorService;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class WcsServiceImpl implements WcsService {
|
@Autowired
|
private DeviceSiteService deviceSiteService;
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private DeviceBindService deviceBindService;
|
@Autowired
|
private LocServiceImpl locService;
|
@Autowired
|
private LocItemService locItemService;
|
@Autowired
|
private SlaveProperties slaveProperties;
|
@Autowired
|
private WarehouseAreasService warehouseAreasService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private TaskItemService taskItemService;
|
@Autowired
|
private WaitPakinItemService waitPakinItemService;
|
@Autowired
|
private BasStationService basStationService;
|
@Autowired
|
private RestTemplate restTemplate;
|
@Autowired
|
private RemotesInfoProperties.RcsApi rcsApi;
|
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void agvTaskPickUpComplete(TaskInParam param) {
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
|
.eq(Task::getBarcode, param.getBarcode())
|
);
|
if (null == task) {
|
throw new CoolException("未找到任务信息");
|
}
|
// if (!task.getTaskStatus().equals(TaskStsType.WCS_CONVEYOR_START.id)){
|
// throw new CoolException("任务状态有误");
|
// }
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, param.getSourceStaNo())
|
);
|
if (null == basStation) {
|
throw new CoolException("未找到站点信息");
|
}
|
task.setTaskStatus(TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id);
|
taskService.updateById(task);
|
|
basStation.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
|
basStation.setBarcode(null);
|
basStationService.updateById(basStation);
|
|
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public InTaskMsgDto createInTask(TaskInParam param) {
|
|
// 验证设备站点
|
DeviceSite deviceSite = validateDeviceSite(param);
|
|
// 验证组拖状态
|
WaitPakin waitPakin = validateWaitPakin(param.getBarcode());
|
|
// 生成任务编码
|
String ruleCode = generateTaskCode();
|
|
// 获取库位号
|
InTaskMsgDto locNo = null;
|
try {
|
locNo = getLocNo(param);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
|
// 创建并保存任务
|
Task task = createTask(ruleCode, locNo.getLocNo(), waitPakin.getBarcode(),
|
deviceSite.getDeviceSite(), param.getSourceStaNo().toString(), param.getUser());
|
|
// 更新库位状态
|
updateLocStatus(task.getTargLoc(), waitPakin.getBarcode());
|
|
// 获取并验证组拖明细
|
List<WaitPakinItem> waitPakinItems = getWaitPakinItems(waitPakin.getId());
|
|
// 创建并保存任务明细
|
saveTaskItems(task.getId(), waitPakinItems, param.getUser());
|
|
// 更新组托状态
|
updateWaitPakinStatus(param.getBarcode(), param.getUser());
|
|
// 设置工作单号并返回
|
locNo.setWorkNo(ruleCode);
|
return locNo;
|
}
|
|
|
/**
|
* 验证设备站点
|
*/
|
private DeviceSite validateDeviceSite(TaskInParam param) {
|
DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getSite, param.getSourceStaNo())
|
.eq(DeviceSite::getType, param.getIoType()));
|
|
if (Objects.isNull(deviceSite)) {
|
throw new CoolException("站点不存在！！");
|
}
|
return deviceSite;
|
}
|
|
/**
|
* 验证组拖状态
|
*/
|
private WaitPakin validateWaitPakin(String barcode) {
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, barcode)
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
|
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("请检查组拖状态是否完成！！");
|
}
|
return waitPakin;
|
}
|
|
/**
|
* 生成任务编码
|
*/
|
private String generateTaskCode() {
|
String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TASK_CODE, null);
|
if (StringUtils.isBlank(ruleCode)) {
|
throw new CoolException("编码错误：请确认编码「SYS_TASK_CODE」是否已生成!!");
|
}
|
return ruleCode;
|
}
|
|
/**
|
* 创建并保存任务
|
*/
|
private Task createTask(String ruleCode, String targetLoc, String barcode,
|
String targetSite, String sourceSiteNo, Long loginUserId) {
|
Task task = new Task();
|
task.setTaskCode(ruleCode)
|
.setTaskStatus(TaskStsType.GENERATE_IN.id)
|
.setTaskType(TaskType.TASK_TYPE_IN.type)
|
.setWarehType(WarehType.WAREHOUSE_TYPE_CRN.val)
|
.setTargLoc(targetLoc)
|
.setBarcode(barcode)
|
.setTargSite(targetSite)
|
.setCreateBy(loginUserId)
|
.setUpdateBy(loginUserId)
|
.setOrgSite(sourceSiteNo);
|
|
if (!taskService.save(task)) {
|
throw new CoolException("任务保存失败！！");
|
}
|
return task;
|
}
|
|
/**
|
* 更新库位状态
|
*/
|
private void updateLocStatus(String locCode, String barcode) {
|
boolean updated = locService.update(new LambdaUpdateWrapper<Loc>()
|
.eq(Loc::getCode, locCode)
|
.set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_S.type)
|
.set(Loc::getBarcode, barcode));
|
if (!updated) {
|
throw new CoolException("库位预约失败！！");
|
}
|
}
|
|
/**
|
* 获取并验证组拖明细
|
*/
|
private List<WaitPakinItem> getWaitPakinItems(Long pakinId) {
|
List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, pakinId));
|
if (waitPakinItems.isEmpty()) {
|
throw new CoolException("数据错误：组拖明细不存在");
|
}
|
return waitPakinItems;
|
}
|
|
/**
|
* 创建并保存任务明细
|
*/
|
private void saveTaskItems(Long taskId, List<WaitPakinItem> waitPakinItems, Long loginUserId) {
|
List<TaskItem> taskItems = waitPakinItems.stream().map(item -> {
|
TaskItem taskItem = new TaskItem();
|
BeanUtils.copyProperties(item, taskItem);
|
|
return taskItem.setTaskId(taskId)
|
.setOrderType(OrderType.ORDER_IN.type)
|
.setSource(item.getId())
|
.setTrackCode(item.getTrackCode())
|
.setCreateBy(loginUserId)
|
.setUpdateBy(loginUserId)
|
.setOrderId(item.getAsnId())
|
.setOrderItemId(item.getAsnItemId());
|
}).collect(Collectors.toList());
|
|
if (!taskItemService.saveBatch(taskItems)) {
|
throw new CoolException("任务明细保存失败！！");
|
}
|
}
|
|
/**
|
* 更新组托状态
|
*/
|
private void updateWaitPakinStatus(String barcode, Long loginUserId) {
|
boolean updated = waitPakinService.update(new LambdaUpdateWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, barcode)
|
.set(WaitPakin::getUpdateBy, loginUserId)
|
.set(WaitPakin::getCreateBy, loginUserId)
|
.set(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_TASK_EXCE.val));
|
|
if (!updated) {
|
throw new CoolException("组托状态修改失败！！");
|
}
|
}
|
|
// @Override
|
// public InTaskMsgDto createInTask(TaskInParam param, Long loginUserId) {
|
// InTaskMsgDto locNo = getLocNo(param);
|
// DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
// .eq(DeviceSite::getSite, param.getSourceStaNo())
|
// .eq(DeviceSite::getType,param.getIoType())
|
// );
|
// if (Objects.isNull(deviceSite)) {
|
// throw new CoolException("站点不存在！！");
|
// }
|
//
|
// WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
// .eq(WaitPakin::getBarcode, param.getBarcode())
|
// .eq(WaitPakin::getIoStatus, Short.parseShort(PakinIOStatus.PAKIN_IO_STATUS_DONE.val)));
|
// if (Cools.isEmpty(waitPakin)) {
|
// throw new CoolException("请检查组拖状态是否完成！！");
|
// }
|
//
|
// List<TaskItem> taskItems = new ArrayList<>();
|
// String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TASK_CODE, null);
|
// if (StringUtils.isBlank(ruleCode)) {
|
// throw new CoolException("编码错误：请确认编码「SYS_TASK_CODE」是否已生成!!");
|
// }
|
// Task task = new Task();
|
// task.setTaskCode(ruleCode)
|
// .setTaskStatus(TaskStsType.GENERATE_IN.id.shortValue())
|
// .setTaskType(TaskType.TASK_TYPE_IN.type.shortValue())
|
// .setTargLoc(locNo.getLocNo())
|
// .setBarcode(waitPakin.getBarcode())
|
// .setTargSite(deviceSite.getDeviceSite())
|
// .setCreateBy(loginUserId)
|
// .setUpdateBy(loginUserId)
|
// .setOrgSite(param.getSourceStaNo().toString());
|
//
|
//
|
//
|
//
|
// if (!taskService.save(task)) {
|
// throw new CoolException("任务保存失败！！");
|
// }
|
// if (!locService.update(new LambdaUpdateWrapper<Loc>().eq(Loc::getCode, task.getTargLoc())
|
// .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_S.type).set(Loc::getBarcode, waitPakin.getBarcode()))) {
|
// throw new CoolException("库位预约失败！！");
|
// }
|
// /**获取组拖明细**/
|
// List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
// if (waitPakinItems.isEmpty()) {
|
// throw new CoolException("数据错误：组拖明细不存在");
|
// }
|
// waitPakinItems.forEach(item -> {
|
// TaskItem taskItem = new TaskItem();
|
// BeanUtils.copyProperties(item, taskItem);
|
|
/// / AsnOrder order = asnOrderService.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getId, item.getAsnId()));
|
/// / if (Objects.isNull(order)) {
|
/// / throw new CoolException("数据错误: 单据不存在！！");
|
/// / }
|
// taskItem.setTaskId(task.getId())
|
// .setOrderType(OrderType.ORDER_RECEIPT.type)
|
// .setSource(item.getId())
|
// .setTrackCode(item.getTrackCode())
|
// .setCreateBy(loginUserId)
|
// .setUpdateBy(loginUserId)
|
// .setOrderId(item.getAsnId())
|
// .setOrderItemId(item.getAsnItemId());
|
// taskItems.add(taskItem);
|
// });
|
// if (!taskItemService.saveBatch(taskItems)) {
|
// throw new CoolException("任务明细保存失败！！");
|
// }
|
//
|
//
|
// if (!waitPakinService.update(new LambdaUpdateWrapper<WaitPakin>()
|
// .eq(WaitPakin::getBarcode, param.getBarcode())
|
// .set(WaitPakin::getUpdateBy, loginUserId)
|
// .set(WaitPakin::getCreateBy, loginUserId)
|
// .set(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_TASK_EXCE.val))) {
|
// throw new CoolException("组托状态修改失败！！");
|
// }
|
// locNo.setWorkNo(ruleCode);
|
// return locNo;
|
// }
|
@Override
|
public InTaskMsgDto getLocNo(TaskInParam param) throws Exception {
|
String matnr = null;
|
String batch = null;
|
List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, param.getBarcode()));
|
if (Cools.isEmpty(waitPakins) && param.getIoType().equals(TaskType.TASK_TYPE_IN.type)) {
|
throw new CoolException("未找到组托信息，请组托");
|
} else if (!Cools.isEmpty(waitPakins)) {
|
matnr = waitPakins.get(0).getCode();
|
batch = waitPakins.get(0).getCode();
|
}
|
List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getSite, param.getSourceStaNo())
|
.eq(DeviceSite::getType, param.getIoType())
|
);
|
if (Cools.isEmpty(deviceSites)) {
|
throw new CoolException("未找到站点路径信息");
|
}
|
DeviceBind deviceBind = deviceBindService.getById(LocUtils.getAreaType(param.getSourceStaNo()));
|
if (Cools.isEmpty(deviceBind)) {
|
throw new CoolException("数据异常，请联系管理员===>库位规则未知");
|
}
|
WarehouseAreas warehouseArea = warehouseAreasService.getById(deviceBind.getTypeId());
|
if (Cools.isEmpty(warehouseArea)) {
|
throw new CoolException("未找到所属库区信息");
|
}
|
LocTypeDto locTypeDto = new LocTypeDto(param);
|
InTaskMsgDto dto = null;
|
//根据立库类型获取获取库位
|
if (warehouseArea.getType().equals(WarehType.WAREHOUSE_TYPE_CRN.val)) {
|
//堆垛机
|
dto = getLocNoCrn(param.getOrgLoc(), deviceBind, warehouseArea.getId(), param.getSourceStaNo(), matnr, batch, locTypeDto, 0, param.getIoType());
|
|
} else if (warehouseArea.getType().equals(WarehType.WAREHOUSE_TYPE_FOUR_DIRECTIONS.val)) {
|
//四向库
|
} else {
|
//CTU 库以及其它
|
dto = getLocNoCtu(deviceBind, warehouseArea.getId(), param.getSourceStaNo(), matnr, batch, locTypeDto, 0, param.getIoType());
|
}
|
return dto;
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/8/28
|
* @description: Wcs库位同步
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void syncLocsToWms() {
|
/**RCS基础配置链接*/
|
CommonRequest params = new CommonRequest();
|
params.setPageSize(100);
|
ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(1);
|
scheduled.scheduleWithFixedDelay(new Runnable() {
|
int current = 1;
|
|
@Override
|
public void run() {
|
params.setCurrent(current);
|
List<SyncLocsDto> dtos = syncLocs(params);
|
if (dtos.isEmpty()) {
|
scheduled.shutdown();
|
}
|
for (SyncLocsDto dto : dtos) {
|
Loc loc = new Loc();
|
String string = new Random().nextInt(10000000) + "";
|
Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, dto.getLocNo()));
|
if (!Objects.isNull(one)) {
|
string = new Random().nextInt(10000000) + "";
|
}
|
loc.setCode(dto.getLocNo())
|
.setBarcode(dto.getBarcode())
|
.setRow(dto.getRow())
|
.setLev(dto.getLev())
|
.setId(null)
|
.setAreaId(42L)
|
.setWarehouseId(29L)
|
.setBarcode(string)
|
.setCol(dto.getBay())
|
.setType(dto.getLocType().equals("16") ? "17" : "15")
|
.setStatus(dto.getStatusBool())
|
.setUseStatus(LocStsType.getLocSts(dto.getLocSts()));
|
if (!locService.save(loc)) {
|
scheduled.shutdown();
|
throw new CoolException("WCS库位同步失败！！");
|
}
|
}
|
current++;
|
}
|
}, 1, 1, TimeUnit.SECONDS);
|
|
}
|
|
/**
|
* 异常信息上报
|
*
|
* @return
|
*/
|
@Override
|
public R receiveExMsg(ExMsgParams params) {
|
if (Objects.isNull(params)) {
|
return R.error("参数不能为空！！");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, params.getSeqNum()));
|
if (Objects.isNull(task)) {
|
throw new CoolException("任务不存在可已结束！！");
|
}
|
|
/**料箱搬运中， 修改站点状态*/
|
// if (params.getEventType().equals(CallBackEvent.CALL_BACK_EVENT_OBIT.event)) {
|
// if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)
|
// || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)
|
// || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)
|
// || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type)
|
// || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_IN.type)
|
// || task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
|
//
|
// }
|
// /**取箱完成， 修改任务状态*/
|
// } else
|
if (params.getEventType().equals(CallBackEvent.CALL_BACK_EVENT_END.event)) {
|
if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_IN.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
|
|
if (!task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
|
BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getOrgSite()));
|
if (Objects.isNull(station)) {
|
throw new CoolException("数据错误，站点不存在！！");
|
}
|
if (station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
|
station.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
|
if (!basStationService.updateById(station)) {
|
throw new CoolException("站点状态修改失败！！");
|
}
|
}
|
}
|
|
if (!taskService.update(new LambdaUpdateWrapper<Task>()
|
.lt(Task::getTaskStatus, TaskStsType.COMPLETE_IN.id)
|
.eq(Task::getTaskCode, task.getTaskCode())
|
.set(Task::getTaskStatus, TaskStsType.COMPLETE_IN.id))) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
} else if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
|
|| task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)) {
|
|
|
/**修改出库站点状态*/
|
BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, task.getTargSite()));
|
if (Objects.isNull(station)) {
|
throw new CoolException("数据错误，站点不存在！！");
|
}
|
if (station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
|
station.setUseStatus(LocStsType.LOC_STS_TYPE_F.type);
|
if (!basStationService.updateById(station)) {
|
throw new CoolException("站点状态修改失败！！");
|
}
|
}
|
|
if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
|
.lt(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id)
|
.set(Task::getTaskStatus, TaskStsType.AWAIT.id))) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
}
|
}
|
log.info(JSONObject.toJSONString(params));
|
return R.ok(JSONObject.toJSONString(params));
|
}
|
|
/**
|
* 下发任务至中转API
|
*
|
* @param params
|
* @return
|
*/
|
@Override
|
public R pubWcsTask(WcsTaskParams params) {
|
String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.pubTask;
|
log.info("任务下发，请求地址： {}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
HttpEntity httpEntity = new HttpEntity(params, headers);
|
ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
|
log.info("任务下发后，响应结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("任务下发失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults()
|
.setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
return R.ok();
|
} else {
|
throw new CoolException("任务下发失败！！");
|
}
|
} catch (JsonProcessingException e) {
|
throw new CoolException(e.getMessage());
|
}
|
}
|
}
|
|
|
private List<SyncLocsDto> syncLocs(CommonRequest params) {
|
String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.syncLocs;
|
log.info("库位同步，请求地址： {}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
HttpEntity httpEntity = new HttpEntity(params, headers);
|
ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
|
log.info("库位同步，响应结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("库位同步下发失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults()
|
.setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
JSONObject jsonObject = JSONObject.parseObject(exchange.getBody());
|
return JSONArray.parseArray(jsonObject.getJSONArray("data").toJSONString(), SyncLocsDto.class);
|
} else {
|
throw new CoolException("库位同步失败！！");
|
}
|
} catch (JsonProcessingException e) {
|
throw new CoolException(e.getMessage());
|
}
|
}
|
}
|
|
private InTaskMsgDto getLocNoCrn(String orgLoc, DeviceBind deviceBind, Long area, String sourceStaNo, String matnr, String batch, LocTypeDto locTypeDto, int times, Integer ioType) {
|
if (Cools.isEmpty(matnr)) { //物料号
|
matnr = "";
|
}
|
if (Cools.isEmpty(batch)) { //批次
|
batch = "";
|
}
|
// 初始化参数
|
int channel = 0; //堆垛机号
|
int nearRow = 0; //最浅库位排
|
int curRow = 0; //最深库位排
|
int rowCount = 0; //轮询轮次
|
Loc loc = null; // 目标库位
|
|
InTaskMsgDto inTaskMsgDto = new InTaskMsgDto();
|
|
int deviceQty = deviceBind.getDeviceQty();
|
|
|
// ===============>>>> 开始执行
|
curRow = deviceBind.getCurrentRow();
|
|
//获取排
|
int[] locNecessaryParameters = LocUtils.LocNecessaryParameters(deviceBind, curRow, deviceQty);
|
curRow = locNecessaryParameters[1];
|
channel = locNecessaryParameters[2];
|
rowCount = locNecessaryParameters[0];
|
nearRow = locNecessaryParameters[3];
|
|
|
if (nearRow == 0) {
|
throw new CoolException("无可用堆垛机");
|
}
|
//入库靠近摆放
|
if (ioType == 1 && deviceBind.getBeSimilar().equals("1") && !Cools.isEmpty(matnr) && Cools.isEmpty(orgLoc)) {
|
if (nearRow != curRow) {
|
List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>().eq(LocItem::getMatnrCode, matnr));
|
for (LocItem locItem : locItems) {
|
Loc loc1 = locService.getById(locItem.getLocId());
|
if (LocUtils.isShallowLoc(loc1.getCode())) {
|
continue;
|
}
|
String shallowLocNo = LocUtils.getShallowLoc(loc1.getCode());
|
// 检测目标库位是否为空库位
|
Loc shallowLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, shallowLocNo));
|
if (shallowLoc != null && shallowLoc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
|
if (LocUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
|
loc = shallowLoc;
|
channel = shallowLoc.getChannel();
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
// // 靠近摆放规则 --- 空托 //互通版
|
// if (ioType == 10 && deviceBind.getEmptySimilar().equals("1")) {
|
// List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
|
// .eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow).eq("whs_type", rowLastnoType.getType().longValue()));
|
// if (!locMasts.isEmpty()) {
|
// for (LocMast loc : locMasts) {
|
// if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
|
// continue;
|
// }
|
// String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
|
// // 检测目标库位是否为空库位
|
// LocMast shallowLoc = locMastService.selectById(shallowLocNo);
|
// if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
|
// if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
|
// if (basCrnpService.checkSiteError(shallowLoc.getCrnNo(), true)) {
|
// locMast = shallowLoc;
|
// crnNo = locMast.getCrnNo();
|
// break;
|
// }
|
// }
|
// }
|
// }
|
// }
|
// }
|
//查找路径
|
DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getType, ioType)
|
.eq(DeviceSite::getSite, sourceStaNo)
|
.eq(DeviceSite::getChannel, channel)
|
);
|
if (Cools.isEmpty(deviceSite)) {
|
channel = 0;
|
} else {
|
inTaskMsgDto.setStaNo(deviceSite.getDeviceSite());
|
}
|
|
//更新当前排
|
deviceBind.setCurrentRow(curRow);
|
deviceBindService.updateById(deviceBind);
|
|
// 开始查找库位 ==============================>>
|
|
// 1.按规则查找库位
|
if (Cools.isEmpty(loc) && channel != 0) {
|
List<Loc> locMasts = null;
|
locMasts = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getRow, nearRow)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getType, locTypeDto.getLocType1())
|
.eq(Loc::getAreaId, area)
|
.orderByAsc(Loc::getLev)
|
.orderByAsc(Loc::getCol)
|
);
|
Loc orgMoveLoc = null;
|
if (!Cools.isEmpty(orgLoc)) {
|
orgMoveLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, orgLoc));
|
}
|
for (Loc locMast1 : locMasts) {
|
if (!LocUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
|
continue;
|
}
|
String shallowLoc = LocUtils.getDeepLoc(locMast1.getCode());
|
if ((ioType == 1 && deviceBind.getBeSimilar().equals("1"))) {
|
//相似物料打开，判断深库位有没有货，没货就放深库位，有货就不操作
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
|
if (!Cools.isEmpty(locMast2)) {
|
if (null != orgMoveLoc) {
|
if (!locMast2.getChannel().equals(orgMoveLoc.getChannel())) {
|
break;
|
}
|
}
|
loc = locMast2;
|
break;
|
}
|
} else {
|
//相似物料关闭，判断深库位有没有货，有货就放浅库位，无货就不操作
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.in(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type, LocStsType.LOC_STS_TYPE_F.type)
|
.eq(Loc::getAreaId, area)
|
);
|
|
if (!Cools.isEmpty(locMast2)) {
|
if (null != orgMoveLoc) {
|
if (!locMast2.getChannel().equals(orgMoveLoc.getChannel())) {
|
break;
|
}
|
}
|
loc = locMast1;
|
break;
|
} else {
|
locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
|
if (!Cools.isEmpty(locMast2)) {
|
if (null != orgMoveLoc) {
|
if (!locMast2.getChannel().equals(orgMoveLoc.getChannel())) {
|
break;
|
}
|
}
|
loc = locMast2;
|
break;
|
}
|
}
|
}
|
}
|
if (Cools.isEmpty(loc) && deviceBind.getBeSimilar().equals("1")) {
|
for (Loc locMast1 : locMasts) {
|
if (!LocUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
|
continue;
|
}
|
if (deviceBind.getBeSimilar().equals("1")) {
|
String shallowLoc = LocUtils.getDeepLoc(locMast1.getCode());
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
|
if (!Cools.isEmpty(locMast2)) {
|
if (null != orgMoveLoc) {
|
if (!locMast2.getChannel().equals(orgMoveLoc.getChannel())) {
|
break;
|
}
|
}
|
loc = locMast2;
|
break;
|
} else {
|
locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.in(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type, LocStsType.LOC_STS_TYPE_D.type)
|
.eq(Loc::getAreaId, area)
|
);
|
|
if (!Cools.isEmpty(locMast2)) {
|
if (null != orgMoveLoc) {
|
if (!locMast2.getChannel().equals(orgMoveLoc.getChannel())) {
|
break;
|
}
|
}
|
loc = locMast1;
|
break;
|
}
|
}
|
} else {
|
if (!Cools.isEmpty(locMast1)) {
|
loc = locMast1;
|
break;
|
}
|
}
|
}
|
}
|
}
|
//查询当前库位类型空库位 小于5个则locmast = null
|
List<Loc> locTypeLocMasts = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getChannel, channel)
|
.eq(Loc::getType, locTypeDto.getLocType1())
|
.eq(Loc::getAreaId, area)
|
);
|
if (null != locTypeLocMasts && locTypeLocMasts.size() <= 5) {
|
loc = null;
|
}
|
// 递归查询
|
if (Cools.isEmpty(loc) || !loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
|
// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
|
if (times < rowCount * 2) {
|
times = times + 1;
|
return getLocNoCrn(orgLoc, deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, times, ioType);
|
|
}
|
// 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
|
if (locTypeDto.getLocType1() < 3) {
|
int i = locTypeDto.getLocType1() + 1;
|
locTypeDto.setLocType1(i);
|
return getLocNoCrn(orgLoc, deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, 0, ioType);
|
}
|
throw new CoolException("没有空库位");
|
}
|
String locNo = loc.getCode();
|
|
// 返回dto
|
inTaskMsgDto.setDeviceNo(channel);
|
inTaskMsgDto.setSourceStaNo(sourceStaNo);
|
// inTaskMsgDto.setStaNo();
|
inTaskMsgDto.setLocNo(locNo);
|
return inTaskMsgDto;
|
}
|
|
private InTaskMsgDto getLocNoCtu(DeviceBind deviceBind, Long area, String sourceStaNo, String matnr, String batch, LocTypeDto locTypeDto, int times, Integer ioType) {
|
if (Cools.isEmpty(matnr)) { //物料号
|
matnr = "";
|
}
|
if (Cools.isEmpty(batch)) { //批次
|
batch = "";
|
}
|
int deviceNo = 0;
|
Loc loc = new Loc();
|
InTaskMsgDto inTaskMsgDto = new InTaskMsgDto();
|
List<Loc> loc1 = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getAreaId, area)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getType, locTypeDto.getLocType1())
|
.ge(Loc::getRow, deviceBind.getStartRow())
|
.le(Loc::getRow, deviceBind.getEndRow())
|
.orderByAsc(Loc::getLev)
|
.orderByAsc(Loc::getCol)
|
.orderByAsc(Loc::getRow)
|
);
|
for (Loc loc2 : loc1) {
|
if (!LocUtils.locMoveCheckLocTypeComplete(loc2, locTypeDto)) {
|
continue;
|
}
|
loc = loc2;
|
break;
|
}
|
//查找路径
|
DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getType, ioType)
|
.eq(DeviceSite::getSite, sourceStaNo)
|
.eq(!Objects.isNull(loc.getDeviceNo()), DeviceSite::getDeviceCode, loc.getDeviceNo())
|
);
|
if (Cools.isEmpty(deviceSite)) {
|
deviceNo = 0;
|
loc = null;
|
} else {
|
inTaskMsgDto.setStaNo(deviceSite.getDeviceSite());
|
}
|
// 递归查询
|
if (Cools.isEmpty(loc) || !loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
|
// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
|
if (times < 5) {
|
times = times + 1;
|
return getLocNoCtu(deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, times, ioType);
|
|
}
|
// 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
|
if (locTypeDto.getLocType1() < 3) {
|
int i = locTypeDto.getLocType1() + 1;
|
locTypeDto.setLocType1(i);
|
return getLocNoCtu(deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, 0, ioType);
|
}
|
throw new CoolException("没有空库位");
|
}
|
|
String locNo = loc.getCode();
|
|
// 返回dto
|
inTaskMsgDto.setDeviceNo(deviceNo);
|
inTaskMsgDto.setSourceStaNo(sourceStaNo);
|
// inTaskMsgDto.setStaNo();
|
inTaskMsgDto.setLocNo(locNo);
|
return inTaskMsgDto;
|
}
|
}
|
