/*
|
* Copyright (c) 2018-2025, ztt All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the pig4cloud.com developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: ztt
|
*/
|
package com.chinaztt.mes.warehouse.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.http.HttpRequest;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.chinaztt.ifs.api.feign.IfsFeignClient;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.basic.util.DictUtils;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.warehouse.dto.*;
|
import com.chinaztt.mes.warehouse.entity.*;
|
import com.chinaztt.mes.warehouse.mapper.*;
|
import com.chinaztt.mes.warehouse.service.PackagingService;
|
import com.chinaztt.mes.warehouse.state.constant.LocationTypeStringValues;
|
import com.chinaztt.mes.warehouse.state.constant.ReportCodeStringValues;
|
import com.chinaztt.mes.warehouse.state.escort.constant.EscortEvents;
|
import com.chinaztt.mes.warehouse.state.splittask.constant.SplitTaskStateStringValues;
|
import com.chinaztt.mes.warehouse.util.StockUtils;
|
import com.chinaztt.mes.warehouse.util.TransactionType;
|
import com.chinaztt.mes.warehouse.util.WareHouseUtils;
|
import com.chinaztt.ztt.admin.api.entity.SysDictItem;
|
import com.chinaztt.ztt.admin.api.feign.RemoteParamService;
|
import com.chinaztt.ztt.common.core.constant.SecurityConstants;
|
import com.chinaztt.ztt.common.core.util.R;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.lang3.RandomStringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 包装主表
|
*
|
* @author sunxl
|
* @date 2021-06-03 13:56:52
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class PackagingServiceImpl extends ServiceImpl<PackagingMapper, Packaging> implements PackagingService {
|
private NumberGenerator<Packaging> numberGenerator;
|
private PackagingItemMapper packagingItemMapper;
|
private PartMapper partMapper;
|
private PackingBean packingBean;
|
private PackagingStaffMapper packagingStaffMapper;
|
private DictUtils dictUtils;
|
private SplitTaskMapper splitTaskMapper;
|
private StockMapper stockMapper;
|
private StockUtils stockUtils;
|
private WareHouseUtils wareHouseUtils;
|
private StockConfigBean stockConfigBean;
|
private IfsFeignClient ifsFeignClient;
|
private RemoteParamService remoteParamService;
|
|
private final static String TX_PACK_WEIGHT_DIFF_LIMIT_VALUE = "TX_PACK_WEIGHT_DIFF_LIMIT_VALUE";
|
|
@Override
|
public Packaging fullSave(PackagingDTO packagingDTO) {
|
Packaging newPackaging = baseMapper.selectOne(Wrappers.<Packaging>lambdaQuery().eq(Packaging::getNo, packagingDTO.getNo()));
|
if (newPackaging != null) {
|
throw new RuntimeException("包装箱号重复：" + newPackaging.getNo());
|
}
|
|
if (StringUtils.isBlank(packagingDTO.getNo())) {
|
throw new RuntimeException("箱号不可为空！");
|
}
|
|
//射频包装编号取消自动生成
|
//packagingDTO.setNo(numberGenerator.generateNumberWithPrefix(Packaging.DIGIT, Packaging.PREFIX, Packaging::getNo));
|
//射频不需要计算这个
|
//packagingDTO.setMetre(packagingDTO.getEndMetre().subtract(packagingDTO.getStartMetre()));//根据开始、结束米标自动计算米标
|
|
// if (StringUtils.isNotBlank(packagingDTO.getReelType())){
|
// //获取字典的数组值
|
// List<SysDictItem> dict = dictUtils.getDict("reel_weight");
|
// if (CollectionUtil.isNotEmpty(dict)){
|
// dict.forEach(a -> {
|
// if (a.getLabel().equals(packagingDTO.getReelType())){
|
// packagingDTO.setRealWeight(new BigDecimal(a.getValue()));
|
// }
|
// });
|
// }
|
// }
|
baseMapper.insert(packagingDTO);
|
|
|
if (CollectionUtil.isNotEmpty(packagingDTO.getStaffIds())) {
|
for (Long id : packagingDTO.getStaffIds()) {
|
PackagingStaff packagingStaff = new PackagingStaff();
|
packagingStaff.setStaffId(id);
|
packagingStaff.setPackagingId(packagingDTO.getId());
|
packagingStaffMapper.insert(packagingStaff);
|
}
|
}
|
return packagingDTO;
|
}
|
|
@Override
|
public Packaging addPackagingStock(PackagingDTO packagingDTO) {
|
if (wareHouseUtils.isPackConfirm(packagingDTO.getId())) {
|
throw new RuntimeException("包装已提交->冻结该操作");
|
}
|
|
Packaging packaging = baseMapper.selectById(packagingDTO.getId());
|
BigDecimal weight = BigDecimal.ZERO;
|
//说明请求该接口时，前端已经通过SN号调库存接口获取了零件库存信息
|
if (CollectionUtil.isNotEmpty(packagingDTO.getStockList())) {
|
BigDecimal number = BigDecimal.ZERO;
|
//这边传过来的库存信息为什么是一个list？
|
for (Stock stock : packagingDTO.getStockList()) {
|
//判断是否已经添加过当前系统号
|
int count = packagingItemMapper.selectCount(Wrappers.<PackagingItem>lambdaQuery().eq(PackagingItem::getStockId, stock.getId()));
|
if (count > 0) {
|
throw new RuntimeException("该系统号已经经过包装，请选择其它系统号");
|
}
|
PackagingItem packagingItem = new PackagingItem();
|
|
//计算当前实时库存的零件的理论重量
|
Part part = partMapper.selectById(stock.getPartId());//根据零件id获取零件对象
|
if (part != null) {
|
weight = weight.add(part.getWeight().multiply(stock.getAvailableStockQuantity()));//理论重量=单位重量*可用库存数量 累加
|
packagingItem.setTheoryWeight(part.getWeight().multiply(stock.getAvailableStockQuantity()));//明细行的理论计算重量
|
}
|
|
packagingItem.setOutBatchNo(stock.getPartBatchNo());//批次号
|
packagingItem.setPackageQty(stock.getAvailableStockQuantity());//包装数量=可用库存数量
|
packagingItem.setPartId(stock.getPartId());//零件id
|
packagingItem.setSystemNo(stock.getSystemNo());//报工产出系统编号
|
packagingItem.setPackagingId(packagingDTO.getId());//包装主表id
|
packagingItem.setStockId(stock.getId());//实时库存id
|
packagingItem.setInLocationId(packagingDTO.getInLocationId());//至库位id
|
packagingItem.setLocationId(stock.getLocationId());//库位id
|
packagingItem.setIfsBatchNo(stock.getIfsBatchNo());//ifs批次号
|
packagingItemMapper.insert(packagingItem);
|
number = number.add(stock.getAvailableStockQuantity());//可用数量累加
|
}
|
//更新包装主表
|
//包装净重 = 包装净重 + 明细理论重量
|
packaging.setNetWeight(packaging.getNetWeight().add(weight));
|
//毛重 = 净重 + 包装重量
|
if(null != packaging.getNetWeight() && null != packaging.getPackWeight()){
|
packaging.setGrossWeight(packaging.getNetWeight().add(packaging.getPackWeight()));
|
}
|
//差异重量 = 净重 - 实际重量
|
if(null != packaging.getNetWeight() && null != packaging.getRealWeight()){
|
packaging.setDifferenceWeight(packaging.getNetWeight().subtract(packaging.getRealWeight()));
|
}
|
//装箱数量
|
packaging.setNumber(packaging.getNumber().add(number));
|
//校验理论装箱数量
|
if(packaging.getNumber().compareTo(packaging.getTheoreticalNumber()) == 1){
|
throw new RuntimeException("实际数量不可以超过理论装箱数量");
|
}
|
//不在明细新增中更新净重，在保存主表时自动计算净重
|
//packaging.setNetWeight(packaging.getGrossWeight().subtract(packaging.getPackWeight()));//净重等于毛重-包装重量
|
//差异重量也不在明细新增中更新，在保存主表时自动结算差异重量，明细表新增一个理论计算重量，用于保存理论计算重量
|
//packaging.setDifferenceWeight(packaging.getNetWeight().subtract(packaging.getRealWeight()));//差异重量=理论重量-实际重量
|
//packaging.setNumber(packaging.getNumber().add(number));//可用数量/包装数量
|
|
//判断数量和理论装箱数量，数量不可以超过理论装箱数量（移植跳线的校验）理论装箱数量是怎么来的？？？，估计这边会跟据包装尺寸获取包装的理论数量，先注释掉
|
// if (packaging.getNumber().compareTo(packaging.getTheoreticalNumber())==1){
|
// throw new RuntimeException("实际数量不可以超过理论装箱数量");
|
// }
|
|
|
baseMapper.updateById(packaging);
|
} else {
|
throw new RuntimeException("查询的实时库存为空");
|
}
|
return packaging;
|
}
|
|
@Override
|
public Boolean removePackagingById(Long id) {
|
if (wareHouseUtils.isPackConfirm(id)) {
|
throw new RuntimeException("包装已提交->冻结该操作");
|
}
|
|
baseMapper.deleteById(id);
|
packagingItemMapper.delete(Wrappers.<PackagingItem>lambdaQuery().eq(PackagingItem::getPackagingId, id));
|
return true;
|
}
|
|
@Override
|
public IPage<PackagingDTO> getPackagingPage(Page page, QueryWrapper<PackagingDTO> gen) {
|
return baseMapper.getPackagingPage(page, gen);
|
}
|
|
@Override
|
public PackagingDTO getPackingById(Long id) {
|
return baseMapper.getPackingById(id);
|
}
|
|
@Override
|
public boolean fullUpdate(PackagingDTO packagingDTO) {
|
//校验包装编号（箱号）是否重复，射频的包装编号是可以修改的
|
//判断逻辑：编号相等且行号不等，存在则重复
|
Packaging newPackaging = baseMapper.selectOne(Wrappers.<Packaging>lambdaQuery().eq(Packaging::getNo, packagingDTO.getNo()).ne(Packaging::getId, packagingDTO.getId()));
|
if (newPackaging != null) {
|
throw new RuntimeException("包装箱号重复：" + newPackaging.getNo());
|
}
|
|
if (wareHouseUtils.isPackConfirm(packagingDTO.getId())) {
|
throw new RuntimeException("包装已提交->冻结该操作");
|
}
|
|
//射频主表无需计算米标（留着也不报错）
|
if(null != packagingDTO.getEndMetre() && null != packagingDTO.getStartMetre()){
|
packagingDTO.setMetre(packagingDTO.getEndMetre().subtract(packagingDTO.getStartMetre()));//计算米标
|
}
|
//射频主表无需盘具重量（留着也不报错）
|
//根据盘具类型，获取盘具重量
|
if (StringUtils.isNotBlank(packagingDTO.getReelType())) {
|
//获取字典的数组值
|
List<SysDictItem> dict = dictUtils.getDict("reel_weight");
|
if (CollectionUtil.isNotEmpty(dict)) {
|
dict.forEach(a -> {
|
if (a.getLabel().equals(packagingDTO.getReelType())) {
|
packagingDTO.setRealWeight(new BigDecimal(a.getValue()));
|
}
|
});
|
}
|
}
|
//根据包装尺寸获取包装重量
|
//如果存在包装尺寸，则获取包装重量
|
if (StringUtils.isNotBlank(packagingDTO.getPackSize())) {
|
//获取数据字典
|
List<SysDictItem> dictItemList = dictUtils.getDict("pack_size_weight");
|
if (CollectionUtil.isNotEmpty(dictItemList)) {
|
dictItemList.forEach(a -> {
|
if (a.getLabel().equals(packagingDTO.getPackSize())) {
|
if(StringUtils.isNotBlank(a.getDescription())){
|
packagingDTO.setPackWeight(new BigDecimal(a.getDescription()));//包装重量
|
}
|
}
|
});
|
}
|
}
|
|
//如果包装重量&毛重存在，则更新净重
|
// if (packagingDTO.getPackWeight() != null && packagingDTO.getGrossWeight() != null) {
|
// packagingDTO.setNetWeight(packagingDTO.getGrossWeight().subtract(packagingDTO.getPackWeight()));
|
// }
|
|
//更新差异重量(差异重量=理论计算重量-净重)
|
//根据主表id获取明细行的理论计算重量总和
|
Double theoryWeight = packagingItemMapper.getTheoryWeightTotal(packagingDTO.getId());
|
//判断不为 null
|
if (null != theoryWeight) {
|
//包装总净重 = 明细的理论重量和
|
packagingDTO.setNetWeight(new BigDecimal(theoryWeight));
|
|
//毛重 = 净重 + 包装重量
|
if(null != packagingDTO.getPackWeight() && null != packagingDTO.getNetWeight()){
|
packagingDTO.setGrossWeight(packagingDTO.getNetWeight().add(packagingDTO.getPackWeight()));
|
}
|
|
//差异重量 = 理论重量 - 实际净重(该计算方式作废)
|
//packagingDTO.setDifferenceWeight(new BigDecimal(theoryWeight).subtract(packagingDTO.getNetWeight()));
|
//差异重量 = 净重 - 实际重量
|
packagingDTO.setDifferenceWeight(packagingDTO.getNetWeight().subtract(packagingDTO.getRealWeight()));
|
}
|
baseMapper.updateById(packagingDTO);
|
|
//射频不需要用到包装人员，放在这也不会报错
|
packagingStaffMapper.delete(Wrappers.<PackagingStaff>lambdaQuery().eq(PackagingStaff::getPackagingId, packagingDTO.getId()));
|
if (CollectionUtil.isNotEmpty(packagingDTO.getStaffIds())) {
|
for (Long id : packagingDTO.getStaffIds()) {
|
PackagingStaff packagingStaff = new PackagingStaff();
|
packagingStaff.setStaffId(id);
|
packagingStaff.setPackagingId(packagingDTO.getId());
|
packagingStaffMapper.insert(packagingStaff);
|
}
|
}
|
//return false;//return 恒等于fasle？？？
|
return true;
|
}
|
|
@Override
|
public boolean batchSave(List<PackagingDTO> packagingDTOList) {
|
packagingDTOList.forEach(packagingDTO -> {
|
|
SplitTask splitTask = splitTaskMapper.selectById(packagingDTO.getSplitTaskId());
|
splitTask.setStatus(SplitTaskStateStringValues.USED);
|
splitTaskMapper.updateById(splitTask);
|
|
packagingDTO.setNo(numberGenerator.generateNumberWithPrefix(Packaging.DIGIT, Packaging.PREFIX, Packaging::getNo));
|
packagingDTO.setStatus(SplitTaskStateStringValues.UNSUBMIT);
|
baseMapper.insert(packagingDTO);
|
});
|
return true;
|
}
|
|
@Override
|
public synchronized boolean submit(Long id) {
|
String billNo = RandomStringUtils.random(10, true, true);
|
PackagingDTO packaging = baseMapper.getPackingById(id);
|
SplitTask splitTask = splitTaskMapper.selectById(packaging.getSplitTaskId());
|
if (null == splitTask) {
|
throw new RuntimeException("分割记录丢失");
|
}
|
Stock stock = stockMapper.selectById(splitTask.getStockId());
|
if (null == stock) {
|
throw new RuntimeException("库存记录丢失");
|
}
|
BigDecimal num = BigDecimal.ONE;
|
if (SplitTaskStateStringValues.PACKM1.equals(packaging.getPackingManner())) {
|
num = packaging.getCylinderNumber();
|
} else if (SplitTaskStateStringValues.PACKM2.equals(packaging.getPackingManner())) {
|
num = BigDecimal.ONE;
|
}
|
//库存事务
|
stockUtils.createTransaction(stock.getStockQuantity(), packaging.getNumber().negate(), stock.getPartId(),
|
stock.getLocationId(), stock.getPartBatchNo(), billNo, TransactionType.STOCK.getValue(), stock.getIfsBatchNo());
|
//修改原来库存数据的库存
|
stock.setStartMetre(packaging.getStartMetre());
|
stock.setEndMetre(packaging.getEndMetre());
|
stock.setCustomerOrderNo(packaging.getCustomerOrderNo());
|
stock.setStockQuantity(stock.getStockQuantity().add(packaging.getNumber().negate()));
|
stock.setReserveQuantity(stock.getReserveQuantity().add(packaging.getNumber().negate()));
|
stockMapper.updateById(stock);
|
List<Stock> stockList = stockMapper.selectList(Wrappers.<Stock>lambdaQuery().like(Stock::getPartBatchNo, stock.getPartBatchNo() + "_").orderByDesc(Stock::getPartBatchNo));
|
int j = 0;
|
if (!CollectionUtils.isEmpty(stockList)) {
|
String partBatchNo = stockList.get(0).getPartBatchNo();
|
j = Integer.parseInt(partBatchNo.substring(partBatchNo.length() - 3, partBatchNo.length()));
|
}
|
//新增库存数据
|
for (int i = 1; i <= num.intValue(); i++) {
|
j++;
|
Stock stockInsert = new Stock();
|
String partBatchNo = stock.getPartBatchNo() + "_" + String.format("%03d", j);
|
stockInsert.setPartId(stock.getPartId());
|
stockInsert.setPartBatchNo(partBatchNo);
|
stockInsert.setLocationId(packaging.getInLocationId());
|
stockInsert.setReserveQuantity(BigDecimal.ZERO);
|
stockInsert.setStockQuantity(packaging.getNumber().divide(num, 6, BigDecimal.ROUND_HALF_UP));
|
stockInsert.setAvailableStockQuantity(packaging.getNumber().divide(num, 6, BigDecimal.ROUND_HALF_UP));
|
stockInsert.setSystemNo(stock.getSystemNo());
|
stockInsert.setReelNumber(packaging.getRoutineReelNumber());
|
stockInsert.setStartMetre(packaging.getStartMetre());
|
stockInsert.setEndMetre(packaging.getEndMetre());
|
stockInsert.setCustomerOrderNo(packaging.getCustomerOrderNo());
|
stockMapper.insert(stockInsert);
|
PackagingItem packagingItem = new PackagingItem();
|
packagingItem.setOutBatchNo(partBatchNo);
|
packagingItem.setPackageQty(packaging.getNumber().divide(num, 6, BigDecimal.ROUND_HALF_UP));
|
packagingItem.setPackagingId(packaging.getId());
|
packagingItem.setPartId(packaging.getPartId());
|
packagingItem.setStockId(stockInsert.getId());
|
packagingItem.setSystemNo(stock.getSystemNo());
|
packagingItemMapper.insert(packagingItem);
|
stockUtils.createTransaction(BigDecimal.ZERO, packaging.getNumber().divide(num, 6,
|
BigDecimal.ROUND_HALF_UP), stock.getPartId(), packaging.getInLocationId(), partBatchNo, billNo,
|
TransactionType.STOCK.getValue(), stock.getIfsBatchNo());
|
}
|
packaging.setStatus(SplitTaskStateStringValues.SUBMIT);
|
baseMapper.updateById(packaging);
|
|
return true;
|
}
|
|
@Override
|
public R weighVerifyCheck(PackagingDTO packaging) {
|
//目前前台传过来的值跟跳线的不一样，不能用前台穿过来的对象进行更新，后台需要重新查询一遍
|
if(null == packaging.getId() || packaging.getId() == 0){
|
throw new RuntimeException("传入包装主表id = 【" + packaging.getId() + "】信息异常");
|
}else{
|
packaging = baseMapper.getPackingById(packaging.getId());
|
if(null == packaging){
|
throw new RuntimeException("根据包装主表id = 【" + packaging.getId() + "】 --> 无法查询包装信息");
|
}
|
}
|
String ok = "OK";
|
String key = "result";
|
String weight = "message";
|
BigDecimal partWeight = BigDecimal.ZERO;
|
//查询包装的从表
|
List<PackagingItem> packagingItemList = packagingItemMapper.selectList(Wrappers.<PackagingItem>lambdaQuery().eq(PackagingItem::getPackagingId, packaging.getId()));
|
JSONObject jsonObject = new JSONObject();
|
try {
|
//从地磅获取称重
|
Map<String, Object> paramMap = new HashMap<>(16);
|
String result = HttpRequest.get(packingBean.getHost()).form(paramMap).execute().body();
|
//String result = "[{\"result\":\"OK\",\"message\":\"0.5\"}]";//测试用
|
JSONArray jsonArray = JSONObject.parseArray(result);
|
jsonObject = jsonArray.getJSONObject(0);
|
} catch (Exception e) {
|
throw new RuntimeException("调用接口失败");
|
}
|
if (packagingItemList.size() == 0) {
|
throw new RuntimeException("包装的零件为空，请重新检查箱子");
|
} else if (packagingItemList.size() > 1) {
|
//当从表不止一根产出，所以是最后的称重，先判断产出与理论装箱数量，数量必须要等于理论装箱数量
|
if (packaging.getNumber().compareTo(packaging.getTheoreticalNumber()) != 0) {
|
throw new RuntimeException("最后称重时，实际数量必须等于理论装箱数量");
|
} else {
|
if (jsonObject.getString(key).equals(ok)) {
|
packaging.setRealWeight(new BigDecimal(jsonObject.getString(weight)));
|
packaging.setDifferenceWeight(packaging.getNetWeight().subtract(packaging.getRealWeight()));
|
|
//称重防呆提醒
|
String res = remoteParamService.getByKey(TX_PACK_WEIGHT_DIFF_LIMIT_VALUE, SecurityConstants.FROM_IN).getData();
|
if (null == res) {
|
throw new RuntimeException("未设置称重防呆阈值");
|
}
|
int a = weighVerify(packaging.getDifferenceWeight(),res);
|
if(a<0){
|
return R.ok(ValidateWeighPackagingDTO.builder().success(Boolean.FALSE).message("实际重量偏小，偏差超过系统预设值【"+ res +"】，请确认是否继续称重？").build());
|
}else if(a>0){
|
return R.ok(ValidateWeighPackagingDTO.builder().success(Boolean.FALSE).message("实际重量偏大，偏差超过系统预设值【"+ res +"】，请确认是否继续称重？").build());
|
}else{
|
return R.ok(ValidateWeighPackagingDTO.builder().success(Boolean.TRUE).build());
|
}
|
|
} else {
|
throw new RuntimeException("获取称重" + jsonObject.getString(weight));
|
}
|
}
|
}
|
return R.ok(ValidateWeighPackagingDTO.builder().success(Boolean.TRUE).build());
|
}
|
|
|
@Override
|
public R getWeight(PackagingDTO packaging) {
|
Boolean isRecException = packaging.getIsRecException();
|
//目前前台传过来的值跟跳线的不一样，不能用前台穿过来的对象进行更新，后台需要重新查询一遍
|
if(null == packaging.getId() || packaging.getId() == 0){
|
throw new RuntimeException("传入包装主表id = 【" + packaging.getId() + "】信息异常");
|
}else{
|
packaging = baseMapper.getPackingById(packaging.getId());
|
if(null == packaging){
|
throw new RuntimeException("根据包装主表id = 【" + packaging.getId() + "】 --> 无法查询包装信息");
|
}
|
}
|
String ok = "OK";
|
String key = "result";
|
String weight = "message";
|
BigDecimal partWeight = BigDecimal.ZERO;
|
//查询包装的从表
|
List<PackagingItem> packagingItemList = packagingItemMapper.selectList(Wrappers.<PackagingItem>lambdaQuery().eq(PackagingItem::getPackagingId, packaging.getId()));
|
JSONObject jsonObject = new JSONObject();
|
try {
|
//从地磅获取称重
|
Map<String, Object> paramMap = new HashMap<>(16);
|
String result = HttpRequest.get(packingBean.getHost()).form(paramMap).execute().body();
|
//String result = "[{\"result\":\"OK\",\"message\":\"0.5\"}]";//测试用
|
JSONArray jsonArray = JSONObject.parseArray(result);
|
jsonObject = jsonArray.getJSONObject(0);
|
} catch (Exception e) {
|
throw new RuntimeException("调用接口失败");
|
}
|
if (packagingItemList.size() == 0) {
|
throw new RuntimeException("包装的零件为空，请重新检查箱子");
|
} else if (packagingItemList.size() == 1) {
|
//当从表只有一根产出时，同步称重重量到产出零件的重量，并更新包装
|
if (jsonObject.getString(key).equals(ok)) {
|
//同步称重重量到产出零件的重量
|
Part part = partMapper.selectOne(Wrappers.<Part>lambdaQuery().eq(Part::getId, packagingItemList.get(0).getPartId()));
|
if (part != null) {
|
part.setWeight(new BigDecimal(jsonObject.getString(weight)));
|
partMapper.updateById(part);
|
Stock stock = stockMapper.selectById(packagingItemList.get(0).getStockId());
|
if (stock != null) {
|
partWeight = partWeight.add(part.getWeight().multiply(stock.getAvailableStockQuantity()));
|
//更新包装主表
|
packaging.setNetWeight(partWeight);
|
packaging.setDifferenceWeight(packaging.getNetWeight().subtract(packaging.getRealWeight()));
|
//更新毛重
|
packaging.setGrossWeight(packaging.getNetWeight().add(packaging.getPackWeight()));
|
//不是最后一把称重不需要设置 包装称重是否接收异常
|
packaging.setIsRecException(null);
|
//更新明细的重量（第一条称重明细的计算重量不是通过称重获取的单位重量）
|
packagingItemList.get(0).setTheoryWeight(packagingItemList.get(0).getPackageQty().multiply(part.getWeight()));
|
packagingItemMapper.updateById(packagingItemList.get(0));
|
baseMapper.updateById(packaging);
|
}
|
}
|
} else {
|
throw new RuntimeException("获取称重" + jsonObject.getString(weight));
|
}
|
} else {
|
//当从表不止一根产出，所以是最后的称重，先判断产出与理论装箱数量，数量必须要等于理论装箱数量
|
if (packaging.getNumber().compareTo(packaging.getTheoreticalNumber()) != 0) {
|
throw new RuntimeException("最后称重时，实际数量必须等于理论装箱数量");
|
} else {
|
if (jsonObject.getString(key).equals(ok)) {
|
packaging.setRealWeight(new BigDecimal(jsonObject.getString(weight)));
|
packaging.setDifferenceWeight(packaging.getNetWeight().subtract(packaging.getRealWeight()));
|
//更新毛重
|
packaging.setGrossWeight(packaging.getNetWeight().add(packaging.getPackWeight()));
|
packaging.setIsRecException(isRecException);
|
baseMapper.updateById(packaging);
|
} else {
|
throw new RuntimeException("获取称重" + jsonObject.getString(weight));
|
}
|
}
|
}
|
return R.ok(packaging);
|
}
|
|
|
|
|
//称重防呆提醒
|
public int weighVerify(BigDecimal differenceWeight,String res){
|
//实际重量偏小
|
if(differenceWeight.compareTo(BigDecimal.ZERO)<0){
|
if(differenceWeight.abs().compareTo(new BigDecimal(res))>0){
|
return -1;
|
}
|
}
|
//实际重量偏大
|
if(differenceWeight.compareTo(BigDecimal.ZERO)>0){
|
if(differenceWeight.abs().compareTo(new BigDecimal(res))>0){
|
return 1;
|
}
|
}
|
return 0;
|
}
|
|
|
|
|
@Override
|
public IPage<PackageReportDTO> getEveryDayReport(Page page, PackageReportDTO packageReportDTO) {
|
return packagingItemMapper.getPackageReport(page, packageReportDTO);
|
}
|
|
@Override
|
public R getPackJmreportUrl(String reportCode) {
|
switch (reportCode) {
|
case ReportCodeStringValues.GDHHL_HUAWEI:
|
return R.ok(packingBean.getGdhhlHuawei());
|
case ReportCodeStringValues.WEIGHT_LABLE:
|
return R.ok(packingBean.getWeightLable());
|
case ReportCodeStringValues.GW_HUAWEI:
|
return R.ok(packingBean.getGwHuaweiUrl());
|
case ReportCodeStringValues.GD_HUAWEI:
|
return R.ok(packingBean.getGdHuaweiUrl());
|
default:
|
return R.failed("该报表code=" + reportCode + "->无法识别");
|
}
|
}
|
|
@Override
|
public R packConfirm(Long id) {
|
if (wareHouseUtils.isPackConfirm(id)) {
|
return R.failed("包装状态为=已确认->请勿重复确认");
|
}
|
|
List<MoveLibraryBoxDTO> moveLibraryBoxDTOList = packagingItemMapper.getMoveLibraryBoxDTOListBypackagingId(id);
|
|
//数据校验
|
R r = wareHouseUtils.checkMoveLibraryBox(moveLibraryBoxDTOList, id);
|
if (r.getCode() == 1) {
|
return R.failed(r.getMsg());
|
}
|
|
//更新包装主表确认状态
|
baseMapper.updatePackagingIsConfirmById(id, true);
|
|
//移库
|
EscortEvents escortEvents = EscortEvents.COMPLETE;
|
wareHouseUtils.packagingMoveLibrary(moveLibraryBoxDTOList, escortEvents, id);
|
|
return R.ok(null, "操作成功");
|
}
|
|
|
@Override
|
public R packCancelConfirm(Long id) {
|
if (!wareHouseUtils.isPackConfirm(id)) {
|
return R.failed("包装状态为=未确认->请勿重复取消");
|
}
|
|
List<MoveLibraryBoxDTO> moveLibraryBoxDTOList = packagingItemMapper.getMoveLibraryBoxDTOListBypackagingId(id);
|
|
//数据校验
|
R r = wareHouseUtils.checkMoveLibraryBox(moveLibraryBoxDTOList, id);
|
if (r.getCode() == 1) {
|
return R.failed(r.getMsg());
|
}
|
|
//更新包装主表确认状态
|
baseMapper.updatePackagingIsConfirmById(id, false);
|
|
//移库
|
EscortEvents escortEvents = EscortEvents.CANCEL;
|
wareHouseUtils.packagingMoveLibrary(moveLibraryBoxDTOList, escortEvents, id);
|
|
return R.ok(null, "操作成功");
|
}
|
|
@Override
|
public R getPackHeadBasicInfoList() {
|
PackHeadBasicInfoDTO packHeadBasicInfoDTO = new PackHeadBasicInfoDTO();
|
List<PackHeadBasicInfoDTO.DataBean> packSizeWeightList = new ArrayList<>();
|
List<String> packSizeList = new ArrayList<>();//包装尺寸
|
List<String> packMaterialList = new ArrayList<>();//包装材质
|
List<String> locationNoList = new ArrayList<>();//库位编号
|
List<SysDictItem> dictItemList;
|
//包装尺寸-重量
|
dictItemList = dictUtils.getDict("pack_size_weight");
|
if (CollectionUtil.isNotEmpty(dictItemList)) {
|
for (SysDictItem dictItem : dictItemList) {
|
PackHeadBasicInfoDTO.DataBean dataBean = new PackHeadBasicInfoDTO.DataBean();
|
dataBean.setPackSize(dictItem.getValue());
|
dataBean.setPackWeight(dictItem.getDescription());
|
packSizeWeightList.add(dataBean);
|
}
|
}
|
|
//包装材质
|
dictItemList = dictUtils.getDict("pack_material");
|
if (CollectionUtil.isNotEmpty(dictItemList)) {
|
for (SysDictItem dictItem : dictItemList) {
|
packMaterialList.add(dictItem.getValue());
|
}
|
}
|
|
//成品库位
|
locationNoList = packagingItemMapper.getEnableFinishProdList(LocationTypeStringValues.FINISHLOCATIONCODE);
|
|
packHeadBasicInfoDTO.setPackSizeWeightList(packSizeWeightList);
|
packHeadBasicInfoDTO.setPackMaterialList(packMaterialList);
|
packHeadBasicInfoDTO.setLocationNoList(locationNoList);
|
|
|
return R.ok(packHeadBasicInfoDTO);
|
}
|
|
|
@Override
|
public R getPackagingAndSizeByPackagingNo(String packagingNo) {
|
Packaging packaging = baseMapper.selectOne(Wrappers.<Packaging>lambdaQuery().eq(Packaging::getNo, packagingNo));
|
if(packaging==null){
|
throw new RuntimeException("{"+packagingNo+"}未进行包装登记");
|
}
|
List<PackagingItem> packagingItemList = packagingItemMapper.getPackagingItemList(packagingNo);
|
if(CollectionUtil.isEmpty(packagingItemList)){
|
throw new RuntimeException("{"+packagingNo+"}未进行扫码装箱");
|
}
|
List<String> outBatchNoList = packagingItemList.stream().map(r -> r.getOutBatchNo()).collect(Collectors.toList());
|
PackingPdaDTO packingPdaDTO = new PackingPdaDTO();
|
BeanUtils.copyProperties(packaging, packingPdaDTO);
|
packingPdaDTO.setItemSize(packagingItemList.size());
|
packingPdaDTO.setSnList(outBatchNoList);
|
return R.ok(packingPdaDTO);
|
}
|
}
|
