Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override

guoyujie

2025-11-20 5fb1f180d0e6eceb83cda226c1daeca3f634e813

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

@@ -1,5 +1,6 @@
package com.example.erp.service.sd;

import cn.dev33.satoken.stp.StpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
@@ -10,7 +11,7 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.example.erp.common.Constants;
import com.example.erp.dto.sd.OrderDTO;
import com.example.erp.dto.sd.OrderDetailProductDTO;
import com.example.erp.dto.sd.OrderSearchDTO;
import com.example.erp.entity.sd.*;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
@@ -20,7 +21,8 @@
import com.example.erp.mapper.sd.*;
import com.example.erp.service.userInfo.LogService;
import com.example.erp.service.userInfo.SysErrorService;
import org.springframework.beans.factory.annotation.Autowired;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
@@ -28,12 +30,11 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.SQLOutput;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

import static org.apache.coyote.http11.Constants.a;

@Service
@DS("sd")
@@ -84,13 +85,12 @@
            log.setContent(orderMap.toString());

            if(order.getOrderId() == null || order.getOrderId().isEmpty()){
                insertOrder(order,OrderDetails,orderOtherMoneyList,orderIdType);
                insertOrder(order,OrderDetails,orderOtherMoneyList,orderIdType, (Map<String, String>) orderMap.get("position"));
                log.setFunction("saveOrder创建:"+order.getOrderId());
            }else {
                updateOrder(order,OrderDetails,orderOtherMoneyList);
                updateOrder(order,OrderDetails,orderOtherMoneyList,(Map<String, String>) orderMap.get("position"));
                log.setFunction("saveOrder修改:"+order.getOrderId());
            }

            logService.saveLog(log);
        }catch (Exception e){
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
@@ -100,7 +100,6 @@
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

            //throw new Exception();
        }
        return saveState;
@@ -109,7 +108,6 @@
    public boolean saveOrderTitle(Map<String,Object> orderMap) throws Exception {
        JSONObject orderJson = new JSONObject(orderMap);
        Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("title")), Order.class);

        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
@@ -122,7 +120,15 @@
            log.setFunction("saveOrderTitle保存表头:"+order.getOrderId());

            Order order1 = orderMapper.selectOrderId(order.getOrderId());
            //使用订单原本的状态和计算方式
            order.setCalculateType(order1.getCalculateType());
            order.setCreateOrder(order1.getCreateOrder());
            order.setProcessReview(order1.getProcessReview());
            order.setOrderReview(order1.getOrderReview());
            order.setProductionOrder(order1.getProductionOrder());
            order.setProcessingCard(order1.getProcessingCard());
            order.setWarehousing(order1.getWarehousing());
            order.setDelivery(order1.getDelivery());

            LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(Order::getOrderId, order.getOrderId());
@@ -140,7 +146,6 @@
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

            //throw new Exception();
        }
        return saveState;
@@ -160,15 +165,14 @@
        return map;
    }
    //生成订单数据
    public void insertOrder(Order order, List<OrderDetail> OrderDetails, List<OrderOtherMoney> orderOtherMoneyList, String orderIdType) {
    public void insertOrder(Order order, List<OrderDetail> OrderDetails, List<OrderOtherMoney> orderOtherMoneyList, String orderIdType, Map<String,String> position) {
        //根据传入的当前月份或者当天生成订单id
        String orderId =  getOrderId(orderIdType);
        //往主表插数据
        order.setOrderId(orderId);
        order.setCreateOrder(2);
        orderMapper.insert(order);

        insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);
        insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList,position);
    }

    private String getOrderId(String dateType){
@@ -198,15 +202,21 @@
            String formattedDate = dateFormat.format(currentDate);
            orderId =  "NG"+formattedDate+formattedNumber;
        }

        return orderId;
    }


    //修改订单数据，并且重新生成多个副表数据
    public void updateOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {

    public void updateOrder(Order order, List<OrderDetail> OrderDetails, List<OrderOtherMoney> orderOtherMoneyList, Map<String, String> position) throws Exception {
        Order oldOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId,order.getOrderId()));
        if(oldOrder.getProcessReview()==2){
            throw  new ServiceException(Constants.Code_600,"该订单已经审核，无法修改");
        }
        if(!Objects.equals(oldOrder.getVersion(), order.getVersion())){
            throw  new ServiceException(Constants.Code_600,"该订单已经修改，请刷新页面");
        }
        order.setCreateTime(null);
        order.setVersion(order.getVersion()+1);
        LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Order::getOrderId, order.getOrderId());
        orderMapper.update(order,updateWrapper);
