标签不显示标题问题

guoyujie

13 小时以前 91b61fe723df498d62c596372521d426299f0f8b

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

@@ -6,16 +6,27 @@
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.dynamic.datasource.annotation.DS;
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.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.*;
@@ -36,9 +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) {
@@ -150,13 +167,13 @@
        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="";
            String oddNumber;
            if (object.get("deliveryId") != null) {
@@ -164,11 +181,17 @@
            } 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) {
                //编辑还原数据
@@ -184,7 +207,7 @@
                    }
                }

                List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryDetailNumber, deliveryId);
                List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryId);
                if (!deliveryDetaillist.isEmpty()) {
                    for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
                        //还原库存数以及订单明细的发货数
@@ -199,11 +222,14 @@
                //删除订单额外金额的数据
                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);
            }
            double area = 0.0;
            Integer quantity = 0;
@@ -214,36 +240,142 @@
            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);
                            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();

                    Map<String,Double> otherColumns = JSON.parseObject(orderDetail.getOtherColumns(), new TypeReference<Map<String, Double>>(){});
                    if(otherColumns!=null){
                        otherColumns.forEach((key, value) ->{
                            if(value!=null) {
                                deliveryOtherMoneyList.forEach(deliveryOtherMoney ->{
                                    if(deliveryOtherMoney.getColumn().equals(key)){
                                        deliveryOtherMoney.setQuantity(deliveryOtherMoney.getQuantity()+(value * orderDetail.getDeliveryDetail().getQuantity()));
                            }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";
                                        }
                                    }
                                });
                                }

                            }
                        });
                    }

                    //新增发货明细数据
                    deliveryDetailMapper.insertDeliveryDetail(orderDetail, oddNumber, deliveryDetailmaximum + 1);
                    //修改订单明细
                    deliveryDetailMapper.updateOrderDetailDeliveryNum(orderDetail);
                    //修改库存表出库数量
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getOrderId(), orderDetail.getOrderNumber(), orderDetail.getDeliveryDetail().getQuantity());

                            //对循环明细的数据进行累加
                            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";
                        }
                    }

                }
                //往订单其他金额副表传入数据
@@ -256,33 +388,84 @@
                        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(String.format("%.2f", money)), otherMoney.get(), oddNumber);

                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) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("insertDelivery");
            sysErrorService.insert(sysError);
            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;



@@ -297,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;

@@ -315,28 +515,150 @@

    }

    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>>();//最终结果
        List<DeliveryDetail> deliveryDetailList=deliveryDetailMapper.getSelectDeliveryPrinting(deliveryDetail);
        for (DeliveryDetail detail : deliveryDetailList) {

            Map<String, Object> itemmap = new HashMap<>();
            List<Map<String, Object>> deliveryDetailList2 = deliveryDetailMapper.getSelectDeliveryDetailPrinting(detail.getDeliveryId(),
                    detail.getOrderDetail().getProductId(), detail.getOrderDetail().getOrderId());
            itemmap.put("DeliveryDetail", detail);
            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());
        }
        Delivery delivery=deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail);
        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("money", toChinese(delivery.getMoney().toString(), false));
        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 List<DeliveryDetailProductDTO> exportDeliveryDetailProductReport(List<LocalDate> dates) {
        return deliveryDetailMapper.exportDeliveryDetailProductReport(dates);
    }

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





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

@@ -581,21 +903,34 @@
        }
    }

    public String orderNumberSetting(String type) {
    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;
    }
}