root/XuGongHanYunWMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rev：业务修改

Browse Source
This commit is contained in:
liuxy
2025-09-02 18:45:22 +08:00
parent ee523f576c
commit 3e409b93b2
24 changed files with 126 additions and 1522 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/controller/PdaEmpVehicleController.java
View File

@@ -1,49 +0,0 @@
package org.nl.wms.pda.ios_manage.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.ios_manage.service.PdaEmpVehicleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 手持空托盘管理 控制层
* </p>
*
* @author Liuxy
* @since 2025-08-05
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/empVehicle")
@Slf4j
public class PdaEmpVehicleController {
@Autowired
private PdaEmpVehicleService pdaEmpVehicleService;
@PostMapping("/in")
@Log("空托盘入库")
@SaIgnore
public ResponseEntity<Object> empVehicleIn(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaEmpVehicleService.empVehicleIn(whereJson),HttpStatus.OK);
}
@PostMapping("/out")
@Log("空托盘出库")
@SaIgnore
public ResponseEntity<Object> empVehicleOut(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaEmpVehicleService.empVehicleOut(whereJson),HttpStatus.OK);
}
}

49
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/controller/PdaIosCheckController.java
View File

@@ -1,49 +0,0 @@
package org.nl.wms.pda.ios_manage.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.ios_manage.service.PdaIosCheckService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 手持盘点确认 控制层
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/iosCheck")
@Slf4j
public class PdaIosCheckController {
@Autowired
private PdaIosCheckService pdaIosCheckService;
@PostMapping("/getDtl")
@Log("获取盘点明细")
@SaIgnore
public ResponseEntity<Object> getDtl(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosCheckService.getDtl(whereJson), HttpStatus.OK);
}
@PostMapping("/confirm")
@Log("确认")
@SaIgnore
public ResponseEntity<Object> confirm(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosCheckService.confirm(whereJson), HttpStatus.OK);
}
}

91
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/controller/PdaIosInController.java
View File

@@ -1,91 +0,0 @@
package org.nl.wms.pda.ios_manage.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.ios_manage.service.PdaIosInService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 手持入库确认 控制层
* </p>
*
* @author Liuxy
* @since 2025-06-05
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/iosIn")
@Slf4j
public class PdaIosInController {
@Autowired
private PdaIosInService pdaIosInService;
@PostMapping("/sweepCode")
@Log("扫码解析")
@SaIgnore
public ResponseEntity<Object> sweepCode(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.sweepCode(whereJson),HttpStatus.OK);
}
@PostMapping("/groupPlate")
@Log("组盘")
@SaIgnore
public ResponseEntity<Object> groupPlate(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.groupPlate(whereJson),HttpStatus.OK);
}
@PostMapping("/getPlateDtl")
@Log("查询明细")
@SaIgnore
public ResponseEntity<Object> getPlateDtl(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.getPlateDtl(whereJson),HttpStatus.OK);
}
@PostMapping("/deleteDtl")
@Log("删除明细")
@SaIgnore
public ResponseEntity<Object> deleteDtl(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.deleteDtl(whereJson),HttpStatus.OK);
}
@PostMapping("/getSect")
@Log("获取库区")
@SaIgnore
public ResponseEntity<Object> getSect() {
return new ResponseEntity<>(pdaIosInService.getSect(),HttpStatus.OK);
}
@PostMapping("/confirmIn")
@Log("入库确认")
@SaIgnore
public ResponseEntity<Object> confirmIn(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.confirmIn(whereJson),HttpStatus.OK);
}
@PostMapping("/getMaterCode")
@Log("获取物料信息")
@SaIgnore
public ResponseEntity<Object> getMaterCode(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.getMaterCode(whereJson),HttpStatus.OK);
}
@PostMapping("/groupPlateTwo")
@Log("人工组盘确认")
@SaIgnore
public ResponseEntity<Object> groupPlateTwo(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosInService.groupPlateTwo(whereJson),HttpStatus.OK);
}
}

49
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/controller/PdaIosOutController.java
View File

@@ -1,49 +0,0 @@
package org.nl.wms.pda.ios_manage.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.ios_manage.service.PdaIosOutService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 手持入库确认 控制层
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/iosOut")
@Slf4j
public class PdaIosOutController {
@Autowired
private PdaIosOutService pdaIosOutService;
@PostMapping("/getDtl")
@Log("获取库存明细")
@SaIgnore
public ResponseEntity<Object> getDtl(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosOutService.getDtl(whereJson), HttpStatus.OK);
}
@PostMapping("/confirm")
@Log("出库确认")
@SaIgnore
public ResponseEntity<Object> confirm(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaIosOutService.confirm(whereJson), HttpStatus.OK);
}
}

36
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/PdaEmpVehicleService.java
View File

@@ -1,36 +0,0 @@
package org.nl.wms.pda.ios_manage.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.pda.util.PdaResponse;
/**
* <p>
* 手持空托盘管理 服务类
* </p>
*
* @author Liuxy
* @since 2025-08-05
*/
public interface PdaEmpVehicleService {
/**
* 空托盘入库
* @param whereJson {
* point_code： 起点
* storagevehicle_code： 载具编码
*
* }
* @return PdaResponse
*/
PdaResponse empVehicleIn(JSONObject whereJson);
/**
*
* @param whereJson {
* point_code: 终点
* storagevehicle_type: 载具类型
* }
* @return PdaResponse
*/
PdaResponse empVehicleOut(JSONObject whereJson);
}

46
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/PdaIosCheckService.java
View File

@@ -1,46 +0,0 @@
package org.nl.wms.pda.ios_manage.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.IService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.warehouse_management.service.dao.StIvtCheckdtl;
/**
* <p>
* 手持盘点确认 服务类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
public interface PdaIosCheckService extends IService<StIvtCheckdtl> {
/**
* 获取盘点明细
* @param whereJson {
* storagevehicle_code： 载具编码
* struct_code： 仓位
* }
* @return PdaResponse
*/
PdaResponse getDtl(JSONObject whereJson);
/**
* 确认
* @param whereJson {
* storagevehicle_code： 载具编码
* struct_code：仓位编码
* data: [
* checkdtl_id: 明细标识
* bill_code: 单据编码
* bill_code: 单据编码
* pcsn: 批次
* base_qty: 库存数量
* fac_qty: 盘点数量
* qty_unit_name: 单位
* ]
* }
* @return PdaResponse
*/
PdaResponse confirm(JSONObject whereJson);
}

98
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/PdaIosInService.java
View File

