#

Junjie

2025-02-14 ac4341ea6b66ae02427d39d35f41d42d78b2eb2e

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/impl/WorkServiceImpl.java

@@ -1,13 +1,20 @@
package com.zy.asrs.wms.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.R;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.enums.*;
import com.zy.asrs.wms.asrs.entity.param.FieldParam;
import com.zy.asrs.wms.asrs.entity.param.GeneratePakInParam;
import com.zy.asrs.wms.asrs.entity.param.LocAdjustParam;
import com.zy.asrs.wms.asrs.entity.param.LocTransferParam;
import com.zy.asrs.wms.asrs.service.*;
import com.zy.asrs.wms.utils.LocUtils;
import com.zy.asrs.wms.utils.OrderUtils;
import com.zy.asrs.wms.utils.Utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -36,6 +43,10 @@
    @Autowired
    private LocService locService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private LocDetlFieldService locDetlFieldService;
    @Autowired
    private LocStsService locStsService;
    @Autowired
    private TaskLogService taskLogService;
@@ -57,6 +68,12 @@
    private LocTypeService locTypeService;
    @Autowired
    private MatService matService;
    @Autowired
    private OrderUtils orderUtils;
    @Autowired
    private WaveDetlService waveDetlService;
    @Autowired
    private MatFieldService matFieldService;

    @Override
    public String generateTaskNo(Long taskType) {
@@ -263,7 +280,7 @@

        Task task = new Task();
        task.setTaskNo(this.generateTaskNo(taskType.getId()));//任务号
        task.setTaskSts(1L);//1.生成入库任务
        task.setTaskSts(TaskStsType.GENERATE_IN.id);//1.生成入库任务
        task.setTaskType(taskType.getId());//任务类型
        task.setIoPri(this.generateIoPri(taskType.getId()));//优先级
        task.setOriginLoc(null);
@@ -372,7 +389,7 @@

        Task task = new Task();
        task.setTaskNo(this.generateTaskNo(taskType.getId()));//任务号
        task.setTaskSts(1L);//1.生成入库任务
        task.setTaskSts(TaskStsType.GENERATE_IN.id);//1.生成入库任务
        task.setTaskType(taskType.getId());//任务类型
        task.setIoPri(this.generateIoPri(taskType.getId()));//优先级
        task.setOriginLoc(null);
@@ -410,10 +427,15 @@

        if (task.getTaskType() < 100) {
            //入库
            task.setTaskSts(99L);//99.入库完成
            task.setTaskSts(TaskStsType.COMPLETE_IN.id);//99.入库完成
        }else {
            //出库
            task.setTaskSts(199L);//199.出库完成
            TaskDetl taskDetl = taskDetls.get(0);
            if (taskDetl.getWaveId() == null) {
                task.setTaskSts(TaskStsType.COMPLETE_OUT.id);//199.出库完成
            }else {
                task.setTaskSts(TaskStsType.WAVE_SEED.id);//198.播种中
            }
        }

        task.setUpdateTime(new Date());
@@ -470,6 +492,53 @@
                if(!locService.updateById(loc)){
                    throw new CoolException("库位状态变更失败");
                }

                List<TaskDetl> taskDetls = taskDetlService.getTaskDetlByTaskId(taskId);
                for (TaskDetl taskDetl : taskDetls) {
                    if (taskDetl.getWaveId() == null) {
                        continue;
                    }

                    String matUniqueKey = Utils.getMatUniqueKey(taskDetl.getMatnr(), taskDetl.getBatch(), taskDetl.getUniqueField());
                    WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, taskDetl.getWaveId()));
                    if(waveDetl == null){
                        continue;
                    }
                    waveDetl.setWorkQty(waveDetl.getWorkQty() - taskDetl.getAnfme());
                    waveDetl.setUpdateTime(new Date());
                    if (!waveDetlService.updateById(waveDetl)) {
                        throw new CoolException("波次明细更新失败");
                    }
                }
                break;
            case 11://库位移转
                Loc originLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, task.getOriginLoc()));
                if(originLoc == null){
                    throw new CoolException("源库位不存在");
                }
                if (originLoc.getLocStsId() != LocStsType.R.val()) {
                    throw new CoolException("源库位状态不处于R.出库预约");
                }

                loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, task.getTargetLoc()));
                if(loc == null){
                    throw new CoolException("目标库位不存在");
                }
                if(loc.getLocStsId() != LocStsType.S.val()){
                    throw new CoolException("目标库位状态不处于S.入库预约");
                }

                originLoc.setLocStsId(LocStsType.F.val());
                originLoc.setUpdateTime(new Date());
                if(!locService.updateById(originLoc)){
                    throw new CoolException("库位状态变更失败");
                }

                loc.setLocStsId(LocStsType.O.val());
                loc.setUpdateTime(new Date());
                if(!locService.updateById(loc)){
                    throw new CoolException("库位状态变更失败");
                }
                break;
        }

