no message

Ryan

2025-04-03 391e56cca8fc835791358ff32e63b1da6574462d

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/MobileServiceImpl.java

@@ -4,13 +4,9 @@
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.params.CheckObjParams;
import com.vincent.rsf.server.api.controller.params.OtherReceiptParams;
import com.vincent.rsf.server.api.controller.params.ReceiptParams;
import com.vincent.rsf.server.api.entity.dto.CheckObjDto;
import com.vincent.rsf.server.api.entity.dto.InspectDetlDto;
import com.vincent.rsf.server.api.entity.dto.InspectItemDto;
import com.vincent.rsf.server.api.entity.dto.ReceiptDetlsDto;
import com.vincent.rsf.server.api.controller.params.*;
import com.vincent.rsf.server.api.entity.dto.*;
import com.vincent.rsf.server.api.entity.enums.OrderType;
import com.vincent.rsf.server.api.entity.enums.OrderWorkType;
import com.vincent.rsf.server.api.service.MobileService;
import com.vincent.rsf.server.common.config.ConfigProperties;
@@ -32,22 +28,20 @@
import com.vincent.rsf.server.system.mapper.TenantMapper;
import com.vincent.rsf.server.system.mapper.UserMapper;
import com.vincent.rsf.server.system.service.FieldsItemService;
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.service.UserLoginService;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import org.apache.tika.utils.StringUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Ryan
@@ -100,13 +94,28 @@

    @Autowired
    private WaitPakinItemService waitPakinItemService;

    @Autowired
    private AsnOrderItemLogService asnOrderItemLogService;

    @Autowired
    private FieldsItemService fieldsItemService;

    @Autowired
    private LocService locService;
    @Autowired
    private PurchaseService purchaseService;
    @Autowired
    private StockService stockService;
    @Autowired
    private StockItemService stockItemService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskItemService taskItemService;
    @Autowired
    private LocAreaMatRelaMapper locAreaMatRelaMapper;
    @Autowired
    private LocAreaRelaMapper locAreaRelaMapper;
    @Autowired
    private LocAreaMapper locAreaMapper;

    /**
     * @author Ryan
@@ -152,7 +161,7 @@
     */
    @Override
    public R getOrderByCode(String barcode) {
        if (StringUtils.isEmpty(barcode)) {
        if (StringUtils.isBlank(barcode)) {
            return R.error("标签码不能为空！！");
        }
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getTrackCode, barcode));
@@ -193,7 +202,7 @@
        List<ReceiptDetlsDto> receipts = params.getReceipts();
        List<WarehouseAreasItem> allOrders = new ArrayList<>();

        double receiptQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getReceiptQty).sum();
        Double receiptQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getReceiptQty).sum();

        String asnCode = receipts.stream().findFirst().get().getAsnCode();