@@ -1,98 +0,0 @@
package org.nl.wms.pda.ios_manage.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.pda.util.PdaResponse;
/**
* <p>
* 手持IOS 服务类
* </p>
*
* @author Liuxy
* @since 2025-06-05
*/
public interface PdaIosInService {
/**
*
* @param whereJson {
* code: 二维码内容
* }
* @return PdaResponse
*/
PdaResponse sweepCode(JSONObject whereJson);
/**
* 组盘
* @param whereJson {
* storagevehicle_code: 载具编码
* group_id： 组盘记录id
* }
* @return PdaResponse
*/
PdaResponse groupPlate(JSONObject whereJson);
/**
* 查询明细
* @param whereJson {
* storagevehicle_code : 载具编码
* }
* @return PdaResponse
*/
PdaResponse getPlateDtl(JSONObject whereJson);
/**
* 删除明细
* @param whereJson {
* group_id: 组盘标识
* material_code: 物料编码
* material_name: 物料名称
* pcsn: 批次
* qty: 数量
* qty_unit_name: 单位
* }
* @return PdaResponse
*/
PdaResponse deleteDtl(JSONObject whereJson);
/**
* 查询库区
* @return PdaResponse
*/
PdaResponse getSect();
/**
* 入库确认
* @param whereJson {
* storagevehicle_code：载具编码
* point_code：点位编码
* sect_id：库区
* }
* @return PdaResponse
*/
PdaResponse confirmIn(JSONObject whereJson);
/**
* 获取物料信息
* @param whereJson {
* material_code: 物料编码
* }
* @return PdaResponse
*/
PdaResponse getMaterCode(JSONObject whereJson);
/**
* 人工组盘确认
* @param whereJson {
* storagevehicle_code: 载具编码
* material_code: 物料编码
* material_name: 物料名称
* material_spec: 物料规格
* pcsn: 批次
* qty: 数量
* prison_area: 监区
* }
* @return PdaResponse
*/
PdaResponse groupPlateTwo(JSONObject whereJson);
}

34
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/PdaIosOutService.java
View File

@@ -1,34 +0,0 @@
package org.nl.wms.pda.ios_manage.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.pda.util.PdaResponse;
/**
* <p>
* 手持IOS 服务类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
public interface PdaIosOutService {
/**
* 获取库存明细
* @param whereJson {
* storagevehicle_code： 载具码
* }
* @return PdaResponse
*/
PdaResponse getDtl(JSONObject whereJson);
/**
* 出库确认
* @param whereJson {
* storagevehicle_code： 载具码
* point_code： 点位编码
* }
* @return PdaResponse
*/
PdaResponse confirm(JSONObject whereJson);
}

186
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/impl/PdaEmpVehicleServiceImpl.java
View File

