#

Junjie

2024-09-20 053e6028bd20e599aea103401137816c6296a9ef

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

@@ -4,9 +4,12 @@
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.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;
@@ -50,6 +53,16 @@
    private LanewayRuleService lanewayRuleService;
    @Autowired
    private CircleRuleService circleRuleService;
    @Autowired
    private LocTypeBindService locTypeBindService;
    @Autowired
    private LocTypeService locTypeService;
    @Autowired
    private MatService matService;
    @Autowired
    private OrderUtils orderUtils;
    @Autowired
    private WaveDetlService waveDetlService;

    @Override
    public String generateTaskNo(Long taskType) {
@@ -134,7 +147,7 @@
    }

    @Override
    public Loc generateLoc(Long taskType, String barcode, Integer locTypeHeight) {
    public synchronized Loc generateLoc(Long taskType, String barcode, Integer locTypeHeight) {
        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
        if (taskType != 10 && waitPakins.isEmpty()) {
            throw new CoolException("托盘未组托");
@@ -145,14 +158,26 @@
        if (detl == null) {
            throw new CoolException("订单明细不存在");
        }
        String batch = detl.getBatch();
        List<FieldParam> uniqueFields = detl.getUniqueField();

        Mat mat = detl.getMat$();
        if (mat == null) {
            throw new CoolException("商品不存在");
        }

        return generateLoc(taskType, mat.getId(), batch, uniqueFields, locTypeHeight);
    }

    @Override
    public synchronized Loc generateLoc(Long taskType, Long matId, String batch, List<FieldParam> uniqueFields, Integer locTypeHeight) {
        Mat mat = matService.getById(matId);
        if (mat == null) {
            throw new CoolException("商品不存在");
        }

        List<ShelvesRule> shelvesRules = shelvesRuleService.list(new LambdaQueryWrapper<ShelvesRule>().eq(ShelvesRule::getStatus, 1).orderByDesc(ShelvesRule::getCreateTime));
        if(shelvesRules.isEmpty()) {
        if (shelvesRules.isEmpty()) {
            throw new CoolException("未配置上架规则");
        }
        ShelvesRule shelvesRule = shelvesRules.get(0);
@@ -176,7 +201,7 @@
        }

        List<ShelvesRuleDetl> ruleDetls = shelvesRule.getRuleDetl$();
        if(ruleDetls.isEmpty()) {
        if (ruleDetls.isEmpty()) {
            throw new CoolException("未配置上架规则明细");
        }

@@ -185,7 +210,7 @@
        for (ShelvesRuleDetl ruleDetl : ruleDetls) {
            if (ruleDetl.getDetlType().equals(ShelvesRuleDetlType.TASK_OR_LOC.id)) {
                //从库存或任务中匹配相邻库位
                defaultLoc = locUtils.getNeighborLoc(taskType, detl, locTypeHeight);
                defaultLoc = locUtils.getNeighborLoc(taskType, mat.getId(), batch, uniqueFields, locTypeHeight);
                if (defaultLoc != null) {
                    return defaultLoc;
                }
@@ -193,11 +218,11 @@

            if (ruleDetl.getDetlType().equals(ShelvesRuleDetlType.SUGGEST.id)) {
                //获取推荐库位
                List<Loc> suggestLoc = locUtils.getSuggestLoc(taskType, mat.getId(), detl.getBatch(), locTypeHeight, laneRowList, currentLev);
                List<Loc> suggestLoc = locUtils.getSuggestLoc(taskType, mat.getId(), batch, locTypeHeight, laneRowList, currentLev);
                //获取库位
                if (!suggestLoc.isEmpty()) {
                    defaultLoc = locUtils.filterLoc(taskType, suggestLoc);
                    if(defaultLoc != null) {
                    if (defaultLoc != null) {
                        return defaultLoc;
                    }
                }
@@ -209,7 +234,7 @@
                //获取库位
                if (!globalLoc.isEmpty()) {
                    defaultLoc = locUtils.filterAllLoc(globalLoc);
                    if(defaultLoc != null) {
                    if (defaultLoc != null) {
                        return defaultLoc;
                    }
                }
@@ -394,7 +419,12 @@
            task.setTaskSts(99L);//99.入库完成
        }else {
            //出库
            task.setTaskSts(199L);//199.出库完成
            TaskDetl taskDetl = taskDetls.get(0);
            if (taskDetl.getWaveId() == null) {
                task.setTaskSts(199L);//199.出库完成
            }else {
                task.setTaskSts(198L);//198.播种中
            }
        }

        task.setUpdateTime(new Date());
@@ -451,7 +481,41 @@
                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;
        }

        //数据保存至历史档
        TaskLog taskLog = new TaskLog();
        taskLog.sync(task);
        taskLog.setId(null);
        if (!taskLogService.save(taskLog)) {
            throw new CoolException("任务档案转历史档案失败");
        }

        //删除任务
        boolean removeTask = taskService.removeById(taskId);
        if(!removeTask){
            throw new CoolException("回滚任务失败");
        }

        if (task.getTaskType() != 10) {
@@ -462,17 +526,8 @@

            //回滚订单
            for (TaskDetl taskDetl : taskDetls) {
                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("工作数量回滚失败");
                if (taskDetl.getDetlId() != null) {
                    orderUtils.updateWorkQty(taskDetl.getDetlId(), taskDetl.getAnfme(), false);
                }

                //入库回滚组托通知档
@@ -490,11 +545,28 @@
                    }
                }

                //明细数据保存至历史档
                TaskDetlLog taskDetlLog = new TaskDetlLog();
                taskDetlLog.sync(taskDetl);
                taskDetlLog.setId(null);
                taskDetlLog.setTaskId(taskLog.getId());
                if (!taskDetlLogService.save(taskDetlLog)) {
                    throw new CoolException("明细数据转历史档案失败");
                }

                //删除明细
                boolean removeDetl = taskDetlService.removeById(taskDetl.getId());
                if(!removeDetl){
                    throw new CoolException("回滚明细失败");
                }

                List<TaskDetlField> detlFields = taskDetlFieldService.list(new LambdaQueryWrapper<TaskDetlField>().eq(TaskDetlField::getDetlId, taskDetl.getId()));
                for (TaskDetlField detlField : detlFields) {
                    //明细扩展字段数据保存至历史档
                    TaskDetlFieldLog taskDetlFieldLog = new TaskDetlFieldLog();
                    taskDetlFieldLog.sync(detlField);
                    taskDetlFieldLog.setId(null);
                    taskDetlFieldLog.setDetlId(taskDetlLog.getId());
                    if (!taskDetlFieldLogService.save(taskDetlFieldLog)) {
                        throw new CoolException("明细扩展字段转历史档案失败");
                    }
@@ -505,34 +577,75 @@
                        throw new CoolException("回滚扩展明细失败");
                    }
                }


                //明细数据保存至历史档
                TaskDetlLog taskDetlLog = new TaskDetlLog();
                taskDetlLog.sync(taskDetl);
                if (!taskDetlLogService.save(taskDetlLog)) {
                    throw new CoolException("明细数据转历史档案失败");
                }

                //删除明细
                boolean removeDetl = taskDetlService.removeById(taskDetl.getId());
                if(!removeDetl){
                    throw new CoolException("回滚明细失败");
                }
            }
        }

        //数据保存至历史档
        TaskLog taskLog = new TaskLog();
        taskLog.sync(task);
        if (!taskLogService.save(taskLog)) {
            throw new CoolException("任务档案转历史档案失败");
        return true;
    }

    @Override
    public boolean pickTask(Long taskId) {
        Task task = taskService.getById(taskId);
        if(task == null){
            throw new CoolException("任务不存在");
        }

        //删除任务
        boolean removeTask = taskService.removeById(taskId);
        if(!removeTask){
            throw new CoolException("回滚任务失败");
        if (task.getTaskType() != 103) {
            throw new CoolException("任务类型不可拣料");
        }

        if (task.getTaskSts() != 200) {
            throw new CoolException("当前状态不可拣料");
        }

        //获取源库位
        Loc originLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, task.getOriginLoc()));
        if(originLoc == null){
            throw new CoolException("源库位不存在");
        }

        //获取源库位高度
        LocTypeBind locTypeBind = locTypeBindService.getOne(new LambdaQueryWrapper<LocTypeBind>().eq(LocTypeBind::getLocId, originLoc.getId()).in(LocTypeBind::getTypeId, LocBindType.HEIGHT.list()));
        if(locTypeBind == null){
            throw new CoolException("库位类型不存在");
        }
        LocType locType = locTypeService.getById(locTypeBind.getTypeId());
        if(locType == null){
            throw new CoolException("库位类型不存在");
        }
        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locType.getFlag());
        if(locTypeHeightType == null){
            throw new CoolException("高低库位类型不存在");
        }

        Long taskType = task.getTaskType() - 50;

        List<TaskDetl> taskDetls = taskDetlService.list(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getTaskId, taskId).gt(TaskDetl::getAnfme, 0));
        if (taskDetls.isEmpty()) {
            throw new CoolException("任务明细不存在");
        }
        TaskDetl taskDetl = taskDetls.get(0);

        //生成库位
        Loc loc = this.generateLoc(taskType, taskDetl.getMatId(), taskDetl.getBatch(), taskDetl.getUniqueField(), locTypeHeightType.id);
        if(loc == null) {
            throw new CoolException("没有空库位");
        }

        task.setTaskSts(1L);//1.生成入库任务
        task.setTaskType(taskType);
        task.setTargetLoc(loc.getLocNo());
        task.setUpdateTime(new Date());
        if (!taskService.updateById(task)) {
            throw new CoolException("拣料失败");
        }

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

        return true;