#

mrzhssss

2022-03-24 4c1e8761e3fa0516d5e6d316e838e83c8e0f5edf

 src/main/java/zy/cloud/wms/manager/service/impl/WorkServiceImpl.java

@@ -14,6 +14,7 @@
import zy.cloud.wms.common.model.MatnrDto;
import zy.cloud.wms.common.model.OrderStoDto;
import zy.cloud.wms.common.model.ReceiveStoDto;
import zy.cloud.wms.common.model.WaveStoDto;
import zy.cloud.wms.common.service.MainService;
import zy.cloud.wms.common.utils.VersionUtils;
import zy.cloud.wms.manager.entity.*;
@@ -60,6 +61,12 @@
    private ReceiveService receiveService;
    @Autowired
    private ReceiveDetlService receiveDetlService;
    @Autowired
    ReceiveLogService receiveLogService;
    @Autowired
    private WaveService waveService;
    @Autowired
    private WaveDetlService waveDetlService;


    @Override
@@ -115,6 +122,23 @@
            if (!pakinService.insert(pakin)) {
                throw new CoolException("保存入库记录失败");
            }

            /**
             * 上架完成之后,存放数据至上架统计表 man_receive_log
             */
            ReceiveLog receiveLog = new ReceiveLog();
            receiveLog.setOrderNo("");//单号
            receiveLog.setNodeId(node.getId());//库位号id
            receiveLog.setNodeName(node.getName());//库位名称
            receiveLog.setMatnr(dto.getMatnr());//物料编码
            receiveLog.setAnfme(dto.getCount());//数量
            receiveLog.setBatch(dto.getBatch());//批号
            receiveLog.setCreateBy(userId);//添加人员
            receiveLog.setUpdateBy(userId);//修改人员
            receiveLog.setCreateTime(now);
            receiveLog.setUpdateTime(now);
            receiveLog.setIoType(1);
            receiveLogService.insert(receiveLog);
            // 修改库存
            LocDetl locDetl = locDetlService.getLocDetl(node.getId(), dto.getMatnr());
            if (locDetl == null) {
@@ -126,6 +150,7 @@
                locDetl.setZpallet("");
                locDetl.setAnfme(dto.getCount());
                VersionUtils.setLocDetl(locDetl, mat);
                locDetl.setBatch(dto.getBatch());
//                locDetl.setDocId(param.getDocType().longValue());
//                locDetl.setDocNum(docNum);
                locDetl.setStatus(1);
@@ -275,12 +300,12 @@

    @Override
    public R stockOutPreview(StockOutParam param, Long userId, Long hostId) {
        Wrapper<Receive> wrapper = new EntityWrapper<Receive>()
        Wrapper<Order> wrapper = new EntityWrapper<Order>()
                .eq("order_no", param.getOrderNo());
        if (hostId != null) {
            wrapper.eq("host_id", hostId);
        }
        Receive order_no = receiveService.selectOne(wrapper);
        Order order_no = orderService.selectOne(wrapper);

        if (order_no.getSettle() != 1){
            return R.error("此单据无法生成拣货单");
@@ -289,8 +314,8 @@
//        if (order.getSettle() != 1) {
//            return R.error("此单据无法生成拣货单");
//        }
        List<ReceiveDetl> receiveDetls = receiveDetlService.selectByOrderNo(order_no.getOrderNo(), hostId);
        if (Cools.isEmpty(receiveDetls)) {
        List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order_no.getOrderNo(), hostId);
        if (Cools.isEmpty(orderDetls)) {
            return R.error("此单据已失效，请联系管理员");
        }
//        List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order.getOrderNo(), hostId);
@@ -298,32 +323,34 @@
//            return R.error("此单据已失效，请联系管理员");
//        }

        ReceiveStoDto receiveStoDto = new ReceiveStoDto().create(order_no.getOrderNo(), receiveDetls);
        OrderStoDto orderStoDto = new OrderStoDto().create(order_no.getOrderNo(), orderDetls);
//        OrderStoDto dto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
        return R.ok().add(mainService.receiveStockOutPreview(receiveStoDto, hostId));
        return R.ok().add(mainService.orderOutPreview(orderStoDto, hostId));
    }

    @Override
    public R stockOutCreate(StockOutParam param, Long userId, Long hostId) {
        Receive receive = receiveService.selectByOrderNo(param.getOrderNo(), hostId);
//        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (receive.getSettle() != 1) {
//        Receive receive = receiveService.selectByOrderNo(param.getOrderNo(), hostId);
        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (order.getSettle() != 1) {
            return R.error("此单据无法生成拣货单");
        }
        List<ReceiveDetl> receiveDetls = receiveDetlService.selectByOrderNo(param.getOrderNo(), hostId);
        List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(param.getOrderNo(), hostId);
//        List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(param.getOrderNo(), hostId);
        if (Cools.isEmpty(receiveDetls)) {
        if (Cools.isEmpty(orderDetls)) {
            return R.error("此单据已失效，请联系管理员");
        }
        ReceiveStoDto receiveStoDto = new ReceiveStoDto().create(receive.getOrderNo(), receiveDetls);
        OrderStoDto orderStoDto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
//        OrderStoDto dto = new OrderStoDto().create(receive.getOrderNo(), receiveDetls);
        // 开始整理出库数据
        mainService.receiveStockOutProcess(receiveStoDto,hostId);
        mainService.orderStockOutProcess(orderStoDto,hostId,userId);
        return R.ok("生成拣货单成功");
    }


    @Override
    public R stockOutPrint(StockOutParam param, Long userId, Long hostId) {

        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (order == null) {
            return R.error("此单据已失效");
@@ -340,6 +367,27 @@
        vo.setCstmrName(order.getCstmrName());
        vo.setWorkerName(Cools.isEmpty(order.getOperMemb())? "" : order.getOperMemb());
        return R.ok().add(vo);
    }

    @Override
    public R stockInPrint(StockOutParam param, Long userId, Long hostId) {
        Receive receive = receiveService.selectByOrderNo(param.getOrderNo(), hostId);
        if (receive == null) {
            return R.error("此单据已失效");
        }
        List<Pakout> pakouts = pakoutService.selectList(new EntityWrapper<Pakout>().eq("doc_num", receive.getOrderNo()).eq("host_id", hostId));
        Double total = 0.0D;
        for (Pakout pakout : pakouts) {
            total = pakout.getAnfme() + total;
        }
        StoPrintVo vo = new StoPrintVo();
        vo.setDocNum(param.getOrderNo());
        vo.setList(pakouts);
        vo.setTotal(total);
        vo.setCstmrName(receive.getCstmrName());
        vo.setWorkerName(Cools.isEmpty(receive.getOperMemb())? "" : receive.getOperMemb());
        return R.ok().add(vo);

    }

    @Override
@@ -540,13 +588,11 @@
        }
        return R.ok("拣货单已取消");
    }

    @Override
    @Transactional
    public R initOrder(InitOrderParam param, Long userId, Long hostId) {
     public R  initReceive(InitOrderParam param, Long userId, Long hostId){
        Receive order_no = receiveService.selectOne(new EntityWrapper<Receive>()
                .eq("order_no", param.getOrderNo()));
//        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (order_no != null) {
            return R.error("抱歉单号已存在，请修改单号");
        }
@@ -591,10 +637,115 @@
                now,    // 修改时间
                null    // 备注
        );
        if (!receiveService.insert(order_no)) {
            throw new CoolException("保存订单表头失败！");
        }

        // 遍历商品数量并保存
        for (MatnrDto dto : param.getList()){
            Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
            if (mat == null) {
                log.error("{}商品不存在。", dto.getMatnr());
                continue;
            }
            ReceiveDetl receiveDetl = new ReceiveDetl();
            receiveDetl.setHostId(hostId);
            receiveDetl.setOrderId(order_no.getId());
            receiveDetl.setAnfme(dto.getCount());
            receiveDetl.setCreateTime(now);
            receiveDetl.setCreateBy(userId);
            receiveDetl.setUpdateBy(userId);
            receiveDetl.setUpdateTime(now);
            receiveDetl.setStatus(1);
            receiveDetl.setMatnr(mat.getMatnr());
            receiveDetl.setMaktx(mat.getMaktx());
            receiveDetl.setName(mat.getName());
            receiveDetl.setSpecs(mat.getSpecs());
            receiveDetl.setModel(mat.getModel());
            receiveDetl.setBatch(mat.getBatch());
            receiveDetl.setUnit(mat.getUnit());
            receiveDetl.setBarcode(mat.getBarcode());
            receiveDetl.setItemNum(mat.getItemNum());
            receiveDetl.setCount(dto.getCount());
            receiveDetl.setUnitPrice(mat.getPrice());
            receiveDetl.setWeight(mat.getWeight());
            if (!receiveDetlService.insert(receiveDetl)) {
                throw new CoolException("保存订单明细失败");
            }
        }
        return R.ok("创建订单成功");
    }

    @Override
    @Transactional
    public R initOrder(InitOrderParam param, Long userId, Long hostId) {
       // Receive order_no = receiveService.selectOne(new EntityWrapper<Receive>()
        //        .eq("order_no", param.getOrderNo()));
        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (order != null) {
            return R.error("抱歉单号已存在，请修改单号");
        }
        Date now = new Date();
        Item item = itemService.selectByName(param.getItem());
        Cstmr cstmr = cstmrService.selectByName(param.getCstmr());
        // 新增订单表头
        Order order1 = new Order();
        order1.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        order1.setHostId(hostId);
        order1.setOrderNo(param.getOrderNo());
        order1.setOrderTime(param.getOrderTime());
        order1.setDocType(param.getDocType());
        order1.setItemId(item == null? null : item.getId());
        order1.setItemName(param.getItem());
        order1.setCstmr(cstmr == null? null : cstmr.getId());
        order1.setCstmrName(param.getCstmr());
        order1.setSettle(1L);
        order1.setStatus(1);
        order1.setCreateBy(userId);
        order1.setCreateTime(now);
        order1.setUpdateBy(userId);
        order1.setUpdateTime(now);
//        order_no = new Receive(
//                hostId,
//                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
//                param.getOrderNo(),    // 订单编号
//                param.getOrderTime(),    // 单据日期
//                param.getDocType(),    // 单据类型
//                item==null?null:item.getId(),    // 项目编号
//                param.getItem(),   // 项目名称
//                null,    // 调拨项目编号
//                null,    // 初始票据号
//                null,    // 票据号
//                cstmr==null?null:cstmr.getId(),    // 客户编号
//                param.getCstmr(),    // 客户
//                null,    // 联系方式
//                null,    // 操作人员
//                null,    // 合计金额
//                null,    // 优惠率
//                null,    // 优惠金额
//                null,    // 销售或采购费用合计
//                null,    // 实付金额
//                null,    // 付款类型
//                null,    // 业务员
//                null,    // 结算天数
//                null,    // 邮费支付类型
//                null,    // 邮费
//                null,    // 付款时间
//                null,    // 发货时间
//                null,    // 物流名称
//                null,    // 物流单号
//                1L,    // 订单状态
//                1,    // 状态
//                userId,    // 添加人员
//                now,    // 添加时间
//                userId,    // 修改人员
//                now,    // 修改时间
//                null    // 备注
//        );
//        if (!orderService.insert(order)) {
//            throw new CoolException("保存订单表头失败！");
//        }
        if (!receiveService.insert(order_no)) {
        if (!orderService.insert(order1)) {
            throw new CoolException("保存订单表头失败！");
        }

@@ -626,28 +777,29 @@
                log.error("{}商品不存在。", dto.getMatnr());
                continue;
            }
            ReceiveDetl receiveDetl = new ReceiveDetl();
            receiveDetl.setHostId(hostId);
            receiveDetl.setOrderId(order_no.getId());
            receiveDetl.setAnfme(dto.getCount());
            receiveDetl.setCreateTime(now);
            receiveDetl.setCreateBy(userId);
            receiveDetl.setUpdateBy(userId);
            receiveDetl.setUpdateTime(now);
            receiveDetl.setStatus(1);
            receiveDetl.setMatnr(mat.getMatnr());
            receiveDetl.setMaktx(mat.getMaktx());
            receiveDetl.setName(mat.getName());
            receiveDetl.setSpecs(mat.getSpecs());
            receiveDetl.setModel(mat.getModel());
            receiveDetl.setBatch(mat.getBatch());
            receiveDetl.setUnit(mat.getUnit());
            receiveDetl.setBarcode(mat.getBarcode());
            receiveDetl.setItemNum(mat.getItemNum());
            receiveDetl.setCount(mat.getCount());
            receiveDetl.setUnitPrice(mat.getPrice());
            receiveDetl.setWeight(mat.getWeight());
            if (!receiveDetlService.insert(receiveDetl)) {
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.setHostId(hostId);
            orderDetl.setOrderId(order1.getId());
            orderDetl.setOrderNo(order1.getOrderNo());
            orderDetl.setAnfme(dto.getCount());
            orderDetl.setCreateTime(now);
            orderDetl.setCreateBy(userId);
            orderDetl.setUpdateBy(userId);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setMatnr(mat.getMatnr());
            orderDetl.setMaktx(mat.getMaktx());
            orderDetl.setName(mat.getName());
            orderDetl.setSpecs(mat.getSpecs());
            orderDetl.setModel(mat.getModel());
            orderDetl.setBatch(mat.getBatch());
            orderDetl.setUnit(mat.getUnit());
            orderDetl.setBarcode(mat.getBarcode());
            orderDetl.setItemNum(mat.getItemNum());
            orderDetl.setCount(mat.getCount() == null ? 0 : mat.getCount());
            orderDetl.setUnitPrice(mat.getPrice());
            orderDetl.setWeight(mat.getWeight());
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("保存订单明细失败");
            }
        }
@@ -853,4 +1005,130 @@
        return R.ok();
    }

    @Override
