iboss-server-mdm/src/main/java/com/dk/mdm/service/sale/OrderService.java

package com.dk.mdm.service.sale;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.dk.common.exception.BaseBusinessException;
import com.dk.common.infrastructure.annotaiton.Pagination;
import com.dk.common.infrastructure.constant.Constant;
import com.dk.common.infrastructure.enums.ErrorCodeEnum;
import com.dk.common.model.pojo.PageList;
import com.dk.common.response.ResponseCodeEnum;
import com.dk.common.response.ResponseResultUtil;
import com.dk.common.response.ResponseResultVO;
import com.dk.mdm.infrastructure.convert.sale.OrderConvert;
import com.dk.mdm.infrastructure.convert.sale.OrderItemConvert;
import com.dk.mdm.mapper.mst.CustomerMapper;
import com.dk.mdm.mapper.sale.OrderItemMapper;
import com.dk.mdm.mapper.sale.OrderMapper;
import com.dk.mdm.model.pojo.mst.Customer;
import com.dk.mdm.model.pojo.sale.Order;
import com.dk.common.service.BaseService;
import com.dk.common.mapper.BaseMapper;
import com.dk.mdm.model.pojo.sale.OrderItem;
import com.dk.mdm.model.query.sale.OrderItemQuery;
import com.dk.mdm.model.query.sale.OrderQuery;
import com.dk.mdm.model.response.sale.OrderItemResponse;
import com.dk.mdm.model.response.sale.OrderResponse;
import com.dk.mdm.model.vo.sale.OrderItemVO;
import com.dk.mdm.model.vo.sale.OrderVO;
import com.dk.mdm.service.common.CommonService;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional
public class OrderService extends BaseService<Order> {

    @Override
    public String getPrimaryKey() {
        return "order_id";
    }

    @Override
    public BaseMapper<Order> getRepository() {
        return orderMapper;
    }

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderConvert orderConvert;

    @Autowired
    private OrderItemConvert orderItemConvert;

    @Autowired
    private OrderItemService orderItemService;

    @Autowired
    private OrderItemMapper orderItemMapper;

    @Autowired
    private CommonService commonService;

    @Autowired
    private CustomerMapper customerMapper;

    /**
     * @desc : 条件查询
     * @author : 付斌
     * @date : 2023/1/9 10:40
     */
    @Pagination
    public ResponseResultVO<PageList<OrderResponse>> selectByCond(OrderQuery orderQuery) {
        return super.mergeListWithCount(orderQuery, orderMapper.selectByCond(orderQuery),
                orderMapper.countByCond(orderQuery));
    }

    /**
     * @desc : 查询订单明细（货物、收款、附件）
     * @author : 付斌
     * @date : 2024-02-28 13:25
     */
    @Pagination
    public ResponseResultVO<Map<String, Object>> selectOrderItemById(String id) {
        Map<String, Object> result = new HashMap<>();
        // 商品明细
        List<OrderItemResponse> orderItem = orderItemMapper.selectByCond(new OrderItemQuery().setOrderId(id));
        result.put("orderItem", orderItem);

        // 收款

        // 附件
        return ResponseResultUtil.success(result);
    }

