订单首页右键查询流程卡进度

guoyuji

2024-03-22 73be6b08f5a94e71550fe788c5d74705daa91be0

 north-glass-erp/src/main/java/com/example/erp/service/sd/DeliveryService.java

New file
@@ -0,0 +1,263 @@
package com.example.erp.service.sd;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.erp.entity.sd.Delivery;
import com.example.erp.entity.sd.DeliveryDetail;
import com.example.erp.entity.sd.Order;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.mapper.mm.FinishedGoodsInventoryMapper;
import com.example.erp.mapper.sd.DeliveryDetailMapper;
import com.example.erp.mapper.sd.DeliveryMapper;
import com.example.erp.mapper.sd.OrderDetailMapper;
import com.example.erp.mapper.sd.OrderMapper;
import com.example.erp.service.userInfo.SysErrorService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;

@Service
@DS("sd")
@Transactional(rollbackFor = Exception.class)
public class DeliveryService {
    @Autowired
    DeliveryMapper deliveryMapper;
    @Autowired
    DeliveryDetailMapper deliveryDetailMapper;
    @Autowired
    OrderMapper orderMapper;
    @Autowired
    OrderDetailMapper orderDetailMapper;
    @Autowired
    FinishedGoodsInventoryMapper finishedGoodsInventoryMapper;
    @Autowired
    SysErrorService sysErrorService;


    public Map<String, Object> getSelectShippingOrder(Integer pageNum, Integer pageSize,List<String> selectDate, Delivery delivery) {
        Integer offset = (pageNum - 1) * pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", deliveryMapper.getSelectShippingOrder(offset, pageSize,startDate,endDate, delivery));
        map.put("total", deliveryMapper.getSelectShippingOrderPageTotal(offset, pageSize,startDate,endDate, delivery));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }

    public Map<String, Object> getSelectShippingOrderDetail(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
        Integer offset = (pageNum - 1) * pageSize;

        Map<String, Object> map = new HashMap<>();
        map.put("data", deliveryDetailMapper.getSelectShippingOrderDetail(offset, pageSize, orderDetail));
        map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDelivery(offset, pageSize, orderDetail));
        map.put("total", deliveryDetailMapper.getSelectShippingOrderDetailPageTotal(offset, pageSize, orderDetail));

