#新增 1. 波次生成出库任务

skyouc

2025-04-28 b0926b3d4379d087d5c0187882b98be0ed88da83

#新增
 1. 波次生成出库任务

 rsf-admin/src/i18n/en.js

@@ -70,7 +70,7 @@
            loadMore: 'Load More Data',
            complete: 'Complete',
            deprecate: 'Deprecate',
            stockError: 'Insuff stock ',
            stockError: 'Empty',
            inputPlaceholder: 'Use commas to separate',
            resend: 'RESEND',
            selected: 'selected',

 rsf-admin/src/i18n/zh.js

@@ -71,7 +71,7 @@
            loadMore: '加载更多',
            complete: '完成',
            deprecate: '废弃',
            stockError: '库存不足',
            stockError: '没有库存',
            resend: '重发',
            selected: '项选中',
            batch: '批量编辑'

 rsf-admin/src/page/orders/wave/ItemToTaskModal.jsx

@@ -165,7 +165,7 @@
    const notify = useNotify();
    const redirect = useRedirect();
    const generateTask = async () => {
        const res = await request.post(`/wave/public/task`, { wave: dataSource });
        const res = await request.post(`/wave/public/task`, { wave: record, waveItem: dataSource });
        if (res?.data?.code === 200) {
            notify(res.data.msg);
            redirect("/task")

 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/enums/TaskStsType.java

@@ -3,13 +3,13 @@
public enum TaskStsType {



    //任务状态

    GENERATE_IN(1L, "创建入库任务"),

    WCS_EXECUTE_IN(2L, "RCS任务已下发"),

    WCS_CONTAINER_RECEIVE(3L, "RCS容器到达"),

    WCS_CONVEYOR_START(4L, "RCS容器流动任务已下发"),

    WCS_TOTE_LOAD(5L, "RCS取箱完成"),

    WCS_TOTE_UNLOAD(6L, "RCS放箱完成"),

    WCS_PUTAWAY_SUCESS(7L, "RCS任务完成"),

    GENERATE_IN("1", "创建入库任务"),

    WCS_EXECUTE_IN("2", "RCS任务已下发"),

    WCS_CONTAINER_RECEIVE("3", "RCS容器到达"),

    WCS_CONVEYOR_START("4", "RCS容器流动任务已下发"),

    WCS_TOTE_LOAD("5", "RCS取箱完成"),

    WCS_TOTE_UNLOAD("6", "RCS放箱完成"),

    WCS_PUTAWAY_SUCESS("7", "RCS任务完成"),



//    WCS_PUTAWAY_FAILED(11L, "任务失败"),

//

@@ -17,36 +17,36 @@
//

//    WCS_PUTAWAY_SUSPEND(13L, "入库任务挂起"),



    COMPLETE_IN(99L, "入库完成"),

    COMPLETE_IN("99", "入库完成"),



    UPDATED_IN(100L, "库存更新完成"),

    UPDATED_IN("100", "库存更新完成"),



    GENERATE_OUT(101L, "创建出库任务"),

    GENERATE_OUT("101", "创建出库任务"),



    WCS_EXECUTE_OUT(102L, "RCS出库任务已下发"),

    WCS_EXECUTE_OUT("102", "RCS出库任务已下发"),



    WCS_EXECUTE_OUT_TOTE_LOAD(103L, "RCS取箱完成"),

    WCS_EXECUTE_OUT_TOTE_LOAD("103", "RCS取箱完成"),



    WCS_EXECUTE_OUT_TOTE_UNLOAD(104L, "RCS放箱完成"),

    WCS_EXECUTE_OUT_TOTE_UNLOAD("104", "RCS放箱完成"),



    WCS_EXECUTE_OUT_TASK_DONE(105L, "RCS任务完成"),

    WCS_EXECUTE_OUT_TASK_DONE("105", "RCS任务完成"),



    WCS_EXECUTE_OUT_ARRIVED(106L, "RCS容器已到达"),

    WCS_EXECUTE_OUT_ARRIVED("106", "RCS容器已到达"),



    WCS_EXECUTE_OUT_CONVEYOR(107L, "RCS容器流动任务已下发"),

    WCS_EXECUTE_OUT_CONVEYOR("107", "RCS容器流动任务已下发"),



    GENERATE_WAVE_SEED(197L, "等待容器到达"),

    WAVE_SEED(198L, "播种中"),

    GENERATE_WAVE_SEED("197", "等待容器到达"),

    WAVE_SEED("198", "播种中"),



    COMPLETE_OUT(199L, "出库完成"),

    UPDATED_OUT(200L, "库存更新完成"),

    COMPLETE_OUT("199", "出库完成"),

    UPDATED_OUT("200", "库存更新完成"),

    ;



    public Long id;

    public Short id;

    public String desc;



    TaskStsType(Long id, String desc) {

        this.id = id;

    TaskStsType(String id, String desc) {

        this.id = Short.parseShort(id);

        this.desc = desc;

    }




 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/enums/TaskType.java

@@ -9,23 +9,23 @@
 */
public enum TaskType {

    TASK_TYPE_IN(1, "入库"),
    TASK_TYPE_EMPITY_IN(10, "空板入库"),
    TASK_TYPE_LOC_MOVE(11, "库格移载"),
    TASK_TYPE_PICK_IN(53, "拣料再入库"),
    TASK_TYPE_MERGE_IN(54, "并板再入库"),
    TASK_TYPE_CHECK_IN(57, "盘点再入库"),
    TASK_TYPE_OUT(101, "出库"),
    TASK_TYPE_PICK_AGAIN_IN(103, "拣料入库"),
    TASK_TYPE_MERGE_OUT(104, "并板出库"),
    TASK_TYPE_CHECK_OUT(107, "盘点出库"),
    TASK_TYPE_EMPITY_OUT(110, "空板出库"),
    TASK_TYPE_IN("1", "入库"),
    TASK_TYPE_EMPITY_IN("10", "空板入库"),
    TASK_TYPE_LOC_MOVE("11", "库格移载"),
    TASK_TYPE_PICK_IN("53", "拣料再入库"),
    TASK_TYPE_MERGE_IN("54", "并板再入库"),
    TASK_TYPE_CHECK_IN("57", "盘点再入库"),
    TASK_TYPE_OUT("101", "出库"),
    TASK_TYPE_PICK_AGAIN_IN("103", "拣料入库"),
    TASK_TYPE_MERGE_OUT("104", "并板出库"),
    TASK_TYPE_CHECK_OUT("107", "盘点出库"),
    TASK_TYPE_EMPITY_OUT("110", "空板出库"),
    ;
    public Integer type;
    public Short type;
    public String desc;

    TaskType(Integer type, String desc) {
        this.type = type;
    TaskType(String type, String desc) {
        this.type = Short.parseShort(type);
        this.desc = desc;
    }
}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/WaveController.java

@@ -118,14 +118,14 @@
        if (Cools.isEmpty(map) || Cools.isEmpty(map.get("wave"))) {
            throw new CoolException("参数不能为空！！");
        }
        return waveService.publicTask(map);
        return waveService.publicTask(map, getLoginUserId());
    }

    @PreAuthorize("hasAuthority('manager:wave:list')")
    @ApiOperation("波次出库任务预览")
    @PostMapping("/wave/locs/preview/page")
    public R mergeWavePreview(@RequestBody Map<String, Object> map) {
        if (Cools.isEmpty(map.get("wave")) || StringUtils.isBlank(map.get("wave").toString())) {
        if (Cools.isEmpty(map.get("waveId")) || StringUtils.isBlank(map.get("waveId").toString())) {
            throw new CoolException("参数不能为空！！");
        }
        Long waveId = Long.parseLong(map.get("waveId").toString());

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/AsnOrder.java

@@ -91,6 +91,9 @@
    @ApiModelProperty(value= "物流单号")
    private String logisNo;

    @ApiModelProperty("波次ID")
    private Long waveId;

    /**
     * 预计到达时间
     */

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/LocItem.java

@@ -1,6 +1,7 @@
package com.vincent.rsf.server.manager.entity;

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.*;

import java.text.SimpleDateFormat;
import java.util.Date;

@@ -9,10 +10,7 @@
import java.text.SimpleDateFormat;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
@@ -106,8 +104,10 @@
    @ApiModelProperty(value= "数量")
    private Double anfme;


    @ApiModelProperty("执行数量")
    private Double workQty;


    @ApiModelProperty("完成数量")
    private Double qty;
@@ -187,6 +187,17 @@
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    @TableField(exist = false)
    private Long waveId;

    @TableField(exist = false)
    private Long waveItemId;

    @TableField(exist = false)
    private String waveCode;



    /**
     * 备注
     */

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/TaskItem.java

@@ -77,6 +77,9 @@
     */
    @ApiModelProperty("物料跟踪码")
    private String trackCode;

    @ApiModelProperty("供应商波次")
    private String splrBatch;
    /**
     * 物料编码
     */

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/Wave.java

@@ -70,6 +70,9 @@
    @ApiModelProperty(value= "已完成数量")
    private Double qty;

    @ApiModelProperty("目标位置")
    private String targSite;

    /**
     * 单据数量
     */

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/WaveItem.java

@@ -184,6 +184,12 @@
    @TableField(exist = false)
    private Double stockQty;


    /***
     * 是否全拖出库
     */
    @TableField(exist = false)
    private Short flagAll;
    /**
     * 备注
     */

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/WaveService.java

@@ -11,13 +11,14 @@
public interface WaveService extends IService<Wave> {

    /**
     * @param
     * @param loginUserId
     * @return
     * @author Ryan
     * @description 波次任务下发
     * @param
     * @return
     * @time 2025/4/25 16:24
     */
    R publicTask(Map<String, Object> map);
    R publicTask(Map<String, Object> map, Long loginUserId);

    /**
     * @author Ryan

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java

@@ -291,6 +291,7 @@
        }

        if (!this.update(new LambdaUpdateWrapper<AsnOrder>()
                .set(AsnOrder::getWaveId, wave.getId())
                .set(AsnOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_WAVE.val)
                .in(AsnOrder::getId, ids))) {
            throw new CoolException("执行状态修改修改失败！！");

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/WaveServiceImpl.java

@@ -6,16 +6,17 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.AsnOrder;
import com.vincent.rsf.server.manager.entity.LocItem;
import com.vincent.rsf.server.manager.entity.WaveItem;
import com.vincent.rsf.server.api.entity.enums.TaskStsType;
import com.vincent.rsf.server.api.entity.enums.TaskType;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.WaveExceStatus;
import com.vincent.rsf.server.manager.mapper.WaveMapper;
import com.vincent.rsf.server.manager.entity.Wave;
import com.vincent.rsf.server.manager.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vincent.rsf.server.manager.utils.OptimalAlgorithmUtil;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -24,7 +25,6 @@

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@Service("waveService")
public class WaveServiceImpl extends ServiceImpl<WaveMapper, Wave> implements WaveService {
@@ -41,9 +41,12 @@
    private TaskItemService taskItemService;
    @Autowired
    private LocItemService locItemService;
    @Autowired
    private LocService locService;

    /**
     * @param
     * @param loginUserId
     * @return
     * @author Ryan
     * @description 波次任务下发
@@ -51,25 +54,24 @@
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R publicTask(Map<String, Object> map) {
        List<WaveItem> itemParams = (List<WaveItem>) map.get("wave");
    public R publicTask(Map<String, Object> map, Long loginUserId) {
        List<WaveItem> itemParams = (List<WaveItem>) map.get("waveItem");
        if (Objects.isNull(itemParams) || itemParams.isEmpty()) {
            throw new CoolException("参数不能为空！！");
        }
        List<Long> ids = itemParams.stream().map(WaveItem::getWaveId).collect(Collectors.toList());
        List<Wave> waves = this.list(new LambdaQueryWrapper<Wave>().in(Wave::getId, ids));
        if (Objects.isNull(waves) || waves.isEmpty()) {
        Wave wave = (Wave) map.get("wave");
        Wave waves = this.getById(new LambdaQueryWrapper<Wave>().in(Wave::getId, wave.getId()));
        if (Objects.isNull(waves)) {
            throw new CoolException("波次数据不存在！！");
        }
        List<Long> list = waves.stream().map(Wave::getId).collect(Collectors.toList());
        List<Long> list = itemParams.stream().map(WaveItem::getWaveId).collect(Collectors.toList());
        List<WaveItem> waveItems = waveItemService.list(new LambdaQueryWrapper<WaveItem>().in(WaveItem::getWaveId, list));
        if (waveItems.isEmpty()) {
            throw new CoolException("波次明细不存在！！");
        }
        List<Long> orderIds = waveItems.stream().map(WaveItem::getOrderId).collect(Collectors.toList());
        /**查询每条明细匹配的库位*/
        /**生成出库任务*/
        try {
//            List<WaveItem> items = getLocs(waveItems);
            generateOutTask(itemParams, loginUserId, wave);
        } catch (Exception e) {
            throw new CoolException("库位获取失败！！！");
        }
@@ -77,17 +79,130 @@
        // 2. 根据物料SKU寻找符合物料库位  {1. 根据物料编码，批次，动态字段 查询符合的库位，再根据库位中物料的数量选择最适合的库位 2. 判断当前订单是全拖出库还是拣料入库}
        // 3. 修改主单、波次执行数量
        // 4. 判断全仓出库或拣料出库
//        List<AsnOrder> orders = asnOrderService.list(new LambdaQueryWrapper<AsnOrder>().in(AsnOrder::getId, orderIds));
//        /**修改原出库单状态*/
//        if (!asnOrderService.update(new LambdaQueryWrapper<AsnOrder>()
//                .eq(AsnOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_WORKING.val)
//                .in(AsnOrder::getId, orders))) {
//            throw new CoolException("出库单据状态修改失败！！");
//        }
//        if (!this.update(new LambdaUpdateWrapper<Wave>().set(Wave::getExceStatus, WaveExceStatus.WAVE_EXCE_STATUS_TASK).in(Wave::getId, ids))) {
//            throw new CoolException("波次状态修改失败！！");
//        }
        List<Long> orderIds = waveItems.stream().map(WaveItem::getOrderId).collect(Collectors.toList());

        List<AsnOrder> orders = asnOrderService.list(new LambdaQueryWrapper<AsnOrder>().in(AsnOrder::getId, orderIds));
        /**修改出库单状态*/
        if (!asnOrderService.update(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_WORKING.val)
                .in(AsnOrder::getId, orders))) {
            throw new CoolException("出库单据状态修改失败！！");
        }
        /**修改波次单据执行状态*/
        if (!this.update(new LambdaUpdateWrapper<Wave>().set(Wave::getExceStatus, WaveExceStatus.WAVE_EXCE_STATUS_TASK).eq(Wave::getId, wave.getId()))) {
            throw new CoolException("波次状态修改失败！！");
        }
        return R.ok();
    }

    /**
     * @param
     * @param loginUserId
     * @param wave
     * @return
     * @author Ryan
     * @description 生成出库任务
     * @time 2025/4/28 14:01
     */
    @Transactional(rollbackFor = Exception.class)
    private synchronized void generateOutTask(List<WaveItem> itemParams, Long loginUserId, Wave wave) throws Exception {
        List<LocItem> locItemList = new ArrayList<>();
        for (WaveItem param : itemParams) {
            String locs = param.getStockLocs();
            List<LocItem> locItems = JSONArray.parseArray(locs, LocItem.class);
            if (locItems.isEmpty()) {
                continue;
            }
            List<Long> list = locItems.stream().map(LocItem::getId).collect(Collectors.toList());
            /**根据供应商批次，物料码， 动态字段查询指定的物料库存信息*/
            List<LocItem> items = locItemService.list(new LambdaQueryWrapper<LocItem>()
                    .eq(LocItem::getSplrBatch, param.getSplrBatch())
                    .in(LocItem::getLocId, list)
                    .eq(StringUtils.isNotBlank(param.getFieldsIndex()), LocItem::getFieldsIndex, param.getFieldsIndex())
                    .eq(LocItem::getMatnrCode, param.getMatnrCode()));
            if (items.isEmpty()) {
                throw new CoolException("库存信息有变，请取消当前波次，生新生成新的波次！！");
            }
            /***将有货有的明细信息存放到库位信息中*/
            for (int i = 0; i < items.size(); i++) {
                items.get(i)
                        .setWaveId(param.getWaveId())
                        .setWaveCode(param.getWaveCode())
                        .setWaveItemId(param.getId());
            }
            locItemList.addAll(items);
        }
        if (locItemList.isEmpty()) {
            throw new CoolException("没有合适库位！！");
        }

        /**拆分波次明细库位集，合并相同库位，分解任务明细*/
        Map<Long, List<LocItem>> listMap = locItemList.stream().collect(Collectors.groupingBy(LocItem::getLocId));
        /**根据库位汇总信息，生成任务明细**/
        listMap.keySet().forEach(key -> {
            List<LocItem> locItems = listMap.get(key);
            LocItem item1 = locItems.stream().findFirst().get();
            WaveItem waveItem = waveItemService.getById(item1.getWaveItemId());
            if (null == waveItem || Objects.isNull(waveItem)) {
                throw new CoolException("数据错误：波次明细不存在！！");
            }
            //TODO 当前任务完成后，通过定时事件判断是全盘出库，还是拣料再入库
            Loc loc = locService.getById(key);
            Task task = new Task();
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TASK_CODE, null);
            if (StringUtils.isBlank(ruleCode)) {
                throw new CoolException("编码规则错误：请检查「SYS_TASK_CODE」是否设置完成！！");
            }
            if (Objects.isNull(loc)) {
                throw new CoolException("库位不存在！！");
            }
            task.setTaskCode(ruleCode)
                    .setTaskType(TaskType.TASK_TYPE_OUT.type)
                    .setTaskStatus(TaskStsType.GENERATE_OUT.id)
                    .setBarcode(loc.getBarcode())
                    .setOrgLoc(loc.getCode())
                    .setCreateBy(loginUserId)
                    .setUpdateBy(loginUserId)
                    .setTargSite(wave.getTargSite());

            if (!taskService.save(task)) {
                throw new CoolException("任务生成失败！！");
            }
            List<TaskItem> taskItems = new ArrayList<>();
            /**生成任务明细信息*/
            for (LocItem item : locItems) {
                TaskItem taskItem = new TaskItem();
                BeanUtils.copyProperties(item, taskItem);
                taskItem.setTaskId(task.getId())
                        .setId(null)
                        .setSource(item.getWaveItemId());
                taskItems.add(taskItem);
            }
            if (!taskItemService.saveBatch(taskItems)) {
                throw new CoolException("任务明细保存失败！！");
            }

            /**修改波次执行数量*/
            taskItems.forEach(item -> {
                boolean update = waveItemService.update(new LambdaUpdateWrapper<WaveItem>()
                        .eq(WaveItem::getWaveId, item.getSource())
                        .set(WaveItem::getWorkQty, item.getAnfme()));
                if (!update) {
                    throw new CoolException("波次执行数量修改失败！！");
                }
            });

            List<WaveItem> waveItems = waveItemService.list(new LambdaQueryWrapper<WaveItem>().eq(WaveItem::getWaveId, wave.getId()));
            double sum = waveItems.stream().mapToDouble(WaveItem::getWorkQty).sum();
            /**波次主单信息修改*/
            if (!update(new LambdaUpdateWrapper<Wave>()
                    .eq(Wave::getId, wave.getId())
                    .set(Wave::getWorkQty, sum)
                    .set(Wave::getExceStatus, WaveExceStatus.WAVE_EXCE_STATUS_TASK.val))) {
                throw new CoolException("波次主单信息修改失败！！");
            }

        });
    }

    /**
@@ -129,7 +244,7 @@
        //TODO  根据物料编码，批次，动态字段 查询符合的库位，再根据库位中物料的数量选择最适合的库位
        waveItems.forEach(waveItem -> {
            List<LocItem> locItems = locItemService.list(new QueryWrapper<LocItem>()
                    .select("id", "loc_id", "loc_code", "order_id", "SUM(anfme) anfme", "SUM(work_qty) work_qty", "splr_batch", "fields_index", "matnr_code")
                    .select("id", "loc_id", "loc_code", "order_id", "SUM(anfme) anfme", "SUM(qty) qty", "SUM(work_qty) work_qty", "splr_batch", "fields_index", "matnr_code")
                    .lambda()
                    .eq(LocItem::getMatnrCode, waveItem.getMatnrCode())
                    .eq(LocItem::getSplrBatch, waveItem.getSplrBatch())
@@ -140,19 +255,21 @@

            /**使用回溯算法计算，获取符合出库量的最简组合*/
            List<Integer> result = OptimalAlgorithmUtil.findCombination(doubles, waveItem.getAnfme());

            String locs = "[]";
            if (Objects.isNull(result)) {
            if (Objects.isNull(result) || result.isEmpty()) {
                waveItem.setStockLocs(locs).setStockQty(0.0);
            } else {
                /**过滤集合中最简短的组合*/
                List<LocItem> locsInfo = result.stream()
                        .filter(i -> i >= 0 && i < locItems.size())
                        .map(locItems::get).collect(Collectors.toList());

                locs = JSONArray.toJSONString(locsInfo);
                double sumQty = locItems.stream().mapToDouble(LocItem::getAnfme).sum();
                double surQty = locItems.stream().mapToDouble(LocItem::getWorkQty).sum();
                double qty = locItems.stream().mapToDouble(LocItem::getQty).sum();
                double v = sumQty - surQty - qty;
                Double sumQty = locsInfo.stream().mapToDouble(LocItem::getAnfme).sum();
                Double surQty = locsInfo.stream().mapToDouble(LocItem::getWorkQty).sum();
                Double qty = locsInfo.stream().mapToDouble(LocItem::getQty).sum();
                Double v = sumQty - surQty - qty;
                waveItem.setStockLocs(locs).setStockQty(v);
            }
        });