@@ -496,19 +565,7 @@
            //回滚订单
            for (TaskDetl taskDetl : taskDetls) {
                if (taskDetl.getDetlId() != null) {
                    OrderDetl orderDetl = orderDetlService.getById(taskDetl.getDetlId());
                    if(orderDetl == null){
                        throw new CoolException("订单明细不存在");
                    }

                    //回滚工作数量
                    orderDetl.setWorkQty(orderDetl.getWorkQty() - taskDetl.getAnfme());
                    orderDetl.setUpdateTime(new Date());
                    boolean orderDetlUpdate = orderDetlService.updateById(orderDetl);
                    if(!orderDetlUpdate){
                        throw new CoolException("工作数量回滚失败");
                    }

                    orderUtils.updateWorkQty(taskDetl.getDetlId(), taskDetl.getAnfme(), false);
                }

                //入库回滚组托通知档
@@ -586,7 +643,7 @@
        }

        //获取源库位高度
        LocTypeBind locTypeBind = locTypeBindService.getOne(new LambdaQueryWrapper<LocTypeBind>().eq(LocTypeBind::getLocId, originLoc.getId()));
        LocTypeBind locTypeBind = locTypeBindService.getOne(new LambdaQueryWrapper<LocTypeBind>().eq(LocTypeBind::getLocId, originLoc.getId()).in(LocTypeBind::getTypeId, LocBindType.HEIGHT.list()));
        if(locTypeBind == null){
            throw new CoolException("库位类型不存在");
        }
@@ -613,7 +670,7 @@
            throw new CoolException("没有空库位");
        }

        task.setTaskSts(1L);//1.生成入库任务
        task.setTaskSts(TaskStsType.GENERATE_IN.id);//1.生成入库任务
        task.setTaskType(taskType);
        task.setTargetLoc(loc.getLocNo());
        task.setUpdateTime(new Date());