@@ -1,186 +0,0 @@
package org.nl.wms.pda.ios_manage.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.basedata_manage.service.IMdPbStoragevehicleinfoService;
import org.nl.wms.basedata_manage.service.IStructattrService;
import org.nl.wms.basedata_manage.service.dao.MdPbStoragevehicleinfo;
import org.nl.wms.basedata_manage.service.dao.Structattr;
import org.nl.wms.pda.ios_manage.service.PdaEmpVehicleService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.sch_manage.service.util.tasks.EmpVehicleInTask;
import org.nl.wms.sch_manage.service.util.tasks.EmpVehicleOutTask;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* <p>
* 手持空托盘管理 实现类
* </p>
*
* @author Liuxy
* @since 2025-08-05
*/
@Service
public class PdaEmpVehicleServiceImpl implements PdaEmpVehicleService {
/**
* 载具服务
*/
@Autowired
private IMdPbStoragevehicleinfoService iMdPbStoragevehicleinfoService;
/**
* 仓位服务
*/
@Autowired
private IStructattrService iStructattrService;
/**
* 载具入库任务类
*/
@Autowired
private EmpVehicleInTask empVehicleInTask;
/**
* 载具出库任务类
*/
@Autowired
private EmpVehicleOutTask empVehicleOutTask;
@Override
@Transactional
public PdaResponse empVehicleIn(JSONObject whereJson) {
// 基础校验
MdPbStoragevehicleinfo vehicleDao = iMdPbStoragevehicleinfoService.getByCode(whereJson.getString("storagevehicle_code"));
if (ObjectUtil.isEmpty(vehicleDao)) {
throw new BadRequestException("载具不存在!【" + whereJson.getString("storagevehicle_code") + "】");
}
if (ObjectUtil.isEmpty(whereJson.getString("point_code"))) {
throw new BadRequestException("起点不能为空！");
}
// 根据托盘类型，尺寸大小找对应入库货位
Structattr attrDao = queryInPoint(vehicleDao);
if (ObjectUtil.isEmpty(attrDao)) {
throw new BadRequestException("仓位不足或条件不满足！");
}
// 锁定终点
attrDao.setLock_type(IOSEnum.LOCK_TYPE.code("空托盘入库锁"));
iStructattrService.updateById(attrDao);
// 创建任务
JSONObject jsonTask = new JSONObject();
jsonTask.put("point_code1", whereJson.getString("point_code"));
jsonTask.put("point_code2", attrDao.getStruct_code());
jsonTask.put("vehicle_code", whereJson.getString("storagevehicle_code"));
jsonTask.put("Priority", IOSConstant.IS_DELETE_YES);
empVehicleInTask.create(jsonTask);
return PdaResponse.requestOk();
}
@Override
@Transactional
public PdaResponse empVehicleOut(JSONObject whereJson) {
// 基础校验
if (ObjectUtil.isEmpty(whereJson.getString("point_code"))) {
throw new BadRequestException("终点不能为空！");
}
if (ObjectUtil.isEmpty(whereJson.getString("storagevehicle_type"))) {
throw new BadRequestException("载具类型不能为空！");
}
// 根据载具类型查找对应载具
Structattr attrDao = queryOutPoint(whereJson);
if (ObjectUtil.isEmpty(attrDao)) {
throw new BadRequestException("库内此类型空托盘不足！【" + whereJson.getString("storagevehicle_type") + "】");
}
// 锁定仓位
attrDao.setLock_type(IOSEnum.LOCK_TYPE.code("空托盘出库锁"));
iStructattrService.updateById(attrDao);
// 创建任务
JSONObject jsonTask = new JSONObject();
jsonTask.put("point_code1", attrDao.getStruct_code());
jsonTask.put("point_code2", whereJson.getString("point_code"));
jsonTask.put("vehicle_code", attrDao.getStoragevehicle_code());
jsonTask.put("Priority", IOSConstant.IS_DELETE_YES);
empVehicleOutTask.create(jsonTask);
return PdaResponse.requestOk();
}
/**
* 查找入库货位
* 分配规则：
* 1.满足托盘类型 2.满足载具的长宽高
*
* @param vehicleDao 载具实体类
* @return Structattr 仓位实体类
*/
private Structattr queryInPoint(MdPbStoragevehicleinfo vehicleDao) {
// 默认库区为主存区
List<Structattr> structattrList = iStructattrService.list(new LambdaQueryWrapper<>(Structattr.class)
.eq(Structattr::getSect_code, IOSConstant.SECT_CODE)
.eq(Structattr::getLock_type, IOSEnum.LOCK_TYPE.code("未锁定"))
.and(wrapper -> wrapper.isNull(Structattr::getStoragevehicle_code).or().eq(Structattr::getStoragevehicle_code, ""))
.eq(vehicleDao.getStoragevehicle_type().equals(IOSEnum.VEHICLE_TYPE.code("金属托盘")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("金属托盘"))
.eq(vehicleDao.getStoragevehicle_type().equals(IOSEnum.VEHICLE_TYPE.code("小料架")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("小料架"))
.eq(vehicleDao.getStoragevehicle_type().equals(IOSEnum.VEHICLE_TYPE.code("大料架（短边）")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("大料架（短边）"))
.eq(vehicleDao.getStoragevehicle_type().equals(IOSEnum.VEHICLE_TYPE.code("大料架（长边）")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("大料架（长边）"))
.orderByAsc(Structattr::getStruct_code)
);
// 校验长宽高
Structattr structattr = structattrList.stream().filter(st ->
st.getWidth().compareTo(vehicleDao.getVehicle_width()) >= 0 &&
st.getHeight().compareTo(vehicleDao.getVehicle_height()) >= 0 &&
st.getZdepth().compareTo(vehicleDao.getVehicle_long()) >= 0
).findAny().get();
return structattr;
}
/**
* 寻找出库托盘仓位
* 分配规则
* 1.根据载具类型匹配
*
* @param whereJson {
* storagevehicle_type: 载具类型
* }
* @return Structattr 仓位实体类
*/
private Structattr queryOutPoint(JSONObject whereJson) {
// 默认库区为主存区
String storagevehicle_type = whereJson.getString("storagevehicle_type");
Structattr attrDao = iStructattrService.getOne(new LambdaQueryWrapper<>(Structattr.class)
.eq(Structattr::getSect_code, IOSConstant.SECT_CODE)
.eq(Structattr::getLock_type, IOSEnum.LOCK_TYPE.code("未锁定"))
.eq(Structattr::getIs_emptyvehicle, IOSConstant.IS_DELETE_YES)
.and(wrapper -> wrapper.isNotNull(Structattr::getStoragevehicle_code).or().ne(Structattr::getStoragevehicle_code, ""))
.eq(storagevehicle_type.equals(IOSEnum.VEHICLE_TYPE.code("金属托盘")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("金属托盘"))
.eq(storagevehicle_type.equals(IOSEnum.VEHICLE_TYPE.code("小料架")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("小料架"))
.eq(storagevehicle_type.equals(IOSEnum.VEHICLE_TYPE.code("大料架（短边）")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("大料架（短边）"))
.eq(storagevehicle_type.equals(IOSEnum.VEHICLE_TYPE.code("大料架（长边）")),
Structattr::getStoragevehicle_type, IOSEnum.VEHICLE_TYPE_PUT.code("大料架（长边）"))
.orderByAsc(Structattr::getStruct_code)
);
return attrDao;
}
}

79
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/impl/PdaIosCheckServiceImpl.java
View File

@@ -1,79 +0,0 @@
package org.nl.wms.pda.ios_manage.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.nl.wms.pda.ios_manage.service.PdaIosCheckService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IStIvtCheckdtlService;
import org.nl.wms.warehouse_management.service.IStIvtCheckmstService;
import org.nl.wms.warehouse_management.service.dao.StIvtCheckdtl;
import org.nl.wms.warehouse_management.service.dao.mapper.StIvtCheckdtlMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 手持盘点确认 实现类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@Service
public class PdaIosCheckServiceImpl extends ServiceImpl<StIvtCheckdtlMapper, StIvtCheckdtl> implements PdaIosCheckService {
/**
* 盘点单主表服务
*/
@Autowired
private IStIvtCheckmstService iStIvtCheckmstService;
/**
* 盘点单明细服务
*/
@Autowired
private IStIvtCheckdtlService iStIvtCheckdtlService;
@Override
public PdaResponse getDtl(JSONObject whereJson) {
return PdaResponse.requestParamOk(this.baseMapper.getPdaDtl(whereJson));
}
@Override
@Transactional
public PdaResponse confirm(JSONObject whereJson) {
List<JSONObject> dataList = whereJson.getJSONArray("data").toJavaList(JSONObject.class);
// 查询明细
List<StIvtCheckdtl> dtlDaoList = this.list(
new QueryWrapper<StIvtCheckdtl>().lambda()
.in(StIvtCheckdtl::getCheckdtl_id, dataList.stream()
.map(row -> row.getString("checkdtl_id"))
.collect(Collectors.toList())
)
);
// 需要更新的明细集合
List<StIvtCheckdtl> needUpdateList = new ArrayList<>();
for (JSONObject json : dataList) {
StIvtCheckdtl dtlDao = dtlDaoList.stream()
.filter(row -> row.getCheckdtl_id().equals(json.getString("checkdtl_id")))
.findFirst().orElse(null);
dtlDao.setStatus(IOSEnum.CHECK_DTL_STATUS.code("完成"));
dtlDao.setFac_qty(json.getBigDecimal("fac_qty"));
needUpdateList.add(dtlDao);
}
// 更新明细
this.updateBatchById(needUpdateList);
// 更新主表状态
iStIvtCheckmstService.updateMst(dtlDaoList.get(0).getCheck_id());
// 创建损益单
iStIvtCheckdtlService.createMore(needUpdateList,dtlDaoList.get(0).getCheck_id());
return PdaResponse.requestOk();
}
}

414
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/impl/PdaIosInServiceImpl.java
View File

@@ -1,414 +0,0 @@
package org.nl.wms.pda.ios_manage.service.impl;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.IdUtil;
import org.nl.common.utils.SecurityUtils;
import org.nl.wms.basedata_manage.service.IMdMeMaterialbaseService;
import org.nl.wms.basedata_manage.service.IMdPbMeasureunitService;
import org.nl.wms.basedata_manage.service.IMdPbStoragevehicleinfoService;
import org.nl.wms.basedata_manage.service.ISectattrService;
import org.nl.wms.basedata_manage.service.dao.MdMeMaterialbase;
import org.nl.wms.basedata_manage.service.dao.MdPbMeasureunit;
import org.nl.wms.basedata_manage.service.dao.MdPbStoragevehicleinfo;
import org.nl.wms.basedata_manage.service.dao.Sectattr;
import org.nl.wms.pda.ios_manage.service.PdaIosInService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IMdPbGroupplateService;
import org.nl.wms.warehouse_management.service.IRawAssistIStorService;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDtl;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDtlMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.MdPbGroupplateMapper;
import org.nl.wms.warehouse_management.service.dto.IOStorInvDisDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.*;
/**
* <p>
* 手持IOS 实现类
* </p>
*
* @author Liuxy
* @since 2025-06-05
*/
@Service
public class PdaIosInServiceImpl implements PdaIosInService {
/**
* 组盘记录mapper
*/
@Autowired
private MdPbGroupplateMapper mdPbGroupplateMapper;
/**
* 组盘记录服务
*/
@Autowired
private IMdPbGroupplateService iMdPbGroupplateService;
/**
* 基础物料服务
*/
@Autowired
private IMdMeMaterialbaseService iMdMeMaterialbaseService;
/**
* 计量单位服务
*/
@Autowired
private IMdPbMeasureunitService iMdPbMeasureunitService;
/**
* 载具服务
*/
@Autowired
private IMdPbStoragevehicleinfoService iMdPbStoragevehicleinfoService;
/**
* 库区服务
*/
@Autowired
private ISectattrService iSectattrService;
/**
* 入库服务
*/
@Autowired
private IRawAssistIStorService iRawAssistIStorService;
/**
* 入库明细服务
*/
@Autowired
private IOStorInvDtlMapper ioStorInvDtlMapper;
@Override
@Transactional
public PdaResponse sweepCode(JSONObject whereJson) {
// 解析二维码内容："wl0001##pc050401##1000##kg##dj000001##01"
String code = whereJson.getString("code");
String[] split = code.split("##");
// 物料编码
String material_code = split[0];
// 批次
String pcsn = split[1];
// 数量
String qty = split[2];
// 计量单位
String unit_code = split[3];
// 单据号
String ext_code = split[4];
// 业务类型
String ext_type = split[5];
// 校验
MdMeMaterialbase materDao = iMdMeMaterialbaseService.getByCode(material_code);
MdPbMeasureunit unitDao = iMdPbMeasureunitService.getByCode(unit_code);
GroupPlate groupDao = iMdPbGroupplateService.getOne(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getPcsn, pcsn)
.eq(GroupPlate::getQty, qty)
.eq(GroupPlate::getQty_unit_id, unitDao.getMeasure_unit_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("生成"))
);
if (ObjectUtil.isEmpty(groupDao)) {
// 插入组盘记录表
groupDao = new GroupPlate();
groupDao.setGroup_id(IdUtil.getStringId());
groupDao.setPcsn(pcsn);
groupDao.setQty_unit_id(unitDao.getMeasure_unit_id());
groupDao.setQty_unit_name(unitDao.getUnit_name());
groupDao.setQty(BigDecimal.valueOf(Double.parseDouble(qty)));
groupDao.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("生成"));
groupDao.setCreate_id(SecurityUtils.getCurrentUserId());
groupDao.setCreate_name(SecurityUtils.getCurrentNickName());
groupDao.setCreate_time(DateUtil.now());
iMdPbGroupplateService.save(groupDao);
}
// 组织返回数据
JSONObject result = new JSONObject();
result.put("group_id", groupDao.getGroup_id());
result.put("material_code", material_code);
result.put("material_name", materDao.getMaterial_name());
result.put("material_spec", materDao.getMaterial_spec());
result.put("pcsn", pcsn);
result.put("qty", qty);
result.put("qty_unit_name", unitDao.getUnit_name());
return PdaResponse.requestParamOk(result);
}
@Override
@Transactional
public PdaResponse groupPlate(JSONObject whereJson) {
// 校验载具
MdPbStoragevehicleinfo vehicleDao = iMdPbStoragevehicleinfoService.getByCode(whereJson.getString("storagevehicle_code"));
// 校验此载具是否有入库状态的组盘信息
boolean is_in = iMdPbGroupplateService.list(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, vehicleDao.getStoragevehicle_code())
).stream()
.anyMatch(row -> row.getStatus().equals(IOSEnum.GROUP_PLATE_STATUS.code("入库")));
if (is_in) {
throw new BadRequestException("当前载具已经入库，请检查数据!【"+whereJson.getString("storagevehicle_code")+"】");
}
// 校验组盘记录
GroupPlate groupDao = iMdPbGroupplateService.getById(whereJson.getString("group_id"));
if (!groupDao.getStatus().equals(IOSEnum.GROUP_PLATE_STATUS.code("生成"))) {
throw new BadRequestException("当前信息已经组盘!【"+whereJson.getString("group_id")+"】");
}
// 校验组盘物料、批次、原单据号、原单据类型是否一样
List<GroupPlate> plateDaoList = iMdPbGroupplateService.list(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, whereJson.getString("storagevehicle_code"))
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("组盘"))
);
if (ObjectUtil.isNotEmpty(plateDaoList)) {
boolean is_like = plateDaoList.stream()
.allMatch(row -> row.getMaterial_id().equals(groupDao.getMaterial_id()) &&
row.getPcsn().equals(groupDao.getPcsn())
);
if (!is_like) {
throw new BadRequestException("当前托盘所绑物料批次或者源单据与当前组盘物料批次不一致!");
}
}
// 更新数据组盘数据
groupDao.setStoragevehicle_code(vehicleDao.getStoragevehicle_code());
groupDao.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("组盘"));
iMdPbGroupplateService.updateById(groupDao);
return PdaResponse.requestOk();
}
@Override
public PdaResponse getPlateDtl(JSONObject whereJson) {
return PdaResponse.requestParamOk(mdPbGroupplateMapper.getDtl(whereJson));
}
@Override
@Transactional
public PdaResponse deleteDtl(JSONObject whereJson) {
iMdPbGroupplateService.removeById(whereJson.getString("group_id"));
return PdaResponse.requestOk();
}
@Override
public PdaResponse getSect() {
List<Sectattr> sectList = iSectattrService.list(
new QueryWrapper<Sectattr>().lambda()
.eq(Sectattr::getIs_delete, IOSConstant.IS_DELETE_NO)
.eq(Sectattr::getIs_used, IOSConstant.IS_DELETE_YES)
);
return PdaResponse.requestParamOk(sectList);
}
@Override
@Transactional
public PdaResponse confirmIn(JSONObject whereJson) {
// 组织新增数据
Map<String, Object> jsonMst = organizeInsertData(whereJson);
// 调用服务新增数据
String iostorinv_id = iRawAssistIStorService.insertDtl(jsonMst);
// 组织分配数据
whereJson.put("iostorinv_id",iostorinv_id);
Map<String, Object> jsonDtl = organizeDivData(whereJson);
// 调用分配
iRawAssistIStorService.divStruct(jsonDtl);
// 下发任务
sendTask(whereJson);
return PdaResponse.requestOk();
}
@Override
public PdaResponse getMaterCode(JSONObject whereJson) {
return PdaResponse.requestParamOk(iMdMeMaterialbaseService.getByCode(whereJson.getString("material_code")));
}
@Override
@Transactional
public PdaResponse groupPlateTwo(JSONObject whereJson) {
// 校验载具
MdPbStoragevehicleinfo vehicleDao = iMdPbStoragevehicleinfoService.getByCode(whereJson.getString("storagevehicle_code"));
if (ObjectUtil.isEmpty(vehicleDao)) {
throw new BadRequestException("载具不存在!【"+whereJson.getString("storagevehicle_code")+"】");
}
// 校验此载具是否有入库状态的组盘信息
boolean is_in = iMdPbGroupplateService.list(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, vehicleDao.getStoragevehicle_code())
).stream()
.anyMatch(row -> row.getStatus().equals(IOSEnum.GROUP_PLATE_STATUS.code("入库")));
if (is_in) {
throw new BadRequestException("当前载具已经入库，请检查数据!【"+whereJson.getString("storagevehicle_code")+"】");
}
// 获取物料信息
MdMeMaterialbase materDao = iMdMeMaterialbaseService.getByCode(whereJson.getString("material_code"));
// 校验组盘物料、批次、原单据号、原单据类型是否一样
List<GroupPlate> plateDaoList = iMdPbGroupplateService.list(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, whereJson.getString("storagevehicle_code"))
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("组盘"))
);
if (ObjectUtil.isNotEmpty(plateDaoList)) {
boolean is_like = plateDaoList.stream()
.allMatch(row -> row.getMaterial_id().equals(materDao.getMaterial_code()) &&
row.getPcsn().equals(whereJson.getString("pcsn"))
);
if (!is_like) {
throw new BadRequestException("当前托盘所绑物料批次与当前组盘物料批次不一致!");
}
}
// 插入组盘记录表
GroupPlate groupDao = new GroupPlate();
groupDao.setGroup_id(org.nl.config.IdUtil.getStringId());
groupDao.setStoragevehicle_code(whereJson.getString("storagevehicle_code"));
groupDao.setPcsn(whereJson.getString("pcsn"));
// 默认数量个
MdPbMeasureunit unitDao = iMdPbMeasureunitService.getByCode("EA");
groupDao.setQty_unit_id(unitDao.getMeasure_unit_id());
groupDao.setQty_unit_name(unitDao.getUnit_name());
groupDao.setQty(whereJson.getBigDecimal("qty"));
groupDao.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("组盘"));
groupDao.setCreate_id(SecurityUtils.getCurrentUserId());
groupDao.setCreate_name(SecurityUtils.getCurrentNickName());
groupDao.setCreate_time(DateUtil.now());
iMdPbGroupplateService.save(groupDao);
return PdaResponse.requestOk();
}
/**
* 组织入库插入数据
* @param whereJson {
* storagevehicle_code：载具编码
* point_code：点位编码
* sect_id：库区
* }
* @return Map<String, Object>
*/
private Map<String, Object> organizeInsertData(JSONObject whereJson) {
// 查询组盘明细
List<GroupPlate> plateDaoList = iMdPbGroupplateService.list(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, whereJson.getString("storagevehicle_code"))
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("组盘"))
);
if (ObjectUtil.isEmpty(plateDaoList)) {
throw new BadRequestException("当前没有可入库的物料!");
}
// 总数量
Double total_qty = plateDaoList.stream()
.map(row -> row.getQty().doubleValue())
.reduce(Double::sum).orElse(0.0);
// 查询库区
Sectattr sectDao = iSectattrService.getById(whereJson.getString("sect_id"));
// 组织主表数据
Map<String, Object> jsonMst = new HashMap<>();
jsonMst.put("stor_id", sectDao.getStor_id());
jsonMst.put("bill_status", IOSEnum.BILL_STATUS.code("生成"));
jsonMst.put("total_qty", total_qty);
jsonMst.put("detail_count", 1);
jsonMst.put("bill_type", IOSEnum.IN_BILL_TYPE.code("收货入库"));
jsonMst.put("biz_date", DateUtil.now());
// 组织明细数据
ArrayList<HashMap> tableData = new ArrayList<>();
HashMap<String, String> dtl = new HashMap<>();
GroupPlate plateDao = plateDaoList.get(0);
dtl.put("storagevehicle_code", plateDao.getStoragevehicle_code());
dtl.put("pcsn", plateDao.getPcsn());
dtl.put("qty_unit_id", plateDao.getQty_unit_id());
dtl.put("qty_unit_name", plateDao.getQty_unit_name());
dtl.put("qty", String.valueOf(total_qty));
MdMeMaterialbase materDao = iMdMeMaterialbaseService.getById(plateDao.getMaterial_id());
dtl.put("material_code", materDao.getMaterial_code());
dtl.put("material_name", materDao.getMaterial_name());
dtl.put("plan_qty", String.valueOf(total_qty));
// 调用新增
tableData.add(dtl);
jsonMst.put("tableData",tableData);
return jsonMst;
}
/**
* 组织分配数据
* @param whereJson {
* iostorinv_id
* sect_id
* }
* @return Map<String, Object>
*/
private Map<String, Object> organizeDivData(JSONObject whereJson) {
// 查询库区
Sectattr sectDao = iSectattrService.getById(whereJson.getString("sect_id"));
// 组织主数据
Map<String, Object> jsonMst = new HashMap<>();
jsonMst.put("checked", true);
jsonMst.put("sect_id", sectDao.getSect_id());
jsonMst.put("stor_id", sectDao.getStor_id());
// 组织明细数据
IOStorInvDtl dtlDao = ioStorInvDtlMapper.selectOne(
new QueryWrapper<IOStorInvDtl>().lambda()
.eq(IOStorInvDtl::getIostorinv_id, whereJson.getString("iostorinv_id"))
);
// 查找分配明细
Map<String, Object> map = new HashMap<>();
map.put("iostorinvdtl_id",dtlDao.getIostorinvdtl_id());
List<IOStorInvDisDto> disDtl = iRawAssistIStorService.getDisDtl(map);
// 类型转换
ArrayList<LinkedHashMap> tableMater = new ArrayList<>();
disDtl.forEach(item -> {
tableMater.add(JSONObject.parseObject(JSONObject.toJSONString(item), LinkedHashMap.class));
});
jsonMst.put("tableMater", tableMater);
return jsonMst;
}
/**
* 下发任务
* @param whereJson {
* storagevehicle_code：载具编码
* point_code：点位编码
* sect_id：库区
* iostorinv_id: id
* }
*/
private void sendTask(JSONObject whereJson) {
// 组织主数据
Map<String, Object> jsonMst = new HashMap<>();
jsonMst.put("point_code", whereJson.getString("point_code"));
// 组织明细数据
IOStorInvDtl dtlDao = ioStorInvDtlMapper.selectOne(
new QueryWrapper<IOStorInvDtl>().lambda()
.eq(IOStorInvDtl::getIostorinv_id, whereJson.getString("iostorinv_id"))
);
// 查找分配明细
Map<String, Object> map = new HashMap<>();
map.put("iostorinvdtl_id",dtlDao.getIostorinvdtl_id());
List<IOStorInvDisDto> disDtl = iRawAssistIStorService.getDisDtl(map);
// 类型转换
ArrayList<LinkedHashMap> tableMater = new ArrayList<>();
disDtl.forEach(item -> {
tableMater.add(JSONObject.parseObject(JSONObject.toJSONString(item), LinkedHashMap.class));
});
jsonMst.put("tableMater", tableMater);
iRawAssistIStorService.divPoint(jsonMst);
}
}

