新建德森项目分支

skyouc

2024-12-21 c635d78b479510ebe2556a420948effcd30a0731

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

@@ -1,197 +1,298 @@
package com.zy.asrs.wms.asrs.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.param.CreateOrderParam;
import com.zy.asrs.wms.asrs.entity.param.UpdateOrderParam;
import com.zy.asrs.wms.asrs.mapper.OrderMapper;
import com.zy.asrs.wms.asrs.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.HashMap;
import java.util.List;

@Service("orderService")
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

    @Autowired
    private MatService matService;
    @Autowired
    private MatFieldService matFieldService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private OrderDetlFieldService orderDetlFieldService;

    @Override
    @Transactional
    public boolean createOrder(CreateOrderParam param) {
        Order order = new Order();
        order.setOrderNo(param.getOrderNo());
        order.setOrderType(param.getOrderType());
        order.setOrderSettle(param.getOrderSettle());
        order.setCreateTime(new Date());
        order.setCreateBy(9527L);
        boolean result = this.save(order);
        if (!result) {
            throw new CoolException("生成订单失败");
        }

        for (HashMap<String, Object> map : param.getList()) {
            double anfme = Double.parseDouble(map.get("anfme").toString());
            String batch = map.get("batch").toString();
            String matnr = map.get("matnr").toString();
            String memo = map.getOrDefault("memo", "").toString();
            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));
            if (mat == null) {
                throw new CoolException(matnr + "物料不存在");
            }

            OrderDetl orderDetl = new OrderDetl();
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setAnfme(anfme);
            orderDetl.setQty(0D);
            orderDetl.setWorkQty(0D);
            orderDetl.setBatch(batch);
            orderDetl.setMatId(mat.getId());
            orderDetl.setMemo(memo);
            orderDetl.setCreateTime(new Date());
            orderDetl.setCreateBy(9527L);
            boolean save = orderDetlService.save(orderDetl);
            if (!save) {
                throw new CoolException("订单明细创建失败");
            }

            //获取扩展字段
            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));
            for (MatField matField : matFields) {
                if (map.containsKey(matField.getName())) {
                    OrderDetlField fieldValue = new OrderDetlField();
                    fieldValue.setDetlId(orderDetl.getId());
                    fieldValue.setFieldId(matField.getId());
                    fieldValue.setName(matField.getName());
                    fieldValue.setValue(map.get(matField.getName()).toString());
                    boolean save1 = orderDetlFieldService.save(fieldValue);
                    if (!save1) {
                        throw new CoolException("订单明细扩展字段创建失败");
                    }
                }
            }

        }

        return true;
    }

    @Override
    public boolean updateOrder(UpdateOrderParam param) {
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, param.getOrderNo()));
        order.setOrderNo(param.getOrderNo());
        order.setOrderType(param.getOrderType());
        order.setOrderSettle(param.getOrderSettle());
        order.setUpdateTime(new Date());
        order.setUpdateBy(9527L);
        boolean result = this.updateById(order);
        if (!result) {
            throw new CoolException("修改订单失败");
        }

        for (HashMap<String, Object> map : param.getList()) {
            double anfme = Double.parseDouble(map.get("anfme").toString());
            String batch = map.get("batch").toString();
            String matnr = map.get("matnr").toString();
            String memo = map.getOrDefault("memo", "").toString();
            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));
            if (mat == null) {
                throw new CoolException(matnr + "物料不存在");
            }

            OrderDetl orderDetl = null;
            if (map.containsKey("detlId")) {
                orderDetl = orderDetlService.getById(map.get("detlId").toString());
            }

            if(orderDetl == null) {
                orderDetl = new OrderDetl();
                orderDetl.setOrderId(order.getId());
                orderDetl.setOrderNo(order.getOrderNo());
                orderDetl.setAnfme(anfme);
                orderDetl.setQty(0D);
                orderDetl.setWorkQty(0D);
                orderDetl.setBatch(batch);
                orderDetl.setMatId(mat.getId());
                orderDetl.setMemo(memo);
                orderDetl.setCreateTime(new Date());
                orderDetl.setCreateBy(9527L);
            }else {
                orderDetl.setOrderNo(order.getOrderNo());
                orderDetl.setAnfme(anfme);
                orderDetl.setBatch(batch);
                orderDetl.setMemo(memo);
                orderDetl.setUpdateTime(new Date());
                orderDetl.setUpdateBy(9527L);
            }
            boolean save = orderDetlService.saveOrUpdate(orderDetl);
            if (!save) {
                throw new CoolException("订单明细修改失败");
            }

            //获取扩展字段
            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));
            for (MatField matField : matFields) {
                if (map.containsKey(matField.getName())) {
                    OrderDetlField fieldValue = orderDetlFieldService.getOne(new LambdaQueryWrapper<OrderDetlField>()
                            .eq(OrderDetlField::getDetlId, orderDetl.getId())
                            .eq(OrderDetlField::getFieldId, matField.getId()));
                    if (fieldValue == null) {
                        fieldValue = new OrderDetlField();
                        fieldValue.setDetlId(orderDetl.getId());
                        fieldValue.setFieldId(matField.getId());
                        fieldValue.setName(matField.getName());
                        fieldValue.setValue(map.get(matField.getName()).toString());
                    }else {
                        fieldValue.setValue(map.get(matField.getName()).toString());
                    }

                    boolean save1 = orderDetlFieldService.saveOrUpdate(fieldValue);
                    if (!save1) {
                        throw new CoolException("订单明细扩展字段修改失败");
                    }
                }
            }

        }

        List<Long> deleteDetlId = param.getDeleteDetlId();
        if (!deleteDetlId.isEmpty()) {
            for (Long detlId : deleteDetlId) {
                //删除明细
                orderDetlService.removeById(detlId);
                //删除明细对应的扩展字段
                orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, detlId));
            }
        }

        return true;
    }

    @Override
    public boolean deleteOrder(Long orderId) {
        //删除订单
        this.removeById(orderId);
        //删除明细
        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, orderId));
        for (OrderDetl orderDetl : orderDetls) {
            orderDetlService.removeById(orderDetl.getId());//删除明细
            //删除明细对应的扩展字段
            orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, orderDetl.getId()));
        }
        return true;
    }
}
package com.zy.asrs.wms.asrs.service.impl;