//    @Transactional
    public R initOutOrder(InitOrderParam param, Long userId, Long hostId) {
        Order order_no = orderService.selectOne(new EntityWrapper<Order>()
                .eq("order_no", param.getOrderNo()));
//        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
        if (order_no != null) {
            return R.error("抱歉单号已存在，请修改单号");
        }
        Date now = new Date();
        Item item = itemService.selectByName(param.getItem());
        Cstmr cstmr = cstmrService.selectByName(param.getCstmr());

        // 新增订单表头
        order_no = new Order();
        order_no.setHostId(hostId);
        order_no.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        order_no.setOrderNo(param.getOrderNo());
        order_no.setOrderTime(param.getOrderTime());
        order_no.setDocType(param.getDocType());
        order_no.setItemId(item==null?null:item.getId());
        order_no.setItemName(param.getItem());
        order_no.setCstmr(cstmr==null?null:cstmr.getId());
        order_no.setCstmrName(param.getCstmr());
        order_no.setSettle(1L);
        order_no.setStatus(1);
        order_no.setCreateTime(now);
        order_no.setCreateBy(userId);
        order_no.setUpdateTime(now);
        order_no.setUpdateBy(userId);

//        if (!orderService.insert(order)) {
//            throw new CoolException("保存订单表头失败！");
//        }
        if (!orderService.insert(order_no)) {
            throw new CoolException("保存订单表头失败！");
        }

//        // 遍历商品数量并保存
//        for (MatnrDto dto : param.getList()){
//            Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
//            if (mat == null) {
//                log.error("{}商品不存在。", dto.getMatnr());
//                continue;
//            }
//            OrderDetl orderDetl = new OrderDetl();
//            orderDetl.setHostId(hostId);
//            orderDetl.setOrderId(order.getId());  // 订单内码
//            orderDetl.setAnfme(dto.getCount());         // 数量
//            orderDetl.setCreateBy(userId);
//            orderDetl.setCreateTime(now);
//            orderDetl.setUpdateBy(userId);
//            orderDetl.setUpdateTime(now);
//            orderDetl.setStatus(1);
//            VersionUtils.setOrderDetl(orderDetl, mat);
//            if (!orderDetlService.insert(orderDetl)) {
//                throw new CoolException("保存订单明细失败");
//            }
//        }
        // 遍历商品数量并保存
        for (MatnrDto dto : param.getList()){
            Mat mat = matService.selectByMatnr(hostId, dto.getMatnr());
            if (mat == null) {
                log.error("{}商品不存在。", dto.getMatnr());
                continue;
            }
            OrderDetl orderDtel = new OrderDetl();
            orderDtel.setHostId(hostId);
            orderDtel.setOrderId(order_no.getId());
            orderDtel.setAnfme(dto.getCount());
            orderDtel.setCreateTime(now);
            orderDtel.setCreateBy(userId);
            orderDtel.setUpdateBy(userId);
            orderDtel.setUpdateTime(now);
            orderDtel.setStatus(1);
            orderDtel.setMatnr(mat.getMatnr());
            orderDtel.setMaktx(mat.getMaktx());
            orderDtel.setName(mat.getName());
            orderDtel.setSpecs(mat.getSpecs());
            orderDtel.setModel(mat.getModel());
            orderDtel.setBatch(mat.getBatch());
            orderDtel.setUnit(mat.getUnit());
            orderDtel.setBarcode(mat.getBarcode());
            orderDtel.setItemNum(mat.getItemNum());
            orderDtel.setCount(mat.getCount() == null ? 0 : mat.getCount());
            orderDtel.setUnitPrice(mat.getPrice());
            orderDtel.setWeight(mat.getWeight());
            if (!orderDetlService.insert(orderDtel)) {
                throw new CoolException("保存订单明细失败");
            }
        }
        return R.ok("创建订单成功");
    }

    @Override
    public R wavePreview(StockOutParam stockOutParam, Long userId, Long hostId) {
        Wrapper<Wave> wrapper = new EntityWrapper<Wave>()
                .eq("id", stockOutParam.getOrderNo());

        if (hostId != null) {
            wrapper.eq("host_id", hostId);
        }
        Wave wave = waveService.selectOne(wrapper);

        if (wave.getStatus() != 0){
            return R.error("此单据无法生成拣货单");
        }
//        Order order = orderService.selectByOrderNo(param.getOrderNo(), hostId);
//        if (order.getSettle() != 1) {
//            return R.error("此单据无法生成拣货单");
//        }
        List<WaveDetl> waveDetls = waveDetlService.selectList(new EntityWrapper<WaveDetl>()
                .eq("wave_id", stockOutParam.getOrderNo()));
        if (Cools.isEmpty(waveDetls)) {
            return R.error("此单据已失效，请联系管理员");
        }
//        List<OrderDetl> orderDetls = orderDetlService.selectByOrderNo(order.getOrderNo(), hostId);
//        if (Cools.isEmpty(orderDetls)) {
//            return R.error("此单据已失效，请联系管理员");
//        }

        WaveStoDto waveStoDto = new WaveStoDto().create(stockOutParam.getOrderNo(),waveDetls);
//        OrderStoDto dto = new OrderStoDto().create(order.getOrderNo(), orderDetls);
        return R.ok().add(mainService.waveOutPreview(waveStoDto, hostId));
    }

}