@@ -220,13 +230,15 @@
        //删除订单工艺表
        // orderProcessDetailMapper.delete(new LambdaQueryWrapper<OrderProcessDetail>().eq(OrderProcessDetail::getOrderId, order.getOrderId()));

        insertOtherDetail(order.getOrderId(),OrderDetails,orderOtherMoneyList);
        orderDetailMapper.deleteOrderFile(order.getOrderId());

        insertOtherDetail(order.getOrderId(),OrderDetails,orderOtherMoneyList, position);
    }



    //插入其他副表数据，被其他方法引用
    public void insertOtherDetail(String orderId,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
    public void insertOtherDetail(String orderId, List<OrderDetail> OrderDetails, List<OrderOtherMoney> orderOtherMoneyList, Map<String, String> position) {
        //先把其他金额副表的金额与数量置0
        if(orderOtherMoneyList!=null){
            orderOtherMoneyList.forEach(orderOtherMoney -> {
@@ -244,7 +256,7 @@
            Product product = productMapper.selectById(OrderDetails.get(i).getProductId());

            OrderDetails.get(i).setWeight(Double.valueOf(String.format("%.2f",product.getThickness()*OrderDetails.get(i).getWidth()*OrderDetails.get(i).getHeight()/1000000*2.5)));
            if(OrderDetails.get(i).getBendRadius()!=null && OrderDetails.get(i).getBendRadius()!=0){
            /*if(OrderDetails.get(i).getBendRadius()!=null && OrderDetails.get(i).getBendRadius()!=0){
                //获取弯钢弧度
                Double bendRadius = OrderDetails.get(i).getBendRadius();
                //获取宽
@@ -253,14 +265,13 @@
                String archRiseS =  String.format("%.1f",bendRadius-(bendRadius*Math.cos(width/2/bendRadius)));
                Double archRise = Double.parseDouble(archRiseS);
                OrderDetails.get(i).setArchRise(archRise);
            }
            }*/

            Map<String,Object> otherColumns = JSON.parseObject(OrderDetails.get(i).getOtherColumns(), new TypeReference<Map<String, Object>>(){});
            int finalI = i;
            if(otherColumns!=null){
                otherColumns.values().removeIf(value -> value == null || value.equals(""));
                OrderDetails.get(i).setOtherColumns(JSON.toJSONString(otherColumns));

                otherColumns.forEach((key, value) ->{

                    if(value!=null && !value.equals("") && key.contains("M")) {
@@ -276,16 +287,62 @@
            }else{
                OrderDetails.get(i).setOtherColumns("{}");
            }
            if(OrderDetails.get(i).getFileName()!=null&&!OrderDetails.get(i).getFileName().trim().isEmpty()){
                orderMapper.saveOrderFile(OrderDetails.get(i).getFileName(), OrderDetails.get(i).getFileData(),orderId,OrderDetails.get(i).getOrderNumber(),OrderDetails.get(i).getFileJson());
            }
            if(OrderDetails.get(i).getShape()==null){
                OrderDetails.get(i).setShape("1");
            }

        }




        //往明细表插数据
        orderDetailMapper.insertBatch(OrderDetails);
        //往小片表传入产品数据
        orderGlassDetailMapper.insertOrderGlassDetail(orderId);
        orderGlassDetailMapper.insertOrderGlassDetail(orderId,position.get("outside"),position.get("inside"));
        //修改成品拱高
        List<OrderDetail> orderDetails = orderDetailMapper
                .selectList(new LambdaQueryWrapper<OrderDetail>()
                        .eq(OrderDetail::getOrderId, orderId)
                        .isNotNull(OrderDetail::getBendRadius)
                );

        orderDetails.forEach(orderDetail -> {
            //获取最小弧度
            List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper
                    .selectList(new LambdaQueryWrapper<OrderGlassDetail>()
                            .eq(OrderGlassDetail::getOrderId, orderId)
                            .eq(OrderGlassDetail::getOrderNumber, orderDetail.getOrderNumber())
                    );

            for(OrderGlassDetail orderGlassDetail:orderGlassDetails) {
                //获取当前层数与之前层数的厚度
                Double glassThickness = productMapper
                        .getGlassThickness(orderDetail.getProductId(), orderGlassDetail.getTechnologyNumber());
                //内半径
                Double radius = orderDetail.getBendRadius() - glassThickness;


                //内片内弧长
                Double innerArc = orderGlassDetails.get(0).getArc()
                        - orderGlassDetails.get(0).getArc() * glassThickness / orderDetail.getBendRadius();

                //拱高
                String archRiseS = String.format("%.1f", radius - radius * Math.cos(innerArc / 2 / radius));
                Double archRise = Double.parseDouble(archRiseS);
                orderGlassDetailMapper.update(null, new LambdaUpdateWrapper<OrderGlassDetail>()
                        .set(OrderGlassDetail::getArchRise, archRise)
                        .eq(OrderGlassDetail::getId, orderGlassDetail.getId())
                );

//                orderDetailMapper.update(null,new LambdaUpdateWrapper<OrderDetail>()
//                        .set(OrderDetail::getArchRise,archRise)
//                        .eq(OrderDetail::getId, orderDetail.getId())
            }

        });


        if(orderOtherMoneyList!=null){
            orderOtherMoneyList.forEach(orderOtherMoney ->{
                orderOtherMoney.setId(null);
@@ -303,8 +360,6 @@

        //修改订单主表面积与周长以及重量
        orderMapper.updateOrderParameter(orderId);

        
    }

    public static List<OrderProcessDetail> getOrderProcessDetails(List<OrderGlassDetail> orderGlassDetails) {
@@ -327,7 +382,7 @@
    public Map<String,Object> getOrderList(Integer pageNum, Integer pageSize, List<String> selectDate, Map<String,Object> config,Integer orderType) {
        Integer offset = (pageNum-1)*pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        String startDate = LocalDate.now().minusDays(365).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
@@ -337,7 +392,7 @@
            }
        }
        JSONObject orderJson = new JSONObject(config);
        Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("filter")), Order.class);
        OrderSearchDTO order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("filter")), OrderSearchDTO.class);
        Map<String,String> sortDate = (Map<String, String>) config.get("sort");
        String field = sortDate.get("field").replaceAll("(?<!^)([A-Z])", "_$1").toLowerCase();
        String orderBy = sortDate.get("order");
@@ -353,7 +408,8 @@
    }
    //删除订单
    public Integer deleteOrder(String id) {
        return  orderMapper.delete(
        orderDetailMapper.deleteOrderFile(id);
        return orderMapper.delete(
                new QueryWrapper<Order>().eq("order_id",id)
        );
    }
@@ -364,16 +420,22 @@
        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
        List<OrderDetail> orderDetails = orderDetailMapper.selectList(new QueryWrapper<OrderDetail>().eq("order_id",id));
        List<OrderOtherMoney> orderOtherMoneyList = orderOtherMoneyMapper.findById(id);


        List<Map<String,String>> orderFileList = orderMapper.selectOrderFileList(id);
        Map<String,Object> map = new HashMap<>();
        map.put("order",order);
        map.put("orderDetails",orderDetails);
        map.put("orderOtherMoneyList",orderOtherMoneyList);
        map.put("orderFile",orderFileList);
        return map;
    }
    //订单审核
    public boolean reviewOrderById(String id, Integer status, String userId, String userName) {
        Log log = new Log();
        log.setOperator(userName);
        log.setOperatorId(userId);
        log.setContent(status.toString());
        log.setFunction("reviewOrderById:"+id);
        logService.saveLog(log);
        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
        if(order.getProcessReview()!=2){
            throw  new ServiceException(Constants.Code_600,"该订单还未审核");
@@ -386,6 +448,9 @@
    }
    //工艺审核界面审核更新数据
    public boolean reviewProcessById(String id, Integer status,List<OrderGlassDetail> orderGlassDetails) {
        Log log = new Log();
        log.setContent(orderGlassDetails.toString());
        log.setFunction("reviewProcessById:"+id);
        if(!orderGlassDetails.isEmpty() && status==2){
            orderGlassDetails.forEach(orderGlassDetail ->{
                double area = Math.round((orderGlassDetail.getChildWidth()*orderGlassDetail.getChildHeight()/1000000) * 100) * 0.01d;
@@ -400,7 +465,7 @@
//            //赋值订单工艺表
//            orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);
        }

        logService.saveLog(log);
        return orderMapper.reviewProcessById(id,status);
    }
    //工艺审核界面数据查询
@@ -493,9 +558,21 @@
        BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
        BigDecimal getQuantity= BigDecimal.valueOf(orderDetail.getQuantity());
        BigDecimal getComputeGrossArea= BigDecimal.valueOf(orderDetail.getComputeGrossArea());
        BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
        BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
        BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
        if (calculateType == 3) {
            orderDetail.setGrossAmount(getPrice.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP).doubleValue());
        } else {
        }else if (calculateType == 4) {
            if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                orderDetail.setGrossAmount(getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
                        divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue());
            }else{
                orderDetail.setGrossAmount(getPrice.multiply(getComputeGrossArea).setScale(2, RoundingMode.HALF_UP).doubleValue());
            }
        }else if (calculateType == 1){
            orderDetail.setGrossAmount(getPrice.multiply(getComputeArea).multiply(getQuantity).setScale(2, RoundingMode.HALF_UP).doubleValue());
        }else{
            orderDetail.setGrossAmount(getPrice.multiply(getComputeGrossArea).setScale(2, RoundingMode.HALF_UP).doubleValue());
        }
        return orderDetail;
@@ -507,10 +584,10 @@
    }


    public Map<String,Object> getOrderReport(Integer pageNum, Integer pageSize, List<String> selectDate, OrderDetail orderDetail) {
    public Map<String,Object> getOrderReport(Integer pageNum, Integer pageSize, List<String> selectDate, OrderDetail orderDetail, Integer model, Integer scope) {
        Integer offset = (pageNum-1)*pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        String startDate = LocalDate.now().minusDays(30).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
@@ -519,9 +596,8 @@
                endDate = selectDate.get(1);
            }
        }

        Map<String,Object> map = new HashMap<>();
        map.put("data",orderDetailMapper.getOrderReport(offset, pageSize, startDate, endDate, orderDetail));
        map.put("data",orderDetailMapper.getOrderReport(offset, pageSize, startDate, endDate, orderDetail,model,scope));
        map.put("total",orderDetailMapper.getOrderReportTotal(offset, pageSize, startDate, endDate, orderDetail,"order"));
        List<String> list = new ArrayList<>();
        list.add(startDate);
@@ -538,7 +614,7 @@
    public Map<String,Object> getOrderSummaryReport(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();
        String startDate = LocalDate.now().minusDays(30).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
@@ -566,7 +642,7 @@
    public Map<String,Object> getOrderProductSummary(Integer pageNum, Integer pageSize, List<String> selectDate, OrderDetail orderDetail) {
        Integer offset = (pageNum-1)*pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        String startDate = LocalDate.now().minusDays(30).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
@@ -613,6 +689,19 @@
            orderProductDetailMap.put("productId",map.get("productId"));
            orderProductDetailMap.put("productName",map.get("productName"));
            List<OrderDetail> orderDetails = orderDetailMapper.getOrderProductByProductId(map.get("productId"),orderId);
            orderDetails.forEach(orderDetail->{

                List<OrderGlassDetail> orderGlassDetails =
                        orderGlassDetailMapper.selectList(
                                new QueryWrapper<OrderGlassDetail>().
                                        eq("order_id",orderId).
                                        eq("order_number",orderDetail.getOrderNumber())
                        );
                Integer differentSize = orderGlassDetailMapper.getDifferentSizeNumber(orderId,orderDetail.getOrderNumber());
                orderDetail.setDifferentSize(differentSize);
                orderDetail.setOrderGlassDetails(orderGlassDetails);
            });

            orderProductDetailMap.put("productDetail",orderDetails);
            orderProductDetail.add(orderProductDetailMap);
        });
@@ -631,13 +720,24 @@
        }else{
            orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
        }

        List<Map<String,Object>> orderProductDetail = new ArrayList<>();
        orderProductDistinct.forEach(map->{
            Map<String,Object> orderProductDetailMap = new HashMap<>();
            orderProductDetailMap.put("productId",map.get("productId"));
            orderProductDetailMap.put("productName",map.get("productName"));
            List<OrderDetail> orderDetails = orderDetailMapper.getOrderProductByProductId(map.get("productId"),orderId);
            orderDetails.forEach(orderDetail->{

                List<OrderGlassDetail> orderGlassDetails =
                        orderGlassDetailMapper.selectList(
                                new QueryWrapper<OrderGlassDetail>().
                                        eq("order_id",orderId).
                                        eq("order_number",orderDetail.getOrderNumber())
                        );
                Integer differentSize = orderGlassDetailMapper.getDifferentSizeNumber(orderId,orderDetail.getOrderNumber());
                orderDetail.setDifferentSize(differentSize);
                orderDetail.setOrderGlassDetails(orderGlassDetails);
            });


            orderProductDetailMap.put("productDetail",orderDetails);
@@ -737,16 +837,7 @@
        });
        returns.put("orderDetail",orderProductDetail);







        return returns;



    }

    public boolean updateOrderPrintNumber(String orderId) {
@@ -816,6 +907,19 @@
    }

    public Object processBack(String orderId,Integer status)  {
        //判断是否转优化
        if(flowCardMapper.flowCardToOptimizeCount(orderId)>0){
            return "false1";
        }
        //判断是否有报工
        if(flowCardMapper.reportingWorkCountByOrderId(orderId)>0){
            return "false2";
        }
        //判断是否有库存
        if(orderMapper.searchOrderWarehousing(orderId)>0){
            return "false3";
        }
        //退回到生产加工单
        if(status<5){
            //更新小片明细表分架状态
            flowCardMapper.updateDeleteState(orderId,"all");
@@ -827,18 +931,142 @@
            flowCardMapper.deleteflowCardSortByOrderId(orderId);
            flowCardMapper.updateProcessingCard(orderId, 0);
        }
        //退回到订单审核后
        if(status<4){
            workOrderMapper.deleteOrderWorkMp(orderId, null);
            workOrderMapper.updateWorkType(orderId, 0);
        }
        //退回到工艺审核后
        if(status<3){
            orderMapper.backReviewOrderById(orderId);
        }

        //退回到下单后
        if(status<2){
            orderMapper.reviewProcessById(orderId,0);
        }
        //日志传入
        Log log = new Log();
        log.setOperator((String) StpUtil.getLoginId());
        log.setOperatorId((String) StpUtil.getLoginId());
        log.setContent(String.valueOf(status));
        log.setFunction("updateOrderMoney金额重置:"+orderId);
        return true;
    }

        return null;
    public Object scannerGlassInfo(String projectNo) {
        try{
            String projectId = "P" + projectNo.substring(0,8);
            //炉号
            Integer heatNo = Integer.valueOf(projectNo.substring(8,11));
            //炉内序号
            Integer sortNo = Integer.valueOf(projectNo.substring(11,14));
            String processId = orderMapper.getProcessIdByOptimizeHeatDetail(projectId,heatNo,sortNo);
            String orderId = flowCardMapper.getOrderIdByProcessId(processId);
            return orderMapper.scannerGlassInfo(projectId,heatNo,sortNo,orderId);
        }catch (Exception e){
            return null;
        }

    }

    public Object uploadDxf(Map<String,Object> object)  {
        String fileName = "";
        if (object.get("fileName") != null) {
            fileName = object.get("fileName").toString();
        }
        String fileData = "";
        if (object.get("fileData") != null) {
            fileData = object.get("fileData").toString();
        }
        byte[] dxfData = Base64.getDecoder().decode(fileData);
        String orderId="NG25010101";
        Integer orderNumber=1;
        //orderMapper.saveOrderFile(fileName, fileData,orderId,orderNumber);
        return true;
    }

    public Map<String,Object> selectUploadDxf(Map<String,Object> object)  {
        String orderId = "";
        if (object.get("orderId") != null) {
            orderId = object.get("orderId").toString();
        }
        int orderNumber =0;
        if (object.get("orderNumber") != null) {
            orderNumber = Integer.parseInt(object.get("orderNumber").toString());
        }
        Map<String,Object> map = new HashMap<>();
        map.put("data",orderMapper.selectOrderFile(orderId,orderNumber));
        return map;
    }

    public boolean updateOrderFile(JSONObject object) throws JsonProcessingException {
        String orderId = "";
        if (object.get("orderId") != null) {
            orderId = object.get("orderId").toString();
        }
        int orderNumber =0;
        if (object.get("orderNumber") != null) {
            orderNumber = Integer.parseInt(object.get("orderNumber").toString());
        }
        String dataBase64 = "";
        if (object.get("dataBase64") != null) {
            dataBase64 = object.get("dataBase64").toString();
        }
        String fileJson = null;
        ObjectMapper om = new ObjectMapper();
        if (object.get("fileJson") != null) {
            fileJson = om.writeValueAsString(object.get("fileJson"));
        }
        Map<String,String> orderFile =orderMapper.selectOrderFile(orderId,orderNumber);
        if(orderFile!=null){
            orderMapper.updateOrderFile("map.dxf", dataBase64,orderId,orderNumber,fileJson);
        }else{
            orderMapper.saveOrderFile("map.dxf", dataBase64,orderId,orderNumber,fileJson);
        }
        return true;
    }

    public Map<String,Object> appGetOrderList(List<String> dates) {
        //设置当前时间
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(30).toString();
        if(dates !=null && dates.size()==2){
            if(dates.get(0) != null){
                startDate = String.valueOf(dates.get(0));
            }
            if(dates.get(1) != null){
                endDate = String.valueOf(dates.get(1));
            }
        }
        List<String> date = new ArrayList<>();
        date.add(startDate);
        date.add(endDate);

        List<Order> list = orderMapper.selectList(new LambdaQueryWrapper<Order>()
                .apply("create_order > 0")
                .apply("date(create_time) between {0} and {1}",startDate, endDate)
        );
        Integer quantity = 0;
        Double area = 0.00;
        Double perimeter = 0.00;
        for(Order order:list){
            quantity += Integer.parseInt(String.valueOf(order.getQuantity()));
            area += Double.parseDouble(String.valueOf(order.getArea()));
            perimeter += order.getPerimeter();
        }
        Map<String, Object> totalSum  = new HashMap<>();
        DecimalFormat df = new DecimalFormat("#.00");
        totalSum.put("quantity",quantity);
        totalSum.put("area", df.format(area));
        totalSum.put("perimeter", df.format(perimeter));
        totalSum.put("count", list.size());


        Map<String,Object> map = new HashMap<>();
        map.put("data",list);
        map.put("date",date);
        map.put("totalSum",totalSum);

        return map;
    }
}