@@ -631,4 +688,176 @@

        return true;
    }

    @Override
    @Transactional
    public boolean locAdjust(LocAdjustParam param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        if (Cools.isEmpty(param.getLocNo())) {
            throw new CoolException("库位号不能为空");
        }

        if (param.getDetls() == null) {
            throw new CoolException("库存明细不能为空");
        }

        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, param.getLocNo()));
        if (loc == null) {
            throw new CoolException("库位不存在");
        }

        //删除源库存
        locDetlService.removeLocDetl(loc.getId());

        List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getUnique, 1));
        for (Map<String, Object> map : param.getDetls()) {
            LocDetl locDetl = JSON.parseObject(JSON.toJSONString(map), LocDetl.class);
            HashMap<String, Object> uniqueFields = new HashMap<>();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                for (MatField field : matFields) {
                    if (entry.getKey().equals(field.getName())) {
                        uniqueFields.put(entry.getKey(), entry.getValue());
                    }
                }
            }
            locDetl.setAnfme(Double.parseDouble(map.get("qty").toString()));
            locDetl.syncFieldMap(uniqueFields);

            if (locDetl.getAnfme() <= 0D) {
                throw new CoolException("数量不能小于0");
            }

            locDetl.setId(null);
            locDetl.setLocId(loc.getId());
            locDetl.setLocNo(loc.getLocNo());
            boolean save = locDetlService.save(locDetl);
            if (!save) {
                throw new CoolException("库存调整失败");
            }

            //插入库存明细字段
            for (MatField matField : matFields) {
                LocDetlField locDetlField = new LocDetlField();
                locDetlField.setDetlId(locDetl.getId());
                locDetlField.setFieldId(matField.getId());
                locDetlField.setName(matField.getName());
                locDetlField.setValue(Optional.ofNullable(uniqueFields.get(matField.getName()).toString()).orElse(""));
                locDetlFieldService.save(locDetlField);
            }

        }

        return true;
    }

    @Override
    @Transactional
    public boolean locTransfer(LocTransferParam param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        if (Cools.isEmpty(param.getSourceLocNo())) {
            throw new CoolException("源库位不能为空");
        }

        if (Cools.isEmpty(param.getTargetLocNo())) {
            throw new CoolException("目标库位不能为空");
        }

        Loc sourceLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, param.getSourceLocNo()));
        if (sourceLoc == null) {
            throw new CoolException("源库位不存在");
        }

        if (sourceLoc.getLocStsId() != LocStsType.F.val()) {
            throw new CoolException("源库位非在库状态");
        }

        Loc targetLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, param.getTargetLocNo()));
        if (targetLoc == null) {
            throw new CoolException("目标库位不存在");
        }

        if(targetLoc.getLocStsId() != LocStsType.O.val()){
            throw new CoolException("目标库位非空状态");
        }

        TaskType taskType = taskTypeService.getById(11);
        if (taskType == null) {
            throw new CoolException("任务类型不存在");
        }

        Task task = new Task();
        task.setTaskNo(this.generateTaskNo(taskType.getId()));//任务号
        task.setTaskSts(TaskStsType.GENERATE_IN.id);//1.生成入库任务
        task.setTaskType(taskType.getId());//任务类型
        task.setIoPri(this.generateIoPri(taskType.getId()));//优先级
        task.setOriginLoc(param.getSourceLocNo());
        task.setTargetLoc(param.getTargetLocNo());
        task.setOriginSite(null);
        task.setTargetSite(null);
        task.setBarcode(sourceLoc.getBarcode());//托盘码
        boolean taskSave = taskService.save(task);
        if (!taskSave) {
            throw new CoolException("任务生成失败");
        }

        List<LocDetl> locDetls = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocId, sourceLoc.getId()));
        if(locDetls.isEmpty()){
            throw new CoolException("源库位明细不存在");
        }

        //生成任务明细
        for (LocDetl locDetl : locDetls) {
            TaskDetl taskDetl = new TaskDetl();
            taskDetl.setTaskId(task.getId());
            taskDetl.setTaskNo(task.getTaskNo());
            taskDetl.setAnfme(locDetl.getAnfme());//数量
            taskDetl.setStock(0D);//库存
            taskDetl.setBatch(locDetl.getBatch());//批号
            taskDetl.setBarcode(sourceLoc.getBarcode());
            taskDetl.setMatId(locDetl.getMatId());
            taskDetl.setMatnr(locDetl.getMatnr());
            boolean taskDetlSave = taskDetlService.save(taskDetl);
            if(!taskDetlSave){
                throw new CoolException("任务明细生成失败");
            }

            //生成明细扩展
            List<LocDetlField> locDetlFieldList = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
            for (LocDetlField locDetlField : locDetlFieldList) {
                TaskDetlField taskDetlField = new TaskDetlField();
                taskDetlField.setName(locDetlField.getName());
                taskDetlField.setFieldId(locDetlField.getFieldId());
                taskDetlField.setDetlId(taskDetl.getId());
                taskDetlField.setValue(locDetlField.getValue());
                boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
                if(!taskDetlFieldSave){
                    throw new CoolException("明细扩展生成失败");
                }
            }
        }

        //库位F => R
        sourceLoc.setLocStsId(LocStsType.R.val());
        sourceLoc.setUpdateTime(new Date());
        boolean sourceLocUpdate = locService.updateById(sourceLoc);
        if(!sourceLocUpdate){
            throw new CoolException("库位状态更新失败");
        }

        //库位O => S
        targetLoc.setLocStsId(LocStsType.S.val());
        targetLoc.setUpdateTime(new Date());
        boolean targetLocUpdate = locService.updateById(targetLoc);
        if(!targetLocUpdate){
            throw new CoolException("库位状态更新失败");
        }

        return true;
    }
}