    /**
     * @desc : 新建方法
     * @author : 付斌
     * @date : 2023/1/9 10:49
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public ResponseResultVO<?> insert(OrderVO orderVO) {

        // 如果没有客户id，要新建
        if (orderVO.getCusId() == null) {
            List<Customer> listCustomer = customerMapper.selectByCond(new Customer().setCpId(orderVO.getCpId()).setCusPhone(orderVO.getCusPhone()));
            // 如果客户电话已存在
            if (listCustomer.size() > 0) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ISEXISTS_CUSPHONE.getMessage());
            }
            // 创建客户,获取编码和主键UuId
            Map<String, Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.CUSTOMER.getName(), true);
            Customer customer = new Customer();
            customer.setCusId(codeMap.get("outId").toString()).setCusCode(codeMap.get("outNote").toString()).setCusName(orderVO.getCusName())
                    .setCusPhone(orderVO.getCusPhone()).setAddressArea(orderVO.getAddressArea()).setAddressName(orderVO.getAddressName())
                    .setAddressNo(orderVO.getAddressNo()).setAddressGcj02(orderVO.getAddressGcj02()).setAddressFull(orderVO.getAddressFull())
                    .setContactName(orderVO.getContactName()).setContactPhone(orderVO.getContactPhone()).setCusFrom(orderVO.getCusFrom())
                    .setChannelId(orderVO.getSalesChannel()).setOrgId(orderVO.getOrgId()).setStaffId(orderVO.getStaffId())
                    .setReportStaff(orderVO.getMakeStaff()).setSaleStatus(Constant.SaleStatus.CHENGJIAO.getName()).setCpId(orderVO.getCpId());
            customerMapper.insert(customer);
            orderVO.setCusId(customer.getCusId());
        }

        // 获取单号
        Map<String , Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.ORDER.getName(),false);
        orderVO.setOrderId(codeMap.get("outId").toString()).setOrderNo(codeMap.get("outNote").toString())
                .setOrderType(Constant.DocumentType.ORDER_CHASE.getName());
        // 转化实体
        Order order = orderConvert.convertToPo(orderVO);
        // 订单总单保存
        super.insert(order);

//        // 更新单号
//        Order updateOrder = new Order();
//        updateOrder.setOrderNo(commonMapper.getDocNo(order.getCpId(), order.getOrderId(), Constant.DocumentType.ORDER_CHASE.getName()));
//        updateOrder.setOrderId(order.getOrderId());
//        super.update(updateOrder,new UpdateWrapper<Order>().lambda().eq(Order::getOrderId,
//                UUID.fromString(updateOrder.getOrderId())));

        // 订单明细保存
        if (orderVO.getItemList() != null && orderVO.getItemList().size() > 0) {
            for (OrderItemVO orderItemVO : orderVO.getItemList()) {
                OrderItem orderItem = orderItemConvert.convertToPo(orderItemVO);
                orderItem.setOrderId(order.getOrderId()).setCpId(order.getCpId()).setOutStatus(Constant.OutStatus.DAICHUKU.getName());
                orderItemMapper.insert(orderItem);
            }
        }
        return ResponseResultUtil.success();
    }

    /**
     * @desc   : 获取订单信息（编辑用）
     * @author : 付斌
     * @date   : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOrderForUpdate(String id) {
        Map<String, Object> orderInfo = new HashMap<>();
        OrderResponse orderResponse = orderMapper.selectById(id);
        orderInfo.put("order", orderResponse);

        // 商品明细
        List<OrderItemResponse> orderItem = orderItemMapper.selectByCond(new OrderItemQuery().setOrderId(id));
        orderInfo.put("orderItem", orderItem);
        return ResponseResultUtil.success(orderInfo);
    }

    /**
     * @desc : 编辑方法
     * @author : 付斌
     * @date : 2023/1/9 10:49
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public ResponseResultVO<Boolean> update(OrderVO orderVO) {
        // 转化实体
        Order order = orderConvert.convertToPo(orderVO);
        //删除的
        List<OrderItemVO> deleteOrderItemVOList = orderVO.getDeleteItemList().stream().filter(it -> it.getItemId() != null).collect(Collectors.toList());
        if(deleteOrderItemVOList.size() > 0){
            for (OrderItemVO orderItemVO : deleteOrderItemVOList) {
                // 非待出库单据不能删除
                if(!Constant.OutStatus.DAICHUKU.getName().equals(orderItemVO.getOutStatus())){
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.NO_WAIT_INTO.getMessage());
                } else {
                    orderItemMapper.deleteById(orderItemVO.getItemId());
                }
            }
        }
        // 编辑的（包括新增的）
        // 新增的
        List<OrderItemVO> insertOrderItemVOList = orderVO.getItemList().stream().filter(it -> it.getItemId() == null).collect(Collectors.toList());
        for (OrderItemVO orderItemVO : insertOrderItemVOList) {
            OrderItem orderItem = orderItemConvert.convertToPo(orderItemVO);
            orderItem.setOrderId(order.getOrderId()).setCpId(order.getCpId()).setOutStatus(Constant.OutStatus.DAICHUKU.getName());
            orderItemMapper.insert(orderItem);
        }
        // 编辑的
        List<OrderItemVO> editOrderItemVOList = orderVO.getItemList().stream().filter(it -> it.getItemId() != null).collect(Collectors.toList());
        for (OrderItemVO orderItemVO : editOrderItemVOList) {
            // 商品数量不能小于出库中数量
            if(orderItemVO.getItemQty().compareTo(orderItemVO.getOutingQty()) == -1){
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ITEMQTY_NO_LESS_OUTQTY.getMessage());
            } else {
                OrderItem orderItem = orderItemConvert.convertToPo(orderItemVO);
                orderItemService.updateByUuid(orderItem);
            }
        }

        return ResponseResultUtil.success(super.update(order, new UpdateWrapper<Order>().lambda().eq(Order::getOrderId,
                UUID.fromString(order.getOrderId()))));
    }

    /**
     * @desc   : 获取订单信息（编辑用）
     * @author : 付斌
     * @date   : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOrderForOut(String id) {
        Map<String, Object> orderInfo = new HashMap<>();
        OrderResponse orderResponse = orderMapper.selectById(id);
        orderInfo.put("order", orderResponse);

        // 商品明细
        List<OrderItemResponse> orderItem = orderItemMapper.selectByCondForOut(new OrderItemQuery().setOrderId(id));
        orderInfo.put("orderItem", orderItem);
        return ResponseResultUtil.success(orderInfo);
    }
}