#

zwl

10 小时以前 44b6b79dd5dee0ebbd2d11b08abbc2be275bed58

 src/main/java/com/zy/api/service/impl/HmesApiServiceImpl.java

@@ -1,26 +1,27 @@
package com.zy.api.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.api.controller.params.ReceviceTaskParams;
import com.zy.api.service.HmesApiService;
import com.zy.api.service.WcsApiService;
import com.zy.asrs.entity.BasDevice;
import com.zy.asrs.entity.LocAroundBind;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.OpenOrderPakoutParam;
import com.zy.asrs.enums.LocStsType;
import com.zy.asrs.service.BasDeviceService;
import com.zy.asrs.service.LocAroundBindService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.*;
import com.zy.asrs.service.impl.LocDetlServiceImpl;
import com.zy.asrs.service.impl.OrderDetlPakoutServiceImpl;
import com.zy.asrs.service.impl.OrderPakoutServiceImpl;
import com.zy.common.model.DetlDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;

@Service
@@ -37,53 +38,149 @@

    @Autowired
    private WcsApiService wcsApiService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private DocTypeService docTypeService;

    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;

    @Autowired
    private MatService matService;

    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private OrderPakoutServiceImpl orderPakoutService;
    @Autowired
    private OrderDetlPakoutServiceImpl orderDetlPakoutService;
    @Autowired
    private LocDetlServiceImpl locDetlService;


    /**
     * 接收MES穿线任务
     * @author Ryan
     * @date 2026/1/10 10:54
     * @param params
     * @param param
     * @return com.core.common.R
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R pubWorkTask(ReceviceTaskParams params) {
        if (Objects.isNull(params) || Objects.isNull(params.getDeviceNo())) {
            return R.error("参数不能为空！！");
        }
        BasDevice basDevice = basDeviceService.selectOne(new EntityWrapper<BasDevice>()
                .eq("status", 1)
                .eq("dev_no", params.getDeviceNo()));
        if (Objects.isNull(basDevice)) {
            throw new CoolException("机台信息不存在或已禁用！！");
        }
        List<LocAroundBind> binds = locAroundBindService.selectList(new EntityWrapper<LocAroundBind>().eq("dev_no", basDevice.getDevNo()));
        if (Objects.isNull(binds) || binds.isEmpty()) {
            throw new CoolException("机台未绑定工作站台！！");
        }
        Set<String> locs = binds.stream().map(LocAroundBind::getBLocNo).collect(Collectors.toSet());

        LocMast locMasts = locMastService.selectOne(new EntityWrapper<LocMast>()
                .in("loc_no", locs)
                .eq("loc_sts", LocStsType.LOC_STS_TYPE_F.type)
                .orderAsc(Arrays.asList("loc_no"))
                .last("OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"));

        if (Objects.isNull(locMasts)) {
            throw new CoolException("未查到可工作线轴！！");
        }

        //todo 锁库位需WCS锁定（相关库位，不可执行任务操作，不能只在WMS锁定）
        List<LocMast> locMs = locMastService.selectList(new EntityWrapper<LocMast>()
                .in("loc_no", locs)
                .eq("loc_sts", LocStsType.LOC_STS_TYPE_O.type));
        locMs.forEach(loc -> {
            loc.setLocSts(LocStsType.LOC_STS_TYPE_X.type);
            if (!locMastService.updateById(loc)) {
                throw new CoolException("工作台周边库位禁用失败，不可执行穿线操作！！");
    public R pubWorkTask(OpenOrderPakoutParam param) {
        OrderPakout order = orderPakoutService.selectByNo(param.getOrderNo());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
            }
        });

        return R.ok("可执行穿线动作!!");
            orderPakoutService.remove(order.getId());
        }
        DocType docType = docTypeService.selectOrAdd(param.getBillType(), Boolean.FALSE);
        Date now = new Date();
        // 单据主档
        order = new OrderPakout(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                DateUtils.convert(now),    // 单据日期
                docType.getDocId(),    // 单据类型
                null,    // 项目编号
                null,    //
                null,    // 调拨项目编号
                null,    // 初始票据号
                null,    // 票据号
                null,    // 客户编号
                null,    // 客户
                null,    // 联系方式
                null,    // 操作人员
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                null,    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                null,    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                9995L,    // 添加人员
                now,    // 添加时间
                9995L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );
        if (!orderPakoutService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<DetlDto> orderDetails = param.getMatList();
        for (DetlDto detail : orderDetails) {
            DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(),detail.getBrand(),detail.getDevNo(),detail.getStandby2(),detail.getStandby3(),detail.getLineNumber(),
                    detail.getBoxType1(),detail.getBoxType2(),detail.getBoxType3(), detail.getAnfme());
            if (DetlDto.hasLineNumber(list, dto)) {
                DetlDto detlDto = DetlDto.findLineNumber(list, dto.getMatnr(), dto.getBatch(),dto.getBrand(),dto.getDevNo(),dto.getStandby2(),dto.getStandby3(),dto.getLineNumber(),
                        dto.getBoxType1(),dto.getBoxType2(),dto.getBoxType3());
                assert detlDto != null;
                detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
            } else {
                list.add(dto);
            }
        }
        //下发的订单明细，查看库存是否有足够的库存，排除机台的库位
        for (DetlDto detail : list) {
            List<LocDetl> matnr = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("matnr", detail.getMatnr()));
            Double count=0.0;
            for (LocDetl detl : matnr) {
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", detl.getLocNo()).eq("loc_sts","F"));
                if (locMast != null) {
                    LocAroundBind bLocNo = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", locMast.getLocNo()));
                    if (Cools.isEmpty(bLocNo)) {
                        count=detl.getAnfme()+count;
                    }
                }
            }
            if (count<detail.getAnfme()) {
                return R.error("物料="+detail.getMatnr()+"库存不足无法生成订单");
            }
        }
        for (DetlDto detlDto : list) {
            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            OrderDetlPakout orderDetl = new OrderDetlPakout();
            orderDetl.sync(mat);
            orderDetl.setLineNumber(detlDto.getLineNumber());
            orderDetl.setBatch(detlDto.getBatch());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setBrand(detlDto.getBrand());
            orderDetl.setStandby1(detlDto.getStandby1());
            orderDetl.setStandby2(detlDto.getStandby2());
            orderDetl.setStandby3(detlDto.getStandby3());
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setPakinPakoutStatus(2);
            if (!orderDetlPakoutService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
        return  R.ok();
    }

    /**
@@ -96,35 +193,31 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R releaseLock(ReceviceTaskParams params) {
        if (Objects.isNull(params) || Objects.isNull(params.getDeviceNo())) {
        if (Objects.isNull(params) || Objects.isNull(params.getDevNo())) {
            return R.error("参数不能为空！！");
        }

        Integer frozen = params.getFreeze().equals("Y") ? 1 : 0;
        String s = params.getFreeze().equals("Y") ? "冻结" : "解冻";
        BasDevice basDevice = basDeviceService.selectOne(new EntityWrapper<BasDevice>()
                .eq("status", 1)
                .eq("dev_no", params.getDeviceNo()));
                .eq("dev_no", params.getDevNo()));
        if (Objects.isNull(basDevice)) {
            throw new CoolException("机台信息不存在或已禁用！！");
        }
        List<LocAroundBind> binds = locAroundBindService.selectList(new EntityWrapper<LocAroundBind>().eq("dev_no", basDevice.getDevNo()));
        List<LocAroundBind> binds = locAroundBindService.selectList(new EntityWrapper<LocAroundBind>()
                .eq("dev_no", basDevice.getType())
                .eq("freeze", frozen==1? 0:1));
        if (Objects.isNull(binds) || binds.isEmpty()) {
            throw new CoolException("机台未绑定工作站台！！");
        }
        Set<String> locs = binds.stream().map(LocAroundBind::getBLocNo).collect(Collectors.toSet());

        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().in("loc_no", locs).eq("loc_sts", LocStsType.LOC_STS_TYPE_X.type));
        if (Objects.isNull(locMasts) || locMasts.isEmpty()) {
            throw new CoolException("没有禁用库位，不需要释放！！");
            throw new CoolException("机台不需要"+s+"！！");
        }

        locMasts.forEach(loc -> {
           loc.setLocSts(LocStsType.LOC_STS_TYPE_O.type);
           if (!locMastService.updateById(loc)) {
               throw new CoolException("库位释放失败，请检查后再操作！！");
        binds.forEach(loc -> {
           loc.setFreeze(frozen);
           if (!locAroundBindService.updateById(loc)) {
               throw new CoolException("库位"+s+"失败，请检查后再操作！！");
           }
        });

        wcsApiService.reportLockLocs(locs, "lock");

        return R.ok("释放成功 ！！");
        return R.ok(s+"成功 ！！");
    }
}