标签不显示标题问题

guoyujie

13 小时以前 91b61fe723df498d62c596372521d426299f0f8b

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

@@ -1,27 +1,36 @@
package com.example.erp.service.sd;

import com.alibaba.excel.util.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
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.dto.mm.FinishedOperateLogDTO;
import com.example.erp.dto.sd.DeliveryDetailDTO;
import com.example.erp.dto.sd.DeliveryDetailProductDTO;
import com.example.erp.entity.mm.FinishedOperateLog;
import com.example.erp.entity.sd.*;
import com.example.erp.entity.userInfo.Log;
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.mapper.mm.FinishedOperateLogMapper;
import com.example.erp.mapper.sd.*;
import com.example.erp.service.mm.FinishedGoodsInventoryService;
import com.example.erp.service.userInfo.LogService;
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.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;

@Service
@DS("sd")
@@ -38,7 +47,15 @@
    @Autowired
    FinishedGoodsInventoryMapper finishedGoodsInventoryMapper;
    @Autowired
    FinishedOperateLogMapper finishedOperateLogMapper;
    @Autowired
    DeliveryOtherMoneyMapper deliveryOtherMoneyMapper;
    @Autowired
    LogService logService;
    @Autowired
    SysErrorService sysErrorService;
    @Autowired
    FinishedGoodsInventoryService finishedGoodsInventoryService;


    public Map<String, Object> getSelectShippingOrder(Integer pageNum, Integer pageSize,List<String> selectDate, Delivery delivery) {
@@ -75,10 +92,31 @@
                endDate = selectDate.get(1);
            }
        }
        System.out.println(pageSize);
        Map<String, Object> map = new HashMap<>();
        map.put("data", deliveryDetailMapper.getSelectDeliveryDetailReport(offset, pageSize,startDate,endDate, deliveryDetail));
        map.put("total", deliveryDetailMapper.getSelectDeliveryDetailReportPageTotal(offset, pageSize,startDate,endDate, deliveryDetail));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }

    public Map<String, Object> getSelectDeliveryDetailProductReport(Integer pageNum, Integer pageSize,List<String> selectDate, DeliveryDetail deliveryDetail) {
        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", deliveryDetailMapper.getSelectDeliveryDetailProductReport(offset, pageSize,startDate,endDate, deliveryDetail));
        map.put("total", deliveryDetailMapper.getSelectDeliveryDetailProductReportPageTotal(offset, pageSize,startDate,endDate, deliveryDetail));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
@@ -93,6 +131,7 @@
        map.put("data", deliveryDetailMapper.getSelectShippingOrderDetail(offset, pageSize, orderDetail));
        map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDelivery(offset, pageSize, orderDetail));
        map.put("total", deliveryDetailMapper.getSelectShippingOrderDetailPageTotal(offset, pageSize, orderDetail));
        map.put("orderOtherMoneyList",deliveryOtherMoneyMapper.findById(orderDetail.getDeliveryDetail().getDeliveryId()));

        return map;
    }
