java_project
/
logisticsplatform-service
4
0
Fork 0
Code Issues Pull Requests Activity
Browse Source

add:增加作业节点的数据推送 

1.预约
2.备货
2.取消预约
3.配送计划创建/编辑
4.装车
5.签收
dist.1.3.0
pref_mail@163.com 7 months ago
parent
5b4ddb23c6
commit
43ab208a36
24 changed files with 1899 additions and 991 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      blade-biz-common/src/main/java/org/springblade/common/constant/ModuleNameConstant.java
  2. 51
      blade-biz-common/src/main/java/org/springblade/common/constant/broadcast/FanoutConstants.java
  3. 33
      blade-biz-common/src/main/java/org/springblade/common/model/DistributionLoadVO.java
  4. 23
      blade-biz-common/src/main/java/org/springblade/common/model/DistributionSignforVO.java
  5. 31
      blade-biz-common/src/main/java/org/springblade/common/model/DistributionTaskVO.java
  6. 5
      blade-biz-common/src/main/java/org/springblade/common/model/NodeFanoutMsg.java
  7. 14
      blade-biz-common/src/main/java/org/springblade/common/model/PlanDriverbindCarVO.java
  8. 66
      blade-biz-common/src/main/java/org/springblade/common/model/ReservationVO.java
  9. 50
      blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataClientLogServiceImpl.java
  10. 11
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/api/DistributionDeliveryAppController.java
  11. 709
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/api/DistributionStockupAppController.java
  12. 7
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/controller/DistributionReservationController.java
  13. 4
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/controller/DistributionSignforController.java
  14. 15
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/mapper/DistributionDeliveryListMapper.java
  15. 32
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/mapper/DistributionDeliveryListMapper.xml
  16. 4
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/receiver/report/PlanReportListener.java
  17. 7
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionDeliveryListService.java
  18. 20
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionNodeWorkService.java
  19. 13
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionStockupService.java
  20. 472
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionDeliveryListServiceImpl.java
  21. 165
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionNodeWorkServiceImpl.java
  22. 165
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionReservationServiceImpl.java
  23. 181
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionSignforServiceImpl.java
  24. 792
      blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionStockupServiceImpl.java

2
blade-biz-common/src/main/java/org/springblade/common/constant/ModuleNameConstant.java
Unescape View File