import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.zy.asrs.framework.common.Cools;

import com.zy.asrs.framework.exception.CoolException;

import com.zy.asrs.wms.asrs.entity.*;

import com.zy.asrs.wms.asrs.entity.dto.OrderInfoDto;

import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType;

import com.zy.asrs.wms.asrs.entity.param.CreateOrderParam;

import com.zy.asrs.wms.asrs.entity.param.UpdateOrderParam;

import com.zy.asrs.wms.asrs.mapper.OrderMapper;

import com.zy.asrs.wms.asrs.service.*;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.zy.asrs.wms.utils.OrderUtils;

import com.zy.asrs.wms.utils.Utils;

import io.netty.util.internal.StringUtil;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;



import java.text.SimpleDateFormat;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;



@Service("orderService")

public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {



    @Autowired

    private MatService matService;

    @Autowired

    private MatFieldService matFieldService;

    @Autowired

    private OrderDetlService orderDetlService;

    @Autowired

    private OrderDetlFieldService orderDetlFieldService;

    @Autowired

    private OrderNoRuleService orderNoRuleService;

    @Autowired

    private OrderUtils orderUtils;



    @Override

    @Transactional

    public boolean createOrder(List<CreateOrderParam> list) {

        for (CreateOrderParam orderParam : list) {

            createOrder(orderParam);

        }

        return true;

    }



    @Override

    @Transactional

    public boolean createOrder(CreateOrderParam param) {

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");



        List<Order> orderList = this.list(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, param.getOrderNo()));

        if (!orderList.isEmpty()) {

            throw new CoolException("订单已存在");

        }



        String orderNo = param.getOrderNo();

        if (Cools.isEmpty(param.getOrderNo())) {

            orderNo = orderNoRuleService.getOrderNo(param.getOrderType().intValue());

        }



        Order order = new Order();

        order.setOrderNo(orderNo);

        order.setOrderType(param.getOrderType());

        order.setOrderSettle(OrderSettleType.INIT.val());

        order.setIoPri(orderUtils.getIoPri());

        order.setOrderTime(format.format(new Date()));

        order.setCreateTime(new Date());

        order.setCreateBy(9527L);

        boolean result = this.save(order);

        if (!result) {

            throw new CoolException("生成订单失败");

        }



        for (HashMap<String, Object> map : param.getList()) {

            double anfme = Double.parseDouble(map.get("anfme").toString());

            String batch = map.get("batch").toString();

            String matnr = map.get("matnr").toString();

            Double qty = 0D;

            Double workQty = 0D;

            if (map.containsKey("qty")) {

                qty = Double.parseDouble(map.get("qty").toString());

            }

            if (map.containsKey("workQty")) {

                workQty = Double.parseDouble(map.get("workQty").toString());

            }

            String memo = map.getOrDefault("memo", "").toString();

            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));

            if (mat == null) {

                throw new CoolException(matnr + "物料不存在");

            }



            OrderDetl orderDetl = new OrderDetl();

            orderDetl.setOrderId(order.getId());

            orderDetl.setOrderNo(order.getOrderNo());

            orderDetl.setAnfme(anfme);

            orderDetl.setQty(qty);

            orderDetl.setWorkQty(workQty);

            orderDetl.setBatch(batch);

            orderDetl.setMatId(mat.getId());

            orderDetl.setMemo(memo);

            orderDetl.setCreateTime(new Date());

            orderDetl.setCreateBy(9527L);

            boolean save = orderDetlService.save(orderDetl);

            if (!save) {

                throw new CoolException("订单明细创建失败");

            }



            //获取扩展字段

            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));

            for (MatField matField : matFields) {

                if (map.containsKey(matField.getName())) {

                    OrderDetlField fieldValue = new OrderDetlField();

                    fieldValue.setDetlId(orderDetl.getId());

                    fieldValue.setFieldId(matField.getId());

                    fieldValue.setName(matField.getName());

                    fieldValue.setValue(map.get(matField.getName()).toString());

                    boolean save1 = orderDetlFieldService.save(fieldValue);

                    if (!save1) {

                        throw new CoolException("订单明细扩展字段创建失败");

                    }

                }

            }



            orderDetl.setStockIndex(Utils.getMatUniqueKey(matnr, batch, orderDetl.getUniqueField()));

            if (!orderDetlService.updateById(orderDetl)) {

                throw new CoolException("更新明细索引失败");

            }



        }



        return true;

    }



    @Override

    public boolean updateOrder(UpdateOrderParam param) {

        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getId, param.getOrderId()));

        if (order == null) {

            throw new CoolException("订单不存在");

        }



        if (order.getHasWave() == 1) {

            throw new CoolException("订单已经生成波次，无法修改");

        }



        order.setOrderType(param.getOrderType());

        order.setOrderSettle(param.getOrderSettle());

        order.setUpdateTime(new Date());

        order.setUpdateBy(9527L);

        boolean result = this.updateById(order);

        if (!result) {

            throw new CoolException("修改订单失败");

        }



        for (HashMap<String, Object> map : param.getList()) {

            double anfme = Double.parseDouble(map.get("anfme").toString());

            String batch = map.get("batch").toString();

            String matnr = map.get("matnr").toString();

            Double qty = Double.parseDouble(map.get("qty").toString());

            Double workQty = Double.parseDouble(map.get("workQty").toString());

            String memo = map.getOrDefault("memo", "").toString();

            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));

            if (mat == null) {

                throw new CoolException(matnr + "物料不存在");

            }



            OrderDetl orderDetl = null;

            if (map.containsKey("detlId")) {

                orderDetl = orderDetlService.getById(map.get("detlId").toString());

            }



            if(orderDetl == null) {

                orderDetl = new OrderDetl();

                orderDetl.setOrderId(order.getId());

                orderDetl.setOrderNo(order.getOrderNo());

                orderDetl.setAnfme(anfme);

                orderDetl.setQty(0D);

                orderDetl.setWorkQty(0D);

                orderDetl.setBatch(batch);

                orderDetl.setMatId(mat.getId());

                orderDetl.setMemo(memo);

                orderDetl.setCreateTime(new Date());

                orderDetl.setCreateBy(9527L);

            }else {

                orderDetl.setOrderNo(order.getOrderNo());

                orderDetl.setAnfme(anfme);

                orderDetl.setQty(qty);

                orderDetl.setWorkQty(workQty);

                orderDetl.setBatch(batch);

                orderDetl.setMemo(memo);

                orderDetl.setUpdateTime(new Date());

                orderDetl.setUpdateBy(9527L);

            }

            boolean save = orderDetlService.saveOrUpdate(orderDetl);

            if (!save) {

                throw new CoolException("订单明细修改失败");

            }



            //获取扩展字段

            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));

            for (MatField matField : matFields) {

                if (map.containsKey(matField.getName())) {

                    OrderDetlField fieldValue = orderDetlFieldService.getOne(new LambdaQueryWrapper<OrderDetlField>()

                            .eq(OrderDetlField::getDetlId, orderDetl.getId())

                            .eq(OrderDetlField::getFieldId, matField.getId()));

                    if (fieldValue == null) {

                        fieldValue = new OrderDetlField();

                        fieldValue.setDetlId(orderDetl.getId());

                        fieldValue.setFieldId(matField.getId());

                        fieldValue.setName(matField.getName());

                        fieldValue.setValue(map.get(matField.getName()).toString());

                    }else {

                        fieldValue.setValue(map.get(matField.getName()).toString());

                    }



                    boolean save1 = orderDetlFieldService.saveOrUpdate(fieldValue);

                    if (!save1) {

                        throw new CoolException("订单明细扩展字段修改失败");

                    }

                }

            }



            orderDetl.setStockIndex(Utils.getMatUniqueKey(matnr, batch, orderDetl.getUniqueField()));

            if (!orderDetlService.updateById(orderDetl)) {

                throw new CoolException("更新明细索引失败");

            }



        }



        List<Long> deleteDetlId = param.getDeleteDetlId();

        if (!deleteDetlId.isEmpty()) {

            for (Long detlId : deleteDetlId) {

                //删除明细

                orderDetlService.removeById(detlId);

                //删除明细对应的扩展字段

                orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, detlId));

            }

        }



        return true;

    }



    @Override

    public boolean deleteOrder(Long orderId) {

        Order order = this.getById(orderId);

        if (order.getHasWave() == 1) {

            throw new CoolException("订单已经生成波次，删除失败");

        }



        //删除订单

        this.removeById(orderId);

        //删除明细

        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, orderId));

        for (OrderDetl orderDetl : orderDetls) {

            orderDetlService.removeById(orderDetl.getId());//删除明细

            //删除明细对应的扩展字段

            orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, orderDetl.getId()));

        }

        return true;

    }



    @Override

    public boolean checkOrderComplete(Long orderId) {

        Order order = this.getById(orderId);

        if (order == null) {

            return false;

        }



        boolean complete = true;

        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, orderId));

        if(orderDetls.isEmpty()) {

            complete = false;

        }



        for (OrderDetl orderDetl : orderDetls) {

            if (!orderDetl.getAnfme().equals(orderDetl.getQty())) {

                complete = false;

            }

        }



        return complete;

    }



    @Override

    public Order selectByBarcode(String barcode) {

        return this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, barcode), false);

    }



    @Override

    public List<OrderInfoDto> getDetlForOrderId(Long id) {

        return this.baseMapper.getDetlForOrderId(id);

    }

}