@@ -128,22 +167,31 @@
        return map;
    }

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

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

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

            Log log = new Log();
            log.setOperator(delivery.getCreator());
            log.setOperatorId(delivery.getCreatorId());
            log.setContent(object.toString());

            if (deliveryConut != 0) {
                //编辑还原数据
@@ -158,7 +206,8 @@

                    }
                }
                List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryDetailNumber, deliveryId);

                List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryId);
                if (!deliveryDetaillist.isEmpty()) {
                    for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
                        //还原库存数以及订单明细的发货数
@@ -167,72 +216,256 @@
                    }
                }
                //还原发货表的面积数量金额
                deliveryMapper.updatedelivery(0.0, 0, 0.0, deliveryId);
                deliveryMapper.updatedelivery(0.0, 0, 0.0,0.0, deliveryId);
                //删除发货明细的数据
                deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
                //删除订单额外金额的数据
                deliveryOtherMoneyMapper.deleteDeliveryOtherMoney(deliveryId);
                oddNumber = deliveryId;
                deliveryMapper.updateDelivery(delivery, oddNumber, orderDetaillist.get(0).getOrderId());
                log.setFunction("insertDelivery修改:"+oddNumber);
            } else {
                //获取单号
                oddNumber = orderNumberSetting("发货");
                oddNumber = orderNumberSetting("发货",deliveryIdType);
                //新增发货表数据
                deliveryMapper.insertDelivery(delivery, oddNumber, orderDetaillist.get(0).getOrderId());
                log.setFunction("insertDelivery新增:"+oddNumber);
            }
            System.out.println(4);
            Double area = 0.0;
            double area = 0.0;
            Integer quantity = 0;
            Double money = 0.0;
            //获取对象集合循环进行新增修改
            double money = 0.0;
            AtomicReference<Double> otherMoney = new AtomicReference<>(0.0);

            //先把其他金额副表的金额与数量置0
            deliveryOtherMoneyList.forEach(deliveryOtherMoney -> {
                deliveryOtherMoney.setQuantity(0.0);
            });
            double otherMoneys=0.0;

            List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
            //获取对象集合循环进行新增修改
            if (!orderDetaillist.isEmpty()) {
                for (OrderDetail orderDetail : orderDetaillist) {
                    if(orderDetail.getDeliveryDetail().getQuantity()>0){
                        OrderDetail orderDetails =deliveryDetailMapper.selectOrderDetailDeliveryCount(orderDetail);
                        Boolean aBoolean1 =orderDetails.getQuantity()>= orderDetail.getDeliveryDetail().getQuantity()+orderDetails.getDeliveryNum();
                        Boolean aBoolean2 = !Integer.valueOf(orderDetails.getQuantity().toString()).equals(orderDetails.getDeliveryNum());
                        //判断是否已经发货
                        if(aBoolean1 && aBoolean2){
                            double deliveryDetailotherMoneys=0.0;
                            Integer calculateType=0;

                    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());
                            if (orderDetail.getOrder().getOrderId()==null){
                                Order order=deliveryMapper.selectOrderId(orderDetail.getOrderId());
                                calculateType=order.getCalculateType();
                            }else{
                                calculateType=orderDetail.getOrder().getCalculateType();
                            }
                            double deliveryDetailMoney = 0.0;
                            double deliveryDetailArea = 0.0;
                            BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
                            BigDecimal getQuantity= BigDecimal.valueOf(orderDetail.getDeliveryDetail().getQuantity());
                            BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
                            BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
                            BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
                            BigDecimal singlePieceArea =getComputeArea.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP)
                                    .multiply(getPrice).setScale(2, RoundingMode.HALF_UP);
                            //根据订单计算方式进行金额计算
                            if (calculateType==1){
                                deliveryDetailMoney=singlePieceArea.doubleValue();
                                deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                            }else if (calculateType==2){
                                //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                                if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                                    deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP)
                                            .multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                }else{
                                    deliveryDetailMoney=singlePieceArea.doubleValue();
                                    deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                                }
                            }else if (calculateType==3){
                                deliveryDetailMoney=getQuantity.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                            }else if (calculateType==4){
                                //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                                if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                                    deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
                                            divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                }else{
                                    deliveryDetailMoney=getComputeArea.multiply(getQuantity).multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                                }
                            }
                    /*if (calculateType==1){
                        deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
                                String.format("%.2f", orderDetail.getComputeArea()*orderDetail.getDeliveryDetail().getQuantity())
                        )*orderDetail.getPrice()));
                    }else if (calculateType==2){
                        if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())){
                            deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
                                    String.format("%.2f", orderDetail.getWidth()*orderDetail.getHeight()*orderDetail.getDeliveryDetail().getQuantity()/1000000)
                            )*orderDetail.getPrice()));
                        }else{
                            deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
                                    String.format("%.2f", orderDetail.getComputeArea()*orderDetail.getDeliveryDetail().getQuantity())
                            )*orderDetail.getPrice()));
                        }
                    }else if (calculateType==3){
                        deliveryDetailMoney=Double.parseDouble(String.format("%.2f",orderDetail.getPrice() * orderDetail.getDeliveryDetail().getQuantity()));

                    }*/



                            if(orderDetail.getOtherColumns()!="{}"&&orderDetail.getOtherColumns()!=null){
                                JSONObject jsonObject = JSON.parseObject(orderDetail.getOtherColumns());
                                for(String key : jsonObject.keySet()){
                                    boolean isnull = key.contains("M");
                                    if(isnull) {
                                        Map<String, Object> moneryItemmap = new HashMap<>();
                                        Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectOrderotherMoney(orderDetail.getOrderId(),orderDetail.getOrderNumber(),
                                                key, Double.valueOf(jsonObject.get(key).toString()),orderDetail.getDeliveryDetail().getQuantity());
                                        if(deliveryDetailOtherMoney.get("monery")!=null){
                                            otherMoneys=otherMoneys+Double.valueOf(deliveryDetailOtherMoney.get("monery").toString());
                                            deliveryDetailotherMoneys=Double.valueOf(deliveryDetailOtherMoney.get("monery").toString());
                                            moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
                                            moneryList.add(moneryItemmap);
                                        }else{
                                            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
                                            return "false1";
                                        }
                                    }
                                }

                            }


                            //对循环明细的数据进行累加
                            quantity += orderDetail.getDeliveryDetail().getQuantity();
                            area += deliveryDetailArea;
                            money += deliveryDetailMoney;
                            Integer deliveryDetailmaximum = deliveryDetailMapper.getdeliveryDetailmaximum(oddNumber);

                            //额外金额修改
                            Map<String,String> otherColumns = JSON.parseObject(orderDetail.getOtherColumns(), new TypeReference<Map<String, String>>(){});
                            if(otherColumns!=null){
                                otherColumns.forEach((key, value) ->{
                                    boolean isnull = key.contains("M");
                                    if(isnull){
                                        deliveryOtherMoneyList.forEach(deliveryOtherMoney ->{
                                            if(deliveryOtherMoney.getColumn().equals(key)){
                                                deliveryOtherMoney.setQuantity(deliveryOtherMoney.getQuantity()+( Double.valueOf(value)* orderDetail.getDeliveryDetail().getQuantity()));
                                            }
                                        });

                                    }
                                });
                            }
                            //新增发货明细数据
                            deliveryDetailMapper.insertDeliveryDetail(orderDetail, oddNumber, deliveryDetailmaximum + 1,deliveryDetailMoney,deliveryDetailotherMoneys,deliveryDetailArea);
                            //修改订单明细
                            deliveryDetailMapper.updateOrderDetailDeliveryNum(orderDetail);
                            //修改库存表出库数量
                            finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getOrderId(), orderDetail.getOrderNumber(), orderDetail.getDeliveryDetail().getQuantity());
                        }else{
                            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
                            return "false2";
                        }
                    }

                }
                //修改发货明细累加面积数量金额
                deliveryMapper.updatedelivery(Double.valueOf(String.format("%.2f", area)), quantity, Double.valueOf(String.format("%.2f", money)), oddNumber);
                //往订单其他金额副表传入数据
                deliveryOtherMoneyList.forEach(deliveryOtherMoney ->{
                    deliveryOtherMoney.setId(null);
                    deliveryOtherMoney.setDeliveryId(oddNumber);
                    if(deliveryOtherMoney.getQuantity()!=null && deliveryOtherMoney.getPrice()!=null){
                        deliveryOtherMoney.setMoney((deliveryOtherMoney.getQuantity()*deliveryOtherMoney.getPrice()));
                        otherMoney.updateAndGet(v -> new Double((double) (v + deliveryOtherMoney.getMoney())));
                        deliveryOtherMoneyMapper.insertDeliveryOtherMoney(deliveryOtherMoney);
                    }
                });
                double freight=0.0;
                if (delivery.getFreightPrice()!=null&&delivery.getFreightQuantity()!=null){
                    freight=delivery.getFreightPrice()*delivery.getFreightQuantity();
                }

                int intMoney= (int) Math.round(money+freight+otherMoneys);
                //修改发货明细累加面积数量金额
                deliveryMapper.updatedelivery(Double.valueOf(String.format("%.2f", area)), quantity, Double.valueOf(intMoney), otherMoneys, oddNumber);
                logService.saveLog(log);
            } else {
                return false;
                return "false3";
            }
        } catch (Exception e) {
        }catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("insertDelivery");
            sysErrorService.insert(sysError);
            saveState = false;
            saveState = "false4";

        }

        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();
    public String updateDeliveryToExamine(Map<String,Object> object) {
        String saveState = "true";
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            Log log = new Log();
            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());
            }

            if(Boolean.parseBoolean(object.get("deliveryOutbound").toString())){
                if(type==2){
                    List<OrderDetail> orderDetaillist=finishedGoodsInventoryMapper.getSelectDeliveryDetailDeliveryId(deliveryId);
                    if(!Objects.equals(finishedGoodsInventoryService.deliveryDetailLogic(orderDetaillist,savePoint,object.get("userName").toString()), "true")){
                        return finishedGoodsInventoryService.deliveryDetailLogic(orderDetaillist,savePoint,object.get("userName").toString());
                    }
                }else{
                    List<FinishedOperateLog> finishedOperateLogslist=finishedOperateLogMapper.getSelectStorageRecordDeliveryId(deliveryId,"出库");
                    if(!Objects.equals(finishedGoodsInventoryService.cancelDeliveryDetailLogic(finishedOperateLogslist,savePoint,object.get("userName").toString(),log), "true")){
                        return finishedGoodsInventoryService.cancelDeliveryDetailLogic(finishedOperateLogslist,savePoint,object.get("userName").toString(),log);
                    }

                }

            }

            deliveryMapper.updateDeliveryToExamine(deliveryId,type);


            log.setOperatorId(object.get("userId").toString());
            log.setOperator(object.get("userName").toString());
            log.setContent(object.toString());
            log.setFunction("updateDeliveryToExamine修改:"+deliveryId);
            logService.saveLog(log);
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("addDeliveryDetail");
            sysErrorService.insert(sysError);
            saveState = "false";

        }

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

        deliveryMapper.updateDeliveryToExamine(deliveryId,type);

        return true;
        return saveState;