@ -9,7 +9,7 @@ public interface ModuleNameConstant {
/**
* 如果不需要 ""
*/
public static final String DEVAUTH ="";
public static final String DEVAUTH ="-pref";
/**
* 工厂对接服务名称

51
blade-biz-common/src/main/java/org/springblade/common/constant/broadcast/FanoutConstants.java
Unescape View File

@ -154,14 +154,35 @@ public abstract class FanoutConstants {
// }
}
/**
* 预约
*/
public interface reservation {
// 自主预约
interface OwnReservation {
String EXCHANGE = "fanout.reservation.own" + ModuleNameConstant.DEVAUTH;
interface QUEUE {
}
}
}
/**
* 配送
*/
public interface distribution {
// 配送计划
interface plan {
interface DeliveryAndPlan {
String EXCHANGE = "fanout.distribution.plan" + ModuleNameConstant.DEVAUTH;
// main: {"distributionCompany":"承运商", "driverName":"司机姓名", "id":"任务ID", "kind":"任务类型 1-自主 2-外协", "taskTime":"任务时间", "trainNumber":"车次号","type":"配送类型 1商配 2市配", "vehicleName":"车牌号"}
@ -172,9 +193,35 @@ public abstract class FanoutConstants {
// 备货节点
interface stock {
String EXCHANGE = "fanout.distribution.stock" + ModuleNameConstant.DEVAUTH;
// main: {"distributionCompany":"承运商", "driverName":"司机姓名", "id":"任务ID", "kind":"任务类型 1-自主 2-外协", "taskTime":"任务时间", "trainNumber":"车次号","type":"配送类型 1商配 2市配", "vehicleName":"车牌号"}
// main: {"id":"备货任务ID", "stockupCode":"备货编码", "typeService":"服务类型 1 商 2 市 3 自", "stockupDate":"备货时间"}
interface QUEUE {
}
}
// 装车节点
interface DeliveryAndLoading {
String EXCHANGE = "fanout.distribution.load" + ModuleNameConstant.DEVAUTH;
// main: {"id":"备货任务ID", "stockupCode":"备货编码", "typeService":"服务类型 1 商 2 市 3 自", "stockupDate":"备货时间"}
interface QUEUE {
}
}
/**
* 签收
*/
interface DeliveryAndSignfor {
String EXCHANGE = "fanout.distribution.signfor2" + ModuleNameConstant.DEVAUTH;
// main: {"id":"备货任务ID", "stockupCode":"备货编码", "typeService":"服务类型 1 商 2 市 3 自", "stockupDate":"备货时间"}
interface QUEUE {
}

33
blade-biz-common/src/main/java/org/springblade/common/model/DistributionLoadVO.java
Unescape View File

@ -0,0 +1,33 @@
package org.springblade.common.model;
import lombok.Data;
import java.io.Serializable;
/**
* 装车/签收VO
*/
@Data
public class DistributionLoadVO implements Serializable {
/**
* 装车表ID
*/
private Long id;
/**
* 司机名
*/
private String driverName;
/**
* 车牌号
*/
private String vehicleName;
/**
* 预约单号
*/
private String reservationCode;
}

23
blade-biz-common/src/main/java/org/springblade/common/model/DistributionSignforVO.java
Unescape View File

@ -0,0 +1,23 @@
package org.springblade.common.model;
import lombok.Data;
import java.io.Serializable;
@Data
public class DistributionSignforVO implements Serializable {
/**
* 司机名
*/
private String driverName;
/**
* 车牌号
*/
private String vehicleName;
/**
* 预约单号
*/
private String reservationCode;
}

31
blade-biz-common/src/main/java/org/springblade/common/model/DistributionTaskVO.java
Unescape View File

@ -0,0 +1,31 @@
package org.springblade.common.model;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* 配送计划
*/
@Data
public class DistributionTaskVO implements Serializable {
private String distributionCompany;
private Long id;
private String kind;
private String taskTime;
private String trainNumber;
private String type;
/**
* 司机名
*/
private String driverName;
/**
* 车牌号
*/
private String vehicleName;
private List<PlanDriverbindCarVO> planDriverbindCars;
}

5
blade-biz-common/src/main/java/org/springblade/common/model/NodeFanoutMsg.java
Unescape View File

@ -23,7 +23,7 @@ import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NodeFanoutMsg implements Serializable {
public class NodeFanoutMsg<T> implements Serializable {
/**
* 作业节点
@ -50,6 +50,7 @@ public class NodeFanoutMsg implements Serializable {
* 当前仓
*/
private String warehouse;
/**
* 当前仓ID
*/
@ -66,7 +67,7 @@ public class NodeFanoutMsg implements Serializable {
* 主单数据
* {"boId":"业务id","":""}
*/
private Object main;
private T main;
/**
* 内容

14
blade-biz-common/src/main/java/org/springblade/common/model/PlanDriverbindCarVO.java
Unescape View File

@ -0,0 +1,14 @@
package org.springblade.common.model;
import lombok.Data;
import java.io.Serializable;
@Data
public class PlanDriverbindCarVO implements Serializable {
private String driverName;
private String carPlate;
}

66
blade-biz-common/src/main/java/org/springblade/common/model/ReservationVO.java
Unescape View File

@ -0,0 +1,66 @@
package org.springblade.common.model;
import lombok.Data;
import java.util.Date;
/**
* 预约作业节点VO
*/
@Data
public class ReservationVO {
private Long id;
/**
* 预约单号
*/
private String reservationCode;
/**
* 预约时间
*/
private Date reservationDate;
/**
* 收货人
*/
private String consignee;
/**
* 收件地址
*/
private String deliveryAddress;
/**
* 收件电话
*/
private String deliveryPhone;
/**
* 商场名称
*/
private String mallName;
/**
* 门店名称
*/
private String storeName;
/**
* 仓库名称
*/
private String warehouseName;
/**
* 配送类型；1-商配、2-市配
*/
private String deliveryType;
}

50
blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataClientLogServiceImpl.java
Unescape View File

@ -16,59 +16,15 @@
*/
package com.logpm.basicdata.service.impl;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.logpm.basic.entity.BasicTenantCodeEntity;
import com.logpm.basic.feign.IBasicTenantCodeClient;
import com.logpm.basicdata.entity.*;
import com.logpm.basicdata.excel.BasicdataClientExcel;
import com.logpm.basicdata.entity.BasicdataClientLogEntity;
import com.logpm.basicdata.mapper.BasicdataClientLogMapper;
import com.logpm.basicdata.mapper.BasicdataClientMapper;
import com.logpm.basicdata.service.*;
import com.logpm.basicdata.vo.BasicdataClientVO;
import com.logpm.basicdata.vo.ClientInfoVO;
import com.logpm.basicdata.service.IBasicdataClientLogService;
import lombok.extern.slf4j.Slf4j;
import org.springblade.common.constant.DictBizConstant;
import org.springblade.common.constant.RedisKeyConstant;
import org.springblade.common.constant.basiccode.BasicCodeShowConstant;
import org.springblade.common.constant.basiccode.BasicCodeTypeConstant;
import org.springblade.common.model.dto.NameDTO;
import org.springblade.core.excel.util.ExcelUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springblade.system.cache.DictBizCache;
import org.springblade.system.entity.DictBiz;
import org.springblade.system.feign.IRegionFeign;
import org.springblade.system.feign.IUserClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.PostConstruct;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import static org.springblade.common.constant.DictBizConstant.OPEN_ORDER_PAY_WAY;
import java.util.List;
/**
* 基础客户表 服务实现类

11
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/api/DistributionDeliveryAppController.java
Unescape View File

@ -258,16 +258,7 @@ public class DistributionDeliveryAppController {
return msg;
}
// /**
// * 配送管理 配送库存品装车
// */
// @PostMapping("/loadinginventoryDe")
// @ApiOperationSupport(order = 7)
// @ApiOperation(value = "库存品装车", notes = "传入DistrilbutionloadingscanDTO")
// public R loadinginventoryDe(@Valid @RequestBody DistrilbutionloadingscanDTO distrilbutionloadingscanDTO) {
// R msg = distributionDeliveryListService.loadinginventoryDe(distrilbutionloadingscanDTO);
// return msg;
// }
/**
* 配送管理 装车扫描（取消）

709
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/api/DistributionStockupAppController.java
Unescape View File

@ -59,6 +59,7 @@ import org.springblade.common.constant.reservation.ReservationSigningStatusConst
import org.springblade.common.constant.stockup.StockupTypeStatusConstant;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.common.utils.CommonUtil;
@ -746,8 +747,6 @@ public class DistributionStockupAppController extends BladeController {
}
//todo 这里代码没有写完 等TJJ 和CYZ 空了来写
@ResponseBody
@PostMapping("/updateStockup")
@ -1006,32 +1005,20 @@ public class DistributionStockupAppController extends BladeController {
@ApiOperation(value = "备货扫描", notes = "传入stockupDTO")
public R stockupScan(@RequestBody StockupDTO stockupDTO) {
Integer scanType = stockupDTO.getScanType();//扫码类型 1 包件 2库存品
//手动
// TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
// try{
//设置lockey
String lockKey = "Lock:" + stockupDTO.getPacketBarCode() + stockupDTO.getStockupId();
log.info("#################stockupScan：获取redisson对象开始");
// RLock lock = redisson.getLock(lockKey);
// if (lock.isLocked()) {
// String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
// return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
// }
// lock.lock(5, TimeUnit.SECONDS);
if (redis.exists(lockKey)) {
String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
}
redis.setEx(lockKey, stockupDTO.getPacketBarCode() + stockupDTO.getStockupId(), 5L);
if (scanType == 1) {
//包件
return stockupScanByCustom(stockupDTO);
return distributionStockupService.stockupScanByCustom(stockupDTO);
} else if (scanType == 2) {
//库存平
R fail = stockupScanByStock(stockupDTO);
R fail = distributionStockupService.stockupScanByStock(stockupDTO);
if (fail != null) {
return fail;
}
@ -1043,695 +1030,5 @@ public class DistributionStockupAppController extends BladeController {
}
/**
* 库存品扫码
*
* @param stockupDTO
* @return
*/
@Nullable
private R stockupScanByStock(StockupDTO stockupDTO) {
//库存品扫描
Long reservationId = stockupDTO.getReservationId();
Long stockListId = stockupDTO.getStockListId();
String packetBarCode = stockupDTO.getPacketBarCode();
// String stockupArea = stockupDTO.getStockupArea();//备货区
Long stockupId = stockupDTO.getStockupId();//备货区
Long allocationId = stockupDTO.getAllocationId();//备货区
Integer stockPrint = stockupDTO.getStockPrint(); // 库存
BasicdataWarehouseEntity myCurrentWarehouse = basicdataWarehouseClient.getMyCurrentWarehouse();
if (Func.isEmpty(myCurrentWarehouse)) {
return R.data(403, "未授权!!!");
}
if (StringUtil.isBlank(packetBarCode)) {
log.warn("##################stockupScan: 库存品扫码，包件码为空");
return R.fail("库存品扫码:包件码不能为空");
}
if (ObjectUtils.isNull(stockupId)) {
log.warn("##################stockupScan: 库存品扫码，备货区为空");
return R.fail("库存品扫码:备货任务ID不能为空");
}
// if (Objects.isNull(stockListId)) {
// log.warn("##################stockupScan: 库存品扫码，库存品id为空");
// return R.fail("库存品扫码:库存品id不能为空");
// }
if (Objects.isNull(reservationId)) {
log.warn("##################stockupScan: 库存品扫码，预约单id为空");
return R.fail("库存品扫码:预约单id不能为空");
}
if (Objects.isNull(stockPrint)) {
log.warn("##################stockupScan: 库存品扫码，类型为空");
return R.fail("库存品扫码:类型不能为空");
}
if (Objects.isNull(allocationId)) {
log.warn("##################allocationId: 货位ID为空！");
return R.fail("货位ID不能为空");
}
//判断是否可以继续备货
DistributionStockListEntity byId = null;
// if (ObjectUtils.isNull(stockListId)) {
// 通过扫码的二维码 查询其对应的库存存信息
if (stockupDTO.getStockPrint() == 1) {
//1 原有包条
byId = distributionStockListService.selectStockInforByOrderPackageCode(stockupDTO.getPacketBarCode());
} else {
// 判断stockupDTO.getMallName() 是否存在
if (ObjectUtils.isNull(stockupDTO.getMallName()) || "null".equals(stockupDTO.getMallName())) {
// 查询出来 重新复制
DistributionStockListEntity byId1 = distributionStockListService.getById(stockupDTO.getStockListId());
log.info("##################stockupScan: 库存品扫码，库存品id{}",byId1);
if (!ObjectUtils.isNull(byId1)) {
stockupDTO.setMallName(byId1.getMarketName());
}
}
// 2打印处理的扫码
// 查询当前库位上最早入库的指定物料库存品
byId = disStockOrdercodeRecoService.selectStockOrdercodeRecoListByCode(stockupDTO.getCargoNumber(), stockupDTO.getAllocationId(), stockupDTO.getMallName());
// 需要判断当前这个找到的备货批次和计划的批次是否一直，如果不一致 就需要新增一个预约备货记录 扣减当前的数量
// updateStockOrdercodeRecoS(reservationId,byId);
if (Func.isEmpty(byId)) {
return Resp.scanFail("当前库位无此物料库存品", "当前库位无此物料库存品");
}
//判断当前库位上满足条件的库存品是否存在于预约计划中，如果不存在则需要对预约计划进行修改
List<DistributionReservationStocklistEntity> reservationStocklistEntityList = distributionReservationMapper.selectInventoryListByIdAndMateriel(stockupDTO.getReservationId(), stockupDTO.getCargoNumber());
if (Func.isNotEmpty(reservationStocklistEntityList)) {
DistributionStockListEntity finalById = byId;
boolean flag = reservationStocklistEntityList.stream()
.map(DistributionReservationStocklistEntity::getStocklistId)
.anyMatch(s -> s.equals(finalById.getId()));
if (!flag) {
DistributionReservationStocklistEntity rs = new DistributionReservationStocklistEntity();
rs.setReservationNum(1);
rs.setStockListStatus(ReservationOrderStatusConstant.zengjia.getValue());
rs.setReservationId(stockupDTO.getReservationId());
rs.setRealityNum(0);
rs.setUnit(byId.getCargoUnit());
rs.setLoadingStatus(ReservationLoadingStatusConstant.daizhuangche.getValue());
rs.setSigningStatus(ReservationSigningStatusConstant.daiqianshou.getValue());
rs.setStocklistId(byId.getId());
distributionReservationStocklistService.save(rs);
DistributionStockListEntity stockListEntity = distributionStockListService.getById(byId.getId());
stockListEntity.setQuantityOccupied(stockListEntity.getQuantityOccupied() + 1);
distributionStockListService.updateById(stockListEntity);
//原来对应的需要进行计划减少
//收集满足修改条件的计划库存品
List<DistributionReservationStocklistEntity> reservationStocklistEntities = new ArrayList<>();
for (DistributionReservationStocklistEntity reservationStocklistEntity : reservationStocklistEntityList) {
if (reservationStocklistEntity.getReservationNum() >= reservationStocklistEntity.getRealityNum() && reservationStocklistEntity.getReservationNum() > 0) {
reservationStocklistEntities.add(reservationStocklistEntity);
}
}
if (Func.isEmpty(reservationStocklistEntities)) {
return R.fail("该物料库存品备货已完成");
}
DistributionReservationStocklistEntity reservationStocklistEntity = reservationStocklistEntities.get(0);
int oldRsNum = reservationStocklistEntity.getReservationNum() - 1;
if (oldRsNum < 0) {
return R.fail("操作数据错误");
}
reservationStocklistEntity.setReservationNum(oldRsNum);
if (reservationStocklistEntity.getReservationNum() == 0) {
reservationStocklistEntity.setStockListStatus(ReservationOrderStatusConstant.quxiao.getValue());
}
distributionReservationStocklistService.updateById(reservationStocklistEntity);
//维护老的的冻结数量
DistributionStockListEntity oldStockList = distributionStockListService.getById(reservationStocklistEntity.getStocklistId());
oldStockList.setQuantityOccupied(oldStockList.getQuantityOccupied() - 1);
distributionStockListService.updateById(oldStockList);
//查询对应的包件进行修改
List<DisStockListDetailEntity> stockListDetailEntities = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda()
.eq(DisStockListDetailEntity::getReservationId, stockupDTO.getReservationId())
.eq(DisStockListDetailEntity::getStockListId, oldStockList.getId())
.ne(DisStockListDetailEntity::getStockPackageStatus, ReservationPackageStatusConstant.quxiao.getValue())
);
DisStockListDetailEntity disStockListDetailEntity = stockListDetailEntities.stream().filter(s -> Func.isBlank(s.getStockPackageCode())).collect(Collectors.toList()).get(0);
disStockListDetailEntity.setStockListId(rs.getStocklistId());
// disStockListDetailEntity.setStockStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
disStockListDetailService.updateById(disStockListDetailEntity);
} else {
//判断是否是为增加库存品进行数据维护
DistributionStockListEntity finalById1 = byId;
DistributionReservationStocklistEntity reservationStocklistEntity = reservationStocklistEntityList.stream().filter(f -> f.getStocklistId().equals(finalById1.getId())).collect(Collectors.toList()).get(0);
//因为新增库存品的时候会完成扫描 此时的增加数和备货数量时一样的
if (reservationStocklistEntity.getStockListStatus().equals(ReservationOrderStatusConstant.zengjia.getValue()) && Objects.equals(reservationStocklistEntity.getReservationNum(), reservationStocklistEntity.getRealityNum())) {
List<DistributionReservationStocklistEntity> oldRS = distributionReservationMapper.selectStockListByReservationIdAndCargoNumber(reservationStocklistEntity.getReservationId(), stockupDTO.getCargoNumber(), reservationStocklistEntity.getStocklistId());
//收集满足条件的库存品
List<DistributionReservationStocklistEntity> rs = new ArrayList<>();
for (DistributionReservationStocklistEntity oldR : oldRS) {
if (oldR.getReservationNum() >= oldR.getRealityNum() && oldR.getReservationNum() > 0) {
rs.add(oldR);
}
}
if (Func.isEmpty(rs)) {
//不存在还需要进行备货的库存品
return R.fail("该物料库存品备货已完成");
}
DistributionReservationStocklistEntity oldReservationStockList = rs.get(0);
int oldReservationNum = oldReservationStockList.getReservationNum() - 1;
oldReservationStockList.setReservationNum(oldReservationNum);
if (oldReservationNum == 0) {
oldReservationStockList.setStockListStatus(ReservationOrderStatusConstant.quxiao.getValue());
}
distributionReservationStocklistService.updateById(oldReservationStockList);
//修改对应库存品数量
DistributionStockListEntity stockListEntity = distributionStockListService.getById(oldReservationStockList.getStocklistId());
stockListEntity.setQuantityOccupied(stockListEntity.getQuantityOccupied() - 1);
distributionStockListService.updateById(stockListEntity);
//找出对库存品包件信息进行包件的修改
List<DisStockListDetailEntity> oldRsPack = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda()
.eq(DisStockListDetailEntity::getReservationId, oldReservationStockList.getReservationId())
.eq(DisStockListDetailEntity::getStockListId, oldReservationStockList.getStocklistId())
.ne(DisStockListDetailEntity::getStockPackageStatus, ReservationPackageStatusConstant.quxiao.getValue())
);
if (Func.isEmpty(oldRsPack)) {
return R.fail("该物料库存品备货已完成");
}
List<DisStockListDetailEntity> collect = oldRsPack.stream().filter(f -> Func.isBlank(f.getStockPackageCode())).collect(Collectors.toList());
DisStockListDetailEntity disStockListDetailEntity = collect.get(0);
disStockListDetailEntity.setStockListId(reservationStocklistEntity.getStocklistId());
// disStockListDetailEntity.setStockStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
disStockListDetailService.updateById(disStockListDetailEntity);
reservationStocklistEntity.setReservationNum(reservationStocklistEntity.getReservationNum() + 1);
distributionReservationStocklistService.updateById(reservationStocklistEntity);
//维护库存品在库数量
DistributionStockListEntity newStockList = distributionStockListService.getById(reservationStocklistEntity.getStocklistId());
newStockList.setQuantityOccupied(newStockList.getQuantityOccupied() + 1);
distributionStockListService.updateById(newStockList);
}
}
//当前库位最先入库的批次和计划批次一致
}
}
if (Func.isNotEmpty(byId)) {
stockupDTO.setStockListId(byId.getId());
}
// } else {
// byId = distributionStockListService.getById(stockListId);
// }
List<WarehouseUpdownGoodsEntity> locationInformation;
if ("2".equals(byId.getSourceType())) {
//导入
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setIncomingBatch(byId.getIncomingBatch());
warehouseUpdownGoodsEntity.setMarketId(byId.getMarketId());
warehouseUpdownGoodsEntity.setAssociationId(byId.getMaterialId());
warehouseUpdownGoodsEntity.setAssociationValue(byId.getCargoNumber());
warehouseUpdownGoodsEntity.setAssociationType("4");
warehouseUpdownGoodsEntity.setWarehouseId(byId.getWarehouseId());
locationInformation = warehouseUpdownGoodsClient.getLocationStockListInformation(warehouseUpdownGoodsEntity);
if (locationInformation.isEmpty()) {
return Resp.scanFail("当前货位的库存品已为零，请更换货位继续！！", "当前货位的库存品已为零，请更换货位继续！！");
}
} else {
// 读取码表上的配置项 是否开启验证批次号
String isCheckIncomingBatch = DictBizCache.getValue("isCheckIncomingBatch", "isCheckIncomingBatch");
List<DistributionParcelListEntity> list = distributionParcelListService.list(Wrappers.<DistributionParcelListEntity>query().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, packetBarCode)
.eq(DistributionParcelListEntity::getOrderCode, byId.getIncomingBatch())
.eq(DistributionParcelListEntity::getWarehouseId, byId.getWarehouseId())
);
//查询包件信息
if (ObjectUtils.isNotNull(list) && list.size() > 1) {
return Resp.scanFail("查询到重复包条信息!!", "查询到重复包条信息！！");
}
if (ObjectUtils.isNull(list)) {
return Resp.scanFail("没有查询到包件信息!", "没有查询到包件信息 ! ");
}
log.info(">>>>> obj {}", list.get(0).getConditions());
DistributionParcelListEntity distributionParcelListEntity = list.get(0);
if (2 != distributionParcelListEntity.getConditions()) {
return Resp.scanFail("当前包件不是库存品，无法备货！！", "当前包件不是库存品，无法备货！！");
}
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setAssociationId(list.get(0).getId());
warehouseUpdownGoodsEntity.setAssociationType("3");
warehouseUpdownGoodsEntity.setWarehouseId(byId.getWarehouseId());
locationInformation = warehouseUpdownGoodsClient.getLocationStockListInformation(warehouseUpdownGoodsEntity);
if (locationInformation.isEmpty()) {
return Resp.scanFail("当前货位没有该包件信息！！", "当前货位没有该包件信息！！");
}
}
//有数数据校验 修改库存品数据
if ("1".equals(byId.getSourceType())) {
R r1 = distributionStockupService.handlingPackages(stockupDTO);
if (r1.getCode() != 200) {
Resp.scanFail(r1.getMsg(), r1.getMsg());
}
}
Integer i = distributionStockupService.selectPackagePrint(stockupDTO);
switch (i) {
case 1:
//绑定
Integer integer = distributionStockupService.selectPackage(stockupDTO);
switch (integer) {
case 1:
DistributionStockupEntity stockupEntity = distributionStockupService.getById(stockupDTO.getStockupId());
//先保存扫码包件信息,后续由队列来出来余下补充信息
DistributionStockEntity entity = new DistributionStockEntity();
entity.setCoding(packetBarCode);
DistributionStockupEntity byId1 = distributionStockupService.getById(stockupId);
entity.setStockupArea(byId1.getStockupArea());
entity.setStockupId(stockupId);
entity.setStockQuantity(1);
entity.setScanUser(AuthUtil.getUser().getNickName());
if ("3".equals(stockupEntity.getTypeService())) {
entity.setBillLadingId(reservationId);
} else {
entity.setReservationId(reservationId);
}
entity.setReservationId(reservationId);
entity.setStockListId(stockupDTO.getStockListId());
//添加物料信息
// DistributionStockListEntity byId = iDistributionStockListService.getById(stockListId);
if (ObjectUtils.isNotNull(byId.getMarketId())) {
entity.setMarketId(byId.getMarketId());
entity.setMaterialId(byId.getMaterialId());
// WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
// warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
// warehouseUpdownGoodsEntity.setIncomingBatch(byId.getIncomingBatch());
// warehouseUpdownGoodsEntity.setMarketId(byId.getMarketId());
// warehouseUpdownGoodsEntity.setAssociationType("4");
// WarehouseUpdownGoodsEntity locationInformation = warehouseUpdownGoodsClient.getLocationStockListInformation(warehouseUpdownGoodsEntity);
if (!locationInformation.isEmpty()) {
if ("2".equals(byId.getSourceType())) {
//导入下架
entity.setAllocationTitle(locationInformation.get(0).getPositionCode());
entity.setAllocationId(stockupDTO.getAllocationId());
//todo 待下架操作
JSONObject jsonObject = new JSONObject();
jsonObject.put("marketId", byId.getMarketId());
jsonObject.put("materialCode", byId.getCargoNumber());
jsonObject.put("warehouseId", byId.getWarehouseId());
jsonObject.put("incomingBatch", byId.getIncomingBatch());
jsonObject.put("enterNum", 1);
jsonObject.put("allocationId", stockupDTO.getAllocationId());
jsonObject.put("remark", "备货无数据库存品下架");
List<JSONObject> list = new ArrayList<>();
list.add(jsonObject);
R r = warehouseUpdownTypeClient.downStock(list);
if (r.getCode() != 200) {
log.debug("##########" + r.getMsg());
// return Resp.scanFail("下架失败，请联系管理员！！", "下架失败，请联系管理员！！");
}
} else {
R r = warehouseUpdownTypeClient.downPackage(packetBarCode, byId.getWarehouseId(), "备货下架包件");
if (r.getCode() != 200) {
log.debug("##########" + r.getMsg());
// return Resp.scanFail("下架失败，请联系管理员！！", "下架失败，请联系管理员！！");
}
}
} else {
return Resp.scanFail("本货位的物料已为0，请更换货位继续！！", "本货位的物料已为0，请更换货位继续！！");
}
} else {
return Resp.scanFail("物料信息查询失败，请联系管理员！！", "物料信息查询失败，请联系管理员！！");
}
entity.setConditions("0");
entity.setType(2);
entity.setAllocationId(stockupDTO.getAllocationId());
entity.setOutboundType(stockupEntity.getTypeService());
// entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
// entity.setStockupArea(stockupDTO.getStockupAllocationName());
// //修改备货时间
distributionAsyncService.updateStockupStockListDate(stockupDTO);
// dataSourceTransactionManager.commit(transactionStatus);//提交
Map<String, Object> map = new HashMap<>();
map.put("messageId", CommonUtil.getUUID());
map.put("scanType", stockupDTO.getScanType());
map.put("logId", entity.getId());
map.put("messageData", entity);
map.put("createTime", System.currentTimeMillis());
// 完成对扫描库存品信息的数量维护
// 根据当前扫码对象查询得到当前的扫码对象的库存品信息
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_SCAN_EXCHANGE, RabbitConstant.STOCKUP_SCAN_ROUTING, map);
String audioValue = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.saomiaochenggong.getValue());
//进行备货库位上架
if (!Func.isEmpty(stockupDTO.getStockupAllocationId())) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("warehouseId", myCurrentWarehouse.getId());
jsonObject.put("code", packetBarCode);
jsonObject.put("stockUpAllocationId", stockupDTO.getStockupAllocationId());
jsonObject.put("type", 2);
jsonObject.put("num", 1);
warehouseUpdownStockUpAreaClient.upStockUpShelf(jsonObject);
entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
}
entity.setTenantId(AuthUtil.getTenantId());
distributionStockService.save(entity);
//这里尝试修改备货库存品包件的备货状态
boolean update = distributionParcelListService.update(Wrappers.<DistributionParcelListEntity>update().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, entity.getCoding())
.eq(DistributionParcelListEntity::getWarehouseId, myCurrentWarehouse.getId())
.eq(DistributionParcelListEntity::getConditions, "2")
.eq(DistributionParcelListEntity::getMaterialId, entity.getMaterialId())
.eq(entity.getStockArticle() != null,DistributionParcelListEntity::getStockArticleId, entity.getStockArticle())
.set(DistributionParcelListEntity::getOrderPackageStockupStatus, OrderPackageStockupStatusConstant.yibeihu.getValue())
);
// todo 这里需要完善
// 备货作业节点
// NodeFanoutMsg nodeFanoutMsg = sendStockUpNodeData(distributionStockupEntity, parcelListEntity);
// if(ObjectUtils.isNotNull(nodeFanoutMsg)){
// distributionNodeWorkService.planStock(nodeFanoutMsg,user);
// }
//扫码成功
return Resp.scanSuccess(PdaAudioLingoStatus.saomiaochenggong.getName(), audioValue);
case 2:
//重复扫描
String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
case 3:
//包件不存在
String audioValue3 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baojianbucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baojianbucunzai.getName(), audioValue3);
case 4:
//操作失败
String audioValue4 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.caozuoshibai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.caozuoshibai.getName(), audioValue4);
case 5:
//窜货
String audioValue5 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.cuanhuo.getValue());
return Resp.scanFail(PdaAudioLingoStatus.cuanhuo.getName(), audioValue5);
case 6:
//已完成
String audioValue6 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.yiwancheng.getValue());
return Resp.scanFail(PdaAudioLingoStatus.yiwancheng.getName(), audioValue6);
case 7:
//包条码不存在
String audioValue7 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue7);
default:
log.warn("###备货扫描：未知错误");
return Resp.scanFail(PdaAudioLingoStatus.weizhicuowu.getName(), PdaAudioLingoStatus.weizhicuowu.getName());
}
case 7:
//包条码不存在
String audioValue7 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue7);
case 8:
//条码已使用
String audioValue8 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomayishiyong.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomayishiyong.getName(), audioValue8);
case 9:
//"没有待绑定的库存品信息！"
String audioValue9 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.meiyou.getValue());
return Resp.scanFail(PdaAudioLingoStatus.meiyou.getName(), audioValue9);
case 10:
//"没有待绑定的库存品信息！"
return Resp.scanFail("该包件与备货物料不匹配！", "该包件与备货物料不匹配！");
}
return null;
}
/**
* 扫描定制品信息
*
* @param stockupDTO
* @return
*/
@NotNull
private R stockupScanByCustom(StockupDTO stockupDTO) {
BasicdataWarehouseEntity myCurrentWarehouse = basicdataWarehouseClient.getMyCurrentWarehouse();
//包件扫描
String orderCode = stockupDTO.getOrderCode();//订单自编号
String packetBarCode = stockupDTO.getPacketBarCode();//包件码
Long stockupId = stockupDTO.getStockupId();//备货任务ID
Long reservationId = stockupDTO.getReservationId();//预约单id
// Long stockUpAllocationId = stockupDTO.getStockupAllocationId();//备货库位ID
if (Objects.isNull(myCurrentWarehouse)) {
log.warn("##################stockupScan: 未选择仓库，订单自编号为空");
return R.fail(403, "未授权!!");
}
if (StringUtil.isBlank(orderCode)) {
log.warn("##################stockupScan: 包件扫码，订单自编号为空");
return R.fail("包件扫码:订单自编号不能为空");
}
if (StringUtil.isBlank(packetBarCode)) {
log.warn("##################stockupScan: 包件扫码，包件码为空");
return R.fail("包件扫码:包件码不能为空");
}
if (ObjectUtils.isNull(stockupId)) {
log.warn("##################stockupId: 包件扫码，备货区为空");
return R.fail("包件扫码:备货任务ID不能为空");
}
if (Objects.isNull(reservationId)) {
log.warn("##################stockupScan: 包件扫码，预约单id为空");
return R.fail("包件扫码:预约单id不能为空");
}
// if (Objects.isNull(stockUpAllocationId)) {
// log.warn("##################stockupScan: 备货库位不存在，stockUpAllocationId:{}",stockUpAllocationId);
// return Resp.scanFail("请扫描备货库位","请扫描备货库位");
// }
Integer integer = distributionStockupService.selectPackage(stockupDTO);
switch (integer) {
case 1:
DistributionStockupEntity distributionStockupEntity = distributionStockupService.getById(stockupDTO.getStockupId());
List<JSONObject> aaa = new ArrayList<>();
//正常
//先保存扫码包件信息,后续由队列来出来余下补充信息
DistributionStockEntity entity = new DistributionStockEntity();
DistributionParcelListEntity one = distributionParcelListService.getOne(Wrappers.<DistributionParcelListEntity>query().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, stockupDTO.getPacketBarCode())
.eq(DistributionParcelListEntity::getWarehouseId, myCurrentWarehouse.getId())
);
entity.setOrderSelfNumbering(one.getOrderCode());
entity.setStockArticle(one.getStockArticleId());
entity.setCoding(packetBarCode);
entity.setScanUser(AuthUtil.getUser().getNickName());
entity.setStockupId(stockupId);
entity.setStockupId(stockupId);
entity.setParcelListId(one.getId());
entity.setStockQuantity(1);
// //修改包件备货状态
if ("3".equals(distributionStockupEntity.getTypeService())) {
entity.setBillLadingId(reservationId);
DistributionStockupEntity byId = distributionStockupService.getById(stockupId);
entity.setStockupArea(byId.getStockupArea());
} else {
entity.setReservationId(reservationId);
}
if (ObjectUtils.isNotNull(stockupDTO.getAllocationId())) {
// warehouseUpdownGoodsClient.selectMsgBywrap();
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setAssociationValue(stockupDTO.getPacketBarCode());
warehouseUpdownGoodsEntity.setWarehouseId(distributionStockupEntity.getWarehouseId());
WarehouseUpdownGoodsEntity locationInformation = warehouseUpdownGoodsClient.getLocationInformation(warehouseUpdownGoodsEntity);
if (ObjectUtils.isNotNull(locationInformation)) {
entity.setAllocationTitle(locationInformation.getPositionCode());
}
entity.setAllocationId(stockupDTO.getAllocationId());
}
entity.setConditions("0");
entity.setType(2);
entity.setOutboundType(distributionStockupEntity.getTypeService());
//修改订单备货状态
distributionAsyncService.updateStockArticleStock(one.getStockArticleId());
//修改备货时间
distributionAsyncService.updateStockupDate(stockupDTO);
Map<String, Object> map = new HashMap<>();
map.put("messageId", CommonUtil.getUUID());
map.put("scanType", stockupDTO.getScanType());
map.put("stockupId", stockupDTO.getStockupId());
map.put("logId", entity.getId());
map.put("messageData", entity);
map.put("createTime", System.currentTimeMillis());
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_SCAN_EXCHANGE, RabbitConstant.STOCKUP_SCAN_ROUTING, map);
//查询是否货位数据是否该下架
Map<String, Object> mapState = new HashMap<>();
mapState.put("messageId", CommonUtil.getUUID());
mapState.put("scanType", stockupDTO.getScanType());
mapState.put("stockupId", stockupDTO.getStockupId());
mapState.put("typeService", stockupDTO.getTypeService());
mapState.put("reservationId", stockupDTO.getReservationId());
mapState.put("logId", entity.getId());
mapState.put("messageData", entity);
mapState.put("warehouseId", myCurrentWarehouse.getId());
mapState.put("createTime", System.currentTimeMillis());
String audioValue = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.saomiaochenggong.getValue());
log.info(">>>>>>>>>>>>>>>>>>>> 对扫码的包件进行下架");
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_STATE_UPDATE_EXCHANGE, RabbitConstant.STOCKUP_STATE_UPDATE_ROUTING, mapState, message -> {
message.getMessageProperties()
.setHeader("x-delay", 3000);
return message;
});
//查询是否货位数据是否该下架
BladeUser user = AuthUtil.getUser();
if (!Func.isEmpty(stockupDTO.getStockupAllocationId())) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("warehouseId", myCurrentWarehouse.getId());
jsonObject.put("code", packetBarCode);
jsonObject.put("stockUpAllocationId", stockupDTO.getStockupAllocationId());
jsonObject.put("type", 1);
jsonObject.put("num", 1);
//进行了备货库位的选择才进行备货库位的上架
warehouseUpdownStockUpAreaClient.upStockUpShelf(jsonObject);
entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
String content = "包件在" + myCurrentWarehouse.getName() + "由" + AuthUtil.getNickName() + "备货上架,操作方式:备货上架同步操作,备货任务号:" + distributionStockupEntity.getStockupCode() ;
JSONObject js = handleLogJSONObject(myCurrentWarehouse, user, entity.getCoding(), content, WorkNodeEnums.STOCKING_OPERATION.getCode());
aaa.add(js);
}
distributionStockService.save(entity);
//增加备货扫描节点
String content = "包件在" + myCurrentWarehouse.getName() + "由" + AuthUtil.getNickName() + "备货作业,备货任务号:" + distributionStockupEntity.getStockupCode() ;
JSONObject js = handleLogJSONObject(myCurrentWarehouse, user, entity.getCoding(), content, WorkNodeEnums.STOCKING_OPERATION.getCode());
aaa.add(js);
//修改包件备货状态
DistributionParcelListEntity parcelListEntity = new DistributionParcelListEntity();
parcelListEntity.setId(entity.getParcelListId());
parcelListEntity.setOrderPackageStockupStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
distributionParcelListService.updateById(parcelListEntity);
trunklinePackageTrackLogClient.addPackageTrackLog(aaa);
parcelListEntity = distributionParcelListService.getById(entity.getParcelListId());
// 备货作业节点
NodeFanoutMsg nodeFanoutMsg = sendStockUpNodeData(distributionStockupEntity, parcelListEntity);
if(ObjectUtils.isNotNull(nodeFanoutMsg)){
distributionNodeWorkService.planStock(nodeFanoutMsg,user);
}
return Resp.scanSuccess(PdaAudioLingoStatus.saomiaochenggong.getName(), audioValue);
case 2:
//重复扫描
String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
case 3:
//包件不存在
String audioValue3 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue3);
case 4:
//操作失败
String audioValue4 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.caozuoshibai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.caozuoshibai.getName(), audioValue4);
case 5:
//窜货
String audioValue5 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.buzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.buzai.getName(), audioValue5);
default:
log.warn("###备货扫描：未知错误");
return Resp.scanFail(PdaAudioLingoStatus.weizhicuowu.getName(), PdaAudioLingoStatus.weizhicuowu.getName());
}
}
private NodeFanoutMsg sendStockUpNodeData(DistributionStockupEntity distributionStockupEntity, DistributionParcelListEntity parcelListEntity) {
try {
BladeUser user = AuthUtil.getUser();
NodeFanoutMsg nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.STOCKING_OPERATION);
BasicdataWarehouseEntity entityWarehouse = basicdataWarehouseClient.getEntityWarehouseId(distributionStockupEntity.getWarehouseId());
if(entityWarehouse != null){
nodeFanoutMsg.setWarehouse(entityWarehouse.getName());
}
nodeFanoutMsg.setWarehouseId(distributionStockupEntity.getWarehouseId());
nodeFanoutMsg.setOperator(user.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionStockupEntity.getCreateTime());
JSONObject jsonObject = new JSONObject();
jsonObject.put("id", distributionStockupEntity.getId());
jsonObject.put("stockupCode", distributionStockupEntity.getStockupCode());
jsonObject.put("typeService", distributionStockupEntity.getTypeService());
jsonObject.put("stockupDate", distributionStockupEntity.getStockupDate());
String jsonString = jsonObject.toJSONString();
nodeFanoutMsg.setMain(jsonString);
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
List<PackageData> packageDataList = new ArrayList<>();
PackageData packageData = getPackageData(parcelListEntity);
packageDataList.add(packageData);
nodeFanoutMsg.setDetails(packageDataList);
return nodeFanoutMsg;
} catch (Exception e) {
log.error("备货扫描：发送备货节点消息失败", e);
}
return null;
}
@NotNull
private static PackageData getPackageData(DistributionParcelListEntity parcelListEntity) {
PackageData packageData = new PackageData();
packageData.setWaybillNumber(parcelListEntity.getWaybillNumber());
packageData.setBrand(parcelListEntity.getBrandName());
packageData.setPackageCode(parcelListEntity.getOrderPackageCode());
packageData.setMaterialCode(parcelListEntity.getMaterialCode());
packageData.setMaterialName(parcelListEntity.getMaterialName());
packageData.setNumber(1);
packageData.setOrderCode(parcelListEntity.getOrderCode());
packageData.setPackageType(PackageTypeEnums.CMP);
return packageData;
}
private JSONObject handleLogJSONObject(BasicdataWarehouseEntity warehouse, BladeUser user, String orderPackageCode, String content, Integer node) {
JSONObject trunklinePackageTrackLog = new JSONObject();
trunklinePackageTrackLog.put("tenantId", user.getTenantId());
trunklinePackageTrackLog.put("createTime", new Date());
trunklinePackageTrackLog.put("createUser", user.getUserId());
trunklinePackageTrackLog.put("updateUser", user.getUserId());
trunklinePackageTrackLog.put("updateTime", new Date());
trunklinePackageTrackLog.put("isDeleted", 0);
trunklinePackageTrackLog.put("status", 1);
trunklinePackageTrackLog.put("createDept", warehouse.getDepartment());
trunklinePackageTrackLog.put("orderPackageCode", orderPackageCode);
trunklinePackageTrackLog.put("warehouseId", warehouse.getId());
trunklinePackageTrackLog.put("warehouseName", warehouse.getName());
trunklinePackageTrackLog.put("workNode", node);
trunklinePackageTrackLog.put("content", content);
trunklinePackageTrackLog.put("operator", user.getNickName());
return trunklinePackageTrackLog;
}
}