175
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/ios_manage/service/impl/PdaIosOutServiceImpl.java
View File

@@ -1,175 +0,0 @@
package org.nl.wms.pda.ios_manage.service.impl;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.basedata_manage.service.IStructattrService;
import org.nl.wms.basedata_manage.service.dao.Structattr;
import org.nl.wms.basedata_manage.service.dao.mapper.MdPbStoragevehicleextMapper;
import org.nl.wms.pda.ios_manage.service.PdaIosOutService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.sch_manage.enums.TaskEnum;
import org.nl.wms.sch_manage.service.ISchBasePointService;
import org.nl.wms.sch_manage.service.dao.SchBasePoint;
import org.nl.wms.sch_manage.service.util.tasks.BackInTask;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IRawAssistIStorService;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDis;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDtl;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDisMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDtlMapper;
import org.nl.wms.warehouse_management.service.util.UpdateIvtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
/**
* <p>
* 手持IOS 实现类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@Service
public class PdaIosOutServiceImpl implements PdaIosOutService {
/**
* 载具扩展属性服务
*/
@Autowired
private MdPbStoragevehicleextMapper mdPbStoragevehicleextMapper;
/**
* 点位服务
*/
@Autowired
private ISchBasePointService iSchBasePointService;
/**
* 仓位服务
*/
@Autowired
private IStructattrService iStructattrService;
/**
* 出入库单明细mapper
*/
@Autowired
private IOStorInvDtlMapper ioStorInvDtlMapper;
/**
* 出入库单分配明细mapper
*/
@Autowired
private IOStorInvDisMapper ioStorInvDisMapper;
/**
* 更新库存服务
*/
@Autowired
private UpdateIvtUtils updateIvtUtils;
/**
* 回库任务类
*/
@Autowired
private BackInTask backInTask;
/**
* 入库服务服务
*/
@Autowired
private IRawAssistIStorService iRawAssistIStorService;
@Override
public PdaResponse getDtl(JSONObject whereJson) {
return PdaResponse.requestParamOk(mdPbStoragevehicleextMapper.getIosDtl(whereJson));
}
@Override
@Transactional
public PdaResponse confirm(JSONObject whereJson) {
// 获取点位信息
SchBasePoint pointDao = iSchBasePointService.getById(whereJson.getString("point_code"));
if (ObjectUtil.isEmpty(pointDao)) {
throw new BadRequestException("当前点位不存在!!");
}
// 获取出入库单明细信息
IOStorInvDis disDao = ioStorInvDisMapper.selectById(pointDao.getIos_id());
if(ObjectUtil.isEmpty(disDao)) {
throw new BadRequestException("未查询到出库单分配明细!");
}
IOStorInvDtl dtlDao = ioStorInvDtlMapper.selectById(disDao.getIostorinvdtl_id());
// 获取点位库存信息
JSONObject jsonIvt = mdPbStoragevehicleextMapper.getIosDtl(whereJson).get(0);
if (ObjectUtil.isEmpty(jsonIvt)) {
throw new BadRequestException("当前点位没有库存信息!");
}
// 判断是否整出
double plan_qty = dtlDao.getPlan_qty().doubleValue();
double real_qty = NumberUtil.add(dtlDao.getReal_qty(), jsonIvt.getDoubleValue("qty")).doubleValue();
if (plan_qty >= real_qty) {
// ------整出------
// 删除当前库存记录
mdPbStoragevehicleextMapper.deleteById(jsonIvt.getString("storagevehicleext_id"));
// 释放点位
iSchBasePointService.unLockPoint(pointDao.getPoint_code());
// 更新明细实际出库重量
dtlDao.setReal_qty(BigDecimal.valueOf(real_qty));
ioStorInvDtlMapper.updateById(dtlDao);
// 更新分配明细实际出库数量
disDao.setReal_qty(jsonIvt.getBigDecimal("qty"));
ioStorInvDisMapper.updateById(disDao);
} else {
// ------剩余回库------
// 更新库存 ：变动数量 = 减可用(库存数量-（实际出库数量-计划数量）)
jsonIvt.put("type", IOSConstant.UPDATE_IVT_TYPE_SUB_CANUSE_IVT);
BigDecimal change_qty = NumberUtil.sub(jsonIvt.getBigDecimal("qty"), NumberUtil.sub(real_qty, plan_qty));
jsonIvt.put("change_qty", change_qty);
jsonIvt.put("remark", "剩余回库");
updateIvtUtils.updateIvt(jsonIvt);
// 更新明细实际出库重量（明细计划数量）
dtlDao.setReal_qty(BigDecimal.valueOf(plan_qty));
ioStorInvDtlMapper.updateById(dtlDao);
// 更新分配明细实际出库重量 = 变动数量
disDao.setReal_qty(change_qty);
ioStorInvDisMapper.updateById(disDao);
// 查找入库货位
JSONObject paramPoint = new JSONObject();
paramPoint.put("sect_id", disDao.getSect_id());
paramPoint.put("storagevehicle_code", jsonIvt.getString("storagevehicle_code"));
Structattr attrDao = iRawAssistIStorService.autoDis(paramPoint);
// 生成回库任务
JSONObject task = new JSONObject();
task.put("config_code", IOSConstant.BACK_IN_TASK);
task.put("point_code1", pointDao.getPoint_code());
task.put("point_code2", attrDao.getStruct_code());
task.put("vehicle_code", jsonIvt.getString("storagevehicle_code"));
task.put("Priority", TaskEnum.ACS_PRIORITY.code("1"));
String task_id = backInTask.create(task);
// 更新终点锁定状态
attrDao.setLock_type(IOSEnum.LOCK_TYPE.code("入库锁"));
attrDao.setTaskdtl_id(task_id);
iStructattrService.updateById(attrDao);
// 更新起点绑定id
iSchBasePointService.update(
new UpdateWrapper<SchBasePoint>().lambda()
.set(SchBasePoint::getIos_id, null)
.eq(SchBasePoint::getPoint_code, pointDao.getPoint_code())
);
}
return PdaResponse.requestOk();
}
}