@@ -247,16 +480,33 @@
            if (object.get("deliveryId") != null) {
                deliveryId = object.get("deliveryId").toString();
            }
            List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryId);
            if (!deliveryDetaillist.isEmpty()) {
                for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
                    //还原库存数以及订单明细的发货数
                    finishedGoodsInventoryMapper.updateInventoryquantityInt(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
                    deliveryDetailMapper.updateIsNotOrderDetailDeliveryNum(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
                }
            }
            //删除订单额外金额的数据
            deliveryOtherMoneyMapper.deleteDeliveryOtherMoney(deliveryId);
            deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
            deliveryMapper.deleteDelivery(deliveryId);

            Log log = new Log();
            log.setOperatorId(object.get("userId").toString());
            log.setOperator(object.get("userName").toString());
            log.setContent(object.toString());
            log.setFunction("deleteDelivery删除:"+deliveryId);
            logService.saveLog(log);

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

@@ -265,45 +515,422 @@

    }

    public Map<String, Object> getSelectDeliveryPrinting( DeliveryDetail deliveryDetail) {
    public List<Map<String, Object>> getSelectDeliveryPrinting(Map<String,Object> object) throws IllegalAccessException {
        List<Delivery> deliveries = JSONArray.parseArray(JSONObject.toJSONString(object.get("deliveryId")), Delivery.class);
        String type = "";
        if (object.get("type") != null) {
            type = object.get("type").toString();
        }
        List <Map<String, Object>> list1=new ArrayList<Map<String, Object>>();//最终结果
        for(Delivery deliverys:deliveries){

            Map<String, Object> map = new HashMap<>();
            List <Map<String, Object>> list=new ArrayList<Map<String, Object>>();//最终结果
            List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
            List<DeliveryDetail> deliveryDetailList=deliveryDetailMapper.getSelectDeliveryPrinting(deliverys.getDeliveryId(),type);
            String orderId="";
            double otherMoney=0.0;
            for (DeliveryDetail detail : deliveryDetailList) {
                orderId=detail.getOrderDetail().getOrderId();
                Map<String, Object> itemmap = new HashMap<>();

                List<Map<String, Object>> deliveryDetailList2 = deliveryDetailMapper.getSelectDeliveryDetailPrinting(detail.getDeliveryId(),
                        detail.getOrderDetail().getProductId(), detail.getOrderDetail().getOrderId());

                for (Map<String, Object> stringObjectMap : deliveryDetailList2) {
                    if(stringObjectMap.get("other_columns")!=null){
                        JSONObject jsonObject = JSON.parseObject(stringObjectMap.get("other_columns").toString());
                        for(String key : jsonObject.keySet()){
                            boolean isnull = key.contains("M");
                            if(isnull) {
                                Map<String, Object> moneryItemmap = new HashMap<>();
                                Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectotherMoney(detail.getOrderDetail().getOrderId(),
                                        detail.getDeliveryId(),Integer.parseInt(stringObjectMap.get("order_number").toString()), key,Double.valueOf(jsonObject.get(key).toString()));
                                Double sss= Double.valueOf(jsonObject.get(key).toString());
                                moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
                                moneryList.add(moneryItemmap);
                            }
                        }

                    }
                }
                itemmap.put("DeliveryDetail", detail);
                itemmap.put("DeliveryDetailList", deliveryDetailList2);
                list.add(itemmap);

            }
            /*Delivery delivery=deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail);
            delivery.setMoney(delivery.getMoney()+otherMoney);
            map.put("data", list);
            map.put("otherMoney",moneryList);
            map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail));
            map.put("money", toChinese(delivery.getMoney().toString(), false));*/

            deliverys.setMoney(deliverys.getMoney()+otherMoney);
            map.put("data", list);
            map.put("otherMoney",moneryList);
            map.put("delivery",deliverys );
            map.put("money", toChinese(deliverys.getMoney().toString(), false));
            list1.add(map);
        }


        return list1;

    }

    public Map<String, Object> getSelectOrderPrinting(OrderDetail orderDetail,List<String> productId) {
        Map<String, Object> map = new HashMap<>();
        List <Map<String, Object>> list=new ArrayList<Map<String, Object>>();//最终结果
        System.out.println(deliveryDetail);
        List<DeliveryDetail> deliveryDetailList=deliveryDetailMapper.getSelectDeliveryPrinting(deliveryDetail);
        for (int i = 0; i < deliveryDetailList.size(); i++) {

            Map<String, Object> itemmap = new HashMap<>();

            List <Map<String, Object>> deliveryDetailList2=deliveryDetailMapper.getSelectDeliveryDetailPrinting(deliveryDetailList.get(i).getDeliveryId(),
                    deliveryDetailList.get(i).getOrderDetail().getProductId(),deliveryDetailList.get(i).getOrderDetail().getOrderId());
            itemmap.put("DeliveryDetail",deliveryDetailList.get(i));
            itemmap.put("DeliveryDetailList",deliveryDetailList2);
            list.add(itemmap);


        List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
        List<Map<String,Object>> orderProductDistinct;
        if (!Objects.equals(productId.get(0), "null")){
            orderProductDistinct = orderDetailMapper.getOrderProductDistinctByIds(orderDetail.getOrderId(),productId);
        }else{
            orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderDetail.getOrderId());
        }
        BigDecimal areSum=new BigDecimal("0");
        BigDecimal grossAmount=new BigDecimal("0");
        int quantity=0;
        for (Map<String, Object> maps : orderProductDistinct) {
            List<OrderDetail> orderDetails = deliveryDetailMapper.getSelectOrderPrinting(maps.get("productId"),orderDetail.getOrderId());
            for (OrderDetail detail : orderDetails) {

                areSum=areSum.add(BigDecimal.valueOf(detail.getArea()));
                quantity+=detail.getQuantity();
                grossAmount=grossAmount.add(BigDecimal.valueOf(detail.getGrossAmount()));

                Map<String, Object> itemmap = new HashMap<>();
                List<Map<String, Object>> deliveryDetailList2 = deliveryDetailMapper.getSelectOrderDetailPrinting(
                        detail.getProductId(), detail.getOrderId());
                for (Map<String, Object> stringObjectMap : deliveryDetailList2) {

                    if(stringObjectMap.get("other_columns")!=null){
                        JSONObject jsonObject = JSON.parseObject(stringObjectMap.get("other_columns").toString());
                        for(String key : jsonObject.keySet()){
                            boolean isnull = key.contains("M");
                            if(isnull){
                                Map<String, Object> moneryItemmap = new HashMap<>();
                                Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectOrderotherMoneys(detail.getOrderId(),Integer.parseInt(stringObjectMap.get("order_number").toString())
                                        ,key,Double.valueOf(jsonObject.get(key).toString()));
                                grossAmount=grossAmount.add(BigDecimal.valueOf(Double.parseDouble(deliveryDetailOtherMoney.get("monery").toString())));
                                moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
                                moneryList.add(moneryItemmap);
                            }

                        }

                    }
                }
                itemmap.put("productId",maps.get("productId"));
                itemmap.put("productName",maps.get("productName"));
                itemmap.put("remarks",maps.get("remarks"));
                itemmap.put("DeliveryDetail", detail);
                itemmap.put("DeliveryDetailList", deliveryDetailList2);
                list.add(itemmap);

            }
        }

        Order order=deliveryMapper.getSelectShippingOrderDetailPrinting(orderDetail);
        order.setMoney((double) Math.round(grossAmount.doubleValue()));
        order.setQuantity((long) quantity);
        order.setArea(areSum.doubleValue());
        map.put("data", list);
        map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail));
        map.put("otherMoney",moneryList);
        map.put("delivery", order);
        map.put("money", toChinese(order.getMoney().toString(), false));
        return map;

    }

    public List<DeliveryDetailDTO> exportDeliveryDetailReport(List<LocalDate> dates) {
        return deliveryDetailMapper.exportDeliveryDetailReport(dates);
    }

    public String orderNumberSetting(String type) {
    public List<DeliveryDetailProductDTO> exportDeliveryDetailProductReport(List<LocalDate> dates) {
        return deliveryDetailMapper.exportDeliveryDetailProductReport(dates);
    }

    public boolean updateDeliveryPrintNumber(String deliveryId) {
        return deliveryMapper.updateDeliveryPrintNumber(deliveryId);
    }





    private static final String[] NUMBERS = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

    private static final String[] IUNIT = {"元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟"};

    private static final String[] DUNIT = {"角", "分"};

    private static final String[] CN_NUMBERS = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

    private static final String[] CN_IUNIT = {"", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};



    /**
     *  转换为大写的中文金额,支持负数
     * @param amount 金额
     * @param isSimplified 是否简体中文：true:简体，false：繁体
     * @return
     */
    public static String toChinese(String amount, boolean isSimplified) {
        // 判断输入的金额字符串是否符合要求
        if (StringUtils.isBlank(amount) || !amount.matches("(-)?[\\d]*(.)?[\\d]*")) {
            throw new RuntimeException("请输入数字");
        }

        if ("0".equals(amount) || "0.00".equals(amount) || "0.0".equals(amount)) {
            return isSimplified ? "零" : "零元";
        }

        // 判断金额数字中是否存在负号"-"
        boolean flag = false;
        if (amount.startsWith("-")) {
            // 标志位，标志此金额数字为负数
            flag = true;
            amount = amount.replaceAll("-", "");
        }
        // 去掉金额数字中的逗号","
        amount = amount.replaceAll(",", "");
        // 初始化：分离整数部分和小数部分
        String[] separateNum = separateNum(amount);
        // 整数部分数字
        String integerStr = separateNum[0];
        // 小数部分数字
        String decimalStr = separateNum[1];
        // beyond超出计算能力，直接返回
        if (integerStr.length() > IUNIT.length) {
            throw new RuntimeException("输入数字超限");
        }
        // 整数部分数字
        int[] integers = toIntArray(integerStr);
        // 判断整数部分是否存在输入012的情况
        if (integers.length > 1 && integers[0] == 0) {
            throw new RuntimeException("输入数字不符合要求");
        }
        // 设置万单位
        boolean isWan = isWan5(integerStr);
        // 小数部分数字
        int[] decimals = toIntArray(decimalStr);
        // 返回最终的大写金额
        String result = "";
        String chineseInteger = getChineseInteger(integers, isWan, isSimplified);
        String chineseDecimal = getChineseDecimal(decimals, isSimplified);
        if (decimals.length > 0 && isSimplified) {
            result = chineseInteger;
            if (!chineseDecimal.equals("零零")) {
                result = result + "点" + chineseDecimal;
            }
        } else {
            result = chineseInteger + chineseDecimal;

        }
        if (flag) {
            // 如果是负数，加上"负"
            return "负" + result;
        } else {
            return result;
        }
    }

    /**
     * 分离整数部分和小数部分
     * @param str
     * @return
     */
    private static String[] separateNum(String str) {
        String integerStr;// 整数部分数字
        String decimalStr;// 小数部分数字
        if (str.indexOf('.') >= 1) {
            integerStr = str.substring(0, str.indexOf('.'));
            decimalStr = str.substring(str.indexOf('.') + 1);
            if (decimalStr.length() > 2) {
                decimalStr = decimalStr.substring(0, 2);
            }
        } else if (str.indexOf('.') == 0) {
            integerStr = "";
            decimalStr = str.substring(1);
        } else {
            integerStr = str;
            decimalStr = "";
        }
        return new String[] {integerStr, decimalStr};
    }

    /**
     *  将字符串转为int数组
     * @param number  数字
     * @return
     */
    private static int[] toIntArray(String number) {
        int[] array = new int[number.length()];
        for (int i = 0; i < number.length(); i++) {
            array[i] = Integer.parseInt(number.substring(i, i + 1));
        }
        return array;
    }

    /**
     *  将整数部分转为大写的金额
     * @param integers 整数部分数字
     * @param isWan  整数部分是否已经是达到【万】
     * @return
     */
    private static String getChineseInteger(int[] integers, boolean isWan, boolean isSimplified) {

        int length = integers.length;
        if (!isSimplified && length == 1 && integers[0] == 0) {
            return "";
        }
        if (!isSimplified) {
            return traditionalChineseInteger(integers, isWan);
        } else {
            return simplifiedChineseInteger(integers, isWan);
        }
    }

    /**
     * 繁体中文整数
     * @param integers
     * @param isWan
     * @return
     */
    private static String traditionalChineseInteger(int[] integers, boolean isWan) {
        StringBuilder chineseInteger = new StringBuilder("");
        int length = integers.length;
        for (int i = 0; i < length; i++) {
            String key = "";
            if (integers[i] == 0) {
                if ((length - i) == 13)// 万（亿）
                    key = IUNIT[4];
                else if ((length - i) == 9) {// 亿
                    key = IUNIT[8];
                } else if ((length - i) == 5 && isWan) {// 万
                    key = IUNIT[4];
                } else if ((length - i) == 1) {// 元
                    key = IUNIT[0];
                }
                if ((length - i) > 1 && integers[i + 1] != 0) {
                    key += NUMBERS[0];
                }
            }
            chineseInteger.append(integers[i] == 0 ? key : (NUMBERS[integers[i]] + IUNIT[length - i - 1]));
        }
        return chineseInteger.toString();
    }

    /**
     * 简体中文整数
     * @param integers
     * @param isWan
     * @return
     */
    private static String simplifiedChineseInteger(int[] integers, boolean isWan) {
        StringBuilder chineseInteger = new StringBuilder("");
        int length = integers.length;
        for (int i = 0; i < length; i++) {
            String key = "";
            if (integers[i] == 0) {
                if ((length - i) == 13) {// 万（亿）
                    key = CN_IUNIT[4];
                } else if ((length - i) == 9) {// 亿
                    key = CN_IUNIT[8];
                } else if ((length - i) == 5 && isWan) {// 万
                    key = CN_IUNIT[4];
                } else if ((length - i) == 1) {// 元
                    key = CN_IUNIT[0];
                }
                if ((length - i) > 1 && integers[i + 1] != 0) {
                    key += CN_NUMBERS[0];
                }
                if (length == 1 && integers[i] == 0) {
                    key += CN_NUMBERS[0];
                }
            }
            chineseInteger.append(integers[i] == 0 ? key : (CN_NUMBERS[integers[i]] + CN_IUNIT[length - i - 1]));
        }
        return chineseInteger.toString();
    }

    /**
     *  将小数部分转为大写的金额
     * @param decimals 小数部分的数字
     * @return
     */
    private static String getChineseDecimal(int[] decimals, boolean isSimplified) {
        StringBuilder chineseDecimal = new StringBuilder("");
        if (!isSimplified) {
            for (int i = 0; i < decimals.length; i++) {
                String key = "";

                if ((decimals.length - i) > 1 && decimals[i + 1] != 0) {
                    key += NUMBERS[0];
                }

                chineseDecimal.append(decimals[i] == 0 ? key : (NUMBERS[decimals[i]] + DUNIT[i]));
            }
        } else {
            for (int i = 0; i < decimals.length; i++) {
                chineseDecimal.append(CN_NUMBERS[decimals[i]]);
            }

        }
        return chineseDecimal.toString();
    }

    /**
     *  判断当前整数部分是否已经是达到【万】
     * @param integerStr  整数部分数字
     * @return
     */
    private static boolean isWan5(String integerStr) {
        int length = integerStr.length();
        if (length > 4) {
            String subInteger = "";
            if (length > 8) {
                subInteger = integerStr.substring(length - 8, length - 4);
            } else {
                subInteger = integerStr.substring(0, length - 4);
            }
            return Integer.parseInt(subInteger) > 0;
        } else {
            return false;
        }
    }

    public String orderNumberSetting(String type,String deliveryIdType) {
        //根据类型自动生成不同的操作单号
        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;
        String oddNumbers="";

        if(deliveryIdType.equals("day")){
            //查询当天的最大数量
            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);
             oddNumbers =  alias+formattedDate+formattedNumber;
        }else if(deliveryIdType.equals("month")){
            Integer maximum = deliveryMapper.getmaximumMonth();
            String formattedNumber = String.format("%04d", maximum+1);
            Date currentDate = new Date();
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyMM");
            String formattedDate = dateFormat.format(currentDate);
            oddNumbers =  alias+formattedDate+formattedNumber;

        }

        return oddNumbers;
    }
}