7
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/controller/DistributionReservationController.java
Unescape View File

@ -323,7 +323,12 @@ public class DistributionReservationController extends BladeController {
@ApiOperationSupport(order = 7)
@ApiOperation(value = "取消预约")
public R cancelReservation(@RequestBody DistributionReservationDTO reservationDTO) {
boolean result = reservationService.cancelReservation(reservationDTO);
boolean result = false;
try {
result = reservationService.cancelReservation(reservationDTO);
} catch (Exception e) {
return R.fail(e.getMessage());
}
return R.status(result);
}

4
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/controller/DistributionSignforController.java
Unescape View File

@ -338,7 +338,7 @@ public class DistributionSignforController extends BladeController {
}
/**
* 签收管理 修改
* 签收管理 复核
*/
@PostMapping("/update")
@ApiOperationSupport(order = 5)
@ -356,6 +356,8 @@ public class DistributionSignforController extends BladeController {
distributionSignforService.updateSign(distributionSignforDTO);
distributionDeliveryListService.maintenanceDeliveryInfo(distributionSignfor.getDeliveryId());
distributionStockupInfoService.maintenanceStockUp(distributionSignfor.getReservationId(),1);
}
// return R.status(distributionSignforService.updateById(distributionSignfor));
return r;

15
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/mapper/DistributionDeliveryListMapper.java
Unescape View File

@ -291,7 +291,6 @@ public interface DistributionDeliveryListMapper extends BaseMapper<DistributionD
/**
* 查询配送任务下的所有包件列表--分页
* @param page
* @param deliveryId
* @return
*/
@ -473,8 +472,6 @@ public interface DistributionDeliveryListMapper extends BaseMapper<DistributionD
/**
* 根据车次号查询配送计划
* @param id
* @param searchCode
* @return
*/
DistributionDeliveryListEntity selectDeliveryByTrainNumber(@Param("warehouseId") Long warehouseId,@Param("trainNumber") String trainNumber);
@ -530,9 +527,6 @@ public interface DistributionDeliveryListMapper extends BaseMapper<DistributionD
/**
* 查询配送单详情
* @param id
* @param id1
* @param warehouse
* @return
*/
List<DistributionParcelListEntity> getPackageByDeliveryAndOrderId(@Param("deliveryId") Long deliveryId,@Param("orderId") Long orderId,@Param("warehouseId") Long warehouseId);
@ -569,6 +563,15 @@ public interface DistributionDeliveryListMapper extends BaseMapper<DistributionD
*/
List<Map<String,Object>> getBroadcastDataByZeroOrder(@Param("deliveryId")Long deliveryId,@Param("warehouseId") Long warehouseId);
/**
* 配送计划内的零担查询
* @param deliveryId 配送ID
* @param warehouseId 仓库Io
* @param parcelListId 零担包件ID
* @return
*/
Map<String,Object> getBroadcastDataByZeroOrderAndParcId(@Param("deliveryId")Long deliveryId,@Param("warehouseId") Long warehouseId,@Param("parcelListId") Long parcelListId);
/**
* 查询计划中的包件信息
* @param orderPackageCode

32
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/mapper/DistributionDeliveryListMapper.xml
Unescape View File

@ -2597,6 +2597,38 @@
AND ldrzp.zero_package_status != 2
AND lddl.tenant_id = '627683'
</select>
<select id="getBroadcastDataByZeroOrderAndParcId" resultType="java.util.Map">
SELECT
ldpl.order_package_code AS packageCode,
ldpl.order_code AS orderCode,
ldpl.waybill_number AS waybillNumber,
IF
( ldrzp.id IS NOT NULL, '', NULL ) AS pickupBatch,
ldpl.material_name AS materialName,
ldpl.material_code AS materialCode,
ldsa.mall_name AS mallName,
ldrzp.quantity AS number,
ldsa.brand AS brandName,
ldpl.firsts as productName
FROM
logpm_distribution_delivery_list lddl
LEFT JOIN logpm_distribution_signfor lds ON lddl.id = lds.delivery_id
AND lds.tenant_id = '627683'
LEFT JOIN logpm_distribution_reservation_zero_package ldrzp ON ldrzp.reservation_id = lds.reservation_id
AND ldrzp.tenant_id = '627683'
LEFT JOIN logpm_distribution_parcel_list ldpl ON ldpl.id = ldrzp.parcel_list_id
AND ldpl.tenant_id = '627683'
LEFT JOIN logpm_distribution_stock_article ldsa ON ldsa.id = ldpl.stock_article_id
AND ldsa.tenant_id = '627683'
WHERE
lddl.id = #{deliveryId}
AND lddl.warehouse_id = #{warehouseId}
AND ldrzp.parcel_list_id = #{parcelListId}
AND ldrzp.zero_package_status != 2
AND lddl.tenant_id = '627683'
</select>
<select id="selectPackageByorderPackageCodeAndDeliveryId"
resultType="java.lang.Long">
SELECT

4
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/receiver/report/PlanReportListener.java
Unescape View File

@ -53,8 +53,8 @@ public class PlanReportListener {
private IBasicdataWarehouseClient warehouseClient;
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = FanoutConstants.distribution.plan.QUEUE.REPORT, durable = "true"),
exchange = @Exchange(name = FanoutConstants.distribution.plan.EXCHANGE, type = ExchangeTypes.FANOUT)
value = @Queue(name = FanoutConstants.distribution.DeliveryAndPlan.QUEUE.REPORT, durable = "true"),
exchange = @Exchange(name = FanoutConstants.distribution.DeliveryAndPlan.EXCHANGE, type = ExchangeTypes.FANOUT)
))
public void nodeDataPushDelayed(String msg) {
log.info("配送计划生成明细报表: {}", msg);

7
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionDeliveryListService.java
Unescape View File

@ -34,9 +34,13 @@ import com.logpm.distribution.vo.app.*;
import com.logpm.distribution.vo.print.PrintPreviewVO;
import com.logpm.warehouse.entity.WarehouseRetentionRecordEntity;
import com.logpm.warehouse.entity.WarehouseRetentionScanEntity;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.model.DistributionTaskVO;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.core.mp.base.BaseService;
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.tool.api.R;
import java.text.ParseException;
@ -172,6 +176,9 @@ public interface IDistributionDeliveryListService extends BaseService<Distributi
* @return
*/
R<?> updateDeliveryListInfo(DistributionDeliveryListDTO deliveryListDTO);
NodeFanoutMsg<DistributionTaskVO> buildNodeFanoutMsgForPlan(DistributionDeliveryListEntity distributionDeliveryListEntity, BladeUser user, BizOperationEnums bizOperation);
/**
* App-配送库存品装车
*

20
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionNodeWorkService.java
Unescape View File

@ -3,7 +3,7 @@ package com.logpm.distribution.service;
import com.logpm.distribution.entity.DistributionDeliveryListEntity;
import com.logpm.distribution.entity.DistributionParcelListEntity;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.*;
import org.springblade.core.secure.BladeUser;
/**
@ -13,14 +13,17 @@ import org.springblade.core.secure.BladeUser;
*/
public interface IDistributionNodeWorkService {
/**
* 配送计划性节点
* @param distributionDeliveryListEntity
* 预约
* @param nodeFanoutMsg
* @param user
* @param bizOperation
*/
void planDelivery(DistributionDeliveryListEntity distributionDeliveryListEntity, BladeUser user, BizOperationEnums bizOperation);
void planReservation(NodeFanoutMsg<ReservationVO> nodeFanoutMsg, BladeUser user);
void cancelReservation(NodeFanoutMsg<ReservationVO> nodeFanoutMsg, BladeUser user);
void planDelivery(NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg, BladeUser user);
/**
* 备货计划节点
@ -32,12 +35,12 @@ public interface IDistributionNodeWorkService {
/**
* 装车
*/
void nodeLoad();
void nodeLoading(NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg, BladeUser user);
/**
* 异常装车
*/
void abnormalLoading();
void abnormalLoading(NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg, BladeUser user);
/**
* 取消装车
@ -61,6 +64,9 @@ public interface IDistributionNodeWorkService {
void signFor(DistributionParcelListEntity parcelListEntity, Long taskId, String operationTime, String destinationWarehouse);
void signFor(NodeFanoutMsg<DistributionSignforVO> nodeFanoutMsg, BladeUser user);
/**
* 签收复核
*/

13
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/IDistributionStockupService.java
Unescape View File

@ -302,4 +302,17 @@ public interface IDistributionStockupService extends BaseService<DistributionSto
R detailOwnSelfInventoryDetail(Long billLadingId, Long stockListId);
/**
* 定制品备货
* @param stockupDTO
* @return
*/
R stockupScanByCustom(StockupDTO stockupDTO);
/**
* 库存品备货
* @param stockupDTO
* @return
*/
R stockupScanByStock(StockupDTO stockupDTO);
}

472
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionDeliveryListServiceImpl.java
Unescape View File

@ -17,6 +17,7 @@
package com.logpm.distribution.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
@ -80,7 +81,9 @@ import org.springblade.common.constant.signing.SignforStatusConstant;
import org.springblade.common.constant.stockup.StockAssignStatusConstant;
import org.springblade.common.constant.stockup.StockupStatusConstant;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.*;
import org.springblade.common.serviceConstant.ServiceConstant;
import org.springblade.common.utils.CommonUtil;
import org.springblade.common.utils.QRCodeUtil;
@ -94,6 +97,7 @@ import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springblade.system.cache.DictBizCache;
@ -270,6 +274,9 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
@Autowired
private IDistributionNodeWorkService distributionNodeWorkService;
@Autowired
private IBasicdataDriverArteryClient basicdataDriverArteryClient;
@Override
public IPage<DistributionDeliveryListEntity> selectDistributionDeliveryListPage(IPage<DistributionDeliveryListEntity> page, DistributionDeliveryListDTO distributionDeliveryList) {
//转换创建时间
@ -610,13 +617,6 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
}
}
// -----------------------------------2023-09-25 签收调整----------------------------------------------------------------
// 首先这里需要查看该包件是否属于该配送任务
// 属于该配送任务需要进行是否属于该客户进行判断
// 如果属于该客户则进行装车扫描
//
//获取当前用户司机
DistributionDeliveryListEntity distributionDeliveryListEntity = distributionDeliveryListMapper.selectById(distrilbutionloadingscanDTO.getDeliveryId());
@ -645,6 +645,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
BeanUtils.copyProperties(distributionDeliveryTripartiteEntity, distributionDeliverySelfEntity);
}
List<DistributionParcelListEntity> pushList = new ArrayList<>();
List<DistributionLoadscanEntity> pushNodeList = new ArrayList<>();
if (distrilbutionloadingscanDTO.getType() == 1) {
List<DisStockListDetailEntity> list = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda()
.eq(DisStockListDetailEntity::getStockPackageCode, distrilbutionloadingscanDTO.getBarcode())
@ -766,6 +767,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
loadscanEntity.setIsAbnormalLoading(1);
loadscanEntity.setLoadedNub(parcelListEntity.getQuantity());
distributionLoadscanService.save(loadscanEntity);
pushNodeList.add(loadscanEntity);
//更新包件装车状态
packageLockIds.add(loadscanEntity.getPackageId());
parcelListEntity.setOrderPackageLoadingStatus(OrderPackageLoadingStatusConstant.yizhuangche.getValue());
@ -813,7 +815,6 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
pushList.add(parcelListEntity);
// extracteOrderPackageStatus(distrilbutionloadingscanDTO, parcelListEntity, myCurrentWarehouse, reservationEntity);
@ -1000,6 +1001,8 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
aaa.add(trunklinePackageTrackLog);
orderPackageCodes.add(loadscanEntity.getOrderPackageCode());
pushList.add(parcelListEntity);
pushNodeList.add(loadscanEntity);
}
}
JSONObject jsonObject = new JSONObject();
@ -1043,7 +1046,18 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
return Resp.scanFail("查询托盘货物失败", "查询托盘货物失败");
}
}
if(CollUtil.isNotEmpty(pushNodeList)){
DistributionDeliveryListEntity deliveryListEntity = distributionDeliveryListService.getById(distrilbutionloadingscanDTO.getDeliveryId());
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = buildNodeFanoutMsgByPackage(deliveryListEntity, pushNodeList);
distributionNodeWorkService.nodeLoading(nodeFanoutMsg, AuthUtil.getUser());
}
if (CollUtil.isNotEmpty(pushList)) {
for (DistributionParcelListEntity parcelListEntity : pushList) {
List<Object> contents = new ArrayList<>();
PushData pushData = PushData.builder()
@ -1061,6 +1075,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
log.info("推送工厂数据：{}", JSONUtil.toJsonStr(msg));
factoryDataMessageSender.sendNodeDataByBrand(msg);
}
}
//添加缓存
if (!packageLockIds.isEmpty()) {
@ -1088,6 +1103,205 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
return Resp.scanSuccessWithData("装车成功", carLaodNum + "件", carLaodNum);
}
private DistributionTaskVO buildDistributionTaskVO(DistributionDeliveryListEntity distributionDeliveryListEntity, Long userId) {
DistributionTaskVO taskVO = new DistributionTaskVO();
taskVO.setId(distributionDeliveryListEntity.getId());
taskVO.setTrainNumber(distributionDeliveryListEntity.getTrainNumber());
taskVO.setKind(distributionDeliveryListEntity.getKind());
taskVO.setType(distributionDeliveryListEntity.getType());
taskVO.setDistributionCompany(distributionDeliveryListEntity.getDistributionCompany());
taskVO.setTaskTime(distributionDeliveryListEntity.getTaskTime());
List<PlanDriverbindCarVO> planDriverbindCarVOS = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
taskVO.setPlanDriverbindCars(planDriverbindCarVOS);
String driverName = distributionDeliveryListEntity.getDriverName();
String vehicleName = distributionDeliveryListEntity.getVehicleName();
// 如果是自主配送 需要去获取当前司机绑定的车牌
if ("1".equals(distributionDeliveryListEntity.getKind())) {
BasicdataDriverArteryEntity driverArteryById = basicdataDriverArteryClient.getDriverArteryById(userId);
if (driverArteryById != null) {
for (int i = 0; i < planDriverbindCarVOS.size(); i++) {
if (planDriverbindCarVOS.get(i).getDriverName().equals(driverArteryById.getName())) {
driverName = planDriverbindCarVOS.get(i).getDriverName();
vehicleName = planDriverbindCarVOS.get(i).getCarPlate();
break;
}
}
}
}
taskVO.setDriverName(driverName);
taskVO.setVehicleName(vehicleName);
return taskVO;
}
private NodeFanoutMsg<DistributionLoadVO> buildNodeFanoutMsgByPackage(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscanEntity> pushNodeList) {
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_LOADING);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getUpdateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
DistributionLoadVO distributionLoadVO = new DistributionLoadVO();
List<PlanDriverbindCarVO> planDriverbindCarVOS = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
String driverName = distributionDeliveryListEntity.getDriverName();
String vehicleName = distributionDeliveryListEntity.getVehicleName();
// 如果是自主配送 需要去获取当前司机绑定的车牌
if ("1".equals(distributionDeliveryListEntity.getKind())) {
BasicdataDriverArteryEntity driverArteryById = basicdataDriverArteryClient.getDriverArteryById(AuthUtil.getUserId());
if (driverArteryById != null) {
for (int i = 0; i < planDriverbindCarVOS.size(); i++) {
if (planDriverbindCarVOS.get(i).getDriverName().equals(driverArteryById.getName())) {
driverName = planDriverbindCarVOS.get(i).getDriverName();
vehicleName = planDriverbindCarVOS.get(i).getCarPlate();
break;
}
}
}
}
distributionLoadVO.setDriverName(driverName);
distributionLoadVO.setVehicleName(vehicleName);
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscanEntity distributionParcelListEntity : pushNodeList) {
PackageData packageData = new PackageData();
packageData.setPackageCode(distributionParcelListEntity.getOrderPackageCode());
packageData.setPackageType(PackageTypeEnums.CMP);
data.add(packageData);
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
private List<PlanDriverbindCarVO> buildDeliveryCarDriverInfor(DistributionDeliveryListEntity distributionDeliveryListEntity) {
List<PlanDriverbindCarVO> jsonArray = new ArrayList<>();
// 自主配送
if ("1".equals(distributionDeliveryListEntity.getKind())) {
LambdaQueryWrapper<DistributionDeliverySelfEntity> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DistributionDeliverySelfEntity::getDeliveryId, distributionDeliveryListEntity.getId());
List<DistributionDeliverySelfEntity> list = distributionDeliverySelfService.list(queryWrapper);
if (list != null && !list.isEmpty()) {
for (DistributionDeliverySelfEntity distributionDeliverySelfEntity : list) {
PlanDriverbindCarVO planDriverbindCarVO = new PlanDriverbindCarVO();
planDriverbindCarVO.setCarPlate(distributionDeliverySelfEntity.getVehicleNub());
planDriverbindCarVO.setDriverName(distributionDeliverySelfEntity.getDriverName());
jsonArray.add(planDriverbindCarVO);
}
}
} else {
LambdaQueryWrapper<DistributionDeliveryTripartiteEntity> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DistributionDeliveryTripartiteEntity::getDeliveryId, distributionDeliveryListEntity.getId());
List<DistributionDeliveryTripartiteEntity> list = distributionDeliveryTripartiteService.list(queryWrapper);
if (list != null && !list.isEmpty()) {
for (DistributionDeliveryTripartiteEntity distributionDeliverySelfEntity : list) {
PlanDriverbindCarVO planDriverbindCarVO = new PlanDriverbindCarVO();
planDriverbindCarVO.setCarPlate(distributionDeliverySelfEntity.getVehicleNum());
planDriverbindCarVO.setDriverName(distributionDeliverySelfEntity.getDriverName());
jsonArray.add(planDriverbindCarVO);
}
}
}
return jsonArray;
}
private NodeFanoutMsg<DistributionLoadVO> buildNodeFanoutMsgByStock(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscaninvnEntity> ts) {
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_LOADING);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getCreateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
// nodeFanoutMsg.setMain(taskVO);
DistributionLoadVO distributionLoadVO = new DistributionLoadVO();
List<PlanDriverbindCarVO> planDriverbindCarVOS = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
String driverName = distributionDeliveryListEntity.getDriverName();
String vehicleName = distributionDeliveryListEntity.getVehicleName();
// 如果是自主配送 需要去获取当前司机绑定的车牌
if ("1".equals(distributionDeliveryListEntity.getKind())) {
BasicdataDriverArteryEntity driverArteryById = basicdataDriverArteryClient.getDriverArteryById(AuthUtil.getUserId());
if (driverArteryById != null) {
for (int i = 0; i < planDriverbindCarVOS.size(); i++) {
if (planDriverbindCarVOS.get(i).getDriverName().equals(driverArteryById.getName())) {
driverName = planDriverbindCarVOS.get(i).getDriverName();
vehicleName = planDriverbindCarVOS.get(i).getCarPlate();
break;
}
}
}
}
distributionLoadVO.setDriverName(driverName);
distributionLoadVO.setVehicleName(vehicleName);
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscaninvnEntity distributionParcelListEntity : ts) {
data.add(getPackageDataByStock(distributionParcelListEntity));
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
@NotNull
private PackageData getPackageDataByStock(DistributionLoadscaninvnEntity stockEntity) {
PackageData packageData = new PackageData();
// 查询出库存品信息
DistributionStockListEntity stockListEntity = distributionStockListService.getById(stockEntity.getInventoryId());
if (stockListEntity == null) {
throw new CustomerException("库存品信息不存在");
}
packageData.setBrand(stockListEntity.getBrandName());
packageData.setPackageCode(stockEntity.getOrderPackageCode());
packageData.setMallName(stockListEntity.getMallName());
packageData.setMaterialCode(stockListEntity.getMarketCode());
packageData.setMaterialName(stockListEntity.getDescriptionGoods());
packageData.setOrderCode(stockListEntity.getOrderCode());
packageData.setPackageType(PackageTypeEnums.INV);
packageData.setNumber(1);
return packageData;
}
@NotNull
private PackageData getPackageData(DistributionParcelListEntity parcelListEntity) {
PackageData packageData = new PackageData();
packageData.setWaybillNumber(parcelListEntity.getWaybillNumber());
packageData.setBrand(parcelListEntity.getBrandName());
packageData.setPackageCode(parcelListEntity.getOrderPackageCode());
packageData.setMaterialCode(parcelListEntity.getMaterialCode());
packageData.setMaterialName(parcelListEntity.getMaterialName());
packageData.setNumber(1);
packageData.setOrderCode(parcelListEntity.getOrderCode());
packageData.setPackageType(PackageTypeEnums.CMP);
return packageData;
}
private void extracteOrderPackageStatus(DistrilbutionloadingscanDTO distrilbutionloadingscanDTO, DistributionParcelListEntity parcelListEntity, BasicdataWarehouseEntity myCurrentWarehouse, DistributionReservationEntity reservationEntity) {
Map<String, Object> map = new HashMap<>();
map.put("orderPackageCode", parcelListEntity.getOrderPackageCode());
@ -1671,6 +1885,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
@Override
@Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
public Resp loadinginventory(DistrilbutionloadingscanDTO distrilbutionloadingscanDTO) {
List<DistributionLoadscaninvnEntity> ts = new ArrayList<>();
BasicdataWarehouseEntity myCurrentWarehouse = warehouseClient.getMyCurrentWarehouse();
if (Func.isEmpty(myCurrentWarehouse)) {
return Resp.scanFail("未授权", "未授权!!!");
@ -1701,7 +1916,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
//这里进行扫描数据的插入和库存品包件信息出库数量维护，状态维护
List<DisStockListDetailEntity> list = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda().eq(DisStockListDetailEntity::getReservationId, distrilbutionloadingscanDTO.getReservationId()).ne(DisStockListDetailEntity::getStockPackageStatus, ReservationInventoryStatusConstant.quxiao.getValue()));
List<DisStockListDetailEntity> detailEntities = list.stream().filter(l -> Func.isNotEmpty(l.getStockPackageCode())).collect(Collectors.toList());
if (detailEntities.size() <= 0) {
if (detailEntities.isEmpty()) {
return Resp.scanFail("此码无效", "此码无效");
} else {
List<DisStockListDetailEntity> disStockListDetailEntities = detailEntities.stream().filter(d -> d.getStockPackageCode().equals(barcode)).collect(Collectors.toList());
@ -1724,6 +1939,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
DistributionLoadscaninvnEntity distributionLoadscaninvnEntity = getDistributionLoadscaninvnEntity(distrilbutionloadingscanDTO, distributionDeliverySelfEntity, disStockListDetailEntities, myCurrentWarehouse);
packageLockIds.add(distributionLoadscaninvnEntity.getInventoryPackageId());
distributionLoadscaninvnService.save(distributionLoadscaninvnEntity);
ts.add(distributionLoadscaninvnEntity);
//查询本车次是否第一次扫码,没有则更新上车时间
Integer a = distributionDeliveryListMapper.updateloadingTimeById(distributionLoadscaninvnEntity.getDeliveryId());
//更新签收表的装车数量
@ -1766,6 +1982,10 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
bladeRedis.setEx("warehouseId:" + myCurrentWarehouse.getId() + "trainNumber:" + distributionDeliveryListEntity.getTrainNumber() + "orderPackageCode:", packageLockIds, 60L);
}
}
DistributionDeliveryListEntity deliveryListEntity = distributionDeliveryListService.getById(distrilbutionloadingscanDTO.getDeliveryId());
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = buildNodeFanoutMsgByStock(deliveryListEntity, ts);
distributionNodeWorkService.nodeLoading(nodeFanoutMsg, AuthUtil.getUser());
String msg = getLoadingMsg(distrilbutionloadingscanDTO);
return Resp.scanSuccess("扫描成功", msg);
}
@ -3340,7 +3560,10 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
//对修改计划下的所有包件进行维护
// 作业节点推送
distributionNodeWorkService.planDelivery(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
// distributionNodeWorkService.planDelivery(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = buildNodeFanoutMsgForPlan(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
distributionNodeWorkService.planDelivery(nodeFanoutMsg, AuthUtil.getUser());
trunklinePackageTrackLogClient.addPackageTrackLog(logs);
return R.status(true);
@ -3348,6 +3571,88 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
}
@Override
public NodeFanoutMsg<DistributionTaskVO> buildNodeFanoutMsgForPlan(DistributionDeliveryListEntity distributionDeliveryListEntity, BladeUser user, BizOperationEnums bizOperation){
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(bizOperation);
nodeFanoutMsg.setNode(WorkNodeEnums.PLAN_DELIVERY);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(user.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getCreateTime());
DistributionTaskVO distributionTaskVO = getDistributionTaskVO(distributionDeliveryListEntity);
List<PlanDriverbindCarVO> planDriverbindCarVOS = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
distributionTaskVO.setPlanDriverbindCars(planDriverbindCarVOS);
nodeFanoutMsg.setMain(distributionTaskVO);
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
Map<String, List<Map<String, Object>>> deliveryreBroadcastData = distributionDeliveryListService.getDeliveryreBroadcastData(distributionDeliveryListEntity.getId(), distributionDeliveryListEntity.getWarehouseId());
// 构建返回数据
List<PackageData> packageDataList = buildSendNodePackageData(deliveryreBroadcastData);
nodeFanoutMsg.setDetails(packageDataList);
return nodeFanoutMsg;
}
@NotNull
private List<PackageData> buildSendNodePackageData(Map<String, List<Map<String, Object>>> deliveryreBroadcastData) {
List<PackageData> packageDataList = new ArrayList<>();
// 定制品
List<Map<String, Object>> data = deliveryreBroadcastData.get("1");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.CMP;
packageData.setPackageType(type);
packageDataList.add(packageData);
}
}
// 库存品
data = deliveryreBroadcastData.get("2");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.INV;
packageData.setPackageType(type);
packageDataList.add(packageData);
}
}
//零担
data = deliveryreBroadcastData.get("3");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.LTL;
packageData.setPackageType(type);
packageData.setProductName(Convert.toStr(map.get("productName")));
packageDataList.add(packageData);
}
}
return packageDataList;
}
@NotNull
private DistributionTaskVO getDistributionTaskVO(DistributionDeliveryListEntity distributionDeliveryListEntity) {
DistributionTaskVO distributionTaskVO = new DistributionTaskVO();
distributionTaskVO.setId(distributionDeliveryListEntity.getId());
distributionTaskVO.setTrainNumber(distributionDeliveryListEntity.getTrainNumber());
distributionTaskVO.setKind(distributionDeliveryListEntity.getKind());
distributionTaskVO.setType(distributionDeliveryListEntity.getType());
distributionTaskVO.setDistributionCompany(distributionDeliveryListEntity.getDistributionCompany());
distributionTaskVO.setTaskTime(distributionDeliveryListEntity.getTaskTime());
return distributionTaskVO;
}
private boolean checkList(List<DistributionReservationPackageEntity> list, Long id, Long stockArticleId, String orderPackageCode) {
return list.stream().anyMatch(e -> e.getStockArticleId().equals(stockArticleId) && e.getPacketBarCode().equals(orderPackageCode) && e.getReservationId().equals(id));
@ -3803,7 +4108,8 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
this.updateById(deliveryListEntity);
// 作业节点推送
distributionNodeWorkService.planDelivery(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = buildNodeFanoutMsgForPlan(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
distributionNodeWorkService.planDelivery(nodeFanoutMsg, AuthUtil.getUser());
//进行日志记录
handleUpdateDistributionLog(deliveryListEntity, user, reservationDTOS, distributionReservationEntities, myCurrentWarehouse);
@ -5208,6 +5514,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
.eq(DistributionParcelListEntity::getWarehouseId, myCurrentWarehouse.getId())
);
List<String> orderPackageCodes = new ArrayList<>();
List<DistributionLoadscanEntity> pushNodeList = new ArrayList<>();
List<JSONObject> aaa = new ArrayList<>();
if (Func.isNotEmpty(parcelListEntities) && parcelListEntities.size() == 1) {
DistributionParcelListEntity parcelListEntity = parcelListEntities.get(0);
@ -5327,6 +5634,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
loadscanEntity.setLoadingId(distrilbutionloadingscanDTO.getLoadingId());
loadscanEntity.setIsAbnormalLoading(2);
distributionLoadscanService.save(loadscanEntity);
pushNodeList.add(loadscanEntity);
distributionLoadscanAbnormalEntity.setLoadingId(loadscanEntity.getId());
distributionLoadscanAbnormalService.save(distributionLoadscanAbnormalEntity);
orderPackageCodes.add(loadscanEntity.getOrderPackageCode());
@ -5403,7 +5711,11 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
trunklinePackageTrackLogClient.addPackageTrackLog(aaa);
// 发送作业节点数据
if(CollUtil.isNotEmpty(pushNodeList)){
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = buildNodeFanoutMsgByPackage(deliveryListEntity, pushNodeList);
distributionNodeWorkService.abnormalLoading(nodeFanoutMsg, AuthUtil.getUser());
}
return Resp.scanSuccess("操作成功", "异常" + abnormalTotal + "件");
}
@ -5503,6 +5815,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
log.error("############################# 配送任务查询为空,deliveryId为:{}", distributionDeliveryListEntity);
return Resp.scanFail("参数错误", "参数错误!!!");
}
List<DistributionLoadscanEntity> pushNodeList = new ArrayList();
//零担订单进行装车
//这里需要进行判定是进行编辑还是进行的装车
DistributionDeliverySelfEntity distributionDeliverySelfEntity = new DistributionDeliverySelfEntity();
@ -5634,6 +5947,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
loadscanEntity.setLoadingId(distrilbutionloadingscanDTO.getLoadingId());
loadscanEntity.setIsAbnormalLoading(1);
distributionLoadscanService.save(loadscanEntity);
pushNodeList.add(loadscanEntity);
//更新装车时间
Integer i = distributionDeliveryListMapper.updateloadingTimeById(distrilbutionloadingscanDTO.getDeliveryId());
//更新装车数量
@ -5698,6 +6012,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
loadscanEntity.setLoadingId(distrilbutionloadingscanDTO.getLoadingId());
loadscanEntity.setIsAbnormalLoading(1);
distributionLoadscanService.save(loadscanEntity);
pushNodeList.add(loadscanEntity);
//更新装车时间
Integer i = distributionDeliveryListMapper.updateloadingTimeById(distrilbutionloadingscanDTO.getDeliveryId());
//更新装车数量
@ -5775,9 +6090,77 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
bladeRedis.setEx("warehouseId:" + myCurrentWarehouse.getId() + "trainNumber:" + distributionDeliveryListEntity.getTrainNumber() + "orderPackageCode:", packageLockIds, 60L);
}
}
if(CollUtil.isNotEmpty(pushNodeList)){
DistributionDeliveryListEntity deliveryListEntity = distributionDeliveryListService.getById(distrilbutionloadingscanDTO.getDeliveryId());
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = buildNodeFanoutMsgByZeroOrder(deliveryListEntity, pushNodeList);
distributionNodeWorkService.nodeLoading(nodeFanoutMsg, AuthUtil.getUser());
}
return Resp.scanSuccess("装车成功", str.toString());
}
private NodeFanoutMsg<DistributionLoadVO> buildNodeFanoutMsgByZeroOrder(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscanEntity> pushNodeList) {
NodeFanoutMsg<DistributionLoadVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_LOADING);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getCreateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
DistributionLoadVO distributionLoadVO = new DistributionLoadVO();
List<PlanDriverbindCarVO> planDriverbindCarVOS = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
String driverName = distributionDeliveryListEntity.getDriverName();
String vehicleName = distributionDeliveryListEntity.getVehicleName();
// 如果是自主配送 需要去获取当前司机绑定的车牌
if ("1".equals(distributionDeliveryListEntity.getKind())) {
BasicdataDriverArteryEntity driverArteryById = basicdataDriverArteryClient.getDriverArteryById(AuthUtil.getUserId());
if (driverArteryById != null) {
for (int i = 0; i < planDriverbindCarVOS.size(); i++) {
if (planDriverbindCarVOS.get(i).getDriverName().equals(driverArteryById.getName())) {
driverName = planDriverbindCarVOS.get(i).getDriverName();
vehicleName = planDriverbindCarVOS.get(i).getCarPlate();
break;
}
}
}
}
distributionLoadVO.setDriverName(driverName);
distributionLoadVO.setVehicleName(vehicleName);
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscanEntity distributionLoadscanEntity : pushNodeList) {
Map<String, Object> broadcastDataByZeroOrderAndParcId = baseMapper.getBroadcastDataByZeroOrderAndParcId(distributionLoadscanEntity.getDeliveryId(), distributionLoadscanEntity.getWarehouseId(), distributionLoadscanEntity.getPackageId());
PackageData packageData = BeanUtil.copy(broadcastDataByZeroOrderAndParcId, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(broadcastDataByZeroOrderAndParcId.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.LTL;
packageData.setPackageType(type);
packageData.setProductName(Convert.toStr(broadcastDataByZeroOrderAndParcId.get("productName")));
packageData.setNumber(distributionLoadscanEntity.getLoadedNub());
data.add(packageData);
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
@Override
public R retentionScan(DistrilbutionloadingscanDTO distrilbutionloadingscanDTO) {
if (distrilbutionloadingscanDTO.getBarcode().isEmpty()) {
@ -7833,25 +8216,23 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
}
@Override
public Map<String, List<Map<String, Object>>> getDeliveryreBroadcastData(Long id, Long warehouseId) {
Map<String, List<Map<String, Object>>> data = new HashMap<>();
// 定制品
List<Map<String, Object>> broadcastDataByArticles = baseMapper.getBroadcastDataByArticles(id, warehouseId);
if(!broadcastDataByArticles.isEmpty()){
data.put("1",broadcastDataByArticles);
if (!broadcastDataByArticles.isEmpty()) {
data.put("1", broadcastDataByArticles);
}
// 库寸品
List<Map<String, Object>> broadcastDataByStock = baseMapper.getBroadcastDataByStock(id, warehouseId);
if(!broadcastDataByStock.isEmpty()){
data.put("2",broadcastDataByStock);
if (!broadcastDataByStock.isEmpty()) {
data.put("2", broadcastDataByStock);
}
// 零担
List<Map<String, Object>> broadcastDataByZeroOrder = baseMapper.getBroadcastDataByZeroOrder(id, warehouseId);
if(!broadcastDataByZeroOrder.isEmpty()){
data.put("3",broadcastDataByZeroOrder);
if (!broadcastDataByZeroOrder.isEmpty()) {
data.put("3", broadcastDataByZeroOrder);
}
return data;
@ -7972,7 +8353,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
Long warehouseId = myCurrentWarehouse.getId();
DistributionDeliveryListEntity deliveryListEntity = this.getById(deliveryId);
if (Objects.isNull(deliveryListEntity)) {
log.error(method + "配送任务异常deliveryId:{}",deliveryId);
log.error(method + "配送任务异常deliveryId:{}", deliveryId);
return R.fail(403, "配送任务错误!!!");
}
//查询当前登录人所在计划
@ -7987,7 +8368,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
//日志信息收集
List<JSONObject> packageLogs = new ArrayList<>();
//查询司机信息
DistributionDeliverySelfEntity distributionDeliverySelfEntity = getDriver(deliveryListEntity,user,distrilbutionloadingscanDTO,isDriverFlag);
DistributionDeliverySelfEntity distributionDeliverySelfEntity = getDriver(deliveryListEntity, user, distrilbutionloadingscanDTO, isDriverFlag);
switch (type) {
case 1:
if (Objects.isNull(distrilbutionloadingscanDTO.getBarcode())) {
@ -8004,7 +8385,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
);
if (!list.isEmpty()) {
return Resp.scanFail("请在库存品页面扫描此码", "请在库存品页面扫描此码");
}else {
} else {
return Resp.scanFail("系统无编码", "系统无编码");
}
}
@ -8023,12 +8404,12 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
Long reservationId = baseMapper.selectPackageByorderPackageCodeAndDeliveryId(orderPackageCode, deliveryId, warehouseId);
DistributionReservationEntity reservationEntity = distributionReservationService.getById(reservationId);
if (Objects.isNull(reservationEntity)) {
log.error(method + "预约任务错误reservationId:{}",reservationId);
log.error(method + "预约任务错误reservationId:{}", reservationId);
return R.fail(403, "预约任务错误!!!");
}
if (Objects.isNull(reservationId)) {
//判定是否满足异常装车
Boolean isAbnormalLoadingFlag = judgeIsAbnormalLoading(deliveryId, parcelListEntity,reservationId);
Boolean isAbnormalLoadingFlag = judgeIsAbnormalLoading(deliveryId, parcelListEntity, reservationId);
if (isAbnormalLoadingFlag) {
log.info("异常装车判定成功>>>>>>packageCode:{},reservationId:{}", distrilbutionloadingscanDTO.getBarcode(), distrilbutionloadingscanDTO.getReservationId());
return R.fail(5000, "异常装车");
@ -8036,7 +8417,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
return Resp.scanFail("蹿货", "蹿货");
}
//正常进行装车
DistributionLoadscanEntity loadscanEntity = createdDistributionLoadscanEntity(deliveryListEntity,distributionDeliverySelfEntity,reservationId,parcelListEntity,myCurrentWarehouse,user);
DistributionLoadscanEntity loadscanEntity = createdDistributionLoadscanEntity(deliveryListEntity, distributionDeliverySelfEntity, reservationId, parcelListEntity, myCurrentWarehouse, user);
distributionLoadscanService.save(loadscanEntity);
//更新包件装车状态
packageLockIds.add(parcelListEntity.getId());
@ -8069,11 +8450,11 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
pushList.add(parcelListEntity);
break;
case 2:
if (Objects.isNull(distrilbutionloadingscanDTO.getReservationId())){
if (Objects.isNull(distrilbutionloadingscanDTO.getReservationId())) {
log.error(method + "参数缺失ReservationId");
return Resp.fail("参数缺失,请联系管理员");
}
if (Objects.isNull(distrilbutionloadingscanDTO.getParcelListDTOS())){
if (Objects.isNull(distrilbutionloadingscanDTO.getParcelListDTOS())) {
log.error(method + "参数缺失ParcelListDTOS");
return Resp.fail("参数缺失,请联系管理员");
}
@ -8130,7 +8511,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
if (parcelListDTO.getLoadingNum() <= reservationZeroPackageEntity.getQuantity()) {
//零担修改装车
DistributionLoadscanEntity zeroLoadscanEntity = loadscanEntities.get(0);
updateZeroLoadingEntity(zeroLoadscanEntity,parcelListDTO,myCurrentWarehouse,zeroPackageMap);
updateZeroLoadingEntity(zeroLoadscanEntity, parcelListDTO, myCurrentWarehouse, zeroPackageMap);
JSONObject zeroJsonObject = new JSONObject();
zeroJsonObject.put("code", zeroParcelListEntity.getOrderCode());
zeroJsonObject.put("warehouseId", myCurrentWarehouse.getId());
@ -8147,7 +8528,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
distributionDeliverySelfEntity,
deliveryListEntity,
distrilbutionloadingscanDTO.getReservationId(),
parcelListDTO,myCurrentWarehouse,
parcelListDTO, myCurrentWarehouse,
user,
zeroPackageMap);
packageLockIds.add(parcelListDTO.getParcelListId());
@ -8168,7 +8549,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
distributionDeliverySelfEntity,
deliveryListEntity,
distrilbutionloadingscanDTO.getReservationId(),
parcelListDTO,myCurrentWarehouse,
parcelListDTO, myCurrentWarehouse,
user,
zeroPackageMap);
packageLockIds.add(parcelListDTO.getParcelListId());
@ -8202,8 +8583,8 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
}
String inventoryPackageCode = distrilbutionloadingscanDTO.getBarcode();
//查询库存品
reservationId = baseMapper.selectInventoryPackageByDeliveryIdAndInventoryPackageCode(deliveryId,inventoryPackageCode);
if (Objects.nonNull(reservationId)){
reservationId = baseMapper.selectInventoryPackageByDeliveryIdAndInventoryPackageCode(deliveryId, inventoryPackageCode);
if (Objects.nonNull(reservationId)) {
parcelListEntity = distributionParcelListMapper.selectByOrderPackageCode(inventoryPackageCode, myCurrentWarehouse.getId());
if (!Objects.isNull(parcelListEntity)) {
return Resp.scanFail("请在定制品页面扫描此码", "请在定制品页面扫描此码");
@ -8217,7 +8598,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
.ne(DisStockListDetailEntity::getStockPackageStatus, InventoryPackageStatusConstant.quxiao.getValue())
);
if (invemtoryPackageList.size() > 1) {
log.error(method+"此库存品包件在预约计划中存在多条,reservationId:{},inventoryPackageCode:{}",reservationId,inventoryPackageCode);
log.error(method + "此库存品包件在预约计划中存在多条,reservationId:{},inventoryPackageCode:{}", reservationId, inventoryPackageCode);
return Resp.scanFail("此包件数据错误", "此包件数据错误");
}
DisStockListDetailEntity disStockListDetailEntity = invemtoryPackageList.get(0);
@ -8236,10 +8617,10 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
.set(DistributionParcelListEntity::getOrderPackageStatus, OrderPackageStatusConstant.yichuku.getValue())
);
if (update){
if (update) {
//修改成功 此包件是转的
DistributionParcelListEntity parcelListEntity1 = distributionParcelListService.selectByOrderPackageCode(inventoryPackageCode, myCurrentWarehouse.getId());
if (Objects.isNull(parcelListEntity1)){
if (Objects.isNull(parcelListEntity1)) {
pushList.add(parcelListEntity1);
}
}
@ -8385,7 +8766,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
}
break;
default:
log.error(method+"未知类型type:{}",distrilbutionloadingscanDTO.getType());
log.error(method + "未知类型type:{}", distrilbutionloadingscanDTO.getType());
break;
}
//添加缓存
@ -8426,11 +8807,10 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
warehouseUpdownStockUpAreaClient.downStockUpShelf(jsonObjects);
return null;
}
private void updateZeroLoadingEntity(DistributionLoadscanEntity loadscanEntity, DistributionParcelNumberDTO parcelListDTO, BasicdataWarehouseEntity myCurrentWarehouse,Map<Long, DistributionParcelNumberEntity> zeroPackageMap) {
private void updateZeroLoadingEntity(DistributionLoadscanEntity loadscanEntity, DistributionParcelNumberDTO parcelListDTO, BasicdataWarehouseEntity myCurrentWarehouse, Map<Long, DistributionParcelNumberEntity> zeroPackageMap) {
//维护零担出库数量
DistributionParcelNumberEntity parcelNumberEntity = zeroPackageMap.get(parcelListDTO.getParcelListId());
BigDecimal deliveryQuantity = new BigDecimal(parcelNumberEntity.getDeliveryQuantity());
@ -8467,7 +8847,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
BasicdataWarehouseEntity myCurrentWarehouse,
BladeUser user,
Map<Long, DistributionParcelNumberEntity> zeroPackageMap) {
DistributionLoadscanEntity zeroLoadscanEntity = createdDistributionZeroLoadscanEntity(distributionDeliverySelfEntity,deliveryListEntity,distrilbutionloadingscanDTO.getReservationId(),parcelNumberDTO,myCurrentWarehouse,user);
DistributionLoadscanEntity zeroLoadscanEntity = createdDistributionZeroLoadscanEntity(distributionDeliverySelfEntity, deliveryListEntity, distrilbutionloadingscanDTO.getReservationId(), parcelNumberDTO, myCurrentWarehouse, user);
distributionLoadscanService.save(zeroLoadscanEntity);
//更新装车时间
Integer i = distributionDeliveryListMapper.updateloadingTimeById(distrilbutionloadingscanDTO.getDeliveryId());
@ -8520,7 +8900,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
zeroLoadscanEntity.setOrderId(parcelNumberDTO.getStockArticleId());
zeroLoadscanEntity.setScanTime(now);
zeroLoadscanEntity.setScanUser(user.getNickName());
zeroLoadscanEntity.setLoadingId(distributionDeliverySelfEntity.getId()+"");
zeroLoadscanEntity.setLoadingId(distributionDeliverySelfEntity.getId() + "");
zeroLoadscanEntity.setIsAbnormalLoading(1);
return zeroLoadscanEntity;
}
@ -8561,13 +8941,13 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
loadscanEntity.setOrderId(parcelListEntity.getStockArticleId());
loadscanEntity.setScanTime(now);
loadscanEntity.setScanUser(user.getNickName());
loadscanEntity.setLoadingId(distributionDeliverySelfEntity.getId()+"");
loadscanEntity.setLoadingId(distributionDeliverySelfEntity.getId() + "");
loadscanEntity.setIsAbnormalLoading(1);
loadscanEntity.setLoadedNub(parcelListEntity.getQuantity());
return loadscanEntity;
}
private DistributionDeliverySelfEntity getDriver(DistributionDeliveryListEntity deliveryListEntity, BladeUser user,DistrilbutionloadingscanDTO distrilbutionloadingscanDTO,boolean isDriverFlag) {
private DistributionDeliverySelfEntity getDriver(DistributionDeliveryListEntity deliveryListEntity, BladeUser user, DistrilbutionloadingscanDTO distrilbutionloadingscanDTO, boolean isDriverFlag) {
DistributionDeliverySelfEntity distributionDeliverySelfEntity = new DistributionDeliverySelfEntity();
if ("1".equals(deliveryListEntity.getKind())) {
if (isDriverFlag) {
@ -8577,7 +8957,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
throw new CustomerException("没有司机的信息");
}
//查询当前扫描司机是否属于当前配送任务
distributionDeliverySelfEntity = distributionDeliverySelfMapper.selectDriverInfoByDeliveryIdAndDriverId(driverArtery.getId(),deliveryListEntity.getId());
distributionDeliverySelfEntity = distributionDeliverySelfMapper.selectDriverInfoByDeliveryIdAndDriverId(driverArtery.getId(), deliveryListEntity.getId());
} else {
if (Objects.isNull(distrilbutionloadingscanDTO.getDriverId())) {
log.error("文员扫描未选择司机!!");
@ -8589,7 +8969,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
throw new CustomerException("没有司机的信息");
}
//默认为文员进行扫描，此时需要文员选择进行帮助扫描的司机
distributionDeliverySelfEntity = distributionDeliverySelfMapper.selectDriverInfoByDeliveryIdAndDriverId(driverArtery.getId(),deliveryListEntity.getId());
distributionDeliverySelfEntity = distributionDeliverySelfMapper.selectDriverInfoByDeliveryIdAndDriverId(driverArtery.getId(), deliveryListEntity.getId());
}
} else {
DistributionDeliveryTripartiteEntity distributionDeliveryTripartiteEntity = distributionDeliveryTripartiteMapper.selectDriverInfoByDeliveryId(deliveryListEntity.getId());
@ -8603,7 +8983,7 @@ public class DistributionDeliveryListServiceImpl extends BaseServiceImpl<Distrib
return distributionDeliverySelfEntity;
}
private Boolean judgeIsAbnormalLoading(Long deliveryId, DistributionParcelListEntity parcelListEntity,Long reservationId) {
private Boolean judgeIsAbnormalLoading(Long deliveryId, DistributionParcelListEntity parcelListEntity, Long reservationId) {
List<DistributionReservationEntity> reservationEntityList = distributionDeliveryListMapper.selectReservationByDeliveryListId(deliveryId);
if (!reservationEntityList.isEmpty()) {
boolean shangpeiFlag = reservationEntityList.stream().allMatch(r -> r.getDeliveryType().equals(DistributionTypeConstant.shipie.getValue()));

165
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionNodeWorkServiceImpl.java
Unescape View File

@ -24,10 +24,7 @@ import org.springblade.common.constant.broadcast.FanoutConstants;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.BroadcastNodeData;
import org.springblade.common.model.FanoutMsg;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.common.model.*;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
@ -49,139 +46,38 @@ public class DistributionNodeWorkServiceImpl implements IDistributionNodeWorkSer
private RabbitTemplate rabbitTemplate;
@Autowired
private FactoryDataMessageSender factoryDataMessageSender;
@Autowired
@Lazy
private IDistributionDeliveryListService distributionDeliveryListService;
@Autowired
private IDistributionDeliverySelfService distributionDeliverySelfService;
@Autowired
private IDistributionDeliveryTripartiteService distributionDeliveryTripartiteService;
@Override
public void planDelivery(DistributionDeliveryListEntity distributionDeliveryListEntity, BladeUser user, BizOperationEnums bizOperation) {
try {
public void planReservation(NodeFanoutMsg nodeFanoutMsg, BladeUser user) {
NodeFanoutMsg nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(bizOperation);
nodeFanoutMsg.setNode(WorkNodeEnums.PLAN_DELIVERY);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(user.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getCreateTime());
com.alibaba.fastjson.JSONObject jsonObject = new com.alibaba.fastjson.JSONObject();
jsonObject.put("id", distributionDeliveryListEntity.getId());
jsonObject.put("trainNumber", distributionDeliveryListEntity.getTrainNumber());
jsonObject.put("kind", distributionDeliveryListEntity.getKind());
jsonObject.put("type", distributionDeliveryListEntity.getType());
jsonObject.put("distributionCompany", distributionDeliveryListEntity.getDistributionCompany());
jsonObject.put("taskTime", distributionDeliveryListEntity.getTaskTime());
JSONArray jsonArray = buildDeliveryCarDriverInfor(distributionDeliveryListEntity);
jsonObject.put("planDriverbindCars", jsonArray);
String jsonString = jsonObject.toJSONString();
nodeFanoutMsg.setMain(jsonString);
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
Map<String, List<Map<String, Object>>> deliveryreBroadcastData = distributionDeliveryListService.getDeliveryreBroadcastData(distributionDeliveryListEntity.getId(), distributionDeliveryListEntity.getWarehouseId());
// 构建返回数据
List<PackageData> packageDataList = buildSendNodePackageData(deliveryreBroadcastData);
if (!packageDataList.isEmpty()) {
nodeFanoutMsg.setDetails(packageDataList);
rabbitTemplate.convertAndSend(FanoutConstants.distribution.plan.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
}
try {
rabbitTemplate.convertAndSend(FanoutConstants.reservation.OwnReservation.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
}
/**
* 构建车辆信息
*
* @param distributionDeliveryListEntity
* @return
*/
private JSONArray buildDeliveryCarDriverInfor(DistributionDeliveryListEntity distributionDeliveryListEntity) {
JSONArray jsonArray = new JSONArray();
// 自主配送
if ("1".equals(distributionDeliveryListEntity.getKind())) {
LambdaQueryWrapper<DistributionDeliverySelfEntity> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DistributionDeliverySelfEntity::getDeliveryId, distributionDeliveryListEntity.getId());
List<DistributionDeliverySelfEntity> list = distributionDeliverySelfService.list(queryWrapper);
if (list != null && !list.isEmpty()) {
for (DistributionDeliverySelfEntity distributionDeliverySelfEntity : list) {
com.alibaba.fastjson.JSONObject jsonObject = new com.alibaba.fastjson.JSONObject();
jsonObject.put("driverName", distributionDeliverySelfEntity.getDriverName());
jsonObject.put("carPlate", distributionDeliverySelfEntity.getVehicleNub());
jsonArray.add(jsonObject);
}
}
} else {
LambdaQueryWrapper<DistributionDeliveryTripartiteEntity> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DistributionDeliveryTripartiteEntity::getDeliveryId, distributionDeliveryListEntity.getId());
List<DistributionDeliveryTripartiteEntity> list = distributionDeliveryTripartiteService.list(queryWrapper);
if (list != null && !list.isEmpty()) {
for (DistributionDeliveryTripartiteEntity distributionDeliverySelfEntity : list) {
com.alibaba.fastjson.JSONObject jsonObject = new com.alibaba.fastjson.JSONObject();
jsonObject.put("driverName", distributionDeliverySelfEntity.getDriverName());
jsonObject.put("carPlate", distributionDeliverySelfEntity.getVehicleNum());
jsonArray.add(jsonObject);
}
}
}
return jsonArray;
}
@NotNull
private List<PackageData> buildSendNodePackageData(Map<String, List<Map<String, Object>>> deliveryreBroadcastData) {
List<PackageData> packageDataList = new ArrayList<>();
// 定制品
List<Map<String, Object>> data = deliveryreBroadcastData.get("1");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.CMP;
packageData.setPackageType(type);
packageDataList.add(packageData);
}
}
// 库存品
data = deliveryreBroadcastData.get("2");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.INV;
packageData.setPackageType(type);
packageDataList.add(packageData);
}
@Override
public void planDelivery(NodeFanoutMsg nodeFanoutMsg, BladeUser user) {
try {
rabbitTemplate.convertAndSend(FanoutConstants.distribution.DeliveryAndPlan.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
//零担
data = deliveryreBroadcastData.get("3");
if (data != null) {
for (Map<String, Object> map : data) {
PackageData packageData = BeanUtil.copy(map, PackageData.class);
assert packageData != null;
packageData.setBrand(Convert.toStr(map.get("brandName")));
PackageTypeEnums type = PackageTypeEnums.LTL;
packageData.setPackageType(type);
packageData.setProductName(Convert.toStr(map.get("productName")));
packageDataList.add(packageData);
}
@Override
public void cancelReservation(NodeFanoutMsg<ReservationVO> nodeFanoutMsg, BladeUser user) {
try {
rabbitTemplate.convertAndSend(FanoutConstants.reservation.OwnReservation.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
return packageDataList;
}
@Override
public void planStock(NodeFanoutMsg nodeFanoutMsg, BladeUser user) {
// 备货信息主表
@ -194,13 +90,21 @@ public class DistributionNodeWorkServiceImpl implements IDistributionNodeWorkSer
}
@Override
public void nodeLoad() {
public void nodeLoading(NodeFanoutMsg nodeFanoutMsg, BladeUser user) {
try {
rabbitTemplate.convertAndSend(FanoutConstants.distribution.DeliveryAndLoading.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
}
@Override
public void abnormalLoading() {
public void abnormalLoading(NodeFanoutMsg nodeFanoutMsg, BladeUser user) {
try {
rabbitTemplate.convertAndSend(FanoutConstants.distribution.DeliveryAndLoading.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
}
@Override
@ -218,6 +122,15 @@ public class DistributionNodeWorkServiceImpl implements IDistributionNodeWorkSer
}
@Override
public void signFor(NodeFanoutMsg<DistributionSignforVO> nodeFanoutMsg, BladeUser user) {
try {
rabbitTemplate.convertAndSend(FanoutConstants.distribution.DeliveryAndSignfor.EXCHANGE, null, com.alibaba.fastjson.JSONObject.toJSONString(nodeFanoutMsg));
} catch (AmqpException e) {
log.error(">>>>>>>>>>>>>>>>>>>>>>>>>> 消息推送失败~ 请联系管理员！ ", e);
}
}
@Override
public void signFor(DistributionParcelListEntity parcelListEntity, Long taskId, String operationTime, String destinationWarehouse) {

165
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionReservationServiceImpl.java
Unescape View File

@ -115,9 +115,7 @@ import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.BrandEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.IDict;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.common.model.*;
import org.springblade.common.serviceConstant.ServiceConstant;
import org.springblade.common.utils.AddressUtil;
import org.springblade.common.utils.CommonUtil;
@ -1450,8 +1448,12 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
distributionDeliveryListService.updateById(distributionDeliveryListEntity);
String content = "包件在" + myCurrentWarehouse.getName() + "由" + AuthUtil.getUser().getNickName() + "转车次任务,操作方式:批量预约任务转配送,车次号:" + distributionDeliveryListEntity.getTrainNumber();
distributionAsyncService.recordsReservationDeliveryLog(reservationEntityList, myCurrentWarehouse, user, distributionDeliveryListEntity, WorkNodeEnums.PLAN_DISTRIBUTION.getCode(), content);
//处理广播数据
distributionNodeWorkService.planDelivery(distributionDeliveryListEntity, AuthUtil.getUser(),BizOperationEnums.ADD);
// distributionNodeWorkService.planDelivery(distributionDeliveryListEntity, AuthUtil.getUser(),BizOperationEnums.ADD);
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = distributionDeliveryListService.buildNodeFanoutMsgForPlan(distributionDeliveryListEntity, AuthUtil.getUser(), BizOperationEnums.ADD);
distributionNodeWorkService.planDelivery(nodeFanoutMsg, AuthUtil.getUser());
//日志记录
handleCreatedDistributionLog(distributionDeliveryListEntity, myCurrentWarehouse, user, reservationEntityList);
@ -2601,7 +2603,10 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
}
//处理广播数据
distributionNodeWorkService.planDelivery(distributionDeliveryListEntity, AuthUtil.getUser(),BizOperationEnums.ADD);
// distributionNodeWorkService.planDelivery(distributionDeliveryListEntity, AuthUtil.getUser(),BizOperationEnums.ADD);
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = distributionDeliveryListService.buildNodeFanoutMsgForPlan(distributionDeliveryListEntity, AuthUtil.getUser(), BizOperationEnums.ADD);
distributionNodeWorkService.planDelivery(nodeFanoutMsg, AuthUtil.getUser());
// 创建处理商场信息队列
@ -2656,7 +2661,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
List<DistributionReservationStockarticleEntity> reservationStockarticleEntityList = distributionReservationStockarticleService.list(Wrappers.<DistributionReservationStockarticleEntity>query().lambda()
.eq(DistributionReservationStockarticleEntity::getReservationId, reservationEntity.getId())
.ne(DistributionReservationStockarticleEntity::getStockArticleStatus, ReservationOrderStatusConstant.quxiao.getValue()));
if (Func.isNotEmpty(reservationStockarticleEntityList) && reservationStockarticleEntityList.size() > 0) {
if (Func.isNotEmpty(reservationStockarticleEntityList) && !reservationStockarticleEntityList.isEmpty()) {
List<JSONObject> aaa = new ArrayList<>();
reservationStockarticleEntityList.forEach(rs -> {
rs.setStockArticleStatus(ReservationOrderStatusConstant.quxiao.getValue());
@ -2668,7 +2673,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
.eq(DistributionReservationPackageEntity::getReservationId, rs.getReservationId())
.eq(DistributionReservationPackageEntity::getStockArticleId, rs.getStockArticleId())
.ne(DistributionReservationPackageEntity::getPacketBarStatus, ReservationPackageStatusConstant.quxiao.getValue()));
if (Func.isNotEmpty(reservationPackageEntityList) && reservationPackageEntityList.size() > 0) {
if (Func.isNotEmpty(reservationPackageEntityList) && !reservationPackageEntityList.isEmpty()) {
reservationPackageEntityList.forEach(rp -> {
rp.setPacketBarStatus(ReservationPackageStatusConstant.quxiao.getValue());
distributionReservationPackageService.updateById(rp);
@ -2721,7 +2726,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
}
List<DistributionReservationStocklistEntity> distributionReservationStocklistEntities = distributionReservationMapper.selectStockListByReservationId(reservationEntity.getId());
if (Func.isNotEmpty(distributionReservationStocklistEntities) && distributionReservationStocklistEntities.size() > 0) {
if (Func.isNotEmpty(distributionReservationStocklistEntities) && !distributionReservationStocklistEntities.isEmpty()) {
//进行库存品库存数量的维护
distributionReservationStocklistEntities.forEach(i -> {
DistributionStockListEntity stockListEntity = distributionStockListService.getById(i.getStocklistId());
@ -2733,6 +2738,8 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
//执行物理删除
disStockListDetailMapper.deleteInventoryByReservationId(reservationEntity.getId());
}
if (Func.isEmpty(distributionStockupInfoEntities)) {
//无备货信息
//物理删除关于预约的所有信息
@ -2775,9 +2782,17 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
this.updateById(reservationEntity);
} else {
log.error("###################预约备货任务数据异常,备货任务ID:{}", distributionStockupInfoEntities.get(0).getStockupId());
throw new CustomerException("预约备货任务数据异常，无法取消预约任务");
}
}
NodeFanoutMsg<ReservationVO> nodeFanoutMsg =buildNodeFanoutMsgByReservationByCancel(reservationEntity);
distributionNodeWorkService.cancelReservation(nodeFanoutMsg,AuthUtil.getUser());
return true;
}
@ -2986,6 +3001,13 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
if (Func.isEmpty(myCurrentWarehouse)) {
return R.fail("无仓库信息!!!");
}
Map<String,List> map = new HashMap<>();
List<DistributionReservationPackageEntity> reservationPackageEntityList = new ArrayList<>();
map.put("1",reservationPackageEntityList);
List<DistributionReservationZeroPackageEntity> reservationZeroPackageEntityList = new ArrayList<>();
map.put("2",reservationZeroPackageEntityList);
List<DistributionReservationStocklistEntity> reservationStocklistEntityList = new ArrayList<>();
map.put("3",reservationStocklistEntityList);
//构建预约单
DistributionReservationEntity reservationEntity = new DistributionReservationEntity();
@ -3046,7 +3068,6 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
if (Func.isNotEmpty(s.getAllocation())) {
s.setAllocation(null);
}
DistributionStockArticleDTO stockArticleDTO = Func.copy(s, DistributionStockArticleDTO.class);
DistributionReservationStockarticleEntity distributionReservationStockarticleEntity = new DistributionReservationStockarticleEntity();
if ("0".equals(s.getIsZero())) {
@ -3114,6 +3135,9 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
distributionReservationPackageEntity.setPacketBarCode(dp.getOrderPackageCode());
//维护订单下包件信息
distributionReservationPackageService.save(distributionReservationPackageEntity);
reservationPackageEntityList.add(distributionReservationPackageEntity);
//此时订单下的所有包件都处于预约状态，可用数为0
packageNum.getAndAdd(dp.getQuantity());
//修改订单下的包件状态
@ -3143,6 +3167,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
distributionReservationPackageEntity.setStockArticleId(s.getId());
distributionReservationPackageEntity.setPacketBarCode(p.getOrderPackageCode());
distributionReservationPackageService.save(distributionReservationPackageEntity);
reservationPackageEntityList.add(distributionReservationPackageEntity);
packageNum.getAndAdd(p.getQuantity());
p.setOrderPackageReservationStatus(OrderPackageReservationStatusConstant.yiyueyue.getValue());
distributionParcelListService.updateById(p);
@ -3204,6 +3229,8 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
distributionReservationZeroPackageEntity.setType(DistributionTypeConstant.shipie.getValue());
distributionReservationZeroPackageEntity.setZeroPackageStatus(ReservationOrderStatusConstant.zhengchang.getValue());
distributionReservationZeroPackageService.save(distributionReservationZeroPackageEntity);
reservationZeroPackageEntityList.add(distributionReservationZeroPackageEntity);
//统计数量
zeroPackageNum.getAndAdd(distributionReservationZeroPackageEntity.getQuantity());
//维护零担订单品类对应数量的冻结数量
@ -3236,6 +3263,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
distributionReservationZeroPackageEntity.setType(DistributionTypeConstant.shipie.getValue());
distributionReservationZeroPackageEntity.setZeroPackageStatus(ReservationOrderStatusConstant.zhengchang.getValue());
distributionReservationZeroPackageService.save(distributionReservationZeroPackageEntity);
reservationZeroPackageEntityList.add(distributionReservationZeroPackageEntity);
//统计数量
zeroPackageNum.getAndAdd(distributionReservationZeroPackageEntity.getQuantity());
//维护零担订单品类对应数量的冻结数量
@ -3350,6 +3378,7 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
}
//完成库存品详情的添加
disStockListDetailService.saveBatch(detailEntities);
reservationStocklistEntityList.add(distributionReservationStocklistEntity);
});
}
//这里对订单自编号进行处理
@ -3400,9 +3429,123 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
//进行日志的添加
BladeUser user = AuthUtil.getUser();
handleCreatedReservationPlanLog(reservationEntity, user, myCurrentWarehouse);
NodeFanoutMsg<ReservationVO> nodeFanoutMsg = buildNodeFanoutMsgByReservation(reservationEntity,map);
distributionNodeWorkService.planReservation(nodeFanoutMsg,AuthUtil.getUser());
return R.status(true);
}
private NodeFanoutMsg<ReservationVO> buildNodeFanoutMsgByReservationByCancel(DistributionReservationEntity reservationEntity) {
NodeFanoutMsg<ReservationVO> nodeFanoutMsg = new NodeFanoutMsg<>();
nodeFanoutMsg.setNode(WorkNodeEnums.PLANNED_RESERVATION);
nodeFanoutMsg.setBizOperation(BizOperationEnums.DELETE);
nodeFanoutMsg.setOperator(AuthUtil.getNickName());
nodeFanoutMsg.setOperatorTime(new Date());
nodeFanoutMsg.setWarehouse(reservationEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(reservationEntity.getWarehouseId());
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
ReservationVO reservationVO = getReservationVO(reservationEntity);
nodeFanoutMsg.setMain(reservationVO);
return nodeFanoutMsg;
}
private NodeFanoutMsg<ReservationVO> buildNodeFanoutMsgByReservation(DistributionReservationEntity reservationEntity, Map<String, List> map) {
NodeFanoutMsg<ReservationVO> nodeFanoutMsg = new NodeFanoutMsg<>();
nodeFanoutMsg.setNode(WorkNodeEnums.PLANNED_RESERVATION);
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setOperator(AuthUtil.getNickName());
nodeFanoutMsg.setOperatorTime(new Date());
nodeFanoutMsg.setWarehouse(reservationEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(reservationEntity.getWarehouseId());
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
ReservationVO reservationVO = getReservationVO(reservationEntity);
nodeFanoutMsg.setMain(reservationVO);
// List<DistributionReservationPackageEntity> reservationPackageEntityList = new ArrayList<>();
// map.put("1",reservationPackageEntityList);
// List<DistributionReservationZeroPackageEntity> reservationZeroPackageEntityList = new ArrayList<>();
// map.put("2",reservationZeroPackageEntityList);
// List<DistributionReservationStocklistEntity> reservationStocklistEntityList = new ArrayList<>();
// map.put("3",reservationStocklistEntityList);
List<PackageData> packageDataList = new ArrayList<>();
List<DistributionReservationPackageEntity> list = map.get("1");
if(Func.isNotEmpty(list)){
for (DistributionReservationPackageEntity distributionReservationPackageEntity : list) {
PackageData packageData = new PackageData();
packageData.setPackageCode(distributionReservationPackageEntity.getPacketBarCode());
packageData.setPackageType(PackageTypeEnums.CMP);
packageDataList.add(packageData);
}
}
List<DistributionReservationZeroPackageEntity> list2 = map.get("2");
if(Func.isNotEmpty(list2)){
for (DistributionReservationZeroPackageEntity distributionReservationZeroPackageEntity : list2) {
PackageData packageData = new PackageData();
packageData.setPackageType(PackageTypeEnums.LTL);
packageData.setNumber(distributionReservationZeroPackageEntity.getQuantity());
DistributionParcelListEntity byId = distributionParcelListService.getById(distributionReservationZeroPackageEntity.getParcelListId());
if(Func.isNotEmpty(byId)){
packageData.setOrderCode(byId.getOrderCode());
packageData.setBrand(byId.getBrandName());
packageData.setWaybillNumber(byId.getWaybillNumber());
}
packageData.setProductName(distributionReservationZeroPackageEntity.getCategoryName());
packageDataList.add(packageData);
}
}
List<DistributionReservationStocklistEntity> list3 = map.get("3");
if(Func.isNotEmpty(list3)){
for (DistributionReservationStocklistEntity distributionReservationStocklistEntity : list3) {
PackageData packageData = new PackageData();
packageData.setPackageType(PackageTypeEnums.INV);
DistributionStockListEntity byId = distributionStockListService.getById(distributionReservationStocklistEntity.getStocklistId());
if (Func.isNotEmpty(byId)){
packageData.setBrand(byId.getBrandName());
// packageData.setProductName(byId.getDescriptionGoods());
packageData.setMaterialCode(byId.getCargoNumber());
packageData.setMaterialName(byId.getDescriptionGoods());
packageData.setPickupBatch(byId.getIncomingBatch());
}
packageData.setNumber(distributionReservationStocklistEntity.getReservationNum());
packageDataList.add(packageData);
}
}
nodeFanoutMsg.setDetails(packageDataList);
return nodeFanoutMsg;
}
@NotNull
private static ReservationVO getReservationVO(DistributionReservationEntity reservationEntity) {
ReservationVO reservationVO = new ReservationVO();
reservationVO.setReservationCode(reservationEntity.getReservationCode());
reservationVO.setReservationDate(reservationEntity.getReservationDate());
reservationVO.setConsignee(reservationEntity.getConsignee());
reservationVO.setDeliveryAddress(reservationEntity.getDeliveryAddress());
reservationVO.setDeliveryPhone(reservationEntity.getDeliveryPhone());
reservationVO.setMallName(reservationEntity.getMallName());
reservationVO.setStoreName(reservationEntity.getStoreName());
reservationVO.setWarehouseName(reservationEntity.getWarehouseName());
reservationVO.setDeliveryType(reservationEntity.getDeliveryType());
return reservationVO;
}
private void handleCreatedReservationPlanLog(DistributionReservationEntity reservationEntity, BladeUser user, BasicdataWarehouseEntity warehouse) {
String planContent = user.getNickName() + "在" + warehouse.getName()
+ "创建预约计划;预约计划编号:" + reservationEntity.getReservationCode()
@ -3718,7 +3861,9 @@ public class DistributionReservationServiceImpl extends BaseServiceImpl<Distribu
// 作业节点推送
DistributionDeliveryListEntity deliveryListEntity= distributionDeliveryListService.getById(distributionCancelReservationPackageDTO.getDeliveryId());
distributionNodeWorkService.planDelivery(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
NodeFanoutMsg<DistributionTaskVO> nodeFanoutMsg = distributionDeliveryListService.buildNodeFanoutMsgForPlan(deliveryListEntity, AuthUtil.getUser(), BizOperationEnums.MODIFY);
distributionNodeWorkService.planDelivery(nodeFanoutMsg, AuthUtil.getUser());
return R.status(true);
}

181
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionSignforServiceImpl.java
Unescape View File

@ -18,8 +18,6 @@ package com.logpm.distribution.service.impl;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@ -47,7 +45,6 @@ import com.logpm.distribution.vo.app.*;
import com.logpm.distribution.wrapper.DistributionParcelListAppWrapper;
import com.logpm.distribution.wrapper.DistributionParcelListWrapper;
import com.logpm.distribution.wrapper.DistributionStockArticleWrapper;
import com.logpm.factory.comfac.dto.OrderStatusDTO;
import com.logpm.oldproject.dto.SignPushDataContactDTO;
import com.logpm.oldproject.dto.SignPushDataDTO;
import com.logpm.oldproject.dto.SignPushDataUnitDTO;
@ -56,13 +53,11 @@ import com.logpm.oldproject.feign.IOldSignPushClient;
import com.logpm.oldproject.feign.IWarehouseClient;
import com.logpm.trunkline.dto.WaybillLogDTO;
import com.logpm.trunkline.feign.ITrunklinePackageTrackLogClient;
import com.logpm.trunkline.feign.ITrunklineWaybillOrderClient;
import com.logpm.trunkline.feign.ITrunklineWaybillTrackClient;
import com.logpm.warehouse.feign.IWarehouseUpdownStockUpAreaClient;
import com.logpm.warehouse.feign.IWarehouseUpdownTypeClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.util.Strings;
import org.jetbrains.annotations.NotNull;
import org.springblade.common.constant.DistributionTypeConstant;
import org.springblade.common.constant.Inventory.InventoryLoadingStatusConstant;
@ -80,7 +75,11 @@ import org.springblade.common.constant.reservation.*;
import org.springblade.common.constant.signing.SignforDriverSigningStatusConstant;
import org.springblade.common.constant.signing.SignforStatusConstant;
import org.springblade.common.constant.stockup.StockAssignStatusConstant;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.common.node.BillLadingNode;
import org.springblade.common.node.DeliveryNode;
import org.springblade.common.node.ReservationNode;
@ -116,10 +115,8 @@ import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
@ -2582,6 +2579,10 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
}
List<String> orderPackageCodes = new ArrayList<>();
List<JSONObject> aaa = new ArrayList<>();
List<DistributionLoadscanEntity> pushList = new ArrayList<>();
List<DistributionParcelListEntity> parcelListEntityList = distributionReservationMapper.selectPackageListByReservationId(distrilbutionloadingscanDTO.getReservationId());
//查询该客户是否存在该包件信息
List<DistributionParcelListEntity> collect = parcelListEntityList.stream().filter(p -> p.getOrderPackageCode().equals(distrilbutionloadingscanDTO.getBarcode())).collect(Collectors.toList());
@ -2633,6 +2634,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
distributionLoadscanService.updateById(loadscanEntity);
pushList.add(loadscanEntity);
//缺少一个异步维护包件签收的方法
// distributionAsyncService.changeOrderSignforStatus(collect.get(0));
Integer j = distributionSignforMapper.updateSignforNum(loadscanEntity.getDeliveryId(), loadscanEntity.getReservationId(), loadscanEntity.getPackageNub());
@ -2713,6 +2715,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
distributionLoadscanEntity.setSigningUserId(AuthUtil.getUser().getUserId());
distributionLoadscanEntity.setScanStatus(LoadingStatusConstant.buluzhuangche.getValue());
distributionLoadscanService.save(distributionLoadscanEntity);
pushList.add(distributionLoadscanEntity);
//进行签收数量的修改
Integer i = distributionDeliveryListMapper.updateloadingTimeById(distrilbutionloadingscanDTO.getDeliveryId());
//更新装车包件数和签收包件数
@ -2830,6 +2833,13 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
sendNodeWorkDataBroadcast(parcelListEntity, distributionReservationEntity, singleTime, myCurrentWarehouse);
// 构建新作业节点回传
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = buildDistributionSignforVO(deliveryListEntity,pushList);
iDistributionNodeWorkService.signFor(nodeFanoutMsg,AuthUtil.getUser());
return Resp.scanSuccessWithData("签收成功", str, orderPackageCodes);
} catch (Exception e) {
log.error(">>>>> 签收异常报错", e);
@ -2837,6 +2847,96 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
}
}
private NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> buildDistributionSignforVOByStock(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscaninvnEntity> pushList) {
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_SIGN_FOR);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getUpdateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
org.springblade.common.model.DistributionSignforVO distributionLoadVO = new org.springblade.common.model.DistributionSignforVO();
DistributionLoadscaninvnEntity distributionLoadscanEntity = pushList.get(0);
distributionLoadVO.setDriverName(distributionLoadscanEntity.getDriverName());
distributionLoadVO.setVehicleName(distributionLoadscanEntity.getVehicleName());
DistributionReservationEntity byId = distributionReservationService.getById(distributionLoadscanEntity.getReservationId());
if(!Func.isEmpty(byId)){
distributionLoadVO.setReservationCode(byId.getReservationCode());
}
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscaninvnEntity distributionParcelListEntity : pushList) {
PackageData packageData = new PackageData();
DistributionStockListEntity byIds = distributionStockListService.getById(distributionParcelListEntity.getInventoryId());
if (Func.isNotEmpty(byIds)){
packageData.setBrand(byIds.getBrandName());
// packageData.setProductName(byId.getDescriptionGoods());
packageData.setMaterialCode(byIds.getCargoNumber());
packageData.setMaterialName(byIds.getDescriptionGoods());
packageData.setPickupBatch(byIds.getIncomingBatch());
packageData.setPackageType(PackageTypeEnums.INV);
}
packageData.setNumber(1);
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
private NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> buildDistributionSignforVO(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscanEntity> pushList) {
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_SIGN_FOR);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getUpdateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
org.springblade.common.model.DistributionSignforVO distributionLoadVO = new org.springblade.common.model.DistributionSignforVO();
DistributionLoadscanEntity distributionLoadscanEntity = pushList.get(0);
distributionLoadVO.setDriverName(distributionLoadscanEntity.getDriverName());
distributionLoadVO.setVehicleName(distributionLoadscanEntity.getVehicleName());
DistributionReservationEntity byId = distributionReservationService.getById(distributionLoadscanEntity.getReservationId());
if(!Func.isEmpty(byId)){
distributionLoadVO.setReservationCode(byId.getReservationCode());
}
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscanEntity distributionParcelListEntity : pushList) {
PackageData packageData = new PackageData();
packageData.setPackageCode(distributionParcelListEntity.getOrderPackageCode());
packageData.setPackageType(PackageTypeEnums.CMP);
data.add(packageData);
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
private void sendNodeWorkDataBroadcast(DistributionParcelListEntity parcelListEntity, DistributionReservationEntity distributionReservationEntity, String singleTime, BasicdataWarehouseEntity myCurrentWarehouse) {
try {
//推送信息至工厂
@ -3830,6 +3930,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
return R.fail(403, "配送错误");
}
List<Long> packageLockIds = new ArrayList<>();
List<DistributionLoadscaninvnEntity> pushList =new ArrayList<>();
boolean isHaveCode = detailEntities.stream().anyMatch(inven -> Func.isNotEmpty(inven.getStockPackageCode()));
@ -3856,6 +3957,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
loadscaninvnEntity.setOneQclick(1);
packageLockIds.add(loadscaninvnEntity.getInventoryPackageId());
distributionLoadscaninvnService.updateById(loadscaninvnEntity);
pushList.add(loadscaninvnEntity);
//维护签收数量
Integer j = distributionSignforMapper.updatesignforByinvn(loadscaninvnEntity.getDeliveryId(), loadscaninvnEntity.getReservationId(), loadscaninvnEntity.getPackageNub());
//更新签收人
@ -3916,6 +4018,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
distributionLoadscaninvnEntity.setSigningUserId(user.getUserId());
distributionLoadscaninvnEntity.setSigningTime(simpleDateFormat.format(new Date()));
distributionLoadscaninvnService.save(distributionLoadscaninvnEntity);
pushList.add(distributionLoadscaninvnEntity);
//更新装车数量
Integer j = distributionSignforMapper.updateLoadAndsignforByinvn(distributionLoadscaninvnEntity.getDeliveryId(), distributionLoadscaninvnEntity.getReservationId(), distributionLoadscaninvnEntity.getPackageNub());
//更新签收人
@ -3981,6 +4084,14 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
bladeRedis.setEx("warehouseId:" + myCurrentWarehouse.getId() + "trainNumber:" + deliveryListEntity.getTrainNumber() + "orderPackageCode:", packageLockIds, 60L);
}
}
// 作业节点数据推送
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = buildDistributionSignforVOByStock(deliveryListEntity,pushList);
iDistributionNodeWorkService.signFor(nodeFanoutMsg,AuthUtil.getUser());
return Resp.scanSuccess("签收成功", str);
}
@ -6081,6 +6192,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
List<String> orderCodes = new ArrayList<>();
List<DistributionLoadscanEntity> pushList = new ArrayList<>();
BladeUser user = AuthUtil.getUser();
DistributionSignforEntity signforEntity = distributionSignforMapper.selectOne(Wrappers.<DistributionSignforEntity>query().lambda()
.eq(DistributionSignforEntity::getDeliveryId, distrilbutionloadingscanDTO.getDeliveryId())
@ -6165,6 +6277,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
receivedQuantity += parcelNumberDTO.getSigningNum() ;
//进行签收数量的统计
distributionLoadscanService.updateById(distributionLoadscanEntity);
pushList.add(distributionLoadscanEntity);
JSONObject jsonObject = new JSONObject();
jsonObject.put("code", parcelListEntity.getOrderCode());
jsonObject.put("warehouseId", myCurrentWarehouse.getId());
@ -6219,6 +6332,7 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
loadscanEntity.setOneQclick(2);
loadscanEntity.setSigningTime(simpleDateFormat.format(new Date()));
distributionLoadscanService.save(loadscanEntity);
pushList.add(loadscanEntity);
loadedNumber += loadscanEntity.getLoadedNub();
receivedQuantity += loadscanEntity.getReceivedQuantity();
//维护零担品类信息
@ -6283,9 +6397,62 @@ public class DistributionSignforServiceImpl extends BaseServiceImpl<Distribution
distributionStockArticleService.maintenanceOrderInfo(collect, myCurrentWarehouse.getId());
}
String str = checkSignNum(distrilbutionloadingscanDTO);
// 作业节点推送
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = buildDistributionSignforVOByZero(deliveryListEntity,pushList);
iDistributionNodeWorkService.signFor(nodeFanoutMsg,AuthUtil.getUser());
return Resp.scanSuccess("签收成功", str);
}
private NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> buildDistributionSignforVOByZero(DistributionDeliveryListEntity distributionDeliveryListEntity, List<DistributionLoadscanEntity> pushList) {
NodeFanoutMsg<org.springblade.common.model.DistributionSignforVO> nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.DISTRIBUTION_SIGN_FOR);
nodeFanoutMsg.setWarehouse(distributionDeliveryListEntity.getWarehouseName());
nodeFanoutMsg.setWarehouseId(distributionDeliveryListEntity.getWarehouseId());
nodeFanoutMsg.setOperator(AuthUtil.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionDeliveryListEntity.getUpdateTime());
// DistributionTaskVO taskVO = buildDistributionTaskVO(distributionDeliveryListEntity, AuthUtil.getUserId());
org.springblade.common.model.DistributionSignforVO distributionLoadVO = new org.springblade.common.model.DistributionSignforVO();
DistributionLoadscanEntity distributionLoadscanEntity = pushList.get(0);
distributionLoadVO.setDriverName(distributionLoadscanEntity.getDriverName());
distributionLoadVO.setVehicleName(distributionLoadscanEntity.getVehicleName());
DistributionReservationEntity byId = distributionReservationService.getById(distributionLoadscanEntity.getReservationId());
if(!Func.isEmpty(byId)){
distributionLoadVO.setReservationCode(byId.getReservationCode());
}
nodeFanoutMsg.setMain(distributionLoadVO);
List<PackageData> data = new ArrayList<>();
for (DistributionLoadscanEntity loadscanEntity : pushList) {
PackageData packageData = new PackageData();
packageData.setPackageType(PackageTypeEnums.LTL);
packageData.setNumber(loadscanEntity.getReceivedQuantity());
DistributionParcelListEntity byIds = distributionParcelListService.getById(loadscanEntity.getPackageId());
if(Func.isNotEmpty(byIds)){
packageData.setOrderCode(byIds.getOrderCode());
packageData.setBrand(byIds.getBrandName());
packageData.setWaybillNumber(byIds.getWaybillNumber());
packageData.setProductName(byIds.getFirsts());
}
}
nodeFanoutMsg.setDetails(data);
return nodeFanoutMsg;
}
@Override
@Transactional(rollbackFor = Exception.class)
public R updateSign(DistributionSignforDTO distributionSignfor) {

792
blade-service/logpm-distribution/src/main/java/com/logpm/distribution/service/impl/DistributionStockupServiceImpl.java
Unescape View File

@ -47,6 +47,7 @@ import com.logpm.distribution.service.*;
import com.logpm.distribution.vo.*;
import com.logpm.distribution.vo.app.StockupZeroVO;
import com.logpm.distribution.wrapper.DistributionStockupWrapper;
import com.logpm.trunkline.feign.ITrunklinePackageTrackLogClient;
import com.logpm.warehouse.entity.WarehouseGoodsAllocationEntity;
import com.logpm.warehouse.entity.WarehouseTaryAllocationEntity;
import com.logpm.warehouse.entity.WarehouseTrayGoodsEntity;
@ -54,20 +55,31 @@ import com.logpm.warehouse.entity.WarehouseUpdownGoodsEntity;
import com.logpm.warehouse.feign.*;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springblade.common.constant.CodeDesEnum;
import org.springblade.common.constant.DictBizConstant;
import org.springblade.common.constant.RabbitConstant;
import org.springblade.common.constant.WorkNodeEnums;
import org.springblade.common.constant.common.IsOrNoConstant;
import org.springblade.common.constant.orderpackage.OrderPackageStatusConstant;
import org.springblade.common.constant.orderpackage.OrderPackageStockupStatusConstant;
import org.springblade.common.constant.pda.PdaAudioLingoStatus;
import org.springblade.common.constant.reservation.ReservationLoadingStatusConstant;
import org.springblade.common.constant.reservation.ReservationOrderStatusConstant;
import org.springblade.common.constant.reservation.ReservationPackageStatusConstant;
import org.springblade.common.constant.reservation.ReservationSigningStatusConstant;
import org.springblade.common.constant.stocklist.StockLockingStatusConstant;
import org.springblade.common.constant.stocklist.StockSignfoStatusConstant;
import org.springblade.common.constant.stocklist.StockStatusConstant;
import org.springblade.common.constant.stockup.StockAssignStatusConstant;
import org.springblade.common.constant.stockup.StockupStatusConstant;
import org.springblade.common.constant.stockup.StockupTypeConstant;
import org.springblade.common.enums.BizOperationEnums;
import org.springblade.common.enums.PackageTypeEnums;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.model.NodeFanoutMsg;
import org.springblade.common.model.PackageData;
import org.springblade.common.utils.CommonUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.secure.BladeUser;
@ -80,6 +92,7 @@ import org.springblade.system.entity.DictBiz;
import org.springblade.system.entity.User;
import org.springblade.system.feign.ISysClient;
import org.springblade.system.feign.IUserSearchClient;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
@ -176,7 +189,7 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
@Autowired
private IWarehouseUpdownTypeClient warehouseUpdownTypeClient;
@Autowired
private final IWarehouseUpdownGoodsClient warehouseUpdownGoodsClient;
private IWarehouseUpdownGoodsClient warehouseUpdownGoodsClient;
@Autowired
private IBasicdataGoodsAreaClient basicdataGoodsAreaClient;
@ -216,6 +229,13 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
@Autowired
private IWarehouseUpdownStockUpAreaClient warehouseUpdownStockUpAreaClient;
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private IDistributionNodeWorkService distributionNodeWorkService;
@Autowired
private ITrunklinePackageTrackLogClient trunklinePackageTrackLogClient;
@Override
public IPage<DistributionStockupVO> selectDistributionStockupPage(IPage<DistributionStockupVO> page, DistributionStockupVO distributionStockup) {
@ -306,10 +326,10 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
if ("3".equals(distributionStockupEntity.getTypeService())) {
//自
return baseMapper.pageOweList(page, distributionStockupEntity,warehouseIdList);
return baseMapper.pageOweList(page, distributionStockupEntity, warehouseIdList);
} else {
//商 市
return baseMapper.pageList(page, distributionStockupEntity,warehouseIdList);
return baseMapper.pageList(page, distributionStockupEntity, warehouseIdList);
}
}
@ -1886,6 +1906,7 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
List<DistributionStockEntity> list1 = new ArrayList<>();
AtomicBoolean f = new AtomicBoolean(false); //是否下架
AtomicBoolean fa = new AtomicBoolean(false); //是否有包件
DistributionStockupEntity distributionStockupEntity = distributionStockupService.selectById(stockupDTO.getStockupId());
voList.forEach(i -> {
//查询是否已备货
DistributionParcelListEntity byId = distributionParcelListService.getById(i.getParcelListId());
@ -1927,7 +1948,6 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
distributionStock.setStockArticle(i.getStockArticleId());
// distributionStock.setGoodsAllocation(i.getGoodsAllocation());//货位信息
//备货区
DistributionStockupEntity distributionStockupEntity = distributionStockupService.selectById(stockupDTO.getStockupId());
if (ObjectUtils.isNotNull(distributionStockupEntity)) {
distributionStock.setStockupArea(distributionStockupEntity.getStockupArea());
}
@ -1955,13 +1975,13 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
warehouseId = byId1.getWarehouseId();
}
if (ObjectUtils.isNull(warehouseId)) {
throw new ServiceException("预约信息不存在，无法备货！");
throw new CustomerException("预约信息不存在，无法备货！");
}
String trayCode = stockupDTO.getTrayBarCode();
//货位下架
R r = warehouseUpdownTypeClient.downTray(trayCode, warehouseId);
if (ObjectUtils.isNull(r) || ObjectUtils.isNotNull(r) && r.getCode() != 200) {
throw new ServiceException("下架失败！！");
log.warn("货位下架失败！！！");
}
@ -1977,7 +1997,7 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
);
if (!update) {
log.info("包件备货信息修改失败!!");
throw new ServiceException("包件备货信息修改失败！！");
throw new CustomerException("包件备货信息修改失败！！");
}
//判断备货任务是否完成
@ -1999,6 +2019,21 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
warehouseUpdownStockUpAreaClient.upStockUpShelf(jsonObject);
}
}
if (!list1.isEmpty()) {
List<Long> collect = list1.stream().map(DistributionStockEntity::getParcelListId).collect(Collectors.toList());
List<DistributionParcelListEntity> distributionParcelListEntities = distributionParcelListService.listByIds(collect);
// 备货作业节点
NodeFanoutMsg nodeFanoutMsg = buildStockUpNodeData(distributionStockupEntity, distributionParcelListEntities);
if (ObjectUtils.isNotNull(nodeFanoutMsg)) {
distributionNodeWorkService.planStock(nodeFanoutMsg, AuthUtil.getUser());
}
}
int i = list1.isEmpty() ? 0 : list1.size();
return Resp.scanSuccess("整托拣货" + i + "件", "整托拣货" + i + "件");
}
@ -2407,7 +2442,7 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
throw new ServiceException("注意，注意！拣货人员字典未配置！请配置！");
} else {
List<String> stringList = new ArrayList<>();
warehouseType.stream().forEach(i -> {
warehouseType.forEach(i -> {
//查询这个角色ID
R<String> roleId = sysClient.getRoleIds(tenantId, i.getDictValue());
if (ObjectUtils.isNotNull(roleId.getData())) {
@ -3702,4 +3737,745 @@ public class DistributionStockupServiceImpl extends BaseServiceImpl<Distribution
return R.data(detailVOS);
}
@Override
public R stockupScanByCustom(StockupDTO stockupDTO) {
BasicdataWarehouseEntity myCurrentWarehouse = basicdataWarehouseClient.getMyCurrentWarehouse();
//包件扫描
String orderCode = stockupDTO.getOrderCode();//订单自编号
String packetBarCode = stockupDTO.getPacketBarCode();//包件码
Long stockupId = stockupDTO.getStockupId();//备货任务ID
Long reservationId = stockupDTO.getReservationId();//预约单id
// Long stockUpAllocationId = stockupDTO.getStockupAllocationId();//备货库位ID
if (Objects.isNull(myCurrentWarehouse)) {
log.warn("##################stockupScan: 未选择仓库，订单自编号为空");
return R.fail(403, "未授权!!");
}
if (StringUtil.isBlank(orderCode)) {
log.warn("##################stockupScan: 包件扫码，订单自编号为空");
return R.fail("包件扫码:订单自编号不能为空");
}
if (StringUtil.isBlank(packetBarCode)) {
log.warn("##################stockupScan: 包件扫码，包件码为空");
return R.fail("包件扫码:包件码不能为空");
}
if (ObjectUtils.isNull(stockupId)) {
log.warn("##################stockupId: 包件扫码，备货区为空");
return R.fail("包件扫码:备货任务ID不能为空");
}
if (Objects.isNull(reservationId)) {
log.warn("##################stockupScan: 包件扫码，预约单id为空");
return R.fail("包件扫码:预约单id不能为空");
}
// if (Objects.isNull(stockUpAllocationId)) {
// log.warn("##################stockupScan: 备货库位不存在，stockUpAllocationId:{}",stockUpAllocationId);
// return Resp.scanFail("请扫描备货库位","请扫描备货库位");
// }
Integer integer = this.selectPackage(stockupDTO);
switch (integer) {
case 1:
DistributionStockupEntity distributionStockupEntity = this.getById(stockupId);
List<JSONObject> aaa = new ArrayList<>();
//正常
//先保存扫码包件信息,后续由队列来出来余下补充信息
DistributionStockEntity entity = new DistributionStockEntity();
DistributionParcelListEntity one = distributionParcelListService.getOne(Wrappers.<DistributionParcelListEntity>query().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, stockupDTO.getPacketBarCode())
.eq(DistributionParcelListEntity::getWarehouseId, myCurrentWarehouse.getId())
);
entity.setOrderSelfNumbering(one.getOrderCode());
entity.setStockArticle(one.getStockArticleId());
entity.setCoding(packetBarCode);
entity.setScanUser(AuthUtil.getUser().getNickName());
entity.setStockupId(stockupId);
entity.setStockupId(stockupId);
entity.setParcelListId(one.getId());
entity.setStockQuantity(1);
// //修改包件备货状态
if ("3".equals(distributionStockupEntity.getTypeService())) {
entity.setBillLadingId(reservationId);
entity.setStockupArea(distributionStockupEntity.getStockupArea());
} else {
entity.setReservationId(reservationId);
}
if (ObjectUtils.isNotNull(stockupDTO.getAllocationId())) {
// warehouseUpdownGoodsClient.selectMsgBywrap();
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setAssociationValue(stockupDTO.getPacketBarCode());
warehouseUpdownGoodsEntity.setWarehouseId(distributionStockupEntity.getWarehouseId());
WarehouseUpdownGoodsEntity locationInformation = warehouseUpdownGoodsClient.getLocationInformation(warehouseUpdownGoodsEntity);
if (ObjectUtils.isNotNull(locationInformation)) {
entity.setAllocationTitle(locationInformation.getPositionCode());
}
entity.setAllocationId(stockupDTO.getAllocationId());
}
entity.setConditions("0");
entity.setType(2);
entity.setOutboundType(distributionStockupEntity.getTypeService());
//修改订单备货状态
distributionAsyncService.updateStockArticleStock(one.getStockArticleId());
//修改备货时间
distributionAsyncService.updateStockupDate(stockupDTO);
Map<String, Object> map = new HashMap<>();
map.put("messageId", CommonUtil.getUUID());
map.put("scanType", stockupDTO.getScanType());
map.put("stockupId", stockupDTO.getStockupId());
map.put("logId", entity.getId());
map.put("messageData", entity);
map.put("createTime", System.currentTimeMillis());
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_SCAN_EXCHANGE, RabbitConstant.STOCKUP_SCAN_ROUTING, map);
//查询是否货位数据是否该下架
Map<String, Object> mapState = new HashMap<>();
mapState.put("messageId", CommonUtil.getUUID());
mapState.put("scanType", stockupDTO.getScanType());
mapState.put("stockupId", stockupDTO.getStockupId());
mapState.put("typeService", stockupDTO.getTypeService());
mapState.put("reservationId", stockupDTO.getReservationId());
mapState.put("logId", entity.getId());
mapState.put("messageData", entity);
mapState.put("warehouseId", myCurrentWarehouse.getId());
mapState.put("createTime", System.currentTimeMillis());
String audioValue = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.saomiaochenggong.getValue());
log.info(">>>>>>>>>>>>>>>>>>>> 对扫码的包件进行下架");
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_STATE_UPDATE_EXCHANGE, RabbitConstant.STOCKUP_STATE_UPDATE_ROUTING, mapState, message -> {
message.getMessageProperties()
.setHeader("x-delay", 3000);
return message;
});
//查询是否货位数据是否该下架
BladeUser user = AuthUtil.getUser();
if (!Func.isEmpty(stockupDTO.getStockupAllocationId())) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("warehouseId", myCurrentWarehouse.getId());
jsonObject.put("code", packetBarCode);
jsonObject.put("stockUpAllocationId", stockupDTO.getStockupAllocationId());
jsonObject.put("type", 1);
jsonObject.put("num", 1);
//进行了备货库位的选择才进行备货库位的上架
warehouseUpdownStockUpAreaClient.upStockUpShelf(jsonObject);
entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
String content = "包件在" + myCurrentWarehouse.getName() + "由" + AuthUtil.getNickName() + "备货上架,操作方式:备货上架同步操作,备货任务号:" + distributionStockupEntity.getStockupCode();
JSONObject js = handleLogJSONObject(myCurrentWarehouse, user, entity.getCoding(), content, WorkNodeEnums.STOCKING_OPERATION.getCode());
aaa.add(js);
}
distributionStockService.save(entity);
//增加备货扫描节点
String content = "包件在" + myCurrentWarehouse.getName() + "由" + AuthUtil.getNickName() + "备货作业,备货任务号:" + distributionStockupEntity.getStockupCode();
JSONObject js = handleLogJSONObject(myCurrentWarehouse, user, entity.getCoding(), content, WorkNodeEnums.STOCKING_OPERATION.getCode());
aaa.add(js);
//修改包件备货状态
DistributionParcelListEntity parcelListEntity = new DistributionParcelListEntity();
parcelListEntity.setId(entity.getParcelListId());
parcelListEntity.setOrderPackageStockupStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
distributionParcelListService.updateById(parcelListEntity);
trunklinePackageTrackLogClient.addPackageTrackLog(aaa);
parcelListEntity = distributionParcelListService.getById(entity.getParcelListId());
List<DistributionParcelListEntity> ls = new ArrayList<>();
ls.add(parcelListEntity);
// 备货作业节点
NodeFanoutMsg nodeFanoutMsg = buildStockUpNodeData(distributionStockupEntity, ls);
if (ObjectUtils.isNotNull(nodeFanoutMsg)) {
distributionNodeWorkService.planStock(nodeFanoutMsg, user);
}
return Resp.scanSuccess(PdaAudioLingoStatus.saomiaochenggong.getName(), audioValue);
case 2:
//重复扫描
String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
case 3:
//包件不存在
String audioValue3 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue3);
case 4:
//操作失败
String audioValue4 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.caozuoshibai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.caozuoshibai.getName(), audioValue4);
case 5:
//窜货
String audioValue5 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.buzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.buzai.getName(), audioValue5);
default:
log.warn("###备货扫描：未知错误");
return Resp.scanFail(PdaAudioLingoStatus.weizhicuowu.getName(), PdaAudioLingoStatus.weizhicuowu.getName());
}
}
@Override
public R stockupScanByStock(StockupDTO stockupDTO) {
//库存品扫描
Long reservationId = stockupDTO.getReservationId();
Long stockListId = stockupDTO.getStockListId();
String packetBarCode = stockupDTO.getPacketBarCode();
// String stockupArea = stockupDTO.getStockupArea();//备货区
Long stockupId = stockupDTO.getStockupId();//备货区
Long allocationId = stockupDTO.getAllocationId();//备货区
Integer stockPrint = stockupDTO.getStockPrint(); // 库存
BasicdataWarehouseEntity myCurrentWarehouse = basicdataWarehouseClient.getMyCurrentWarehouse();
if (Func.isEmpty(myCurrentWarehouse)) {
return R.data(403, "未授权!!!");
}
if (StringUtil.isBlank(packetBarCode)) {
log.warn("##################stockupScan: 库存品扫码，包件码为空");
return R.fail("库存品扫码:包件码不能为空");
}
if (ObjectUtils.isNull(stockupId)) {
log.warn("##################stockupScan: 库存品扫码，备货区为空");
return R.fail("库存品扫码:备货任务ID不能为空");
}
// if (Objects.isNull(stockListId)) {
// log.warn("##################stockupScan: 库存品扫码，库存品id为空");
// return R.fail("库存品扫码:库存品id不能为空");
// }
if (Objects.isNull(reservationId)) {
log.warn("##################stockupScan: 库存品扫码，预约单id为空");
return R.fail("库存品扫码:预约单id不能为空");
}
if (Objects.isNull(stockPrint)) {
log.warn("##################stockupScan: 库存品扫码，类型为空");
return R.fail("库存品扫码:类型不能为空");
}
if (Objects.isNull(allocationId)) {
log.warn("##################allocationId: 货位ID为空！");
return R.fail("货位ID不能为空");
}
//判断是否可以继续备货
DistributionStockListEntity byId = null;
// if (ObjectUtils.isNull(stockListId)) {
// 通过扫码的二维码 查询其对应的库存存信息
if (stockupDTO.getStockPrint() == 1) {
//1 原有包条
byId = distributionStockListService.selectStockInforByOrderPackageCode(stockupDTO.getPacketBarCode());
} else {
// 判断stockupDTO.getMallName() 是否存在
if (ObjectUtils.isNull(stockupDTO.getMallName()) || "null".equals(stockupDTO.getMallName())) {
// 查询出来 重新复制
DistributionStockListEntity byId1 = distributionStockListService.getById(stockupDTO.getStockListId());
log.info("##################stockupScan: 库存品扫码，库存品id{}", byId1);
if (!ObjectUtils.isNull(byId1)) {
stockupDTO.setMallName(byId1.getMarketName());
}
}
// 2打印处理的扫码
// 查询当前库位上最早入库的指定物料库存品
byId = disStockOrdercodeRecoService.selectStockOrdercodeRecoListByCode(stockupDTO.getCargoNumber(), stockupDTO.getAllocationId(), stockupDTO.getMallName());
// 需要判断当前这个找到的备货批次和计划的批次是否一直，如果不一致 就需要新增一个预约备货记录 扣减当前的数量
// updateStockOrdercodeRecoS(reservationId,byId);
if (Func.isEmpty(byId)) {
return Resp.scanFail("当前库位无此物料库存品", "当前库位无此物料库存品");
}
//判断当前库位上满足条件的库存品是否存在于预约计划中，如果不存在则需要对预约计划进行修改
List<DistributionReservationStocklistEntity> reservationStocklistEntityList = distributionReservationMapper.selectInventoryListByIdAndMateriel(stockupDTO.getReservationId(), stockupDTO.getCargoNumber());
if (Func.isNotEmpty(reservationStocklistEntityList)) {
DistributionStockListEntity finalById = byId;
boolean flag = reservationStocklistEntityList.stream()
.map(DistributionReservationStocklistEntity::getStocklistId)
.anyMatch(s -> s.equals(finalById.getId()));
if (!flag) {
DistributionReservationStocklistEntity rs = getDistributionReservationStocklistEntity(stockupDTO, byId);
distributionReservationStocklistService.save(rs);
DistributionStockListEntity stockListEntity = distributionStockListService.getById(byId.getId());
stockListEntity.setQuantityOccupied(stockListEntity.getQuantityOccupied() + 1);
distributionStockListService.updateById(stockListEntity);
//原来对应的需要进行计划减少
//收集满足修改条件的计划库存品
List<DistributionReservationStocklistEntity> reservationStocklistEntities = new ArrayList<>();
for (DistributionReservationStocklistEntity reservationStocklistEntity : reservationStocklistEntityList) {
if (reservationStocklistEntity.getReservationNum() >= reservationStocklistEntity.getRealityNum() && reservationStocklistEntity.getReservationNum() > 0) {
reservationStocklistEntities.add(reservationStocklistEntity);
}
}
if (Func.isEmpty(reservationStocklistEntities)) {
return R.fail("该物料库存品备货已完成");
}
DistributionReservationStocklistEntity reservationStocklistEntity = reservationStocklistEntities.get(0);
int oldRsNum = reservationStocklistEntity.getReservationNum() - 1;
if (oldRsNum < 0) {
return R.fail("操作数据错误");
}
reservationStocklistEntity.setReservationNum(oldRsNum);
if (reservationStocklistEntity.getReservationNum() == 0) {
reservationStocklistEntity.setStockListStatus(ReservationOrderStatusConstant.quxiao.getValue());
}
distributionReservationStocklistService.updateById(reservationStocklistEntity);
//维护老的的冻结数量
DistributionStockListEntity oldStockList = distributionStockListService.getById(reservationStocklistEntity.getStocklistId());
oldStockList.setQuantityOccupied(oldStockList.getQuantityOccupied() - 1);
distributionStockListService.updateById(oldStockList);
//查询对应的包件进行修改
List<DisStockListDetailEntity> stockListDetailEntities = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda()
.eq(DisStockListDetailEntity::getReservationId, stockupDTO.getReservationId())
.eq(DisStockListDetailEntity::getStockListId, oldStockList.getId())
.ne(DisStockListDetailEntity::getStockPackageStatus, ReservationPackageStatusConstant.quxiao.getValue())
);
DisStockListDetailEntity disStockListDetailEntity = stockListDetailEntities.stream().filter(s -> Func.isBlank(s.getStockPackageCode())).collect(Collectors.toList()).get(0);
disStockListDetailEntity.setStockListId(rs.getStocklistId());
// disStockListDetailEntity.setStockStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
disStockListDetailService.updateById(disStockListDetailEntity);
} else {
//判断是否是为增加库存品进行数据维护
DistributionStockListEntity finalById1 = byId;
DistributionReservationStocklistEntity reservationStocklistEntity = reservationStocklistEntityList.stream().filter(f -> f.getStocklistId().equals(finalById1.getId())).collect(Collectors.toList()).get(0);
//因为新增库存品的时候会完成扫描 此时的增加数和备货数量时一样的
if (reservationStocklistEntity.getStockListStatus().equals(ReservationOrderStatusConstant.zengjia.getValue()) && Objects.equals(reservationStocklistEntity.getReservationNum(), reservationStocklistEntity.getRealityNum())) {
List<DistributionReservationStocklistEntity> oldRS = distributionReservationMapper.selectStockListByReservationIdAndCargoNumber(reservationStocklistEntity.getReservationId(), stockupDTO.getCargoNumber(), reservationStocklistEntity.getStocklistId());
//收集满足条件的库存品
List<DistributionReservationStocklistEntity> rs = new ArrayList<>();
for (DistributionReservationStocklistEntity oldR : oldRS) {
if (oldR.getReservationNum() >= oldR.getRealityNum() && oldR.getReservationNum() > 0) {
rs.add(oldR);
}
}
if (Func.isEmpty(rs)) {
//不存在还需要进行备货的库存品
return R.fail("该物料库存品备货已完成");
}
DistributionReservationStocklistEntity oldReservationStockList = rs.get(0);
int oldReservationNum = oldReservationStockList.getReservationNum() - 1;
oldReservationStockList.setReservationNum(oldReservationNum);
if (oldReservationNum == 0) {
oldReservationStockList.setStockListStatus(ReservationOrderStatusConstant.quxiao.getValue());
}
distributionReservationStocklistService.updateById(oldReservationStockList);
//修改对应库存品数量
DistributionStockListEntity stockListEntity = distributionStockListService.getById(oldReservationStockList.getStocklistId());
stockListEntity.setQuantityOccupied(stockListEntity.getQuantityOccupied() - 1);
distributionStockListService.updateById(stockListEntity);
//找出对库存品包件信息进行包件的修改
List<DisStockListDetailEntity> oldRsPack = disStockListDetailService.list(Wrappers.<DisStockListDetailEntity>query().lambda()
.eq(DisStockListDetailEntity::getReservationId, oldReservationStockList.getReservationId())
.eq(DisStockListDetailEntity::getStockListId, oldReservationStockList.getStocklistId())
.ne(DisStockListDetailEntity::getStockPackageStatus, ReservationPackageStatusConstant.quxiao.getValue())
);
if (Func.isEmpty(oldRsPack)) {
return R.fail("该物料库存品备货已完成");
}
List<DisStockListDetailEntity> collect = oldRsPack.stream().filter(f -> Func.isBlank(f.getStockPackageCode())).collect(Collectors.toList());
DisStockListDetailEntity disStockListDetailEntity = collect.get(0);
disStockListDetailEntity.setStockListId(reservationStocklistEntity.getStocklistId());
// disStockListDetailEntity.setStockStatus(OrderPackageStockupStatusConstant.yibeihu.getValue());
disStockListDetailService.updateById(disStockListDetailEntity);
reservationStocklistEntity.setReservationNum(reservationStocklistEntity.getReservationNum() + 1);
distributionReservationStocklistService.updateById(reservationStocklistEntity);
//维护库存品在库数量
DistributionStockListEntity newStockList = distributionStockListService.getById(reservationStocklistEntity.getStocklistId());
newStockList.setQuantityOccupied(newStockList.getQuantityOccupied() + 1);
distributionStockListService.updateById(newStockList);
}
}
//当前库位最先入库的批次和计划批次一致
}
}
if (Func.isNotEmpty(byId)) {
stockupDTO.setStockListId(byId.getId());
}
// } else {
// byId = distributionStockListService.getById(stockListId);
// }
List<WarehouseUpdownGoodsEntity> locationInformation;
if ("2".equals(byId.getSourceType())) {
//导入
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setIncomingBatch(byId.getIncomingBatch());
warehouseUpdownGoodsEntity.setMarketId(byId.getMarketId());
warehouseUpdownGoodsEntity.setAssociationId(byId.getMaterialId());
warehouseUpdownGoodsEntity.setAssociationValue(byId.getCargoNumber());
warehouseUpdownGoodsEntity.setAssociationType("4");
warehouseUpdownGoodsEntity.setWarehouseId(byId.getWarehouseId());
locationInformation = warehouseUpdownGoodsClient.getLocationStockListInformation(warehouseUpdownGoodsEntity);
if (locationInformation.isEmpty()) {
return Resp.scanFail("当前货位的库存品已为零，请更换货位继续！！", "当前货位的库存品已为零，请更换货位继续！！");
}
} else {
// 读取码表上的配置项 是否开启验证批次号
String isCheckIncomingBatch = DictBizCache.getValue("isCheckIncomingBatch", "isCheckIncomingBatch");
List<DistributionParcelListEntity> list = distributionParcelListService.list(Wrappers.<DistributionParcelListEntity>query().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, packetBarCode)
.eq(DistributionParcelListEntity::getOrderCode, byId.getIncomingBatch())
.eq(DistributionParcelListEntity::getWarehouseId, byId.getWarehouseId())
);
//查询包件信息
if (ObjectUtils.isNotNull(list) && list.size() > 1) {
return Resp.scanFail("查询到重复包条信息!!", "查询到重复包条信息！！");
}
if (ObjectUtils.isNull(list)) {
return Resp.scanFail("没有查询到包件信息!", "没有查询到包件信息 ! ");
}
log.info(">>>>> obj {}", list.get(0).getConditions());
DistributionParcelListEntity distributionParcelListEntity = list.get(0);
if (2 != distributionParcelListEntity.getConditions()) {
return Resp.scanFail("当前包件不是库存品，无法备货！！", "当前包件不是库存品，无法备货！！");
}
WarehouseUpdownGoodsEntity warehouseUpdownGoodsEntity = new WarehouseUpdownGoodsEntity();
warehouseUpdownGoodsEntity.setAllocationId(stockupDTO.getAllocationId());
warehouseUpdownGoodsEntity.setAssociationId(list.get(0).getId());
warehouseUpdownGoodsEntity.setAssociationType("3");
warehouseUpdownGoodsEntity.setWarehouseId(byId.getWarehouseId());
locationInformation = warehouseUpdownGoodsClient.getLocationStockListInformation(warehouseUpdownGoodsEntity);
if (locationInformation.isEmpty()) {
return Resp.scanFail("当前货位没有该包件信息！！", "当前货位没有该包件信息！！");
}
}
//有数数据校验 修改库存品数据
if ("1".equals(byId.getSourceType())) {
R r1 = this.handlingPackages(stockupDTO);
if (r1.getCode() != 200) {
Resp.scanFail(r1.getMsg(), r1.getMsg());
}
}
Integer i = this.selectPackagePrint(stockupDTO);
switch (i) {
case 1:
//绑定
Integer integer = this.selectPackage(stockupDTO);
switch (integer) {
case 1:
DistributionStockupEntity stockupEntity = this.getById(stockupDTO.getStockupId());
//先保存扫码包件信息,后续由队列来出来余下补充信息
DistributionStockEntity entity = new DistributionStockEntity();
entity.setCoding(packetBarCode);
DistributionStockupEntity byId1 = this.getById(stockupId);
entity.setStockupArea(byId1.getStockupArea());
entity.setStockupId(stockupId);
entity.setStockQuantity(1);
entity.setScanUser(AuthUtil.getUser().getNickName());
if ("3".equals(stockupEntity.getTypeService())) {
entity.setBillLadingId(reservationId);
} else {
entity.setReservationId(reservationId);
}
entity.setReservationId(reservationId);
entity.setStockListId(stockupDTO.getStockListId());
//添加物料信息
// DistributionStockListEntity byId = iDistributionStockListService.getById(stockListId);
if (ObjectUtils.isNotNull(byId.getMarketId())) {
entity.setMarketId(byId.getMarketId());
entity.setMaterialId(byId.getMaterialId());
if (!locationInformation.isEmpty()) {
if ("2".equals(byId.getSourceType())) {
//导入下架
entity.setAllocationTitle(locationInformation.get(0).getPositionCode());
entity.setAllocationId(stockupDTO.getAllocationId());
//todo 待下架操作
JSONObject jsonObject = new JSONObject();
jsonObject.put("marketId", byId.getMarketId());
jsonObject.put("materialCode", byId.getCargoNumber());
jsonObject.put("warehouseId", byId.getWarehouseId());
jsonObject.put("incomingBatch", byId.getIncomingBatch());
jsonObject.put("enterNum", 1);
jsonObject.put("allocationId", stockupDTO.getAllocationId());
jsonObject.put("remark", "备货无数据库存品下架");
List<JSONObject> list = new ArrayList<>();
list.add(jsonObject);
R r = warehouseUpdownTypeClient.downStock(list);
if (r.getCode() != 200) {
log.debug("##########" + r.getMsg());
// return Resp.scanFail("下架失败，请联系管理员！！", "下架失败，请联系管理员！！");
}
} else {
R r = warehouseUpdownTypeClient.downPackage(packetBarCode, byId.getWarehouseId(), "备货下架包件");
if (r.getCode() != 200) {
log.debug("##########" + r.getMsg());
// return Resp.scanFail("下架失败，请联系管理员！！", "下架失败，请联系管理员！！");
}
}
} else {
return Resp.scanFail("本货位的物料已为0，请更换货位继续！！", "本货位的物料已为0，请更换货位继续！！");
}
} else {
return Resp.scanFail("物料信息查询失败，请联系管理员！！", "物料信息查询失败，请联系管理员！！");
}
entity.setConditions("0");
entity.setType(2);
entity.setAllocationId(stockupDTO.getAllocationId());
entity.setOutboundType(stockupEntity.getTypeService());
// entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
// entity.setStockupArea(stockupDTO.getStockupAllocationName());
// //修改备货时间
distributionAsyncService.updateStockupStockListDate(stockupDTO);
// dataSourceTransactionManager.commit(transactionStatus);//提交
Map<String, Object> map = new HashMap<>();
map.put("messageId", CommonUtil.getUUID());
map.put("scanType", stockupDTO.getScanType());
map.put("logId", entity.getId());
map.put("messageData", entity);
map.put("createTime", System.currentTimeMillis());
// 完成对扫描库存品信息的数量维护
// 根据当前扫码对象查询得到当前的扫码对象的库存品信息
//将消息携带绑定键值
rabbitTemplate.convertAndSend(RabbitConstant.STOCKUP_SCAN_EXCHANGE, RabbitConstant.STOCKUP_SCAN_ROUTING, map);
String audioValue = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.saomiaochenggong.getValue());
//进行备货库位上架
if (!Func.isEmpty(stockupDTO.getStockupAllocationId())) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("warehouseId", myCurrentWarehouse.getId());
jsonObject.put("code", packetBarCode);
jsonObject.put("stockUpAllocationId", stockupDTO.getStockupAllocationId());
jsonObject.put("type", 2);
jsonObject.put("num", 1);
warehouseUpdownStockUpAreaClient.upStockUpShelf(jsonObject);
entity.setStockupAreaId(stockupDTO.getStockupAllocationId());
}
entity.setTenantId(AuthUtil.getTenantId());
distributionStockService.save(entity);
//这里尝试修改备货库存品包件的备货状态
boolean update = distributionParcelListService.update(Wrappers.<DistributionParcelListEntity>update().lambda()
.eq(DistributionParcelListEntity::getOrderPackageCode, entity.getCoding())
.eq(DistributionParcelListEntity::getWarehouseId, myCurrentWarehouse.getId())
.eq(DistributionParcelListEntity::getConditions, "2")
.eq(DistributionParcelListEntity::getMaterialId, entity.getMaterialId())
.eq(entity.getStockArticle() != null, DistributionParcelListEntity::getStockArticleId, entity.getStockArticle())
.set(DistributionParcelListEntity::getOrderPackageStockupStatus, OrderPackageStockupStatusConstant.yibeihu.getValue())
);
// todo 这里需要完善
// 备货作业节点
NodeFanoutMsg nodeFanoutMsg = buildStockUpNodeDataByStock(stockupEntity, entity);
if (ObjectUtils.isNotNull(nodeFanoutMsg)) {
distributionNodeWorkService.planStock(nodeFanoutMsg, AuthUtil.getUser());
}
//扫码成功
return Resp.scanSuccess(PdaAudioLingoStatus.saomiaochenggong.getName(), audioValue);
case 2:
//重复扫描
String audioValue2 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.chongfusaomiao.getValue());
return Resp.scanFail(PdaAudioLingoStatus.chongfusaomiao.getName(), audioValue2);
case 3:
//包件不存在
String audioValue3 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baojianbucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baojianbucunzai.getName(), audioValue3);
case 4:
//操作失败
String audioValue4 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.caozuoshibai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.caozuoshibai.getName(), audioValue4);
case 5:
//窜货
String audioValue5 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.cuanhuo.getValue());
return Resp.scanFail(PdaAudioLingoStatus.cuanhuo.getName(), audioValue5);
case 6:
//已完成
String audioValue6 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.yiwancheng.getValue());
return Resp.scanFail(PdaAudioLingoStatus.yiwancheng.getName(), audioValue6);
case 7:
//包条码不存在
String audioValue7 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue7);
default:
log.warn("###备货扫描：未知错误");
return Resp.scanFail(PdaAudioLingoStatus.weizhicuowu.getName(), PdaAudioLingoStatus.weizhicuowu.getName());
}
case 7:
//包条码不存在
String audioValue7 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomabucunzai.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomabucunzai.getName(), audioValue7);
case 8:
//条码已使用
String audioValue8 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.baotiaomayishiyong.getValue());
return Resp.scanFail(PdaAudioLingoStatus.baotiaomayishiyong.getName(), audioValue8);
case 9:
//"没有待绑定的库存品信息！"
String audioValue9 = DictBizCache.getValue(DictBizConstant.PDA_AUDIO, PdaAudioLingoStatus.meiyou.getValue());
return Resp.scanFail(PdaAudioLingoStatus.meiyou.getName(), audioValue9);
case 10:
//"没有待绑定的库存品信息！"
return Resp.scanFail("该包件与备货物料不匹配！", "该包件与备货物料不匹配！");
}
return null;
}
private NodeFanoutMsg buildStockUpNodeData(DistributionStockupEntity distributionStockupEntity, List<DistributionParcelListEntity> parcelListEntitys) {
try {
BladeUser user = AuthUtil.getUser();
NodeFanoutMsg nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.STOCKING_OPERATION);
BasicdataWarehouseEntity entityWarehouse = basicdataWarehouseClient.getEntityWarehouseId(distributionStockupEntity.getWarehouseId());
if (entityWarehouse != null) {
nodeFanoutMsg.setWarehouse(entityWarehouse.getName());
}
nodeFanoutMsg.setWarehouseId(distributionStockupEntity.getWarehouseId());
nodeFanoutMsg.setOperator(user.getTenantId());
nodeFanoutMsg.setOperatorTime(distributionStockupEntity.getCreateTime());
JSONObject jsonObject = new JSONObject();
jsonObject.put("id", distributionStockupEntity.getId());
jsonObject.put("stockupCode", distributionStockupEntity.getStockupCode());
jsonObject.put("typeService", distributionStockupEntity.getTypeService());
jsonObject.put("stockupDate", distributionStockupEntity.getStockupDate());
String jsonString = jsonObject.toJSONString();
nodeFanoutMsg.setMain(jsonString);
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
List<PackageData> packageDataList = new ArrayList<>();
parcelListEntitys.forEach(parcelListEntity -> packageDataList.add(getPackageData(parcelListEntity)));
nodeFanoutMsg.setDetails(packageDataList);
return nodeFanoutMsg;
} catch (Exception e) {
log.error("备货扫描：发送备货节点消息失败", e);
}
return null;
}
@NotNull
private PackageData getPackageData(DistributionParcelListEntity parcelListEntity) {
PackageData packageData = new PackageData();
packageData.setWaybillNumber(parcelListEntity.getWaybillNumber());
packageData.setBrand(parcelListEntity.getBrandName());
packageData.setPackageCode(parcelListEntity.getOrderPackageCode());
packageData.setMaterialCode(parcelListEntity.getMaterialCode());
packageData.setMaterialName(parcelListEntity.getMaterialName());
packageData.setNumber(1);
packageData.setOrderCode(parcelListEntity.getOrderCode());
packageData.setPackageType(PackageTypeEnums.CMP);
return packageData;
}
private JSONObject handleLogJSONObject(BasicdataWarehouseEntity warehouse, BladeUser user, String orderPackageCode, String content, Integer node) {
JSONObject trunklinePackageTrackLog = new JSONObject();
trunklinePackageTrackLog.put("tenantId", user.getTenantId());
trunklinePackageTrackLog.put("createTime", new Date());
trunklinePackageTrackLog.put("createUser", user.getUserId());
trunklinePackageTrackLog.put("updateUser", user.getUserId());
trunklinePackageTrackLog.put("updateTime", new Date());
trunklinePackageTrackLog.put("isDeleted", 0);
trunklinePackageTrackLog.put("status", 1);
trunklinePackageTrackLog.put("createDept", warehouse.getDepartment());
trunklinePackageTrackLog.put("orderPackageCode", orderPackageCode);
trunklinePackageTrackLog.put("warehouseId", warehouse.getId());
trunklinePackageTrackLog.put("warehouseName", warehouse.getName());
trunklinePackageTrackLog.put("workNode", node);
trunklinePackageTrackLog.put("content", content);
trunklinePackageTrackLog.put("operator", user.getNickName());
return trunklinePackageTrackLog;
}
private NodeFanoutMsg buildStockUpNodeDataByStock(DistributionStockupEntity stockupEntity, DistributionStockEntity stockEntity) {
try {
BladeUser user = AuthUtil.getUser();
NodeFanoutMsg nodeFanoutMsg = new NodeFanoutMsg();
nodeFanoutMsg.setBizOperation(BizOperationEnums.ADD);
nodeFanoutMsg.setNode(WorkNodeEnums.STOCKING_OPERATION);
BasicdataWarehouseEntity entityWarehouse = basicdataWarehouseClient.getEntityWarehouseId(stockupEntity.getWarehouseId());
if (entityWarehouse != null) {
nodeFanoutMsg.setWarehouse(entityWarehouse.getName());
}
nodeFanoutMsg.setWarehouseId(stockupEntity.getWarehouseId());
nodeFanoutMsg.setOperator(user.getTenantId());
nodeFanoutMsg.setOperatorTime(stockupEntity.getCreateTime());
JSONObject jsonObject = new JSONObject();
jsonObject.put("id", stockupEntity.getId());
jsonObject.put("stockupCode", stockupEntity.getStockupCode());
jsonObject.put("typeService", stockupEntity.getTypeService());
jsonObject.put("stockupDate", stockupEntity.getStockupDate());
String jsonString = jsonObject.toJSONString();
nodeFanoutMsg.setMain(jsonString);
nodeFanoutMsg.setTenantId(AuthUtil.getTenantId());
List<PackageData> packageDataList = new ArrayList<>();
PackageData packageData = getPackageDataByStock(stockEntity);
packageDataList.add(packageData);
nodeFanoutMsg.setDetails(packageDataList);
return nodeFanoutMsg;
} catch (Exception e) {
log.error("备货扫描：发送备货节点消息失败", e);
throw new CustomerException(e.getMessage());
}
}
@NotNull
private PackageData getPackageDataByStock(DistributionStockEntity stockEntity) {
PackageData packageData = new PackageData();
// 查询出库存品信息
DistributionStockListEntity stockListEntity = distributionStockListService.getById(stockEntity.getStockListId());
if (stockListEntity == null) {
throw new CustomerException("库存品信息不存在");
}
packageData.setBrand(stockListEntity.getBrandName());
packageData.setPackageCode(stockEntity.getCoding());
packageData.setMallName(stockListEntity.getMallName());
packageData.setMaterialCode(stockListEntity.getMarketCode());
packageData.setMaterialName(stockListEntity.getDescriptionGoods());
packageData.setOrderCode(stockListEntity.getOrderCode());
packageData.setPackageType(PackageTypeEnums.INV);
packageData.setNumber(1);
return packageData;
}
/**
* 库存品扫码
*
* @param stockupDTO
* @return
*/
@NotNull
private static DistributionReservationStocklistEntity getDistributionReservationStocklistEntity(StockupDTO stockupDTO, DistributionStockListEntity byId) {
DistributionReservationStocklistEntity rs = new DistributionReservationStocklistEntity();
rs.setReservationNum(1);
rs.setStockListStatus(ReservationOrderStatusConstant.zengjia.getValue());
rs.setReservationId(stockupDTO.getReservationId());
rs.setRealityNum(0);
rs.setUnit(byId.getCargoUnit());
rs.setLoadingStatus(ReservationLoadingStatusConstant.daizhuangche.getValue());
rs.setSigningStatus(ReservationSigningStatusConstant.daiqianshou.getValue());
rs.setStocklistId(byId.getId());
return rs;
}
}

Write Preview
Loading…
Cancel
Save