56
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/sch_manage/controller/PdaSchPointController.java
View File

@@ -1,56 +0,0 @@
package org.nl.wms.pda.sch_manage.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.sch_manage.service.PdaSchPointService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 手持点位操作 控制层
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/schPoint")
@Slf4j
public class PdaSchPointController {
@Autowired
private PdaSchPointService pdaSchPointService;
@PostMapping("/getPoint")
@Log("查询点位信息")
@SaIgnore
public ResponseEntity<Object> getPoint(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaSchPointService.getPoint(whereJson), HttpStatus.OK);
}
@PostMapping("/binding")
@Log("解绑")
@SaIgnore
public ResponseEntity<Object> binding(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaSchPointService.binding(whereJson), HttpStatus.OK);
}
@PostMapping("/dissect")
@Log("绑定")
@SaIgnore
public ResponseEntity<Object> dissect(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(pdaSchPointService.dissect(whereJson), HttpStatus.OK);
}
}

49
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/sch_manage/service/PdaSchPointService.java
View File

@@ -1,49 +0,0 @@
package org.nl.wms.pda.sch_manage.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.IService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.sch_manage.service.dao.SchBasePoint;
/**
* <p>
* 手持点位操作 服务类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
public interface PdaSchPointService extends IService<SchBasePoint> {
/**
* 查询点位信息
* @param whereJson {
* point_code： 点位编码
* }
* @return PdaResponse
*/
PdaResponse getPoint(JSONObject whereJson);
/**
* 解绑
* @param whereJson {
* point_code: 点位编码
* point_name: 点位名称
* storagevehicle_code: 载具编码
* }
* @return PdaResponse
*/
PdaResponse binding(JSONObject whereJson);
/**
* 绑定
* @param whereJson {
* point_code: 点位编码
* point_name: 点位名称
* storagevehicle_code: 载具编码
* }
* @return PdaResponse
*/
PdaResponse dissect(JSONObject whereJson);
}