@@ -202,7 +211,9 @@
        if (Objects.isNull(asnOrder)) {
            throw new CoolException("数据错误：主单不存在！！");
        }
        asnOrder.setQty(receiptQty);
        /**收货数量累加，1. 会出超收情况 2. 会有收货不足情况*/
        Double rcptedQty = asnOrder.getQty() + receiptQty;
        asnOrder.setQty(rcptedQty);

        if (!asnOrderMapper.updateById(asnOrder)) {
            throw new CoolException("已收货数量修改失败！！");
@@ -226,40 +237,14 @@
            if (Objects.isNull(orderItem)) {
                throw new CoolException("通知单明细不存在！！");
            }
            if (Objects.isNull(dto.getReceiptQty()) || Double.compare(dto.getReceiptQty(), 0.0) == 0) {
                throw new CoolException("收货数量不能为零！！");
            }
            orderItem.setQty(dto.getReceiptQty())
                    .setProdTime(dto.getProdTime());

            if (asnOrderItemMapper.updateById(orderItem) < 1) {
                throw new CoolException("通知单明细数量修改失败！！");
            }

            WarehouseAreasItem item = new WarehouseAreasItem();
//            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            String format = null;
//            if (Objects.isNull(dto.getProdTime())) {
//                 format = dateFormat.format(dto.getProdTime());
//            if (Objects.isNull(dto.getReceiptQty()) || Double.compare(dto.getReceiptQty(), 0.0) == 0) {
//                throw new CoolException("收货数量不能为零！！");
//            }
            item.setBarcode(dto.getBarcode())
                    .setAreaName(areasItem.getName())
                    .setAreaId(areasItem.getId())
                    .setProdTime(dto.getProdTime())
                    .setWeight(dto.getWeigth())
            Double itemRcptQty = dto.getReceiptQty() + orderItem.getQty();
            orderItem.setQty(itemRcptQty)
                    .setSplrBatch(dto.getSplrBatch())
                    .setStockUnit(dto.getStockUnit())
                    .setBatch(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto))
                    .setAnfme(dto.getReceiptQty())
                    .setSplrBtch(dto.getSplrBatch())
                    .setMatnrCode(matnr.getCode())
                    .setMatnrId(matnr.getId())
                    .setMatnrName(matnr.getName())
                    //库存单位为最小单位
                    .setUnit(dto.getStockUnit())
                    .setStockUnit(dto.getStockUnit())
                    .setWeight(matnr.getWeight())
                    .setShipperId(matnr.getShipperId());
                    //TODO 供应商标识未设置，标识由PO单供应商编码转换
                    .setProdTime(dto.getProdTime());

            if (!Objects.isNull(fields)) {
                if (!Objects.isNull(dto.getExtendFields())) {
@@ -278,76 +263,65 @@
                                        .setValue(extendFields.get(key).toString())
                                        .setUuid(uuid16);
                                fieldsItems.add(fieldsItem);
                                //唯一标识入库
                                item.setFieldsIndex(uuid16);
                            }
                        });
                    });
                    if (!fieldsItemService.saveBatch(fieldsItems)) {
                        throw new CoolException("扩展字段保存失败！！");
                    }
                    orderItem.setFieldsIndex(uuid16);
                }
            }

            if (asnOrderItemMapper.updateById(orderItem) < 1) {
                throw new CoolException("通知单明细数量修改失败！！");
            }

            WarehouseAreasItem item = new WarehouseAreasItem();
//            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            String format = null;
//            if (Objects.isNull(dto.getProdTime())) {
//                 format = dateFormat.format(dto.getProdTime());
//            }
            item.setBarcode(dto.getBarcode())
                    .setAreaName(areasItem.getName())
                    .setAreaId(areasItem.getId())
                    .setProdTime(dto.getProdTime())
                    .setWeight(dto.getWeigth())
                    .setStockUnit(dto.getStockUnit())
                    .setBatch(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto))
                    .setAnfme(itemRcptQty)
                    .setSplrBtch(dto.getSplrBatch())
                    .setMatnrCode(matnr.getCode())
                    .setMatnrId(matnr.getId())
                    .setMatnrName(matnr.getName())
                    //库存单位为最小单位
                    .setUnit(dto.getStockUnit())
                    .setStockUnit(dto.getStockUnit())
                    .setWeight(matnr.getWeight())
                    .setFieldsIndex(orderItem.getFieldsIndex())
                    .setShipperId(matnr.getShipperId());
                    //TODO 供应商标识未设置，标识由PO单供应商编码转换


            allOrders.add(item);
        });

        if (!warehouseAreasItemService.saveBatch(allOrders)) {
            throw new CoolException("收货失败！！");
        }

        //获取采购数量
        double purQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getPurQty).sum();

        BigDecimal subtract = BigDecimal.valueOf(receiptQty).subtract(BigDecimal.valueOf(purQty));
        //判断已收货数量是否小于等于采购数量
        if (subtract.compareTo(new BigDecimal("0.0")) <= 0) {
            asnOrder.setRleStatus(Short.valueOf("1"));
            //日志表操作
            operateOrderLogs(asnOrder);
        }

