package com.vincent.rsf.server.api.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.controller.erp.params.ReportDataParam;
|
import com.vincent.rsf.server.api.controller.erp.params.ReportParams;
|
import com.vincent.rsf.server.api.controller.erp.params.SaveCheckDiffParams;
|
import com.vincent.rsf.server.api.service.PdaCheckOrderService;
|
import com.vincent.rsf.server.api.service.ReportMsgService;
|
import com.vincent.rsf.server.common.utils.FieldsUtils;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.*;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.system.constant.DictTypeCode;
|
import com.vincent.rsf.server.system.entity.DictData;
|
import com.vincent.rsf.server.system.entity.FieldsItem;
|
import com.vincent.rsf.server.system.entity.User;
|
import com.vincent.rsf.server.system.service.DictDataService;
|
import com.vincent.rsf.server.system.service.DictTypeService;
|
import com.vincent.rsf.server.system.service.FieldsItemService;
|
import com.vincent.rsf.server.system.service.UserService;
|
import com.vincent.rsf.server.system.service.impl.FieldsItemServiceImpl;
|
import com.vincent.rsf.server.system.service.impl.UserServiceImpl;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
@Service
|
public class PdaCheckOrderServiceImpl implements PdaCheckOrderService {
|
|
@Autowired
|
private CheckDiffService checkDiffService;
|
|
@Autowired
|
private CheckDiffItemService checkDiffItemService;
|
|
@Autowired
|
private TaskService taskService;
|
|
@Autowired
|
private TaskItemService taskItemService;
|
@Autowired
|
private DictTypeService dictTypeService;
|
@Autowired
|
private DictDataService dictDataService;
|
@Autowired
|
private MatnrService matnrService;
|
@Autowired
|
private FieldsItemService fieldsItemService;
|
@Autowired
|
private ReportMsgService reportMsgService;
|
@Autowired
|
private UserService userService;
|
|
|
@Override
|
public R getCheckList(String code) {
|
LambdaQueryWrapper<CheckDiff> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(!Cools.isEmpty(code), CheckDiff::getOrderCode, code);
|
List<CheckDiff> waveList = checkDiffService.list(lambdaQueryWrapper);
|
return R.ok(waveList);
|
|
}
|
|
@Override
|
public R getCheckTaskItemList(String barcode, String checkCode) {
|
|
List<CheckDiffItem> checkDiffItems = checkDiffItemService.list(new LambdaQueryWrapper<CheckDiffItem>()
|
.eq(CheckDiffItem::getBarcode, barcode)
|
.eq(CheckDiffItem::getExceStatus, CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_INIT.val)
|
.eq(CheckDiffItem::getOrderCode, checkCode)
|
);
|
if (checkDiffItems.isEmpty()) {
|
throw new CoolException("此条码不在当前盘点单中");
|
}
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
return R.ok(checkDiffItems);
|
}
|
|
@Override
|
public R getCheckDiffReasonList() {
|
List<DictData> list = dictDataService.list(new LambdaQueryWrapper<DictData>()
|
.eq(DictData::getDictTypeCode, DictTypeCode.SYS_CHECK_DIFF_REASON)
|
);
|
return R.ok(list);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R saveCheckDiff(SaveCheckDiffParams params, Long loginUserId) {
|
CheckDiff checkDiff = checkDiffService.getById(params.getCheckId());
|
if (null == checkDiff) {
|
return R.error("未找到盘点差异单");
|
}
|
if (checkDiff.getExceStatus().equals(CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_END.val)) {
|
return R.error("该盘点单已完成");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, params.getContainer()));
|
if (null == task) {
|
throw new CoolException("数据错误，未找到容器码对应盘点任务");
|
}
|
for (CheckDiffItem ckDiffItem : params.getCheckDiffItems()) {
|
CheckDiffItem diffItem = new CheckDiffItem();
|
if (Objects.isNull(ckDiffItem.getId())) {
|
BeanUtils.copyProperties(ckDiffItem, diffItem);
|
diffItem.setCheckId(params.getCheckId())
|
.setOrderCode(checkDiff.getOrderCode())
|
.setTaskId(task.getId())
|
.setBarcode(task.getBarcode())
|
.setAnfme(ckDiffItem.getCheckQty());
|
|
Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, diffItem.getMatnrCode()));
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("单据物料名称不存在！！");
|
}
|
|
if (!checkDiffItemService.save(diffItem)) {
|
throw new CoolException("新增明细保存失败！！");
|
}
|
//新增任务明细信息
|
TaskItem taskItem = new TaskItem();
|
BeanUtils.copyProperties(diffItem, diffItem);
|
taskItem.setTaskId(task.getId())
|
.setOrderType(OrderType.ORDER_CHECK.type)
|
.setSourceCode(diffItem.getOrderCode())
|
.setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_CHECK.type))
|
.setAnfme(diffItem.getCheckQty())
|
.setWorkQty(0.0)
|
.setBatch(diffItem.getBatch())
|
.setMaktx(matnr.getName())
|
.setMatnrCode(diffItem.getMatnrCode())
|
.setSpec(diffItem.getSpec())
|
.setModel(diffItem.getModel())
|
.setMatnrId(matnr.getId())
|
.setCreateBy(loginUserId)
|
//漏盘库存，新增没有盘点单明细ID
|
.setSource(diffItem.getId())
|
.setSourceId(params.getCheckId())
|
.setCreateTime(new Date())
|
.setUpdateBy(loginUserId)
|
.setMemo("不在库明细，盘漏新增")
|
.setUpdateTime(new Date())
|
.setId(null)
|
//盘点单ID
|
.setOrderId(checkDiff.getOrderId());
|
if (!taskItemService.save(taskItem)) {
|
throw new CoolException("新增盘点明细保存失败！！");
|
}
|
|
diffItem.setTaskItemId(taskItem.getId()).setExceStatus(CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_HOLD.val);
|
|
if (!checkDiffItemService.updateById(diffItem)) {
|
throw new CoolException("明细修改失败！！");
|
}
|
} else {
|
diffItem = checkDiffItemService.getById(ckDiffItem.getId());
|
if (null == diffItem) {
|
return R.error("数据错误，未找到差异单明细");
|
}
|
diffItem.setCheckQty(ckDiffItem.getCheckQty()).setReason(ckDiffItem.getReason()).setMemo(ckDiffItem.getMemo());
|
|
diffItem.setExceStatus(CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_HOLD.val);
|
if (!checkDiffItemService.updateById(diffItem)) {
|
throw new CoolException("更新差异单明细失败");
|
}
|
|
if (!taskItemService.update(new LambdaUpdateWrapper<TaskItem>()
|
.set(TaskItem::getAnfme, diffItem.getCheckQty())
|
.eq(TaskItem::getId, diffItem.getTaskItemId()))) {
|
throw new CoolException("任务数量修改失败！！");
|
}
|
}
|
}
|
|
List<CheckDiffItem> diffItems = checkDiffItemService.list(new LambdaQueryWrapper<CheckDiffItem>()
|
.eq(CheckDiffItem::getCheckId, checkDiff.getId()));
|
if (diffItems.isEmpty()) {
|
throw new CoolException("盘点差异单明细不存在！！");
|
}
|
Double sum = diffItems.stream().mapToDouble(CheckDiffItem::getCheckQty).sum();
|
checkDiff.setExceStatus(CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_HOLD.val).setCheckQty(sum);
|
if (!checkDiffService.updateById(checkDiff)) {
|
throw new CoolException("更新差异单失败");
|
}
|
|
task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
|
task.setUpdateBy(loginUserId);
|
task.setUpdateTime(new Date());
|
if (!taskService.updateById(task)) {
|
throw new CoolException("更新任务失败");
|
}
|
return R.ok("盘点完成");
|
}
|
|
@Override
|
public R selectAddMatnr(Map<String, String> map) {
|
String matnrCode = map.get("matnr");
|
if (Cools.isEmpty(matnrCode)) {
|
return R.error("物料码为空");
|
}
|
Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, matnrCode));
|
if (null == matnr) {
|
return R.error("未找到编码对应的明细");
|
}
|
CheckDiffItem checkDiffItem = new CheckDiffItem()
|
.setMatnrCode(matnr.getCode())
|
.setMaktx(matnr.getName())
|
.setAnfme(0D)
|
.setCheckQty(0D);
|
return R.ok(checkDiffItem);
|
}
|
|
@Override
|
public R getCheckTaskItemList2(String barcode) {
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (Cools.isEmpty(taskItems)) {
|
throw new CoolException("未找到该容器码对应的任务明细");
|
}
|
String sourceCode = taskItems.stream().findFirst().map(TaskItem::getSourceCode).orElse(null);
|
CheckDiff checkDiff = checkDiffService.getOne(new LambdaQueryWrapper<CheckDiff>().eq(CheckDiff::getOrderCode, sourceCode));
|
if (null == checkDiff) {
|
return R.error("未找到盘点差异单");
|
}
|
List<CheckDiffItem> checkDiffItems = checkDiffItemService.list(new LambdaQueryWrapper<CheckDiffItem>()
|
.eq(CheckDiffItem::getBarcode, barcode)
|
.eq(CheckDiffItem::getExceStatus, CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_INIT.val)
|
.eq(CheckDiffItem::getOrderCode, sourceCode)
|
);
|
if (checkDiffItems.isEmpty()) {
|
throw new CoolException("此条码不在当前盘点单中");
|
}
|
|
return R.ok(Cools.add("checkDiffItems", checkDiffItems).add("checkDiff", checkDiff));
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/11/5
|
* @description: 希日无单据临时盘点
|
* @version 1.0
|
*/
|
@Override
|
public R tempCheckItem(String barcode) {
|
if (Objects.isNull(barcode)) {
|
throw new CoolException("搬盘码不能为空！！");
|
}
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (Cools.isEmpty(taskItems)) {
|
throw new CoolException("未找到该容器码对应的任务明细");
|
}
|
taskItems.forEach(taskItem -> {
|
if (!Objects.isNull(taskItem.getFieldsIndex())) {
|
Map<String, String> fields = FieldsUtils.getFields(taskItem.getFieldsIndex());
|
taskItem.setExtendFields(fields);
|
}
|
});
|
|
return R.ok().add(taskItems);
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/11/5
|
* @description: 盘点添加新物料
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R confirmMatnr(Map<String, Object> map) {
|
if (Objects.isNull(map)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
if (Objects.isNull(map.get("barcode"))) {
|
throw new CoolException("托盘码不能为空！！");
|
}
|
if (Objects.isNull(map.get("matnrs"))) {
|
throw new CoolException("新增物料不能为空！！");
|
}
|
String barcode = map.get("barcode").toString();
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
|
List<CheckDiffItem> items = JSONArray.parseArray(JSONArray.toJSONString(map.get("matnrs")), CheckDiffItem.class);
|
List<TaskItem> taskItems = new ArrayList<>();
|
|
TaskItem item1 = taskItemService.getOne(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()).last("limit 1"));
|
|
items.forEach(item -> {
|
TaskItem taskItem = new TaskItem();
|
if (!Objects.isNull(item1)) {
|
BeanUtils.copyProperties(item1, taskItem);
|
}
|
Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, item.getMatnrCode()));
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("物料信息不存在 ！！");
|
}
|
|
taskItem.setTaskId(task.getId())
|
.setId(null)
|
.setFieldsIndex(null)
|
.setMatnrId(matnr.getId())
|
.setBatch(item.getBatch())
|
.setMemo(item.getMemo())
|
.setMatnrCode(matnr.getCode())
|
.setMaktx(matnr.getName())
|
.setAnfme(item.getCheckQty());
|
|
FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, item.getFieldsIndex()).last("limit 1"));
|
if (Objects.isNull(fieldsItem)) {
|
throw new CoolException("当前票号不存在库存中，请拿出后重新入库！！");
|
}
|
taskItem.setFieldsIndex(fieldsItem.getUuid());
|
|
taskItems.add(taskItem);
|
});
|
|
if (!taskItemService.saveBatch(taskItems)) {
|
throw new CoolException("新增盘点物料失败！！");
|
}
|
|
return R.ok();
|
}
|
|
/**
|
* @param map
|
* @return com.vincent.rsf.framework.common.R
|
* @author Ryan
|
* 临时盘点提交ERP修改
|
* @date 2025/11/5 20:49
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R tempCheckConfirm(Map<String, Object> map) {
|
if (Objects.isNull(map)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
if (Objects.isNull(map.get("barcode"))) {
|
throw new CoolException("托盘码不能为空！！");
|
}
|
if (Objects.isNull(map.get("items"))) {
|
throw new CoolException("新增物料不能为空！！");
|
}
|
String barcode = map.get("barcode").toString();
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
|
task.setTaskStatus(TaskStsType.GENERATE_IN.id)
|
.setTargLoc(task.getOrgLoc())
|
.setTaskType(TaskType.TASK_TYPE_CHECK_IN.type)
|
.setUpdateTime(new Date());
|
|
if (!taskService.updateById(task)) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
|
uploadCheckResult(task);
|
|
return R.ok("提交成功");
|
}
|
|
|
/**
|
* 上传盘点结果
|
* @author Ryan
|
* @date 2025/11/5 21:50
|
* @param task
|
*/
|
public void uploadCheckResult(Task task) {
|
if (Objects.isNull(task)) {
|
throw new CoolException("任务不能为空！！");
|
}
|
ReportParams params = new ReportParams();
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (Objects.isNull(taskItems) || taskItems.isEmpty()) {
|
throw new CoolException("托盘明细为空！1");
|
}
|
List<ReportDataParam> reportDataParams = new ArrayList<>();
|
taskItems.forEach(taskItem -> {
|
ReportDataParam dataParam = new ReportDataParam();
|
|
User user = userService.getById(taskItem.getUpdateBy());
|
String nickName = null;
|
if (!Objects.isNull(user)) {
|
nickName = user.getNickname();
|
}
|
//获取索引内容
|
Map<String, String> fields = FieldsUtils.getFields(taskItem.getFieldsIndex());
|
//设置通用参数
|
dataParam.setItemCode(taskItem.getMatnrCode())
|
.setPDQty(taskItem.getAnfme())
|
.setEditUser(nickName)
|
.setEditDate(taskItem.getUpdateTime())
|
.setGoodsNO(fields.get("crushNo"))
|
.setIsBad(0 + "")
|
.setMemoDtl(taskItem.getMemo());
|
|
reportDataParams.add(dataParam);
|
});
|
|
params.setOrderType("PD_stock").setAction("Update").setData(reportDataParams);
|
|
reportMsgService.uploadCheckOrder(params);
|
}
|
|
}
|