63
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/sch_manage/service/impl/PdaSchPointServiceImpl.java
View File

@@ -1,63 +0,0 @@
package org.nl.wms.pda.sch_manage.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.nl.wms.basedata_manage.service.IMdPbStoragevehicleinfoService;
import org.nl.wms.pda.sch_manage.service.PdaSchPointService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.sch_manage.service.dao.SchBasePoint;
import org.nl.wms.sch_manage.service.dao.mapper.SchBasePointMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* <p>
* 手持点位操作 实现类
* </p>
*
* @author Liuxy
* @since 2025-06-06
*/
@Service
public class PdaSchPointServiceImpl extends ServiceImpl<SchBasePointMapper, SchBasePoint> implements PdaSchPointService {
/**
* 载具信息服务
*/
@Autowired
private IMdPbStoragevehicleinfoService iMdPbStoragevehicleinfoService;
@Override
public PdaResponse getPoint(JSONObject whereJson) {
SchBasePoint pointDao = this.getById(whereJson.getString("point_code"));
pointDao.setStoragevehicle_code(pointDao.getVehicle_code());
return PdaResponse.requestParamOk(pointDao);
}
@Override
@Transactional
public PdaResponse binding(JSONObject whereJson) {
this.update(
new UpdateWrapper<SchBasePoint>().lambda()
.eq(SchBasePoint::getPoint_code, whereJson.getString("point_code"))
.set(SchBasePoint::getVehicle_code, null)
.set(SchBasePoint::getIos_id, null)
);
return PdaResponse.requestOk();
}
@Override
@Transactional
public PdaResponse dissect(JSONObject whereJson) {
// 判断载具是否存在
iMdPbStoragevehicleinfoService.getByCode(whereJson.getString("storagevehicle_code"));
this.update(
new UpdateWrapper<SchBasePoint>().lambda()
.eq(SchBasePoint::getPoint_code, whereJson.getString("point_code"))
.set(SchBasePoint::getVehicle_code, whereJson.getString("storagevehicle_code"))
);
return PdaResponse.requestOk();
}
}