//        //获取采购数量
//        double purQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getPurQty).sum();
//
//        BigDecimal subtract = BigDecimal.valueOf(receiptQty).subtract(BigDecimal.valueOf(purQty));
//        //判断已收货数量是否小于等于采购数量
//        if (subtract.compareTo(new BigDecimal("0.0")) <= 0) {
//            asnOrder.setRleStatus(Short.valueOf("1"));
//            //日志表操作
//            operateOrderLogs(asnOrder);
//        }
        return R.ok("操作成功");
    }

    /**
     * @author Ryan
     * @description 删除原主单及明细，加入历史档
     * @param
     * @return
     * @time 2025/3/19 19:53
     */
    private void operateOrderLogs(AsnOrder asnOrder) {
        if (!asnOrderMapper.removeById(asnOrder.getId())) {
            throw new CoolException("原单据删除失败！！");
        }

        AsnOrderLog orderLog = new AsnOrderLog();
        BeanUtils.copyProperties(asnOrder, orderLog);
        orderLog.setAsnId(asnOrder.getId());

        if (!asnOrderLogService.save(orderLog)) {
            throw new CoolException("主单历史档添加失败！！");
        }

        List<AsnOrderItemLog> logs = new ArrayList<>();
        List<AsnOrderItem> items = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, asnOrder.getId()));
        items.forEach(item -> {
            AsnOrderItemLog itemLog = new AsnOrderItemLog();
            BeanUtils.copyProperties(item, itemLog);
            itemLog.setAsnItemId(itemLog.getId())
                    .setAsnId(item.getAsnId());
            logs.add(itemLog);
        });

        if (!asnOrderItemLogService.saveBatch(logs)) {
            throw new CoolException("通知单明细历史档保存失败！！");
        }

        if (asnOrderItemMapper.delete(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, asnOrder.getId())) < 1) {
            throw new CoolException("原单据明细删除失败！！");
        }
    }


    /**
     * @author Ryan
@@ -559,6 +533,182 @@
    }

    /**
    * @author Ryan
    * @description 人工上架
    * @param
    * @return
    * @time 2025/4/2 16:33
    */
    @Override
    public R operateToStock(OpStockParams params) {
        if (org.apache.commons.lang3.StringUtils.isBlank(params.getBarcode())) {
            throw new CoolException("拖盘码不能为空！！");
        }
        if (StringUtils.isBlank(params.getAsnCode())) {
            throw new CoolException("单据不能为空！！");
        }
        if (StringUtils.isBlank(params.getMatnrCode())) {
            throw new CoolException("物料编码不能为空！！");
        }
        AsnOrder asnOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getCode, params.getAsnCode()));
        if (Objects.isNull(asnOrders)) {
            throw new CoolException("单据不存在！！");
        }
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, params.getBarcode()));
        if (!locs.isEmpty()) {
            throw new CoolException("拖盘已使用");
        }
        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, params.getBarcode()));
        if (!waitPakins.isEmpty()) {
            throw new CoolException("拖盘已使用!!");
        }
        AsnOrderItem orderItems = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, asnOrders.getId())
                .eq(AsnOrderItem::getMatnrCode, params.getMatnrCode()));
        if (Objects.isNull(orderItems)) {
            return R.ok(null);
        }
        orderItems.setBarcode(params.getBarcode());

        return R.ok(orderItems);
    }

    /**
     * 人工上架入库
     *
     * @param params
     * @param loginUserId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R publicToStock(PublicToStockParams params, Long loginUserId) {
        if (Objects.isNull(params.getLocCode()) || StringUtils.isBlank(params.getLocCode())) {
            throw new CoolException("库位不能为空！！");
        }
        if (Objects.isNull(params.getItemList()) || params.getItemList().isEmpty()) {
            throw new CoolException("单据明细不能为空！！");
        }
        Long OrderId = params.getItemList().stream().findFirst().get().getAsnId();
        /**获取平库订单*/
        AsnOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getId, OrderId)
                .eq(AsnOrder::getType, OrderType.ORDER_PLAT_IN.type));
        if (Objects.isNull(order)) {
            throw new CoolException("单据不存在！！");
        }
        Stock stock = new Stock();
        stock.setAsnId(OrderId).setAsnCode(order.getCode());
        if (!Objects.isNull(order.getPoCode()) && StringUtils.isNotBlank(order.getPoCode())) {
            Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>().eq(Purchase::getCode, order.getPoCode()));
            if (!Objects.isNull(purchase)) {
                stock.setPlatOrderNo(purchase.getPlatCode()).setPlatToken(purchase.getPlatId());
            }
        }
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
        if (StringUtils.isBlank(ruleCode)) {
            throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
        }
        if (!stockService.save(stock)) {
            throw new CoolException("库存保存失败！！");
        }
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, params.getLocCode()));
        if (Objects.isNull(loc)) {
            throw new CoolException("库位不存在！！");
        }
        List<StockItem> stockItems = new ArrayList<>();
        params.getItemList().forEach(orderItem -> {
            StockItem stockItem = new StockItem();
            BeanUtils.copyProperties(orderItem, stockItem);
            stockItem.setAsnItemId(orderItem.getId())
                    .setBarcode(orderItem.getBarcode())
                    .setLocId(loc.getId())
                    .setUpdateBy(loginUserId)
                    .setId(null)
                    .setStockId(stock.getId());
            stockItems.add(stockItem);
        });

        if (!stockItemService.saveBatch(stockItems)) {
            throw new CoolException("任务上架失败！！");
        }
        return R.ok(stock);
    }

    /**
     * 获取任务信息
     * @param code
     * @return
     */
    @Override
    public R taskToStock(String code) {
        if (StringUtils.isBlank(code)) {
            throw new CoolException("拖盘码不能为空！！");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
        if (Objects.isNull(task)) {
            throw new CoolException("拖盘任务不存在！！");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (taskItems.isEmpty()) {
            throw new CoolException("拖盘任务明细不存在！！");
        }
        TaskQueueDto queueDto = new TaskQueueDto();
        queueDto.setTask(task).setTaskItems(taskItems);
        List<Long> list = taskItems.stream().map(TaskItem::getMatnrId).collect(Collectors.toList());
        List<LocAreaMatRela> matRelas = locAreaMatRelaMapper.selectList(new LambdaQueryWrapper<LocAreaMatRela>().in(LocAreaMatRela::getMatnrId,
                list));
        TaskLocAreaDto locAreaDto = new TaskLocAreaDto();
        /**判断是否为空*/
        if (matRelas.isEmpty()) {
            locAreaDto.setLocs(new ArrayList<>());
        } else {
            Long ids = matRelas.stream().map(LocAreaMatRela::getLocId).collect(Collectors.toList()).stream().findFirst().get();
            List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getId, ids));
            if (locs.isEmpty()) {
                locAreaDto.setLocs(new ArrayList<>());
            } else {
                LocArea locArea = locAreaMapper.selectById(new LambdaQueryWrapper<Loc>().in(Loc::getId, ids));
                if (!Objects.isNull(locArea)) {
                    locAreaDto.setAreaName(locArea.getName()).setAreaCode(locArea.getCode()).setAreaId(locArea.getId());
                }
                locAreaDto.setLocs(locs);
            }
        }
        queueDto.setLocArea(locAreaDto);

        return R.ok(queueDto);
    }

    /**
     * @Author Ryan
     * @param code
     * @desc  任务上架
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R taskGetLocs(String code) throws Exception {
        if (StringUtils.isBlank(code)) {
            throw new CoolException("拖盘码不能为空！！");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
        if (Objects.isNull(task)) {
            throw new CoolException("拖盘任务不存在！！");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (!taskItems.isEmpty()) {
            throw new CoolException("拖盘任务明细不存在！！");
        }
        List<Task> tasks = new ArrayList<>();
        tasks.add(task);

        taskService.completeTask(tasks);

        return R.ok();
    }

    /**
     * 获取ReceiptDetlsDtos
     */
    private R getAsnOrderItem(List<AsnOrderItem> items) {