        return map;
    }

    public Map<String, Object> getSelectOrderInventory(Integer pageNum, Integer pageSize,List<String> selectDate, Order order) {
        Integer offset = (pageNum - 1) * pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", deliveryMapper.getSelectOrderInventory(offset, pageSize,startDate,endDate, order));
        map.put("total", deliveryMapper.getSelectOrderInventoryPageTotal(offset, pageSize,startDate,endDate, order));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }

    public Map<String, Object> getSelectShippingOrderDetails(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
        Integer offset = (pageNum - 1) * pageSize;
        Map<String, Object> map = new HashMap<>();
        map.put("data", deliveryDetailMapper.getSelectShippingOrderDetails(offset, pageSize, orderDetail));
        map.put("title", deliveryMapper.getSelectShippingOrderDetailDeliverys(offset, pageSize, orderDetail));
        map.put("total", deliveryDetailMapper.getSelectShippingOrderDetailsPageTotal(offset, pageSize, orderDetail));
        return map;
    }

    public Boolean insertDelivery(Map<String,Object> object) {

        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {

            String deliveryId = "";
            String oddNumber;
            if (object.get("deliveryId") != null) {
                deliveryId = object.get("deliveryId").toString();
            }
            Delivery delivery = JSONObject.parseObject(JSONObject.toJSONString(object.get("title")), Delivery.class);
            List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("delivery")), OrderDetail.class);
            //查询发货单是否存在
            Integer deliveryConut = deliveryMapper.getDeliveryConut(deliveryId);

            if (deliveryConut != 0) {
                //编辑还原数据
                String deliveryDetailNumber = "";
                if (!orderDetaillist.isEmpty()) {
                    for (OrderDetail orderDetail : orderDetaillist) {
                        if (orderDetaillist.size() - 1 == orderDetaillist.indexOf(orderDetail)) {
                            deliveryDetailNumber += orderDetail.getDeliveryDetail().getDeliveryNumber();
                        } else {
                            deliveryDetailNumber += orderDetail.getDeliveryDetail().getDeliveryNumber() + "|";
                        }

                    }
                }
                List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryDetailNumber, deliveryId);
                if (!deliveryDetaillist.isEmpty()) {
                    for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
                        //还原库存数以及订单明细的发货数
                        finishedGoodsInventoryMapper.updateInventoryquantityInt(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
                        deliveryDetailMapper.updateIsNotOrderDetailDeliveryNum(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
                    }
                }
                //还原发货表的面积数量金额
                deliveryMapper.updatedelivery(0.0, 0, 0.0, deliveryId);
                //删除发货明细的数据
                deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
                oddNumber = deliveryId;
            } else {
                //获取单号
                oddNumber = orderNumberSetting("发货");
                //新增发货表数据
                deliveryMapper.insertDelivery(delivery, oddNumber, orderDetaillist.get(0).getOrderId());
            }
            System.out.println(4);
            Double area = 0.0;
            Integer quantity = 0;
            Double money = 0.0;
            //获取对象集合循环进行新增修改

            if (!orderDetaillist.isEmpty()) {
                for (OrderDetail orderDetail : orderDetaillist) {

                    quantity += orderDetail.getDeliveryDetail().getQuantity();
                    area += orderDetail.getFinishedGoodsInventory().getActualSignalArea() * orderDetail.getDeliveryDetail().getQuantity();
                    money += orderDetail.getPrice() * orderDetail.getDeliveryDetail().getQuantity();
                    Integer deliveryDetailmaximum = deliveryDetailMapper.getdeliveryDetailmaximum(oddNumber);
                    //新增发货明细数据
                    deliveryDetailMapper.insertDeliveryDetail(orderDetail, oddNumber, deliveryDetailmaximum + 1);
                    //修改订单明细
                    deliveryDetailMapper.updateOrderDetailDeliveryNum(orderDetail);
                    //修改库存表出库数量
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getOrderId(), orderDetail.getOrderNumber(), orderDetail.getDeliveryDetail().getQuantity());

                }
                //修改发货明细累加面积数量金额
                deliveryMapper.updatedelivery(Double.valueOf(String.format("%.2f", area)), quantity, Double.valueOf(String.format("%.2f", money)), oddNumber);

            } else {
                return false;
            }
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

        }
        return saveState;
    }


    public Boolean updateDeliveryToExamine(Map<String,Object> object) {
        Boolean isinsert=false;
        String deliveryId = "";
        int type =3;
        if (object.get("deliveryId") != null) {
            deliveryId = object.get("deliveryId").toString();
        }

        if (object.get("type") != null) {
            type = Integer.parseInt(object.get("type").toString());
        }

        deliveryMapper.updateDeliveryToExamine(deliveryId,type);

        return true;



    }

    public Boolean deleteDelivery(Map<String,Object> object) {
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String deliveryId = "";
            if (object.get("deliveryId") != null) {
                deliveryId = object.get("deliveryId").toString();
            }
            deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
            deliveryMapper.deleteDelivery(deliveryId);

            return true;
        }catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

        }
        return saveState;

    }


    public String orderNumberSetting(String type) {
        //根据类型自动生成不同的操作单号
        String alias="";
        if(Objects.equals(type, "发货")){
            alias="FH";
        }
        //查询当天的最大数量
        Integer maximum=deliveryMapper.getmaximum(type);
        //设置两位不够补0
        String formattedNumber = String.format("%02d", maximum+1);
        //格式化当前日期
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
        String formattedDate = dateFormat.format(currentDate);
        String oddNumbers =  alias+formattedDate+formattedNumber;
        return oddNumbers;
    }
}