17
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm_manage/service/impl/PdmBomCallMaterialDtlServiceImpl.java
View File

@@ -4,6 +4,7 @@ import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -23,10 +24,14 @@ import org.nl.wms.pdm_manage.service.dto.PdmBomCallMaterialDtlDto;
import org.nl.wms.sch_manage.service.ISchBasePointService;
import org.nl.wms.sch_manage.service.dao.SchBasePoint;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.mapper.GroupPlateMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
@@ -65,6 +70,12 @@ public class PdmBomCallMaterialDtlServiceImpl extends ServiceImpl<PdmBomCallMate
@Autowired
private WmsToAcsService wmsToAcsService;
/*
* 组盘记录服务
*/
@Resource
private GroupPlateMapper groupPlateMapper;
@Override
public IPage<PdmBomCallMaterialDtlDto> queryAll(Map whereJson, PageQuery page) {
return this.baseMapper.queryAllByPage(new Page<>(page.getPage() + 1, page.getSize()),
@@ -134,5 +145,11 @@ public class PdmBomCallMaterialDtlServiceImpl extends ServiceImpl<PdmBomCallMate
// 更新叫料单状态
iPdmBomCallMaterialService.updateStatus(bomDao.getBom_id());
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, dto.getVehicle_code())
);
}
}

18
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/BackOutTask.java
View File

@@ -3,6 +3,7 @@ package org.nl.wms.sch_manage.service.util.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.nl.common.exception.BadRequestException;
@@ -21,7 +22,9 @@ import org.nl.wms.sch_manage.service.util.TaskType;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IOutBillService;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDis;
import org.nl.wms.warehouse_management.service.dao.mapper.GroupPlateMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDisMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -31,7 +34,7 @@ import javax.annotation.Resource;
/**
* <p>
* 退货出库出库任务类
* 退货出库任务类
* </p>
*
* @author Liuxy
@@ -71,6 +74,12 @@ public class BackOutTask extends AbstractTask {
@Resource
private PdaPointTask pdaPointTask;
/*
* 组盘记录服务
*/
@Resource
private GroupPlateMapper groupPlateMapper;
@Override
public String create(JSONObject json) {
SchBaseTask task = new SchBaseTask();
@@ -212,6 +221,13 @@ public class BackOutTask extends AbstractTask {
@Override
public void taskConfirm(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, taskObj.getVehicle_code())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
);
// 判断point_code3是否有值; 有值需要生成点位点任务到库外站点
if (ObjectUtil.isNotEmpty(taskObj.getPoint_code3())) {
createAgvTask(taskObj);

25
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/EmpVehicleInTask.java
View File

@@ -3,6 +3,7 @@ package org.nl.wms.sch_manage.service.util.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.CodeUtil;
@@ -21,6 +22,8 @@ import org.nl.wms.sch_manage.service.util.AcsTaskDto;
import org.nl.wms.sch_manage.service.util.TaskType;
import org.nl.wms.warehouse_management.enums.IOSConstant;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.mapper.GroupPlateMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -57,6 +60,12 @@ public class EmpVehicleInTask extends AbstractTask {
@Resource
private ISchBasePointService iSchBasePointService;
/*
* 组盘记录服务
*/
@Resource
private GroupPlateMapper groupPlateMapper;
@Override
public String create(JSONObject json) {
SchBaseTask task = new SchBaseTask();
@@ -142,10 +151,6 @@ public class EmpVehicleInTask extends AbstractTask {
this.cancelTask(taskObj);
}
@Override
public void taskConfirm(String task_code) {
}
@Transactional
public void finishTask(SchBaseTask taskObj) {
// 更新起点
@@ -169,6 +174,7 @@ public class EmpVehicleInTask extends AbstractTask {
taskObj.setRemark("已完成");
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskService.updateById(taskObj);
this.taskConfirm(taskObj.getTask_code());
}
@Transactional
@@ -186,4 +192,15 @@ public class EmpVehicleInTask extends AbstractTask {
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskService.updateById(taskObj);
}
@Override
public void taskConfirm(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, taskObj.getVehicle_code())
);
}
}

17
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/HandOutTask.java
View File

@@ -3,6 +3,7 @@ package org.nl.wms.sch_manage.service.util.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.nl.common.exception.BadRequestException;
@@ -20,7 +21,9 @@ import org.nl.wms.sch_manage.service.util.AcsTaskDto;
import org.nl.wms.sch_manage.service.util.TaskType;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IOutBillService;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDis;
import org.nl.wms.warehouse_management.service.dao.mapper.GroupPlateMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDisMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -64,6 +67,12 @@ public class HandOutTask extends AbstractTask {
@Resource
private ISchBasePointService iSchBasePointService;
/*
* 组盘记录服务
*/
@Resource
private GroupPlateMapper groupPlateMapper;
@Override
public String create(JSONObject json) {
SchBaseTask task = new SchBaseTask();
@@ -198,5 +207,13 @@ public class HandOutTask extends AbstractTask {
@Override
public void taskConfirm(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, taskObj.getVehicle_code())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
);
}
}

5
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/GroupPlate.java
View File

@@ -100,6 +100,11 @@ public class GroupPlate implements Serializable {
*/
private String box_type;
/**
* 工单信息
*/
private String bom_id;
/**
* 组盘人
*/

2
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/IOStorInvMapper.xml
View File

@@ -100,7 +100,7 @@
LEFT JOIN md_me_materialbase mb ON mb.material_id = dtl.material_id
LEFT JOIN ST_IVT_IOStorInv mst ON mst.iostorinv_id = dtl.iostorinv_id
LEFT JOIN md_pb_groupplate late ON mb.material_id = late.material_id
AND dtl.pcsn = late.pcsn AND late.status = '1'
AND dtl.pcsn = late.pcsn AND late.status = '1' AND dtl.plan_qty = late.qty
where
1=1
<if test="params.bill_code != null and params.bill_code != ''">

54
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/OutBillServiceImpl.java
View File

@@ -1202,25 +1202,14 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
//查询明细信息
IOStorInvDtl ioStorInvDtl = ioStorInvDtlMapper.selectById(ioStorInvDis.getIostorinvdtl_id());
// 如果单据类型为：质检出库、领料出库、烘干出库则更新为出库，否则删除组盘记录
if (ioStorInvDtl.getIs_check().equals(IOSConstant.ONE)) {
groupPlateMapper.update(new GroupPlate(), new LambdaUpdateWrapper<>(GroupPlate.class)
.set(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
} else {
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
}
// 更新组盘信息为出库
groupPlateMapper.update(new GroupPlate(), new LambdaUpdateWrapper<>(GroupPlate.class)
.set(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
}
@@ -1297,25 +1286,14 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
updateIvtList.add(jsonIvt);
iMdPbStoragevehicleextService.updateIvt(updateIvtList);
// 如果单据类型为：质检出库、领料出库、烘干出库则更新为出库，否则删除组盘记录
if (ioStorInvDtl.getIs_check().equals(IOSConstant.ONE)) {
groupPlateMapper.update(new GroupPlate(), new LambdaUpdateWrapper<>(GroupPlate.class)
.set(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
} else {
// 删除组盘信息
groupPlateMapper.delete(
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
}
// 更新组盘信息为出库
groupPlateMapper.update(new GroupPlate(), new LambdaUpdateWrapper<>(GroupPlate.class)
.set(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
.eq(GroupPlate::getPcsn, ioStorInvDis.getPcsn())
.eq(GroupPlate::getStoragevehicle_code, ioStorInvDis.getStoragevehicle_code())
.eq(GroupPlate::getMaterial_id, ioStorInvDis.getMaterial_id())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库"))
);
// 查询该明细下是否还有未完成的分配明细
int countDis = ioStorInvDisMapper.selectCount(new LambdaQueryWrapper<>(IOStorInvDis.class)

13
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/SelectOutServiceImpl.java
View File

@@ -212,7 +212,7 @@ public class SelectOutServiceImpl extends ServiceImpl<IOStorInvDtlMapper, IOStor
new QueryWrapper<GroupPlate>().lambda()
.eq(GroupPlate::getStoragevehicle_code, dto.getSelect_vehicle())
.eq(GroupPlate::getMaterial_id, disDao.getMaterial_id())
.eq(GroupPlate::getPcsn, dto.getPcsn())
.eq(GroupPlate::getPcsn, dto.getSelect_pcsn())
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库"))
);
// 新增组盘信息
@@ -229,9 +229,16 @@ public class SelectOutServiceImpl extends ServiceImpl<IOStorInvDtlMapper, IOStor
groupPlate.setBake_num(oldGroup.getBake_num());
groupPlate.setQuality_type(oldGroup.getQuality_type());
iMdPbGroupplateService.create(groupPlate);
// 更新叫料明细载具信息
iPdmBomCallMaterialDtlService.update(
new UpdateWrapper<PdmBomCallMaterialDtl>().lambda()
.set(PdmBomCallMaterialDtl::getVehicle_code,dto.getNew_vehicle())
.eq(PdmBomCallMaterialDtl::getOut_dis_id, disDao.getIostorinvdis_id())
);
}
// 删除其他组盘信息
/*// 删除其他组盘信息
List<IOStorInvDis> deleteGroupDisList = ioStorInvDisMapper.selectList(
new QueryWrapper<IOStorInvDis>().lambda()
.eq(IOStorInvDis::getIostorinvdtl_id, dto.getIostorinvdtl_id())
@@ -252,7 +259,7 @@ public class SelectOutServiceImpl extends ServiceImpl<IOStorInvDtlMapper, IOStor
}
if (ObjectUtil.isNotEmpty(deleteGroupSet)) {
iMdPbGroupplateService.delete(deleteGroupSet);
}
}*/
// 组织主表数据
Map<String, Object> jsonMst = new HashMap<>();

23
wms/nladmin-ui/src/views/wms/pdm/callmaterialdtl/index.vue
View File

@@ -100,6 +100,17 @@
>
退料确认
</el-button>
<el-button
slot="right"
class="filter-item"
type="primary"
icon="el-icon-check"
size="mini"
:disabled="crud.selections.length !== 1"
@click="empConfirm"
>
空料确认
</el-button>
</crudOperation>
<!--表格渲染-->
<el-table
@@ -136,7 +147,7 @@
<script>
import crudCallMaterialDtl from '@/views/wms/pdm/callmaterialdtl/callmaterialdtl'
import WeighDialog from '@/views/wms/pdm/callmaterialdtl/WeighDialog'
import CRUD, {crud, form, header, presenter} from '@crud/crud'
import CRUD, { crud, form, header, presenter } from '@crud/crud'
import crudOperation from '@crud/CRUD.operation'
import udOperation from '@crud/UD.operation'
import pagination from '@crud/Pagination'
@@ -219,6 +230,16 @@ export default {
this.crud.notify('操作成功！', CRUD.NOTIFICATION_TYPE.SUCCESS)
this.crud.toQuery()
})
},
empConfirm() {
const data = this.$refs.table.selection[0]
if (data.bom_status === '2') {
this.crud.notify('当前明细已确认！', CRUD.NOTIFICATION_TYPE.ERROR)
}
crudCallMaterialDtl.confirm(data).then(res => {
this.crud.notify('操作成功！', CRUD.NOTIFICATION_TYPE.SUCCESS)
this.crud.toQuery()
})
}
}
}