feat : 1.增加生成对账单的Excel功能(AccountStatement)

2.对于invoice和check的状态增加两个状态,提供两个状态的手动设置接口 3.添加扣款单审核功能(需要手动审核) fix ： 1.以前数据库中存储文件oss的永久链接访问,现在只存储文件oss的前缀域名和文件名,后续获取文件都是采用拼接accesskey实时链接获取 2.对于订单状态重新设置

feat : 1.增加生成对账单的Excel功能(AccountStatement)
2.对于invoice和check的状态增加两个状态,提供两个状态的手动设置接口 3.添加扣款单审核功能(需要手动审核) fix ： 1.以前数据库中存储文件oss的永久链接访问,现在只存储文件oss的前缀域名和文件名,后续获取文件都是采用拼接accesskey实时链接获取 2.对于订单状态重新设置
chenhang4442024
1 parent 56ba16e6
Showing 41 changed files with 1919 additions and 210 deletions
src/main/java/com/order/erp/common/constant/Constant.java
src/main/java/com/order/erp/common/utils/AccountStatementExcel.java
src/main/java/com/order/erp/common/utils/EasyPdfUtils.java
src/main/java/com/order/erp/common/utils/SplitUrlGetBucketName.java
src/main/java/com/order/erp/controller/AuditController.java
src/main/java/com/order/erp/controller/InvoiceBillOrderController.java
src/main/java/com/order/erp/controller/OrderController.java
src/main/java/com/order/erp/controller/ProducePaymentCheckBillOrderController.java
src/main/java/com/order/erp/domain/FinanceEnum.java
src/main/java/com/order/erp/domain/FinanceOverEnum.java
src/main/java/com/order/erp/domain/dto/order/InvoiceBillOrderDO.java
src/main/java/com/order/erp/domain/dto/order/OrderBaseInfoDO.java
src/main/java/com/order/erp/domain/dto/order/ProducePaymentCheckBillOrderDO.java
src/main/java/com/order/erp/domain/excel/AccountStatementExcelVO.java
src/main/java/com/order/erp/domain/vo/AccountStatementVO.java
src/main/java/com/order/erp/domain/vo/ImageRespVO.java
src/main/java/com/order/erp/domain/vo/order/AuditDetailQueryVO.java
src/main/java/com/order/erp/domain/vo/order/CheckBillResultVO.java
src/main/java/com/order/erp/domain/vo/order/DeductionUrlFieldVO.java
src/main/java/com/order/erp/domain/vo/order/FinanceOrderResultVO.java
@@ -162,7 +162,7 @@ public class Constant {
     public static final int SEVEN = 7;
     public static final int FOURTEEN= 14;
     public static final int THIRTY = 30;
-
+    public static final int SIXTY = 60;
     public static final int TWENTY_FIRST = 21;
  
  
@@ -337,7 +337,7 @@ public class Constant {
      * redis过期时间。
      */
     public static final  long  REDIS_EMAIL_TIME = 90;
-
+    public static final long  ONEPOINTNINE_HOURS = 6840;   //1.9个小时 114分钟。
     public static final String FINANCE_EVENT_TIME = "请自行去系统中查询！";
  
     public static final String FINANCE_EVENT_TITLE_INNERNO = " , 对应内部编号为 : ";
@@ -345,4 +345,13 @@ public class Constant {
     public static final String FINANCE_EVENT_TITLE_PROJECTNO = " , 对应项目号为 : ";
     public static final String ORDERBASEINFO_PRODUCTIONCOMMENT = " , 更新信息为 : ";
  
+    /**
+     * 文件oss。
+     */
+    public static final String OSS_PIC_URL="oss_pic_url";    //图片资源
+    public static final String OSS_SMALL_PIC_URL="oss_small_pic_url";   //缩略图资源
+    public static final String OSS_INVOICE_DEDUCT_URL="oss_invoice_deduct_url";        //invoice扣款单
+    public static final String OSS_CHECK_DEDUCT_URL="oss_check_deduct_url";        //check扣款单
+    public static final String OSS_BG_URL="oss_bg_url";               //报关单
+    public static final String OSS_INVOICE_URL="oss_invoice_url";     //发票
 }
+package com.order.erp.common.utils;
+
+import com.order.erp.common.constant.Constant;
+import com.order.erp.domain.excel.AccountStatementExcelVO;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.util.IOUtils;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.joda.time.DateTime;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+@Service
+@Slf4j
+public class AccountStatementExcel {
+    public void AccountStatementExcel(HttpServletResponse response, List<AccountStatementExcelVO> accountStatementExcelVOList) throws IOException {
+        Workbook workbook = new XSSFWorkbook();
+        Sheet sheet = workbook.createSheet("对账单");
+        Font font = workbook.createFont();
+        font.setFontHeightInPoints((short) 14);
+
+        CellStyle borderStyle = workbook.createCellStyle();
+        borderStyle.setFont(font);
+        borderStyle.setBorderTop(BorderStyle.THIN);
+        borderStyle.setBorderBottom(BorderStyle.THIN);
+        borderStyle.setBorderLeft(BorderStyle.THIN);
+        borderStyle.setBorderRight(BorderStyle.THIN);
+
+        Row titleRow = sheet.createRow(0);  // 第一行
+        Cell titleheaderCell = titleRow.createCell(0);
+        titleheaderCell.setCellValue(accountStatementExcelVOList.get(0).getTitleCompany());  // 设置你想要的标题内容
+        titleheaderCell.setCellStyle(borderStyle);  // 设置样式
+
+        CellStyle titleStyle = workbook.createCellStyle();
+        Font titleFont = workbook.createFont();
+        titleFont.setFontHeightInPoints((short) 20);
+        titleStyle.setFont(titleFont);
+        titleStyle.setAlignment(HorizontalAlignment.CENTER);  // 水平居中
+        titleStyle.setVerticalAlignment(VerticalAlignment.CENTER);  // 垂直居中
+        titleheaderCell.setCellStyle(titleStyle);  // 将样式应用到单元格
+
+// 合并单元格（例如合并 A1 到 L1）
+        sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 11));
+
+// 设置标题栏的列宽
+        for (int i = 0; i < 12; i++) {
+            sheet.setColumnWidth(i, 5000);  // 根据需求调整宽度
+        }
+        titleRow.setHeightInPoints(30);
+// 设置每页的顶部重复显示标题栏
+        sheet.setRepeatingRows(new CellRangeAddress(0,1,-1,-1));  // 从第1行到第2行（即标题行和生产科,内部编号等等那一行）在每一页重复显示
+
+        Row headerRow = sheet.createRow(1);
+        String[] headers = {"生产科", "内部编号", "Client PC", "STYLE", "REFERENCE", "颜色中文", "PIC 图片", "数量", "拖货时间", "包装类型", "生产科单价", "生产科总价"};
+        for (int i = 0; i < headers.length; i++) {
+            Cell cell = headerRow.createCell(i);
+            cell.setCellValue(headers[i]);
+            cell.setCellStyle(borderStyle);
+        }
+
+        long totalQuantity = 0;
+        double totalPrice = 0;
+
+        for (int i = 0; i < accountStatementExcelVOList.size(); i++) {
+            AccountStatementExcelVO item = accountStatementExcelVOList.get(i);
+
+            URL imageURL = new URL( AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(item.getSmallPicUrl()),SplitUrlGetBucketName.getFileName(item.getSmallPicUrl()),new DateTime().plusYears(Constant.ENABLE_TEN).toDate()));
+            InputStream inputStream = imageURL.openStream();
+            byte[] imageBytes = IOUtils.toByteArray(inputStream);
+            int pictureIndex = workbook.addPicture(imageBytes, Workbook.PICTURE_TYPE_PNG);
+            inputStream.close();
+
+            CreationHelper helper = workbook.getCreationHelper();
+            Drawing<?> drawing = sheet.createDrawingPatriarch();
+            ClientAnchor anchor = helper.createClientAnchor();
+            anchor.setCol1(6);
+            anchor.setRow1(i + 2);
+            anchor.setAnchorType(ClientAnchor.AnchorType.DONT_MOVE_AND_RESIZE);
+
+            Picture picture = drawing.createPicture(anchor, pictureIndex);
+            picture.resize(1.0);
+
+            Row row = sheet.createRow(i + 2);
+            String[] rowData = {
+                    item.getProductionDepartment(), item.getInnerNo(), item.getCustomerPo(),
+                    item.getCustomerStyle(), item.getModeleLo(), item.getCnColor(),
+                    item.getSmallPicUrl(), String.valueOf(item.getOrderCount()),
+                    item.getProductionDepartmentConsignTime().split(" ")[0], item.getPacketType(),
+                    "￥" + String.format("%.2f", item.getProductionDepartmentPrice()),
+                    "￥" + String.format("%.2f", item.getProductionDepartmentTotalPrice())
+            };
+
+            for (int j = 0; j < rowData.length; j++) {
+                Cell cell = row.createCell(j);
+                cell.setCellValue(rowData[j]);
+                cell.setCellStyle(borderStyle);
+            }
+
+            totalQuantity += item.getOrderCount();
+            totalPrice += item.getProductionDepartmentTotalPrice();
+            row.setHeightInPoints(90);
+        }
+
+        int lastRowNum = accountStatementExcelVOList.size() + 2;
+        Row totalRow = sheet.createRow(lastRowNum);
+        for (int j = 0; j < 12; j++) {
+            totalRow.createCell(j);
+        }
+
+        totalRow.getCell(0).setCellValue("合计");
+        totalRow.getCell(7).setCellValue(totalQuantity );
+        totalRow.getCell(11).setCellValue(totalPrice > 0 ? "￥" + String.format("%.2f", totalPrice) : "无数据");
+
+
+
+        for (int j = 0; j < 12; j++) {
+            totalRow.getCell(j).setCellStyle(borderStyle);
+        }
+        totalRow.setHeightInPoints(50);
+
+        int[] columnWidths = {3000, 4000, 7000, 6000, 6000, 4000, 4400, 2500, 4000, 3000, 3100, 4000};
+        for (int i = 0; i < columnWidths.length; i++) {
+            sheet.setColumnWidth(i, columnWidths[i]);
+        }
+
+        //两个小的表格
+        Font smallFont = workbook.createFont();
+        smallFont.setFontHeightInPoints((short) 14);
+        // 记录开始行
+        int smallTableStartRow = lastRowNum + 2;
+
+        List<HashMap<String, Double>> disbursement = accountStatementExcelVOList.get(0).getDisbursement();
+        List<HashMap<String, Double>> deduction = accountStatementExcelVOList.get(0).getDeduction();
+
+// 小表格边框样式
+        CellStyle smallTableStyle = workbook.createCellStyle();
+        smallTableStyle.setFont(smallFont);
+        smallTableStyle.setBorderTop(BorderStyle.THIN);
+        smallTableStyle.setBorderBottom(BorderStyle.THIN);
+        smallTableStyle.setBorderLeft(BorderStyle.THIN);
+        smallTableStyle.setBorderRight(BorderStyle.THIN);
+        smallTableStyle.setAlignment(HorizontalAlignment.CENTER);
+
+// **加粗标题样式**
+        CellStyle boldTitleStyle = workbook.createCellStyle();
+        Font boldFont = workbook.createFont();
+        boldFont.setBold(true);
+        boldFont.setFontHeightInPoints((short) 14);
+        boldTitleStyle.setFont(boldFont);
+        boldTitleStyle.setAlignment(HorizontalAlignment.CENTER);
+
+// 创建黄色背景的单元格样式
+        CellStyle yellowBackgroundStyle = workbook.createCellStyle();
+        yellowBackgroundStyle.setFillForegroundColor(IndexedColors.YELLOW.getIndex());
+        yellowBackgroundStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); // 设置为实心背景
+
+// **左侧小表格（扣费费用）**
+        Row leftTitleRow = sheet.getRow(smallTableStartRow);
+        if (leftTitleRow == null) {
+            leftTitleRow = sheet.createRow(smallTableStartRow);
+        }
+        Cell titleCell = leftTitleRow.createCell(2);
+        titleCell.setCellValue("扣费项目");
+        titleCell.setCellStyle(boldTitleStyle);
+        titleCell.setCellStyle(yellowBackgroundStyle);
+
+        Row leftHeaderRow = sheet.createRow(smallTableStartRow + 1);
+        Cell nameHeaderCell = leftHeaderRow.createCell(2);
+        Cell amountHeaderCell = leftHeaderRow.createCell(3);
+        nameHeaderCell.setCellValue("名称");
+        amountHeaderCell.setCellValue("金额");
+        nameHeaderCell.setCellStyle(boldTitleStyle);
+        amountHeaderCell.setCellStyle(boldTitleStyle);
+
+        int rowIndex = smallTableStartRow + 2;
+        double totalDisbursement = 0.0;
+
+
+        for (HashMap<String, Double> map : disbursement) {
+            for (String key : map.keySet()) {
+                Row row = sheet.getRow(rowIndex);
+                if (row == null) {
+                    row = sheet.createRow(rowIndex);
+                }
+
+                Cell nameCell = row.createCell(2);
+                Cell amountCell = row.createCell(3);
+
+
+
+                nameCell.setCellValue(key);
+                amountCell.setCellValue("￥"+String.format("%.2f",map.get(key)));
+
+                nameCell.setCellStyle(smallTableStyle);
+                amountCell.setCellStyle(smallTableStyle);
+
+                row.setHeightInPoints(30);
+                rowIndex++;
+
+                totalDisbursement += map.get(key);
+
+            }
+        }
+
+// **左侧合计行**
+// **创建合并样式**
+        CellStyle boldBorderStyle = workbook.createCellStyle();
+        boldBorderStyle.cloneStyleFrom(smallTableStyle); // 继承边框样式
+        boldBorderStyle.setFont(boldFont); // 加粗
+
+// **左侧合计行**
+        Row leftTotalRow = sheet.createRow(rowIndex);
+        Cell totalTitleCell = leftTotalRow.createCell(2);
+        Cell totalValueCell = leftTotalRow.createCell(3);
+
+        totalTitleCell.setCellValue("合计");
+        totalValueCell.setCellValue("￥"+String.format("%.2f",totalDisbursement));
+
+        totalTitleCell.setCellStyle(boldBorderStyle);
+        totalValueCell.setCellStyle(boldBorderStyle);
+
+       rowIndex=rowIndex+1;
+// **右侧小表格（垫带费用）**
+// 增加一个空白行以增加间距
+        int totalAmountRowStart= rowIndex++; // 在创建“代垫费用”标题之前增加一个空白行
+
+        Row rightTitleRow = sheet.createRow(rowIndex); // 创建代垫费用标题
+        rightTitleRow.createCell(2).setCellValue("代垫费用");
+        rightTitleRow.getCell(2).setCellStyle(boldTitleStyle);
+
+// **设置黄色背景**
+        rightTitleRow.getCell(2).setCellStyle(yellowBackgroundStyle);
+
+        rowIndex++; // 下一行开始填充数据
+        Row rightHeaderRow = sheet.createRow(rowIndex); // 创建表头
+        rightHeaderRow.createCell(2).setCellValue("名称");
+        rightHeaderRow.createCell(3).setCellValue("金额");
+
+// **为表头添加黄色背景**
+        rightHeaderRow.getCell(2).setCellStyle(yellowBackgroundStyle);
+        rightHeaderRow.getCell(3).setCellStyle(yellowBackgroundStyle);
+
+        rightHeaderRow.getCell(2).setCellStyle(boldTitleStyle);
+        rightHeaderRow.getCell(3).setCellStyle(boldTitleStyle);
+
+        rowIndex++; // 继续到下一行
+        double totalDeduction = 0.0;
+
+        for (HashMap<String, Double> map : deduction) {
+            for (String key : map.keySet()) {
+                Row row = sheet.getRow(rowIndex);
+                if (row == null) {
+                    row = sheet.createRow(rowIndex);
+                }
+                row.createCell(2).setCellValue(key);
+                row.createCell(3).setCellValue("￥"+String.format("%.2f",map.get(key)));
+
+                row.getCell(2).setCellStyle(smallTableStyle);
+                row.getCell(3).setCellStyle(smallTableStyle);
+                row.setHeightInPoints(30);
+                rowIndex++;
+
+                totalDeduction += map.get(key); // 计算合计
+            }
+        }
+
+// **右侧合计行**
+        Row rightTotalRow = sheet.createRow(rowIndex);
+        rightTotalRow.createCell(2).setCellValue("合计");
+        rightTotalRow.createCell(3).setCellValue("￥"+String.format("%.2f",totalDeduction));
+
+// **添加边框样式到合计行**
+        CellStyle totalCellStyle = workbook.createCellStyle();
+        totalCellStyle.cloneStyleFrom(boldBorderStyle);
+        totalCellStyle.setBorderBottom(BorderStyle.THIN);
+        totalCellStyle.setBorderTop(BorderStyle.THIN);
+        totalCellStyle.setBorderLeft(BorderStyle.THIN);
+        totalCellStyle.setBorderRight(BorderStyle.THIN);
+
+        rightTotalRow.getCell(2).setCellStyle(totalCellStyle);
+        rightTotalRow.getCell(3).setCellStyle(totalCellStyle);
+
+
+// 调整小表格列宽
+        sheet.setColumnWidth(2, 7000);
+        sheet.setColumnWidth(3, 6000);
+
+        // 计算总金额: 大表合计 - 小表格合计
+        double totalAmount = totalPrice - totalDisbursement - totalDeduction;
+
+// 在两个小表格的右方展示总金额
+        Row totalAmountRow = sheet.createRow(totalAmountRowStart);  // 新建行
+        totalAmountRow.createCell(10).setCellValue("总金额");
+        totalAmountRow.createCell(11).setCellValue("￥"+String.format("%.2f", totalAmount));
+
+// 添加样式
+        CellStyle totalAmountStyle = workbook.createCellStyle();
+        totalAmountStyle.cloneStyleFrom(boldBorderStyle);  // 继承合计行样式
+        totalAmountRow.getCell(10).setCellStyle(totalAmountStyle);
+        totalAmountRow.getCell(11).setCellStyle(totalAmountStyle);
+
+
+
+
+        PrintSetup printSetup = sheet.getPrintSetup();
+        printSetup.setPaperSize(PrintSetup.A4_PAPERSIZE);
+        sheet.setFitToPage(true);
+        sheet.getPrintSetup().setFitWidth((short) 1);
+        sheet.getPrintSetup().setFitHeight((short) 0);
+        sheet.getPrintSetup().setHeaderMargin(0.5);
+        sheet.getPrintSetup().setFooterMargin(0.5);
+        sheet.setMargin(Sheet.TopMargin, 1.0);
+        sheet.setMargin(Sheet.BottomMargin, 0.5);
+        sheet.setMargin(Sheet.LeftMargin, 0.5);
+        sheet.setMargin(Sheet.RightMargin, 0.5);
+
+        Footer footer = sheet.getFooter();
+        footer.setCenter("第 &P 页，共 &N 页");
+//        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet; charset=UTF-8");
+        response.setHeader("Content-Disposition", "attachment; filename=\"-.xlsx\"");
+        workbook.write(response.getOutputStream());
+        workbook.close();
+    }
+
+}
@@ -13,6 +13,7 @@ import com.order.erp.service.LocalStorageService;
 import com.order.erp.service.order.OrderBaseInfoService;
 import com.order.erp.service.order.OrderProfitAnalysisService;
 import lombok.extern.slf4j.Slf4j;
+import org.joda.time.DateTime;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
@@ -402,7 +403,8 @@ public class EasyPdfUtils {
             }
             dataCellList.add(createCell(StringUtils.isNotEmpty(producePdfVO.getCnColor()) ? producePdfVO.getCnColor() : "", 100F));
             if (StringUtils.isNotBlank(producePdfVO.getPicUrl())) {
-                URL url = new URL(producePdfVO.getPicUrl());
+                String onlineUrl = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(producePdfVO.getPicUrl()), SplitUrlGetBucketName.getFileName(producePdfVO.getPicUrl()), new DateTime().plusMinutes(Constant.ENABLE_TEN).toDate());
+                URL url = new URL(onlineUrl);
                 InputStream inputStream = url.openStream();
                 File imageFile = FileUtil.inputStreamToFile(inputStream, "order" + System.currentTimeMillis() + ".png");
  
+package com.order.erp.common.utils;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Slf4j
+public class SplitUrlGetBucketName {
+    //获取文件名称以及域名。
+    /**
+     例如:  https://alterego.oss-cn-qingdao.aliyuncs.com/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png?accesskey=....
+     ==>
+     https://alterego.oss-cn-qingdao.aliyuncs.com/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png
+     */
+    public static String getUrlFileName(String url){
+        if(StringUtils.isNotEmpty(url)){
+        return url.split("\\?")[0];
+        }
+        return null;
+    }
+
+    //获取bucket名称。
+    /**
+     * 例如: https://alterego.oss-cn-qingdao.aliyuncs.com/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png
+     * ==>
+     * alterego
+     * */
+    public static String getBucket(String url){
+        if(StringUtils.isNotEmpty(url)){
+            String domain = url.replaceFirst("^https?://", "").split("/")[0];
+            return domain.split("\\.")[0];
+        }
+        return null;
+
+    }
+   //获取文件名称。
+   /**
+    * 例如:Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png,如果原始文件中有中文,就返回中文,因为后续还会编码变成乱码,要是这里不返回中文,后面再次编码就相当于中文编码再编码了。
+    * 如果不为中文,则返回文件名。因为不包含中文名的文件名不会编译成乱码。为原始文件名。
+   */
+    public static String getFileName(String url){
+        if(StringUtils.isNotEmpty(url)){
+            //在上传pdf文件时,有时候存到数据库中,会在文件名前加上/upload_file_oss前缀,所以在这里判断一下。
+            /**
+             *  https://alterego.oss-cn-qingdao.aliyuncs.com/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png  则返回 Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.png
+             *  https://alterego.oss-cn-qingdao.aliyuncs.com/upload_file_oss/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.pdf 则返回upload_file_oss/Thumbnails-1731807674577-943%E5%9B%BE%E7%89%871.pdf
+             * */
+            if(url.contains("/upload_file_oss")){
+                String path = url.replaceFirst("https://[^/]+/", "");
+                try {
+                    return URLDecoder.decode(path, StandardCharsets.UTF_8.name());
+                } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException("文件名称解析失败"+e);
+                }
+            }else{
+            String regex = "%[0-9A-Fa-f]{2}";
+            Pattern pattern = Pattern.compile(regex);
+            String fileName = url.substring(url.lastIndexOf("/") + 1);
+            Matcher matcher = pattern.matcher(fileName);
+            if(matcher.find()){
+                // URL 解码  如果包含中文名称就进行解析,回显中文名称。
+                try {
+                    return URLDecoder.decode(fileName, StandardCharsets.UTF_8.name());
+                    // 判断解码后的文件名是否是中文字符
+                    } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException("文件名称解析失败:"+e);
+                   }
+            }else{
+                return fileName;
+            }
+        }
+        }
+        return null;
+    }
+}
+
@@ -3,6 +3,7 @@ package com.order.erp.controller;
 import com.order.erp.common.annotation.AnonymousAccess;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.domain.AuditStatusEnum;
+import com.order.erp.domain.vo.order.AuditDetailQueryVO;
 import com.order.erp.domain.vo.order.AuditVO;
 import com.order.erp.domain.vo.order.OrderFieldLockApplyQueryVO;
 import com.order.erp.service.order.OrderFieldLockApplyService;
@@ -85,5 +86,18 @@ public class AuditController {
     public ServerResult doAudit(@RequestBody @Validated AuditVO auditVO) {
         return applyService.doAudit(auditVO);
     }
+
+    /**
+     * 详情
+     *
+     * @param auditDetailQueryVO 查询条件
+     * @return 查询结果
+     */
+    @ApiOperation("详情接口")
+    @PostMapping("/audit_detail")
+    @AnonymousAccess
+    public ServerResult audit_detail(@RequestBody @Validated AuditDetailQueryVO auditDetailQueryVO) {
+        return applyService.audit_detail(auditDetailQueryVO);
+    }
 }
  
@@ -205,8 +205,8 @@ public class InvoiceBillOrderController {
         return invoiceBillOrderService.deleteDeductUrlById(deleteVo);
     }
  
-    /**
-     *最后一步,确认是否已经完成最终收款,即使审核通过之后,invoice的状态为已收款,这里的作用是在已收款状态的基础上,最后手动确认是否完成收款。人工校验。
+   /**  删除
+     *最后一步,确认是否已经完成最终收款,即使审核通过之后,invoice的状态从未收款转化为待收款,,这里的作用是在待收款状态的基础上,最后手动确认是否完成收款。人工校验,状态为已收款。
      * @param invoiceBillDeductInfoVO id
      * @return
      */
@@ -4,6 +4,7 @@ import com.order.erp.common.annotation.AnonymousAccess;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.common.excel4j.exceptions.Excel4JException;
 import com.order.erp.common.exception.BusinessException;
+import com.order.erp.domain.vo.AccountStatementVO;
 import com.order.erp.domain.vo.ProducePdfVO;
 import com.order.erp.domain.vo.order.*;
 import com.order.erp.mapper.order.OrderBaseInfoMapper;
@@ -169,17 +170,35 @@ public class OrderController {
     public ServerResult oneTimePassRate(@RequestBody OrderOpinionLogVO orderOpinionLogVO) {
         return orderBaseInfoService.passRate(orderOpinionLogVO);
     }
-
+    /**
+     * 生产指示书
+     *
+     * @param  producePdfVO 生成列表
+     *
+     */
     @PostMapping("/produceReport")
     public ServerResult produceReport(@RequestBody ProducePdfVO producePdfVO) {
         return orderBaseInfoService.produceReport(producePdfVO);
     }
-
+    /**
+     * 发送生产指示书至邮箱
+     *
+     * @param  producePdfVO 生成列表
+     *
+     */
     @PostMapping("/send")
     public ServerResult send(@RequestBody ProducePdfVO producePdfVO) throws Exception {
         return orderBaseInfoService.send(producePdfVO);
     }
-
-
+    /**
+     * 生产对账单
+     *
+     * @param  accountStatementVO 生成列表
+     *
+     */
+    @PostMapping("/accountStatement")
+    public ServerResult accountStatement(HttpServletResponse response,@RequestBody AccountStatementVO accountStatementVO) throws Exception {
+        return orderBaseInfoService.accountStatement(response,accountStatementVO);
+    }
 }
  
@@ -217,8 +217,8 @@ public class ProducePaymentCheckBillOrderController {
        return producePaymentCheckBillOrderService.deleteDeductUrlById(deleteVo);
     }
  
-    /**
-     *最后一步,确认是否已经完成最终收款,即使审核通过之后,invoice的状态为已收款,这里的作用是在已收款状态的基础上,最后手动确认是否完成收款。人工校验。
+    /**  删除
+     *最后一步,确认是否已经完成最终收款,即使审核通过之后,check的状态从未收款转化为待收款,这里的作用是在已收款状态的基础上,最后手动确认是否完成收款。人工校验,转化为已收款状态。
      * @param producePaymentCheckBillInvoiceInfoVO id
      * @return
      */
@@ -226,6 +226,7 @@ public class ProducePaymentCheckBillOrderController {
     public ServerResult isFinishStatus(@RequestBody ProducePaymentCheckBillInvoiceInfoVO producePaymentCheckBillInvoiceInfoVO) {
         return producePaymentCheckBillOrderService.isFinishStatus(producePaymentCheckBillInvoiceInfoVO);
     }
+
 }
  
  
@@ -16,8 +16,10 @@ public enum FinanceEnum {
     NOT_CREATED(-1,"未创建"),
     //创建了invoice号没有提交审核,或者审核被驳回了。
     UNPAID_PAYMENTS(0,"未收款"),
-    //审核通过了。
-    RECEIVED_PAYMENT(10,"已收款"),
+    //审核通过了。但是还是叫做待收款。
+    RECEIVED_PAYMENT(10,"待收款"),
+    //审核通过以后叫做待收款,人工确认之后才会由待收款转化为已收款。
+    OK_PAYMENT(40,"已收款"),
     ;
     private Integer status;
  
@@ -14,6 +14,10 @@ public enum FinanceOverEnum {
     CHECK_FAIL("你提交的生产科对账单未通过审核","Hi All 你提交的生产科对账单未通过审核,请重新查看原因并提交审核！\n生产科对账单号为： "),
     CHECK_INVOICEURL_PASS("你提交的生产科对账单发票通过审核","Hi All 你提交的生产科对账单发票通过审核,你现在可以提交生产科对账单了！\n生产科对账单号为： "),
     CHECK_INVOICEURL_FAIL("你提交的生产科对账单发票未通过审核","Hi All 你提交的生产科对账单未通过审核,请重新查看原因并提交审核！\n生产科对账单号为： "),
+    CHECK_DEDUCTURL_PASS("你提交的生产科扣款单通过审核","Hi All 你提交的生产科扣款单通过审核,你现在可以提交生产科对账单了！\n生产科对账单号为： "),
+    CHECK_DEDUCTURL_FAIL("你提交的生产科扣款单未通过审核","Hi All 你提交的生产科扣款单未通过审核,请重新查看原因并提交审核！\n生产科对账单号为： "),
+    INVOICE_DEDUCTURL_PASS("你提交的invoice扣款单已通过审核","Hi All 你提交的invoice扣款单已通过审核,请查收！\nInvoice号为： "),
+    INVOICE_DEDUCTURL_FAIL("你提交的invoice扣款单未通过审核","Hi All 你提交的invoice扣款单未通过审核,请重新查看原因并提交审核！请查收！\nInvoice号为： "),
     ;
  
     private String title;
@@ -33,7 +33,7 @@ public class InvoiceBillOrderDO extends BaseDO implements Serializable {
      */
     private Long orderId ;
     /**
-     * 报关单url地址
+     * 报关单url地址   数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String bgUrl;
     /**
@@ -50,7 +50,7 @@ public class InvoiceBillOrderDO extends BaseDO implements Serializable {
      */
     private BigDecimal deductAmount;
     /**
-     * 扣款单url地址
+     * 扣款单url地址    数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String deductUrl;
     /**
@@ -74,7 +74,7 @@ public class InvoiceBillOrderDO extends BaseDO implements Serializable {
      */
     private BigDecimal otherAmount;
     /**
-     * 状态 -1：未创建、0：未收款，10：已收款
+     * 状态 -1：未创建、0：未收款，10：待收款   20:已收款
      */
     private Integer status;
     //需要在表中添加字段。
@@ -109,8 +109,9 @@ public class InvoiceBillOrderDO extends BaseDO implements Serializable {
      * */
     private String notes;
  
+
     /**
-     * 最终完成状态,需要手动确认   状态 0：未完成，10：已完成
+     * 扣款单状态   状态 0：待审批，10：已通过 20:已驳回
      * */
-    private Integer finishStatus;
+    private Integer invoiceDeductUrlStatus;
 }
@@ -64,12 +64,12 @@ public class OrderBaseInfoDO extends BaseDO implements Serializable {
      * 颜色中文
      */
     private String cnColor;
-    /**
-     * pic图片地址
+    /**0
+     * pic图片地址            数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String picUrl;
     /**
-     * 缩略图地址
+     * 缩略图地址             数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String smallPicUrl;
     /**
@@ -34,11 +34,11 @@ public class ProducePaymentCheckBillOrderDO extends BaseDO implements Serializab
      */
     private Long orderId;
     /**
-     * 发票url地址
+     * 发票url地址      数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String invoiceUrl;
     /**
-     * 扣款单url地址
+     * 扣款单url地址     数据库中只存储域名和文件名,不存储accesskey,所以每次获取时都应该拿着文件名去获取实时链接。
      */
     private String deductUrl;
     /**
@@ -118,9 +118,9 @@ public class ProducePaymentCheckBillOrderDO extends BaseDO implements Serializab
      * */
     private String notes;
     /**
-     * 最终完成状态,需要手动确认   状态 0：未完成，10：已完成
+     * 扣款单状态     0:待审核  10:已通过 20:已驳回
      * */
-    private Integer finishStatus;
+    private Integer checkDeductUrlStatus;
  
  
 }
+package com.order.erp.domain.excel;
+
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+@ToString
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+@SuperBuilder
+public class AccountStatementExcelVO {
+
+    /**
+     * 生产科
+     */
+    private String productionDepartment;
+
+    /**
+     * 内部编号
+     */
+    private String innerNo;
+
+    /**
+     * 客户po号(客户订单号)
+     */
+    private String customerPo;
+
+    /**
+     * 客户STYLE#(客户款号)
+     */
+    private String customerStyle;
+    /**
+     * Modelo(REFERENCE)
+     */
+    private String modeleLo;
+    /**
+     * 颜色中文
+     */
+    private String cnColor;
+
+    /**
+     * pic图片地址(订单图片)
+     */
+    private String smallPicUrl;
+
+    /**
+     * 订单数量
+     */
+    private Integer orderCount;
+
+    /**
+     * 生成科拖货时间(生产科交期)
+     */
+    private String productionDepartmentConsignTime;
+
+    /**
+     * 包装类型
+     */
+    private String packetType;
+
+    /**
+     * 生成科单价￥
+     */
+    private Double productionDepartmentPrice;
+
+    /**
+     * 生成科总价￥
+     */
+    private Double productionDepartmentTotalPrice;
+
+    /**
+     * 代垫费用
+     * */
+    private List<HashMap<String,Double>> disbursement;
+
+    /**
+     * 扣款项目
+     * */
+
+    private List<HashMap<String,Double>> deduction;
+    /**
+     * 公司名称
+     * */
+    private String titleCompany;
+
+}
+package com.order.erp.domain.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class AccountStatementVO {
+    /**
+     * 订单id。
+     * */
+    private List<Long> ids;
+    /**
+     * 代垫费用
+     * */
+    private List<HashMap<String,Double>> disbursement;
+    /**
+     * 扣款项目
+     * */
+
+    private List<HashMap<String,Double>> deduction;
+    /**
+     * 公司名称
+     * */
+
+    private String titleCompany;
+}
@@ -27,4 +27,12 @@ public class ImageRespVO implements Serializable {
      * 缩略图地址
      */
     private String smallPicUrl;
+    /**
+     * 文件name。
+     */
+    private String fileName;
+    /**
+     * 缩略图文件name。
+     */
+    private String SmallfileName;
 }
+package com.order.erp.domain.vo.order;
+
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+@Data
+@AllArgsConstructor
+@ToString
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+@SuperBuilder
+public class AuditDetailQueryVO {
+
+    /**
+     * 申请id
+     */
+    private Long id;
+}
+package com.order.erp.domain.vo.order;
+
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.math.BigDecimal;
+
+@Data
+@AllArgsConstructor
+@ToString
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+@SuperBuilder
+public class CheckBillResultVO {
+    /**
+     * id
+     */
+    private Long id;
+    /**
+     * orderId
+     */
+    private Long orderId;
+    /**
+     * 项目号
+     */
+    private String projectNo;
+    /**
+     * 生产科
+     */
+    private String productionDepartment;
+    /**
+     * 内部编号
+     */
+    private String innerNo;
+    /**
+     * 缩略图片地址     这里不确认前端拿到的数据是缩略图url还是图片url,先采用缩略图url。
+     */
+    private String smallPicUrl;
+    /**
+     * 数量
+     */
+    private Integer orderCount;
+    /**
+     * Modelo(REFERENCE)
+     */
+    private String modeleLo;
+    /**
+     * 生产科单价
+     */
+    private Double productionDepartmentPrice;
+    /**
+     * 生产科总价
+     */
+    private Double productionDepartmentTotalPrice;
+    /**
+     * 生产科对账单
+     */
+    private String checkNo;
+    /**
+     * 生产科必须回款日期
+     */
+    private String payedDate;
+    /**
+     * 生产科扣款金额
+     */
+    private BigDecimal deductAmount;
+    /**
+     * 生产科扣款责任部门
+     */
+    private String deductDept;
+    /**
+     * 扣款单url地址
+     */
+    private String deductUrl;
+    /**
+     * 实际应付金额
+     */
+    private BigDecimal actualPayedAmount;
+    /**
+     * 发票url地址
+     */
+    private String invoiceUrl;
+    /**
+     * 实际应付金额1
+     */
+    private BigDecimal actualPayedAmount1;
+    /**
+     * 实际应付金额2
+     */
+    private BigDecimal actualPayedAmount2;
+    /**
+     * 实际应付金额3
+     */
+    private BigDecimal actualPayedAmount3;
+    /**
+     * 备注。
+     * */
+    private String notes;
+}
+package com.order.erp.domain.vo.order;
+
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.math.BigDecimal;
+
+@Data
+@AllArgsConstructor
+@ToString
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+@SuperBuilder
+public class DeductionUrlFieldVO {
+    /**
+     * 订单id,。
+     */
+    private Long id;
+    /**
+     * 内部编号。
+     */
+    private String innerNo;
+    /**
+     * 发票单号
+     */
+    private String invoiceNo;
+
+    /**
+     * 跟单员
+     * */
+    private String trackerUser;
+    /**
+     * 业务员
+     * */
+    private String businesPerson;
+    /**
+     * 财务人员
+     * */
+    private String financePerson;
+
+    /**
+     * 生产科对账单
+     */
+    private String checkNo;
+
+    /**
+     * 生产科
+     * */
+    private String productionName;
+
+    /**
+     * 扣款单
+     * */
+    private String deductUrl;
+    /**
+     * 扣款金额
+     * */
+    private BigDecimal deductAmount;
+}
@@ -86,6 +86,10 @@ public class FinanceOrderResultVO extends OrderBaseInfoVO {
      */
     private String invoiceDeductUrl;
     /**
+     * 扣款单状态状态。0:待审核  10:已通过 20:已驳回
+     * */
+    private Integer invoiceDeductUrlStatus;
+    /**
      * 实际应收金额
      */
     private BigDecimal invoiceActualReceivableAmount;
@@ -114,10 +118,6 @@ public class FinanceOrderResultVO extends OrderBaseInfoVO {
      * 备注信息
      * */
     private String invoiceNotes;
-    /**
-     * 最终确认,0:未完成 10:已完成
-     * */
-    private Integer invoiceFinishStatus;
  
     //应付款信息
 //    private ProducePaymentCheckBillOrderDO producePaymentCheckBillOrderDO;
@@ -154,6 +154,10 @@ public class FinanceOrderResultVO extends OrderBaseInfoVO {
      */
     private BigDecimal checkDeductAmount;
     /**
+     * 扣款单状态状态。0:待审核  10:已通过 20:已驳回
+     * */
+    private Integer checkDeductUrlStatus;
+    /**
      * 实际应付金额
      */
     private BigDecimal checkActualPayedAmount;
@@ -182,10 +186,6 @@ public class FinanceOrderResultVO extends OrderBaseInfoVO {
      * 备注。
      * */
     private String checkNotes;
-    /**
-     * 最终确认状态。0:未完成  10:已完成
-     * */
-    private Integer checkFinishStatus;
  
  
     //利润信息
@@ -24,6 +24,12 @@ public class InvoiceAndCheckBillSendEmailVO {
     private ProducePaymentCheckBillOrderDO checkBillOrderDO;
  
     /**
+     * 扣款单
+     * */
+
+    private DeductionUrlFieldVO deductionUrlFieldVO;
+
+    /**
      * 拒绝原因
      * */
     private String refuseRemark;
@@ -121,14 +121,6 @@ public class InvoiceBillOrderQueryVO extends BasePageVO implements Serializable 
      */
     private String businessUserName;
  
-    /**
-     * 最终确认状态 0:未完成,10:已完成
-     */
-    private Integer invoiceFinishStatus;
-    /**
-     * 最终确认状态 0:未完成,10:已完成
-     */
-    private Integer checkFinishStatus;
  
 }
  
@@ -20,7 +20,7 @@ public class InvoiceFieldVO {
      */
     private List<Long> invoiceId;
     /**
-     * 订单id,这里取选中多个集合中的第第一个id作为申请id。
+     * 内部编号。
      */
     private List<String> innerNo;
     /**
+package com.order.erp.domain.vo.order;
+
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.math.BigDecimal;
+
+@Data
+@AllArgsConstructor
+@ToString
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+@SuperBuilder
+public class InvoiceResultVO {
+    /**
+     * id
+     */
+    private Long id;
+    /**
+     * orderId
+     */
+    private Long orderId;
+
+    /**
+     * 项目号
+     */
+    private String projectNo;
+    /**
+     * 生产科
+     */
+    private String productionDepartment;
+    /**
+     * 内部编号
+     */
+    private String innerNo;
+    /**
+     * 缩略图片地址     这里不确认前端拿到的数据是缩略图url还是图片url,先采用缩略图url。
+     */
+    private String smallPicUrl;
+    /**
+     * 数量
+     */
+    private Integer orderCount;
+    /**
+     * Modelo(REFERENCE)
+     */
+    private String modeleLo;
+    /**
+     * 客户单价$
+     */
+    private Double customerPrice;
+    /**
+     * 客户总价$
+     */
+    private Double customerTotalPrice;
+    /**
+     * 发票单号
+     */
+    private String invoiceNo;
+    /**
+     * 报关单url地址
+     */
+    private String bgUrl;
+    /**
+     * 必须回款日期
+     */
+    private String backRefundDate;
+    /**
+     * 发生扣款金额
+     */
+    private BigDecimal deductAmount;
+    /**
+     * 扣款单url地址
+     */
+    private String deductUrl;
+    /**
+     * 实际应收金额
+     */
+    private BigDecimal actualReceivableAmount;
+    /**
+     * 实际应付金额1
+     */
+    private BigDecimal actualPayedAmount1;
+    /**
+     * 实际应付金额2
+     */
+    private BigDecimal actualPayedAmount2;
+    /**
+     * 实际应付金额3
+     */
+    private BigDecimal actualPayedAmount3;
+    /**
+     * 其他费用金额
+     */
+    private BigDecimal otherAmount;
+    /**
+     * 备注信息
+     * */
+    private String notes;
+
+}
@@ -80,6 +80,15 @@ public class OrderBaseInfoVO implements Serializable {
      */
     private String smallPicUrl;
     /**
+     * pic图片名称
+     */
+    private String fileName;
+
+    /**
+     * 缩略图片名称
+     */
+    private String smallFileName;
+    /**
      * 生产要求
      */
     private String productionComment;
@@ -48,10 +48,11 @@ public class OrderLockFieldVO implements Serializable {
     /**
      * 应收款账单字段
      */
-//    private List<InvoiceBillOrderDO> invoiceBillOrderDOList;
  
      private  InvoiceFieldVO invoiceFieldVO;
  
+     //这个专门给扣款单使用(应收和应付都可以使用)。
+     private DeductionUrlFieldVO deductionUrlFieldVO;
     /**
      * 应付款账单字段
      */
@@ -6,10 +6,12 @@ import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.order.erp.common.constant.Constant;
 import com.order.erp.common.utils.DateUtils;
 import com.order.erp.common.utils.TransactionHelper;
+import com.order.erp.domain.ApplyStatusEnum;
 import com.order.erp.domain.OrderStatusEnum;
 import com.order.erp.domain.dto.BaseDO;
 import com.order.erp.domain.dto.order.*;
 import com.order.erp.domain.vo.order.OrderInfoResultVO;
+import com.order.erp.mapper.order.OrderBaseInfoMapper;
 import com.order.erp.service.order.*;
 import lombok.extern.slf4j.Slf4j;
 import org.joda.time.DateTime;
@@ -17,10 +19,8 @@ import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
  
 import javax.annotation.Resource;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
+import java.time.LocalDate;
+import java.util.*;
 import java.util.stream.Collectors;
  
 /**
@@ -65,10 +65,17 @@ public class OrderJob {
                 .le(OrderBaseInfoDO::getCreateTime, DateUtils.format(DateTime.now().toDate(), DateUtils.DATE_TIME))
                 .ne(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
         List<OrderBaseInfoDO> ordersDOS = orderBaseInfoService.list(queryWrapper);
-//如果都填充完成为  1.25,如果只填写4个,则为1。    这里面的方法是否是要改成,只要对应的跟单,质检任何一个格子填写了数据,就算上完成就加一。
         List<OrderInfoResultVO> orderInfoResultVOS = orderBaseInfoService.wrapperOrderResultList(false, ordersDOS);
-        if (CollectionUtils.isNotEmpty(orderInfoResultVOS)) {
-            Set<Long> orderIds = orderInfoResultVOS.stream().filter(x -> Objects.nonNull(x.getSchedule()) && Constant.ONE <= x.getSchedule()).map(OrderInfoResultVO::getId).collect(Collectors.toSet());
+        //遍历一下这个集合的数据,如果尾期尾期验货结果为PASS,pass 2ND,PASS 3ND,FAIL RELEASE就为订单完成。
+        Set<String> validResults = new HashSet<>(Arrays.asList("PASS", "PASS 2ND", "PASS 3RD", "FAIL RELEASE"));
+        List<OrderInfoResultVO> filteredOrders = orderInfoResultVOS.stream()
+                .filter(order -> order.getInspectionStageInfo() != null &&
+                        validResults.contains(order.getInspectionStageInfo().getEndCheckResult()))
+                .collect(Collectors.toList());
+        if (CollectionUtils.isNotEmpty(filteredOrders)) {
+            Set<Long> orderIds = filteredOrders.stream().map(OrderInfoResultVO::getId).collect(Collectors.toSet());
+
+            //不再使用上述的方式,
             if (CollectionUtils.isNotEmpty(orderIds)) {
                 LambdaUpdateWrapper<OrderBaseInfoDO> orderBaseUpdateWrapper = new LambdaUpdateWrapper<OrderBaseInfoDO>()
                         .in(OrderBaseInfoDO::getId, orderIds).set(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
@@ -213,4 +220,47 @@ public class OrderJob {
         log.info("执行结束时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
     }
  
+
+//重新扫描一遍,扫描规则为:不扫描所有表,只扫描25年的数据,如果尾期验货为PASS,PASS 2DN,PASS 3ND,或者为FAIL RELEASE,那么它就设置为订单完成状态。并且,如果这个订单设置为订单完成状态。去看看这些订单是否存在相同的
+    //project_no和inner_no,如果存在就进行也设置为订单完成。
+
+
+
+
+
+    //这里需要改成某个时间段只执行一次。
+//@Scheduled(cron = "0 */5 * * * ?")
+public void orderStatusFinishCheck() {
+        LocalDate localDate = LocalDate.of(2023, 10, 1);
+        //查询2023年末之后的基础订单订单。
+        List<OrderBaseInfoDO> orderBaseInfoDOS = orderBaseInfoService.list(new LambdaQueryWrapper<OrderBaseInfoDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .ge(OrderBaseInfoDO::getCreateTime, localDate));
+        List<Long> orderIds = orderBaseInfoDOS.stream().map(orderBaseInfoDO -> orderBaseInfoDO.getId()).collect(Collectors.toList());
+        //先把状态设置为跟单中。(因为现在很多虚假的订单完成状态,所以现在把这些订单设置为跟单中,然后重新扫描过滤。)
+        orderBaseInfoDOS.forEach(orderBaseInfoDO ->
+                orderBaseInfoDO.setOrderStatus(OrderStatusEnum.TRACK_ING.getStatus()));
+        orderBaseInfoService.updateBatchById(orderBaseInfoDOS);
+
+
+       //查询质检信息。
+        List<OrderInspectionStageDO> inspectionStageDOList = inspectionStageService.list(new LambdaQueryWrapper<OrderInspectionStageDO>().eq(BaseDO::getEnableFlag,Constant.ENABLE_TEN).in(OrderInspectionStageDO::getOrderId,orderIds));
+
+        Set<String> validResults = new HashSet<>(Arrays.asList("PASS", "PASS 2ND", "PASS 3RD", "FAIL RELEASE"));
+
+        List<OrderInspectionStageDO> filteredList = inspectionStageDOList.stream()
+                .filter(order -> order.getEndCheckResult() != null && validResults.contains(order.getEndCheckResult()))
+                .collect(Collectors.toList());
+        List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(filteredList.stream().map(OrderInspectionStageDO::getOrderId).collect(Collectors.toList()));
+
+        Set<String> uniqueCombinations=orderBaseInfoDOList.stream().map(order -> order.getProjectNo()+"-"+order.getInnerNo()).collect(Collectors.toSet());
+
+        List<OrderBaseInfoDO> finishStatusOrderBaseinfoList = orderBaseInfoDOS.stream().filter(order -> {
+                    String combination = order.getProjectNo() + "-" + order.getInnerNo();
+                    return uniqueCombinations.contains(combination);
+                })
+                .collect(Collectors.toList());
+        finishStatusOrderBaseinfoList.forEach(orderBaseInfoDO -> orderBaseInfoDO.setOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus()));
+        orderBaseInfoService.updateBatchById(finishStatusOrderBaseinfoList);
+   }
+
 }
@@ -23,6 +23,7 @@ import com.order.erp.service.admin.AdminUserRoleService;
 import com.order.erp.service.admin.AdminUserService;
 import com.order.erp.service.order.*;
 import lombok.extern.slf4j.Slf4j;
+import org.joda.time.DateTime;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 import org.w3c.dom.events.Event;
@@ -139,6 +140,7 @@ public class OrderOverTimeEventJob {
                     OrderBaseInfoVO orderBaseInfoFormat = getDateFormat(orderEventJob.getBaseInfo().getProductionDepartmentConsignTime(), orderEventJob.getBaseInfo().getOrderHodTime());
                     orderEventJob.getBaseInfo().setProductionDepartmentConsignTime(orderBaseInfoFormat.getProductionDepartmentConsignTime());
                     orderEventJob.getBaseInfo().setOrderHodTime(orderBaseInfoFormat.getOrderHodTime());
+                    orderEventJob.getBaseInfo().setSmallPicUrl(AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderEventJob.getBaseInfo().getSmallPicUrl()), SplitUrlGetBucketName.getFileName(orderEventJob.getBaseInfo().getSmallPicUrl()), new DateTime().plusYears(Constant.ENABLE_TEN).toDate()));
                     String productionDepartment = orderEventJob.getBaseInfo().getProductionDepartment();
                     //根据订单的生产科得到生产科用户信息。
                     AdminUserDO productionDepartmentUser = adminUserService.getOne(new LambdaQueryWrapper<AdminUserDO>()
@@ -230,6 +232,7 @@ public class OrderOverTimeEventJob {
                         OrderBaseInfoVO orderBaseInfoFormat = getDateFormat(orderEventJob.getBaseInfo().getProductionDepartmentConsignTime(), orderEventJob.getBaseInfo().getOrderHodTime());
                         orderEventJob.getBaseInfo().setProductionDepartmentConsignTime(orderBaseInfoFormat.getProductionDepartmentConsignTime());
                         orderEventJob.getBaseInfo().setOrderHodTime(orderBaseInfoFormat.getOrderHodTime());
+                        orderEventJob.getBaseInfo().setSmallPicUrl(AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderEventJob.getBaseInfo().getSmallPicUrl()), SplitUrlGetBucketName.getFileName(orderEventJob.getBaseInfo().getSmallPicUrl()), new DateTime().plusYears(Constant.ENABLE_TEN).toDate()));
                         emailSendUtils.sendEmail(EmailTemplateEnum.byTemplate(eventEnum.getTemplateId()),
                                 map.get(map.keySet().iterator().next()), orderEventJob);
                         redisUtils.set(EmailTemplateEnum.byTemplate(
@@ -49,21 +49,19 @@ public interface OrderBaseInfoMapper extends BaseMapper&lt;OrderBaseInfoDO&gt; {
  
     @Select("SELECT YEAR(obi.create_time) AS date, SUM(opa.customer_total_price) AS totalPrice FROM order_base_info obi JOIN order_profit_analysis opa ON opa.order_id = obi.id AND opa.enable_flag = 10 WHERE obi.enable_flag = 10 GROUP BY YEAR(obi.create_time) ORDER BY date;")
     List<DateYearMonthTimeVO> countRecentYearByOrderStatus();
-    @Select("SELECT count(*)  AS count FROM order_base_info WHERE order_status=#{orderStatus} and enable_flag=10;")
-    long countAllYearByOrderStatus(Integer orderStatus);
+
+    long countAllYearByOrderStatus(@Param("orderStatus") Integer orderStatus);
     List<DateYearMonthTimeVO> countRecentMonthValueByOrderStatus(List<Integer> years);
-    @Select("SELECT count(*) FROM order_base_info WHERE  enable_flag=10;")
+
     long countRecentYearByOrderInit();
-    @Select("SELECT count(*)  AS count FROM order_base_info WHERE enable_flag=10 AND create_time >= #{startOfYear} AND create_time < #{endOfYear};")
-    long countRecentMonthValueByOrderInit(LocalDate startOfYear, LocalDate endOfYear);
-    @Select("SELECT count(*)  AS count FROM order_base_info WHERE order_status=#{orderStatus} and enable_flag=10 AND create_time >= #{startOfYear} AND create_time < #{endOfYear};")
-    long countAllMonthByOrderStatus(Integer orderStatus,LocalDate startOfYear,LocalDate endOfYear);
+    long countRecentMonthValueByOrderInit(@Param("dataYear") Long dataYear);
+    long countAllMonthByOrderStatus(@Param("orderStatus") Integer orderStatus,@Param("dataYear") Long dataYear);
     @Select("SELECT  DATE(obi.create_time) AS date,SUM(opa.customer_total_price) AS totalPrice FROM order_base_info obi JOIN order_profit_analysis opa ON opa.order_id=obi.id AND opa.enable_flag = 10  WHERE obi.enable_flag = 10 AND obi.create_time >=#{startDate} AND obi.create_time < #{endDate}  GROUP BY DATE(obi.create_time) ORDER BY date;")
     List<DateYearMonthTimeVO> countRecentDayvalueByOrderStatus(LocalDate startDate, LocalDate endDate);
-    @Select("SELECT count(*) AS count FROM order_base_info WHERE order_status=#{orderStatus} AND enable_flag=10 AND create_time >= #{startDate} AND create_time < #{endDate};")
-    long countAllDayvalueByOrderStatus(Integer orderStatus, LocalDate startDate, LocalDate endDate);
-    @Select("SELECT count(*) AS count FROM order_base_info WHERE  enable_flag=10 AND create_time >= #{startDate} AND create_time < #{endDate};")
-    long countRecentDayByOrderInit(LocalDate startDate, LocalDate endDate);
+
+    long countAllDayvalueByOrderStatus(@Param("orderStatus") Integer orderStatus, @Param("startDate") LocalDate startDate,@Param("endDate") LocalDate endDate,@Param("year") Long year);
+
+    long countRecentDayByOrderInit(@Param("startDate") LocalDate startDate,@Param("endDate") LocalDate endDate,@Param("year") Long year);
     List<OrderBaseInfoDO> sameAttributeOrder(@Param("customerStyle") String customerStyle,
                                   @Param("innerNo") String innerNo,
                                   @Param("isReturnOrder") String isReturnOrder,
@@ -61,7 +61,7 @@ public class LocalStorageServiceImpl extends ServiceImpl&lt;LocalStorageMapper, Loc
         try {
             File tempFile = new File(path + "files" + File.separator + tempFileName);
             if (AliOssUtil.upload(AliOssConfig.ALIYUN_BUCKET, fileName, file.getBytes())) {
-                String fileUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, fileName, new DateTime().plusYears(Constant.ENABLE_TEN).toDate());
+                String fileUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, fileName, new DateTime().plusHours(Constant.TWO).toDate());
                 fileRespVO.setFileUrl(fileUrl);
                 FileUtil.del(tempFile);
             }
@@ -72,6 +72,8 @@ public class LocalStorageServiceImpl extends ServiceImpl&lt;LocalStorageMapper, Loc
         }
     }
  
+
+    //oss
     @Override
     public ServerResult uploadByAliOss(String name, MultipartFile file) {
         FileUtil.checkSize(maxSize, file.getSize());
@@ -81,13 +83,15 @@ public class LocalStorageServiceImpl extends ServiceImpl&lt;LocalStorageMapper, Loc
         try {
             File tempFile = new File(path + "images" + File.separator + tempFileName);
             if (AliOssUtil.upload(AliOssConfig.ALIYUN_BUCKET, fileName, file.getBytes())) {
-                String originImageUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, fileName, new DateTime().plusYears(Constant.ENABLE_TEN).toDate());
+                String originImageUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, fileName, new DateTime().plusHours(Constant.TWO).toDate());
                 imageRespVO.setPicUrl(originImageUrl);
+                imageRespVO.setFileName(fileName);
                 // 生成缩略图
                 Thumbnails.of(file.getInputStream()).size(100, 100).toFile(tempFile);
                 if (AliOssUtil.upload(AliOssConfig.ALIYUN_BUCKET, tempFileName, FileUtil.readBytes(tempFile))) {
-                    String thumbnailImageUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, tempFileName, new DateTime().plusYears(Constant.ENABLE_TEN).toDate());
-                    imageRespVO.setSmallPicUrl(thumbnailImageUrl);
+                    String thumbnailImageUrl = AliOssUtil.createUrl(AliOssConfig.ALIYUN_BUCKET, tempFileName, new DateTime().plusHours(Constant.TWO).toDate());
+                imageRespVO.setSmallPicUrl(thumbnailImageUrl);
+                imageRespVO.setSmallfileName(tempFileName);
                 }
                 FileUtil.del(tempFile);
             }
@@ -6,6 +6,7 @@ import com.order.erp.common.constant.ServerResult;
 import com.order.erp.common.excel4j.exceptions.Excel4JException;
 import com.order.erp.domain.dto.order.OrderBaseInfoDO;
 import com.order.erp.domain.dto.order.QuerySalesStatisticeDO;
+import com.order.erp.domain.vo.AccountStatementVO;
 import com.order.erp.domain.vo.ProducePdfVO;
 import com.order.erp.domain.vo.order.*;
 import freemarker.template.TemplateException;
@@ -131,4 +132,6 @@ public interface OrderBaseInfoService extends IService&lt;OrderBaseInfoDO&gt; {
     ServerResult countByYear(DateTimeVO dateTimeVO);
  
     ServerResult countByDate(DateTimeVO dateTimeVO);
+
+    ServerResult accountStatement(HttpServletResponse response,AccountStatementVO accountStatementVO) throws IOException;
 }
@@ -3,6 +3,7 @@ package com.order.erp.service.order;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.domain.dto.order.OrderFieldLockApplyDO;
+import com.order.erp.domain.vo.order.AuditDetailQueryVO;
 import com.order.erp.domain.vo.order.AuditVO;
 import com.order.erp.domain.vo.order.OrderFieldLockApplyQueryVO;
 import com.order.erp.domain.vo.order.OrderFieldLockApplyVO;
@@ -53,6 +54,7 @@ public interface OrderFieldLockApplyService extends IService&lt;OrderFieldLockApply
      * @return
      */
     ServerResult doAudit(AuditVO auditVO);
+    ServerResult audit_detail(AuditDetailQueryVO auditDetailQueryVO);
  
     /**
      * 修改数据
@@ -14,10 +14,7 @@ import com.order.erp.common.constant.Constant;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.common.constant.ServerResultCode;
 import com.order.erp.common.exception.BusinessException;
-import com.order.erp.common.utils.DateUtils;
-import com.order.erp.common.utils.EmailSendUtils;
-import com.order.erp.common.utils.StringUtils;
-import com.order.erp.common.utils.TransactionHelper;
+import com.order.erp.common.utils.*;
 import com.order.erp.config.DataScope;
 import com.order.erp.domain.*;
 import com.order.erp.domain.dto.BaseDO;
@@ -31,6 +28,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.ss.usermodel.*;
 import org.apache.poi.ss.util.CellRangeAddress;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.joda.time.DateTime;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
  
@@ -43,6 +41,7 @@ import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDateTime;
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -79,6 +78,8 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
     private TransactionHelper transactionHelper;
     @Resource
     private EmailSendUtils emailSendUtils;
+    @Resource
+    private RedisUtils redisUtils;
  
  
     /**
@@ -124,17 +125,98 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
           }
             RoleEnum role = dataScope.getRole();
             Page<FinanceOrderResultVO> page = new Page<>(queryVO.getPage(), queryVO.getPageSize());
+            //跟单员
             if(Objects.nonNull(role) && role.getId().equals(RoleEnum.TRACKER_USER.getId())) {
                 queryVO.setTrackerUserName(dataScope.getLoginUserName());
                 IPage<FinanceOrderResultVO> financeOrderResultVOIPage = baseMapper.byConditionGetOrder(page, queryVO);
+                financeOrderResultVOIPage.getRecords().stream().peek(x -> {
+                    String smallPicUrl="";
+                    if(StringUtils.isNotEmpty(x.getSmallPicUrl())){
+                       String smallPicUrlKey = Constant.OSS_SMALL_PIC_URL+x.getSmallPicUrl();
+                        smallPicUrl= (String)redisUtils.get(smallPicUrlKey);
+                        if(StringUtils.isBlank(smallPicUrl)){
+                          smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getSmallPicUrl())
+                                    ,SplitUrlGetBucketName.getFileName(x.getSmallPicUrl())
+                                    , new DateTime().plusHours(Constant.TWO).toDate());
+                          redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                        }
+                    }
+                    x.setSmallPicUrl(smallPicUrl);
+
+                    if(StringUtils.isNotEmpty(x.getInvoiceBgUrl())){
+                        String invoiceBgUrlKey = Constant.OSS_BG_URL + x.getInvoiceBgUrl();
+                        String invoiceBgUrl = (String) redisUtils.get(invoiceBgUrlKey);
+                        if(StringUtils.isBlank(invoiceBgUrl)){
+                             invoiceBgUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getInvoiceBgUrl())
+                                    ,SplitUrlGetBucketName.getFileName(x.getInvoiceBgUrl())
+                                    , new DateTime().plusHours(Constant.TWO).toDate());
+                            redisUtils.set(invoiceBgUrlKey,invoiceBgUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                        }
+                        x.setInvoiceBgUrl(invoiceBgUrl);
+                    }
+                }).collect(Collectors.toList());
                 return ServerResult.success(financeOrderResultVOIPage);
             }
+            //业务员
             if (Objects.nonNull(role) && role.getId().equals(RoleEnum.BUSINESS_USER.getId())) {
                 queryVO.setBusinessUserName(dataScope.getLoginUserName());
                 IPage<FinanceOrderResultVO> financeOrderResultVOIPage = baseMapper.byConditionGetOrder(page,queryVO);
+                financeOrderResultVOIPage.getRecords().stream().peek(x -> {
+                    String smallPicUrl="";
+                    if(StringUtils.isNotEmpty(x.getSmallPicUrl())){
+                        String smallPicUrlKey = Constant.OSS_SMALL_PIC_URL+x.getSmallPicUrl();
+                        smallPicUrl= (String)redisUtils.get(smallPicUrlKey);
+                        if(StringUtils.isBlank(smallPicUrl)){
+                            smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getSmallPicUrl())
+                                    ,SplitUrlGetBucketName.getFileName(x.getSmallPicUrl())
+                                    , new DateTime().plusHours(Constant.TWO).toDate());
+                            redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                        }
+                    }
+                    x.setSmallPicUrl(smallPicUrl);
+
+                    if(StringUtils.isNotEmpty(x.getInvoiceBgUrl())){
+                        String invoiceBgUrlKey = Constant.OSS_BG_URL + x.getInvoiceBgUrl();
+                        String invoiceBgUrl = (String) redisUtils.get(invoiceBgUrlKey);
+                        if(StringUtils.isBlank(invoiceBgUrl)){
+                            invoiceBgUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getInvoiceBgUrl())
+                                    ,SplitUrlGetBucketName.getFileName(x.getInvoiceBgUrl())
+                                    , new DateTime().plusHours(Constant.TWO).toDate());
+                            redisUtils.set(invoiceBgUrlKey,invoiceBgUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                        }
+                        x.setInvoiceBgUrl(invoiceBgUrl);
+                    }
+                }).collect(Collectors.toList());
                 return ServerResult.success(financeOrderResultVOIPage);
             }
+            //管理员和财务能够看到所有订单。
         IPage<FinanceOrderResultVO> financeOrderResultVOIPage = baseMapper.byConditionGetOrder(page,queryVO);
+            financeOrderResultVOIPage.getRecords().stream().peek(x -> {
+                String smallPicUrl="";
+                if(StringUtils.isNotEmpty(x.getSmallPicUrl())){
+                    String smallPicUrlKey = Constant.OSS_SMALL_PIC_URL+x.getSmallPicUrl();
+                    smallPicUrl= (String)redisUtils.get(smallPicUrlKey);
+                    if(StringUtils.isBlank(smallPicUrl)){
+                        smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getSmallPicUrl())
+                                ,SplitUrlGetBucketName.getFileName(x.getSmallPicUrl())
+                                , new DateTime().plusHours(Constant.TWO).toDate());
+                        redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                    }
+                }
+                x.setSmallPicUrl(smallPicUrl);
+
+                if(StringUtils.isNotEmpty(x.getInvoiceBgUrl())){
+                    String invoiceBgUrlKey = Constant.OSS_BG_URL + x.getInvoiceBgUrl();
+                    String invoiceBgUrl = (String) redisUtils.get(invoiceBgUrlKey);
+                    if(StringUtils.isBlank(invoiceBgUrl)){
+                        invoiceBgUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getInvoiceBgUrl())
+                                ,SplitUrlGetBucketName.getFileName(x.getInvoiceBgUrl())
+                                , new DateTime().plusHours(Constant.TWO).toDate());
+                        redisUtils.set(invoiceBgUrlKey,invoiceBgUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                    }
+                    x.setInvoiceBgUrl(invoiceBgUrl);
+                }
+            }).collect(Collectors.toList());
             return ServerResult.success(financeOrderResultVOIPage);
         }
 //    }
@@ -977,10 +1059,9 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
             return InvoiceBillOrderDO.builder()
                     .invoiceNo(createVO.getInvoiceNo())
                     .orderId(x.getId())
-                    .bgUrl(createVO.getBgUrl())
+                    .bgUrl(StringUtils.isNotEmpty(createVO.getBgUrl()) ?SplitUrlGetBucketName.getUrlFileName(createVO.getBgUrl()) : null)
                     .backRefundDate(createVO.getBackRefundDate())
                     .status(FinanceEnum.UNPAID_PAYMENTS.getStatus())
-                    .finishStatus(FinanceEnum.UNPAID_PAYMENTS.getStatus())
                     .businesPerson(x.getBusinessPerson())
                     .trackerUser(x.getCreateBy())
                     .build();
@@ -1057,6 +1138,7 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
      */
     @Override
     public ServerResult updateDeductInfo(InvoiceBillDeductInfoVO deductInfoVO) {
+        Long loginUserId = dataScope.getLoginUserId();
         if (Objects.isNull(deductInfoVO.getId())) {
             throw new BusinessException("id 不能为空");
         }
@@ -1064,14 +1146,62 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
         if (Objects.isNull(invoiceBillOrderDo)) {
             throw new BusinessException("应收款单据不存在");
         }
-        if(Objects.nonNull(invoiceBillOrderDo.getStatus()) && FinanceEnum.RECEIVED_PAYMENT.getStatus()==invoiceBillOrderDo.getStatus()){
-            throw new BusinessException("应收款单据已收款,无法编辑");
+        if(Objects.nonNull(invoiceBillOrderDo.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDo.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrderDo.getStatus())))){
+            throw new BusinessException("应收款单据已审核通过,无法编辑");
         }
         //todo 审核有问题  完成1
 //        checkCommitApply(invoiceBillOrderDo.getId());
         checkApply(new ArrayList<>(Arrays.asList(deductInfoVO.getId())));
+        //对扣款单进行审批。
+        checkCommitDeductionUrlApply(invoiceBillOrderDo.getId());
+        OrderLockFieldVO orderLockFieldVO = new OrderLockFieldVO();
+        DeductionUrlFieldVO deductionUrlFieldVO=new DeductionUrlFieldVO();
+        invoiceBillOrderDo.setDeductAmount((deductInfoVO.getDeductAmount()==null?BigDecimal.ZERO:deductInfoVO.getDeductAmount()).setScale(2, RoundingMode.HALF_UP));
+        //客户总金额减去发生扣款金额。
+        invoiceBillOrderDo.setActualReceivableAmount((invoiceBillOrderDo.getTotalCustomerAmount().subtract(deductInfoVO.getDeductAmount()==null?BigDecimal.ZERO:deductInfoVO.getDeductAmount())).setScale(2, RoundingMode.HALF_UP));
+        if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
+            invoiceBillOrderDo.setInvoiceDeductUrlStatus(ApplyStatusEnum.WAIT_AUDIT.getStatus());
+        }
+        updateById(invoiceBillOrderDo);
+        if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
+            OrderBaseInfoDO orderBaseInfoDO = orderBaseInfoService.getById(invoiceBillOrderDo.getOrderId());
+            //以后对于文件类型,只存文件名,通过bucket每次实时访问。以前是设置过期时间很长,永久存在数据库中。
+            String urlFileName = SplitUrlGetBucketName.getUrlFileName(deductInfoVO.getDeductUrl());
+            //不保存,仅仅只是做一个审核,千万不要保存。目的是传递给审核的最新的扣款单,审核通过后才保存,不通过则不保存。
+            invoiceBillOrderDo.setDeductUrl(urlFileName);
+            deductionUrlFieldVO.setInvoiceNo(invoiceBillOrderDo.getInvoiceNo());
+            if(Objects.nonNull(orderBaseInfoDO)){
+                deductionUrlFieldVO.setInnerNo(orderBaseInfoDO.getInnerNo());
+            }
+            deductionUrlFieldVO.setId(invoiceBillOrderDo.getId());
+            deductionUrlFieldVO.setBusinesPerson(invoiceBillOrderDo.getBusinesPerson());
+            deductionUrlFieldVO.setFinancePerson(invoiceBillOrderDo.getFinancePerson());
+            deductionUrlFieldVO.setTrackerUser(invoiceBillOrderDo.getTrackerUser());
+            deductionUrlFieldVO.setDeductUrl(urlFileName);
+            deductionUrlFieldVO.setDeductAmount(deductInfoVO.getDeductAmount());
+            orderLockFieldVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+            OrderFieldLockApplyDO applyDO = OrderFieldLockApplyDO.builder()
+                    .applyUserId(loginUserId)
+                    .auditUserId(null)
+                    .fields(JSONObject.toJSONString(orderLockFieldVO))
+                    .orderId(invoiceBillOrderDo.getId())
+                    .type(ApplyTypeEnum.INVOICE_DEDUCT_URL.getType())
+                    .remark(ApplyTypeEnum.INVOICE_DEDUCT_URL.getDesc())
+                    .status(ApplyStatusEnum.WAIT_AUDIT.getStatus())
+                    .auditRoleCodes(RoleEnum.ADMIN.getCode() + Constant.COMMA_CHARACTER + RoleEnum.FINANCE_USER.getCode())
+                    .build();
+            orderFieldLockApplyService.save(applyDO);
+        }
+       return  ServerResult.success();
+
+
+
  
-        if(StringUtils.isNotBlank(invoiceBillOrderDo.getDeductUrl())){
+
+
+
+    /*    if(StringUtils.isNotBlank(invoiceBillOrderDo.getDeductUrl())){
 //记住:需要修改数据表对应的字段deduct_url的varchar数据范围,修改为1000左右。
             if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
                 Set<String> deductUrlSet = new HashSet<>(Arrays.asList(
@@ -1092,7 +1222,7 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
         //客户总金额减去发生扣款金额。
         invoiceBillOrderDo.setActualReceivableAmount((invoiceBillOrderDo.getTotalCustomerAmount().subtract(deductInfoVO.getDeductAmount()==null?BigDecimal.ZERO:deductInfoVO.getDeductAmount())).setScale(2, RoundingMode.HALF_UP));
         updateById(invoiceBillOrderDo);
-        return ServerResult.success();
+        return ServerResult.success();*/
     }
  
     @Override
@@ -1106,8 +1236,9 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
         }
         //todo 审核有问题 完成2
 //        checkCommitApply(invoiceBillOrderDo.getId());
-        if(Objects.nonNull(invoiceBillOrderDo.getStatus()) && FinanceEnum.RECEIVED_PAYMENT.getStatus()==invoiceBillOrderDo.getStatus()){
-            throw new BusinessException("已完成收款,无法更新!");
+        if(Objects.nonNull(invoiceBillOrderDo.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDo.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrderDo.getStatus())))){
+            throw new BusinessException("应收款单据已审核通过,无法编辑");
         }
          checkApply(new ArrayList<>(Arrays.asList(amountInfoVO.getId())));
  
@@ -1153,7 +1284,8 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
             throw  new BusinessException("勾选订单的invoice需一致");
         }
        //判断选择订单中是否包含已审核通过的订单。  todo:这里需要在审核处理之后,给orderid设置状态,给外带的finacneId集合也设置状态,这里才能生效。
-        boolean isTrue = invoiceBillOrderDOS.stream().filter(Objects::nonNull).anyMatch(invoiceBillOrder -> FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrder.getStatus()));
+        boolean isTrue = invoiceBillOrderDOS.stream().filter(Objects::nonNull).anyMatch(invoiceBillOrder -> ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrder.getStatus())))
+                || (FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrder.getStatus())));
         if(isTrue){
             throw new BusinessException("订单中包含已收款的数据,无法提交!");
         }
@@ -1250,6 +1382,22 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
             }
     }
  
+
+    /**
+     * @param id
+     *
+     */
+    private void checkCommitDeductionUrlApply(Long id){
+        List<OrderFieldLockApplyDO> orderFieldLockApplyDOList = orderFieldLockApplyService.list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.INVOICE_DEDUCT_URL.getType())
+                .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT.getStatus())
+                .eq(OrderFieldLockApplyDO::getOrderId, id));
+        if(CollectionUtils.isNotEmpty(orderFieldLockApplyDOList)){
+            throw new BusinessException("存在未审核的扣款单,请联系财务审批上一张扣款单后再上传");
+        }
+    }
+
     /**
      * @param ids
      * @param userId
@@ -1334,7 +1482,8 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
  
         //有一个审核通过不能删除。之所以这样做,是因为避免忘记其他订单创建invoice,然后遗落了,所以需要删掉重新创建,避免每一个都提交审核并且审核后通过了了。
         boolean anyPaid = invoiceBillOrderList.stream().filter(Objects::nonNull)
-                .anyMatch(invoiceBillOrderDO -> FinanceEnum.RECEIVED_PAYMENT.getStatus()== invoiceBillOrderDO.getStatus());
+                .anyMatch(invoiceBillOrderDO -> (FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus()))
+                        || (FinanceEnum.OK_PAYMENT.getStatus().equals( invoiceBillOrderDO.getStatus())));
         if (anyPaid) {
             throw new BusinessException("包含已收款的订单,无法删除!");
         }
@@ -1373,12 +1522,15 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
         }
         Map<String, String> hashMap = new HashMap<>();
         //获取每一个url的文件名称
+        // https://alterego.oss-cn-qingdao.aliyuncs.com/
+        // Thumbnails-1735377429935-4024%E5%9B%BE%E7%89%871.png?Expires=1741938071&OSSAccessKeyId=LTAI5tHKVvrz1xxExYD7E3mo&Signature=rBFguaDI5fEl3Yk%2FjbXburRZ0ok%3D
         Arrays.stream( InvoiceBillOrderDO.getDeductUrl().split(",")).forEach(x->{
             try{
-            String preUrl = x.split("\\?")[0];
-            String fileName = preUrl.substring(preUrl.lastIndexOf("/") + 1);
+//            String preUrl = x.split("\\?")[0];
+            String fileName = x.substring(x.lastIndexOf("/") + 1);
             String decodUrle = URLDecoder.decode(fileName, StandardCharsets.UTF_8.name());
-            hashMap.put(decodUrle,x);
+                String url = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x), decodUrle, new DateTime().plusMinutes(Constant.TWO).toDate());
+                hashMap.put(decodUrle,url);
             }catch (Exception e){
                 throw  new BusinessException("文件名错误!");
             }
@@ -1404,7 +1556,7 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
                 .eq(InvoiceBillOrderDO::getInvoiceNo, invoiceBillOrderDO.getInvoiceNo()));
         List<InvoiceBillOrderDO> invoiceBillOrderDOList= invoiceBillOrderDOS.stream().map(invoiceBillOrder -> {
             //重新上传报关单
-            invoiceBillOrder.setBgUrl(bgUrl.getBgUrl());
+            invoiceBillOrder.setBgUrl(SplitUrlGetBucketName.getUrlFileName(bgUrl.getBgUrl()));
             return invoiceBillOrder;
         }).collect(Collectors.toList());
         updateBatchById(invoiceBillOrderDOList);
@@ -1496,9 +1648,10 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
         }
         List<InvoiceBillOrderDO> invoiceBillOrderDOList = list(new LambdaQueryWrapper<InvoiceBillOrderDO>().eq(InvoiceBillOrderDO::getEnableFlag, Constant.ENABLE_TEN)
                 .eq(InvoiceBillOrderDO::getInvoiceNo, invoiceBillOrderDO.getInvoiceNo()));
-        boolean anyPaid= invoiceBillOrderDOList.stream().filter(Objects::nonNull).anyMatch(invoiceBillOrder -> FinanceEnum.RECEIVED_PAYMENT.getStatus() == invoiceBillOrder.getStatus());
+        boolean anyPaid= invoiceBillOrderDOList.stream().filter(Objects::nonNull).anyMatch(invoiceBillOrder -> (FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrder.getStatus()))
+                ||(FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrder.getStatus())) );
         if(anyPaid){
-            throw new BusinessException("相同invoiceNo的订单已收款完成,无法设置!");
+            throw new BusinessException("相同invoiceNo的订单已审核通过,无法设置!");
         }
         //todo 要审核判断一下,是否处于审核状态。 完成4
         checkApply(invoiceBillOrderDOList.stream().filter(Objects::nonNull).map(invoiceDO -> invoiceDO.getId()).collect(Collectors.toList()));
@@ -1535,8 +1688,9 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
             throw new BusinessException("应收款单不存在！");
         }
         checkApply( new ArrayList<>(Arrays.asList(deleteVo.getId())));
-        if(Objects.nonNull(invoiceBillOrderDO.getStatus()) && FinanceEnum.RECEIVED_PAYMENT.getStatus()==invoiceBillOrderDO.getStatus()){
-            throw new BusinessException("已完成收款,无法删除!");
+        if(Objects.nonNull(invoiceBillOrderDO.getStatus()) && (FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus())
+                || FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus()))){
+            throw new BusinessException("该订单已审核通过,无法删除!");
         }
         invoiceBillOrderDO.setDeductUrl("");
         updateById(invoiceBillOrderDO);
@@ -1545,20 +1699,34 @@ public class InvoiceBillOrderServiceImpl extends ServiceImpl&lt;InvoiceBillOrderMap
  
     @Override
     public ServerResult isFinishStatus(InvoiceBillDeductInfoVO invoiceBillDeductInfoVO) {
+        if(Objects.isNull(invoiceBillDeductInfoVO.getId())){
+            throw  new BusinessException(ServerResultCode.PARAM_ERROR);
+        }
         InvoiceBillOrderDO invoiceBillOrderDO = getById(invoiceBillDeductInfoVO.getId());
         if(Objects.nonNull(invoiceBillOrderDO)){
-            if(!FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus())){
-                throw new BusinessException("该订单还没有完成最终收款,你无法设置最终状态为已完成!");
+            if((!FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus())) && (!FinanceEnum.OK_PAYMENT.getStatus().equals(invoiceBillOrderDO.getStatus()))){
+                throw new BusinessException("该订单还没有审核通过,你无法设置最终状态为已收款!");
             }
             List<InvoiceBillOrderDO> invoiceBillOrderDOList = list(new LambdaQueryWrapper<InvoiceBillOrderDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
                     .eq(InvoiceBillOrderDO::getInvoiceNo, invoiceBillOrderDO.getInvoiceNo())
                     .eq(InvoiceBillOrderDO::getStatus, FinanceEnum.RECEIVED_PAYMENT.getStatus()));
             if(CollectionUtils.isNotEmpty(invoiceBillOrderDOList)){
                 List<InvoiceBillOrderDO> finishSatusList = invoiceBillOrderDOList.stream().map(x -> {
-                    x.setFinishStatus(FinanceEnum.RECEIVED_PAYMENT.getStatus());
+                    x.setStatus(FinanceEnum.OK_PAYMENT.getStatus());
                     return x;
                 }).collect(Collectors.toList());
-                updateBatchById(finishSatusList);
+                //还需要把基础订单的状态也改一下。
+                List<Long> orderIds = invoiceBillOrderDOList.stream().map(InvoiceBillOrderDO::getOrderId).collect(Collectors.toList());
+                List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(orderIds);
+                List<OrderBaseInfoDO> orderBaseInfoDOS = orderBaseInfoDOList.stream().map(order -> {
+                    order.setInvoiceStatus(FinanceEnum.OK_PAYMENT.getStatus());
+                    return order;
+                }).collect(Collectors.toList());
+                transactionHelper.run(() ->{
+                    updateBatchById(finishSatusList);
+                    orderBaseInfoService.updateBatchById(orderBaseInfoDOS);
+                });
+
             }
         }
         return ServerResult.success();
@@ -22,6 +22,7 @@ import com.order.erp.common.constant.ServerResultCode;
 import com.order.erp.common.excel4j.exceptions.Excel4JException;
 import com.order.erp.common.exception.BusinessException;
 import com.order.erp.common.utils.*;
+import com.order.erp.config.AliOssConfig;
 import com.order.erp.config.DataScope;
 import com.order.erp.config.MapResultHandler;
 import com.order.erp.domain.*;
@@ -30,6 +31,8 @@ import com.order.erp.domain.dto.SystemSettingDO;
 import com.order.erp.domain.dto.admin.AdminUserDO;
 import com.order.erp.domain.dto.admin.AdminUserRoleDO;
 import com.order.erp.domain.dto.order.*;
+import com.order.erp.domain.excel.AccountStatementExcelVO;
+import com.order.erp.domain.vo.AccountStatementVO;
 import com.order.erp.domain.vo.ProducePdfVO;
 import com.order.erp.domain.vo.order.*;
 import com.order.erp.job.OrderOverTimeEventJob;
@@ -49,11 +52,10 @@ import org.springframework.transaction.annotation.Transactional;
 import javax.annotation.Resource;
 import javax.mail.MessagingException;
 import javax.servlet.http.HttpServletResponse;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.text.DecimalFormat;
 import java.time.LocalDate;
@@ -151,6 +153,8 @@ public class OrderBaseInfoServiceImpl extends ServiceImpl&lt;OrderBaseInfoMapper, O
  
     @Resource
     private OrderTrackStageService orderTrackStageService;
+    @Resource
+    private AccountStatementExcel accountStatementExcel;
  
  
  
@@ -218,6 +222,32 @@ public class OrderBaseInfoServiceImpl extends ServiceImpl&lt;OrderBaseInfoMapper, O
         List<OrderInfoResultVO> resultVOList = new ArrayList<>();
         if (CollectionUtils.isNotEmpty(orderBaseInfoDOList)) {
             resultVOList = orderBaseInfoDOList.stream().map(x -> {
+                String picUrl = "";
+           if(com.order.erp.common.utils.StringUtils.isNotEmpty(x.getPicUrl())){
+                String picUrlKey=Constant.OSS_PIC_URL+x.getPicUrl();
+                 picUrl= (String) redisUtils.get(picUrlKey);
+                 if(StringUtils.isBlank(picUrl)){
+                     picUrl = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getPicUrl())
+                             ,SplitUrlGetBucketName.getFileName(x.getPicUrl())
+                             , new DateTime().plusHours(Constant.TWO).toDate());
+                     //设置redis过期时间为1.9小时。 oss的实时链接为2小时。
+                     redisUtils.set(picUrlKey,picUrl, Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                 }
+                  }
+                x.setPicUrl(picUrl);
+                String smallPicUrl = "";
+                if(com.order.erp.common.utils.StringUtils.isNotEmpty(x.getSmallPicUrl())){
+                    String smallPicUrlKey=Constant.OSS_SMALL_PIC_URL+x.getSmallPicUrl();
+                    smallPicUrl= (String) redisUtils.get(smallPicUrlKey);
+                    if(StringUtils.isBlank(smallPicUrl)){
+                        smallPicUrl  = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getSmallPicUrl())
+                                , SplitUrlGetBucketName.getFileName(x.getSmallPicUrl()),
+                                new DateTime().plusHours(Constant.TWO).toDate());
+                        //设置redis过期时间为1.9小时。 oss的实时链接为2小时。
+                        redisUtils.set(smallPicUrlKey,smallPicUrl, Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                    }
+                }
+                x.setSmallPicUrl(smallPicUrl);
                 OrderInfoResultVO resultVO = new OrderInfoResultVO();
                 BeanUtils.copyProperties(x, resultVO);
                 return resultVO;
@@ -279,6 +309,27 @@ public class OrderBaseInfoServiceImpl extends ServiceImpl&lt;OrderBaseInfoMapper, O
                     String productionComment = productionCommentS[productionCommentS.length - 1];
                     x.setProductionComment(productionComment);
                 }
+                String picUrl="";
+                if(com.order.erp.common.utils.StringUtils.isNotEmpty(x.getPicUrl())){
+                    String picUrlKey = Constant.OSS_PIC_URL + x.getPicUrl();
+                    picUrl =(String)redisUtils.get(picUrlKey);
+                    if(StringUtils.isBlank(picUrl)){
+                        picUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getPicUrl()),SplitUrlGetBucketName.getFileName(x.getPicUrl()),new DateTime().plusHours(Constant.TWO).toDate());
+                        redisUtils.set(picUrlKey,picUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                    }
+                }
+                x.setPicUrl(picUrl);
+                String smallPicUrl="";
+                if(com.order.erp.common.utils.StringUtils.isNotEmpty(x.getSmallPicUrl())){
+                    String smallPicUrlKey=Constant.OSS_SMALL_PIC_URL+x.getSmallPicUrl();
+                    smallPicUrl=(String)redisUtils.get(smallPicUrlKey);
+                    if(StringUtils.isBlank(smallPicUrl)){
+                        smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x.getSmallPicUrl()),SplitUrlGetBucketName.getFileName(x.getSmallPicUrl()),new DateTime().plusHours(Constant.TWO).toDate());
+                        redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                    }
+
+                }
+                x.setSmallPicUrl(smallPicUrl);
                 OrderInfoResultVO resultVO = new OrderInfoResultVO();
                 BeanUtils.copyProperties(x, resultVO);
                 return resultVO;
@@ -1566,10 +1617,13 @@ end
         }
         Long userId = dataScope.getLoginUserId();
         OrderBaseInfoDO baseInfoDO = new OrderBaseInfoDO();
-        BeanUtils.copyProperties(baseInfoVO, baseInfoDO);
+        BeanUtils.copyProperties(baseInfoVO, baseInfoDO,"picUrl","smallPicUrl");
         baseInfoDO.setOrderStatus(OrderStatusEnum.CREATE_FINISH.getStatus());
         baseInfoDO.setCheckStatus(FinanceEnum.NOT_CREATED.getStatus());
         baseInfoDO.setInvoiceStatus(FinanceEnum.NOT_CREATED.getStatus());
+        //存储时不再存储过期时间为十年的url,而是存储文件名称,到时候访问图片资源时,携带bucket,访问重新生成的携带accesskey的url。
+        baseInfoDO.setPicUrl(SplitUrlGetBucketName.getUrlFileName(baseInfoVO.getPicUrl()));
+        baseInfoDO.setSmallPicUrl(SplitUrlGetBucketName.getUrlFileName(baseInfoVO.getSmallPicUrl()));
         save(baseInfoDO);
  
         OrderOpinionLogDO orderOpinionLogDO = buildOrderOpinionLogDo(baseInfoDO.getId(),
@@ -2318,10 +2372,10 @@ end
             baseInfoDO.setCnColor(baseInfoVO.getCnColor());
         }
         if (StringUtils.isNotBlank(baseInfoVO.getPicUrl())) {
-            baseInfoDO.setPicUrl(baseInfoVO.getPicUrl());
+            baseInfoDO.setPicUrl(SplitUrlGetBucketName.getUrlFileName(baseInfoVO.getPicUrl()));
         }
         if (StringUtils.isNotBlank(baseInfoVO.getSmallPicUrl())) {
-            baseInfoDO.setSmallPicUrl(baseInfoVO.getSmallPicUrl());
+            baseInfoDO.setSmallPicUrl(SplitUrlGetBucketName.getUrlFileName(baseInfoVO.getSmallPicUrl()));
         }
         if (StringUtils.isNotBlank(baseInfoVO.getProductionComment())) {
             baseInfoDO.setProductionComment(baseInfoVO.getProductionComment());
@@ -2680,7 +2734,17 @@ end
             //邮箱收集完毕。
             OrderEventJobVO orderEventJobVO = new OrderEventJobVO();
             orderEventJobVO.setInspectionStageInfo(updateVO.getInspectionStageInfo());
-            OrderBaseInfoVO orderBaseInfoVo = BeanUtil.copyProperties(orderBaseInfoDO, OrderBaseInfoVO.class);
+            OrderBaseInfoVO orderBaseInfoVo = BeanUtil.copyProperties(orderBaseInfoDO, OrderBaseInfoVO.class,"smallPicUrl");
+            String smallPicUrl="";
+            if(com.order.erp.common.utils.StringUtils.isNotEmpty(orderBaseInfoDO.getSmallPicUrl())){
+                String smallPicUrlKey=Constant.OSS_SMALL_PIC_URL+orderBaseInfoDO.getSmallPicUrl();
+                smallPicUrl=(String)redisUtils.get(smallPicUrlKey);
+                if(StringUtils.isBlank(smallPicUrl)){
+                   smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderBaseInfoDO.getSmallPicUrl()), SplitUrlGetBucketName.getFileName(orderBaseInfoDO.getSmallPicUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                    redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                }
+            }
+            orderBaseInfoVo.setSmallPicUrl(smallPicUrl);
             orderEventJobVO.setBaseInfo(orderBaseInfoVo);
  
             //一旦修改完质检信息就自动发送邮件对应的生产科。多次编辑保存多次发送。  只有当这次的尾期结果与上一次不一样才不会发送。
@@ -2723,7 +2787,17 @@ end
             List<String> allEmails=new ArrayList<>(emailsSet);
             OrderEventJobVO orderEventJobVO = new OrderEventJobVO();
             orderEventJobVO.setInspectionStageInfo(inspectionStageVO);
-            OrderBaseInfoVO orderBaseInfoVo = BeanUtil.copyProperties(orderBaseInfoDO, OrderBaseInfoVO.class);
+            OrderBaseInfoVO orderBaseInfoVo = BeanUtil.copyProperties(orderBaseInfoDO, OrderBaseInfoVO.class,"smallPicUrl");
+            String smallPicUrl="";
+            if(com.order.erp.common.utils.StringUtils.isNotEmpty(orderBaseInfoDO.getSmallPicUrl())){
+                String smallPicUrlKey=Constant.OSS_SMALL_PIC_URL+orderBaseInfoDO.getSmallPicUrl();
+                smallPicUrl=(String)redisUtils.get(smallPicUrlKey);
+                if(StringUtils.isBlank(smallPicUrl)){
+                    smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderBaseInfoDO.getSmallPicUrl()),SplitUrlGetBucketName.getFileName(orderBaseInfoDO.getSmallPicUrl()),new DateTime().plusHours(Constant.TWO).toDate());
+                    redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                }
+            }
+            orderBaseInfoVo.setSmallPicUrl(smallPicUrl);
             orderEventJobVO.setBaseInfo(orderBaseInfoVo);
             emailSendUtils.sendCheckResultEmail(EmailTemplateEnum.END_CHECK_REPORT_TEMPLATE, allEmails, orderEventJobVO);
         }else{
@@ -2811,7 +2885,16 @@ end
                     orderEventJobVO.getBaseInfo().setCustomerPo(orderBaseInfoDo.getCustomerPo());
                     orderEventJobVO.getBaseInfo().setCustomerStyle(orderBaseInfoDo.getCustomerStyle());
                     orderEventJobVO.getBaseInfo().setPoColor(orderBaseInfoDo.getPoColor());
-                    orderEventJobVO.getBaseInfo().setSmallPicUrl(orderBaseInfoDo.getSmallPicUrl());
+                    String smallPicUrl="";
+                    if(com.order.erp.common.utils.StringUtils.isNotEmpty(orderBaseInfoDo.getSmallPicUrl())){
+                        String smallPicUrlKey=Constant.OSS_SMALL_PIC_URL+orderBaseInfoDo.getSmallPicUrl();
+                        smallPicUrl=(String)redisUtils.get(smallPicUrlKey);
+                        if(StringUtils.isBlank(smallPicUrl)){
+                            smallPicUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderBaseInfoDo.getSmallPicUrl()),SplitUrlGetBucketName.getFileName(orderBaseInfoDo.getSmallPicUrl()),new DateTime().plusHours(Constant.TWO).toDate());
+                            redisUtils.set(smallPicUrlKey,smallPicUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                        }
+                    }
+                    orderEventJobVO.getBaseInfo().setSmallPicUrl(smallPicUrl);
                     orderEventJobVO.getBaseInfo().setOrderCount(orderBaseInfoDo.getOrderCount());
 //                    String[] split = productionComment.split("\n");
 //                    String[] split1 = split[split.length - 1].split("[:：]+");
@@ -2844,25 +2927,32 @@ end
             if (TimePeriod.YEAR.getDescription().equals(dateTimeVO.getPeriod())) {
                 //查询每一年份的已完成订单数据。
                 //查询所有年份的完成订单数据。
-                long allYearCount = this.baseMapper.countAllYearByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus());
-                //查询所有年份的跟单和质检中的数据。
+                long allYearCountNoReturn = this.baseMapper.countAllYearByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus());
+                long allYearCountReturn = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN).eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE).eq(OrderBaseInfoDO::getOrderStatus,OrderStatusEnum.ORDER_FINISH.getStatus()));
+               /* 查询所有年份的跟单和质检中的数据。
                 long tracking = orderTrackStageService.countRecentYearByOrderStatus(OrderStatusEnum.TRACK_ING.getStatus());
+
                 long inspecting  =  orderInspectionStageService.countRecentYearByOrderStatus(OrderStatusEnum.INSPECT_ING.getStatus());
+                */
+
                 //查询所有年份的利润分析表的数据。(从orderFieldLockApplyDo表中查询。)。
 //                long rofit =this.baseMapper.countAllYearByOrderStatus(OrderStatusEnum.PROFIT_WAIT_AUDIT.getStatus());
                 long rofit = orderFieldLockApplyService.countAllYearByOrderStatus(ApplyTypeEnum.ORDER_PROFIT_APPLY.getType());
                 //查询所有年份的项目报告书待审核的数据。
-//                long report=this.baseMapper.countAllYearByOrderStatus(OrderStatusEnum.REPORT_WAIT_AUDIT.getStatus());
+//                long report=this.baseMapper.count AllYearByOrderStatus(OrderStatusEnum.REPORT_WAIT_AUDIT.getStatus());
                 long report = orderFieldLockApplyService.countAllYearByOrderStatus(ApplyTypeEnum.ORDER_REPORT_APPLY.getType());
+
                 //查询所有年份的订单初始化的数据。
                 long orderInit = this.baseMapper.countRecentYearByOrderInit();
  
+                long returnOrderBaseInfoNumber = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN).eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE));
                 Datecount datecount = new Datecount();
-                datecount.setAllCount(allYearCount);
-                datecount.setTrackingAndInspectingList(tracking+inspecting);
+                datecount.setAllCount(allYearCountNoReturn+allYearCountReturn);
+                datecount.setTrackingAndInspectingList(orderInit+returnOrderBaseInfoNumber-allYearCountNoReturn-allYearCountReturn);
                 datecount.setProfitList(rofit);
                 datecount.setReportList(report);
-                datecount.setOrderInitList(orderInit);
+                //订单初始化的数量计算方式是:对于不是返单的数据,相同的项目号和内部编号只能算一个订单,对于返单来说,就不进行去重。
+                datecount.setOrderInitList(orderInit+returnOrderBaseInfoNumber);
                 return ServerResult.success(datecount);
             }
             //月
@@ -2872,19 +2962,32 @@ end
                 LocalDate endOfYear = startOfYear.plusYears(1);
                 //如果为月,则需要前端传递year,然后得到这个year的数据。
                 //查询这个年每一个月的数据
-                long allMonthCount=this.baseMapper.countAllMonthByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus(),startOfYear,endOfYear);
-                long tracking   =  orderTrackStageService.countRecentMonthValueByOrderStatus(OrderStatusEnum.TRACK_ING.getStatus(),startOfYear,endOfYear);
+                long allMonthCountNoReturn=this.baseMapper.countAllMonthByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus(),(long) (dateTime % 100));
+                long allMonthCountReturn = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>()
+                        .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                        .eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE)
+                        .eq(OrderBaseInfoDO::getOrderStatus,OrderStatusEnum.ORDER_FINISH.getStatus())
+                        .likeRight(OrderBaseInfoDO::getInnerNo, "_____" + dateTime % 100));
+               /* long tracking   =  orderTrackStageService.countRecentMonthValueByOrderStatus(OrderStatusEnum.TRACK_ING.getStatus(),startOfYear,endOfYear);
+                System.out.println("跟单中:"+tracking);
                 long inspecting  =  orderInspectionStageService.countRecentMonthValueByOrderStatus(OrderStatusEnum.INSPECT_ING.getStatus(),startOfYear,endOfYear);
+                System.out.println("质检中:"+inspecting);*/
                 long profit = orderFieldLockApplyService.countRecentMonthValueByOrderStatus(ApplyTypeEnum.ORDER_PROFIT_APPLY.getType(),startOfYear,endOfYear);
                 long report = orderFieldLockApplyService.countRecentMonthValueByOrderStatus(ApplyTypeEnum.ORDER_REPORT_APPLY.getType(),startOfYear,endOfYear);
-                //查询年月的项目报告书待审核/订单初始化。
-                long orderinit=this.baseMapper.countRecentMonthValueByOrderInit(startOfYear,endOfYear);
+
+                long orderInit=this.baseMapper.countRecentMonthValueByOrderInit((long) (dateTime % 100));
+
+                long returnOrderBaseInfoNumber = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>()
+                        .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                        .eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE)
+                        .likeRight(OrderBaseInfoDO::getInnerNo, "_____" + dateTime % 100));
+
                 Datecount datecount = new Datecount();
-                datecount.setTrackingAndInspectingList(tracking+inspecting);
-                datecount.setAllCount(allMonthCount);
+                datecount.setTrackingAndInspectingList(orderInit+returnOrderBaseInfoNumber-allMonthCountNoReturn-allMonthCountReturn);
+                datecount.setAllCount(allMonthCountNoReturn+allMonthCountReturn);
                 datecount.setProfitList(profit);
                 datecount.setReportList(report);
-                datecount.setOrderInitList(orderinit);
+                datecount.setOrderInitList(orderInit+returnOrderBaseInfoNumber);
                 return ServerResult.success(datecount);
             }
         }
@@ -2893,18 +2996,34 @@ end
         int year = currentDate.getYear();
         LocalDate startDate = LocalDate.of(year, currentMonth, 1);
         LocalDate endDate = startDate.plusMonths(1);
-        long allDayCount=this.baseMapper.countAllDayvalueByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus(),startDate,endDate);
-        long tracking   =  orderTrackStageService.countRecentDayvalueByOrderStatus(OrderStatusEnum.TRACK_ING.getStatus(),startDate,endDate);
+        long allDayCountNoReturn=this.baseMapper.countAllDayvalueByOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus(),startDate,endDate,(long)year % 100);
+        long allDayCountReturn = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE)
+                .eq(OrderBaseInfoDO::getOrderStatus,OrderStatusEnum.ORDER_FINISH.getStatus())
+                .ge(OrderBaseInfoDO::getCreateTime,startDate)
+                .lt(OrderBaseInfoDO::getCreateTime,endDate)
+                .likeRight(OrderBaseInfoDO::getInnerNo, "_____" + year % 100));
+       /* long tracking   =  orderTrackStageService.countRecentDayvalueByOrderStatus(OrderStatusEnum.TRACK_ING.getStatus(),startDate,endDate);
+        System.out.println("跟单中:"+tracking);
         long inspecting  =  orderInspectionStageService.countRecentDayvalueByOrderStatus(OrderStatusEnum.INSPECT_ING.getStatus(),startDate,endDate);
+        System.out.println("质检中:"+inspecting);*/
         long profit= orderFieldLockApplyService.countRecentDayvalueByOrderStatus(ApplyTypeEnum.ORDER_PROFIT_APPLY.getType(),startDate,endDate);
         long report=orderFieldLockApplyService.countRecentDayvalueByOrderStatus(ApplyTypeEnum.ORDER_REPORT_APPLY.getType(),startDate,endDate);
-        long orderinit=this.baseMapper.countRecentDayByOrderInit(startDate,endDate);
+
+        long orderInit=this.baseMapper.countRecentDayByOrderInit(startDate,endDate, (long) (year % 100));
+        long returnOrderBaseInfoNumber = this.count(new LambdaQueryWrapper<OrderBaseInfoDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .eq(OrderBaseInfoDO::getReturnOrder, Constant.STRING_ONE)
+                .ge(OrderBaseInfoDO::getCreateTime,startDate)
+                .lt(OrderBaseInfoDO::getCreateTime,endDate)
+                .likeRight(OrderBaseInfoDO::getInnerNo, "_____" + year % 100));
         Datecount datecount = new Datecount();
-        datecount.setTrackingAndInspectingList(tracking+inspecting);
-        datecount.setAllCount(allDayCount);
+        datecount.setTrackingAndInspectingList(orderInit+returnOrderBaseInfoNumber-allDayCountNoReturn-allDayCountReturn);
+        datecount.setAllCount(allDayCountNoReturn+allDayCountReturn);
         datecount.setProfitList(profit);
         datecount.setReportList(report);
-        datecount.setOrderInitList(orderinit);
+        datecount.setOrderInitList(orderInit+returnOrderBaseInfoNumber);
         return ServerResult.success(datecount);
     }
  
@@ -2922,11 +3041,11 @@ end
                 return  ServerResult.success(dateYearMonthTimeVOS);
             }
             if (TimePeriod.MONTH.getDescription().equals(dateTimeVO.getPeriod())) {
-                // 查询当前月份的数据
+                // 查询当前月份的数据。
                 List<DateYearMonthTimeVO> dateYearMonthTimeVOS = this.baseMapper.countRecentMonthValueByOrderStatus(Arrays.asList(dateTimeVO.getDateTime()));
                 List<DateYearMonthTimeVO> combinedList = new ArrayList<>(dateYearMonthTimeVOS);
  
-                // 查询对比的年份
+                // 查询对比的年份。
                 List<Integer> yearList = new ArrayList<>();
                 yearList.add(dateTimeVO.getDateTime());
                 if (CollectionUtils.isNotEmpty(dateTimeVO.getDateTimes())) {
@@ -2935,24 +3054,24 @@ end
                     yearList.addAll(dateTimeVO.getDateTimes());
                 }
  
-                // 使用 Map 来存储已有的日期信息，避免重复遍历
+                // 使用 Map 来存储已有的日期信息，避免重复遍历。
                 Map<String, DateYearMonthTimeVO> existingDates = new HashMap<>();
  
-                // 将已有数据存储到 Map 中
+                // 将已有数据存储到 Map 中。
                 for (DateYearMonthTimeVO item : combinedList) {
                     existingDates.put(item.getDate(), item);
                 }
  
-                // 遍历年份和月份，补充缺失月份
+                // 遍历年份和月份，补充缺失月份。
                 for (Integer targetYear : yearList) {
                     for (int month = 1; month <= 12; month++) {
                         String monthStr = String.format("%s-%02d", targetYear, month);
-                        // 如果该月份没有数据，则补充
+                        // 如果该月份没有数据，则补充。
                         existingDates.putIfAbsent(monthStr, new DateYearMonthTimeVO(monthStr, 0L ,String.valueOf(targetYear)));
                     }
                 }
  
-                // 更新日期前缀
+                // 更新日期前缀。
                 existingDates.forEach((key, item) -> {
                     String[] dateParts = item.getDate().split("-");
                     if (dateParts.length == 2) {
@@ -2960,7 +3079,7 @@ end
                     }
                 });
  
-                // 返回最终结果
+                // 返回最终结果。
                 return ServerResult.success(new ArrayList<>(existingDates.values()));
             }
  
@@ -2975,6 +3094,45 @@ end
         return ServerResult.success(dateYearMonthTimeVOS);
     }
  
+    @Override
+    public ServerResult accountStatement(HttpServletResponse response,AccountStatementVO accountStatementVO) throws IOException {
+          if(CollectionUtils.isEmpty(accountStatementVO.getIds())){
+              return ServerResult.fail("请选中订单！");
+          }
+        List<OrderFieldLockApplyDO> orderFieldLockApplyDOS = orderFieldLockApplyService.list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .in(OrderFieldLockApplyDO::getOrderId, accountStatementVO.getIds())
+                .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.ORDER_PROFIT_APPLY.getType())
+                .eq(OrderFieldLockApplyDO::getStatus,ApplyStatusEnum.WAIT_AUDIT.getStatus()));
+        if(CollectionUtils.isNotEmpty(orderFieldLockApplyDOS)){
+            return ServerResult.fail("订单中包含利润未审批的订单,无法生成！");
+        }
+        List<OrderProfitAnalysisDO> orderProfitAnalysisDOList = profitAnalysisService.list(new LambdaQueryWrapper<OrderProfitAnalysisDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .in(OrderProfitAnalysisDO::getOrderId, accountStatementVO.getIds()));
+          if(CollectionUtils.isEmpty(orderProfitAnalysisDOList) || accountStatementVO.getIds().size() > orderProfitAnalysisDOList.size()){
+              return ServerResult.fail("利润分析未填写,无法进行生成!");
+          }
+        List<OrderBaseInfoDO> orderBaseInfoDOList = listByIds(accountStatementVO.getIds());
+        Map<Long, OrderProfitAnalysisDO> orderProfitAnalysisDOMap = orderProfitAnalysisDOList.stream().collect(Collectors.toMap(OrderProfitAnalysisDO::getOrderId, Function.identity(), (x, y) -> x));
+
+        List<AccountStatementExcelVO> accountStatementExcelVOList = orderBaseInfoDOList.stream().map(x -> {
+            AccountStatementExcelVO accountStatementExcelVO = new AccountStatementExcelVO();
+            BeanUtils.copyProperties(x, accountStatementExcelVO);
+            OrderProfitAnalysisDO orderProfitAnalysisDO = orderProfitAnalysisDOMap.get(x.getId());
+            if (Objects.nonNull(orderProfitAnalysisDO)) {
+                accountStatementExcelVO.setProductionDepartmentPrice(orderProfitAnalysisDO.getProductionDepartmentPrice());
+                accountStatementExcelVO.setProductionDepartmentTotalPrice(orderProfitAnalysisDO.getProductionDepartmentTotalPrice());
+            }
+            return accountStatementExcelVO;
+
+        }).collect(Collectors.toList());
+        accountStatementExcelVOList.get(0).setDeduction(accountStatementVO.getDeduction());
+        accountStatementExcelVOList.get(0).setDisbursement(accountStatementVO.getDisbursement());
+        accountStatementExcelVOList.get(0).setTitleCompany(accountStatementVO.getTitleCompany());
+        accountStatementExcel.AccountStatementExcel(response,accountStatementExcelVOList);
+        return ServerResult.success();
+    }
  
  
     @Override
@@ -4,6 +4,7 @@ import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.Query;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
@@ -14,9 +15,7 @@ import com.order.erp.common.constant.Constant;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.common.constant.ServerResultCode;
 import com.order.erp.common.exception.BusinessException;
-import com.order.erp.common.utils.EmailSendUtils;
-import com.order.erp.common.utils.OrderFieldUtils;
-import com.order.erp.common.utils.TransactionHelper;
+import com.order.erp.common.utils.*;
 import com.order.erp.config.DataScope;
 import com.order.erp.domain.*;
 import com.order.erp.domain.dto.BaseDO;
@@ -25,6 +24,7 @@ import com.order.erp.domain.vo.order.*;
 import com.order.erp.mapper.order.OrderFieldLockApplyMapper;
 import com.order.erp.service.order.*;
 import lombok.extern.slf4j.Slf4j;
+import org.joda.time.DateTime;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -32,6 +32,7 @@ import org.springframework.transaction.annotation.Transactional;
 import javax.annotation.Resource;
 import java.time.LocalDate;
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.stream.Collectors;
  
@@ -74,6 +75,8 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
     private TransactionHelper transactionHelper;
     @Resource
     private EmailSendUtils emailSendUtils;
+    @Resource
+    private RedisUtils redisUtils;
  
     /**
      * 通过ID查询单条数据
@@ -131,37 +134,71 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
                         fieldVO.setProfitAnalysisFields(JSONObject.parseObject(fields, OrderProfitAnalysisFieldVO.class));
                         resultVO.setFieldInfos(fieldVO);
                     }
-                    if (ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(x.getType())) {
+                    if (ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(x.getType()) || ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(x.getType())  ) {
                         OrderLockFieldVO orderLockFieldVO = JSONObject.parseObject(fields, OrderLockFieldVO.class);
+                        //对于扣款单申请,需要看到扣款单的文件,所以这里需要oss实时获取。
+                        if(ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(x.getType())){
+                            DeductionUrlFieldVO deductionUrlFieldVO = orderLockFieldVO.getDeductionUrlFieldVO();
+                            String invoiceDeductUrlKey = Constant.OSS_INVOICE_DEDUCT_URL + deductionUrlFieldVO.getDeductUrl();
+                            String invoiceDeductUrl=(String)redisUtils.get(invoiceDeductUrlKey);
+                            if(StringUtils.isBlank(invoiceDeductUrl)){
+                                invoiceDeductUrl = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(deductionUrlFieldVO.getDeductUrl()), SplitUrlGetBucketName.getFileName(deductionUrlFieldVO.getDeductUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                                redisUtils.set(invoiceDeductUrlKey,invoiceDeductUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                            }
+                            deductionUrlFieldVO.setDeductUrl(invoiceDeductUrl);
+                        }
                         if(RoleEnum.BUSINESS_USER.getCode().equals(roleEnum.getCode())){
-                            if(Objects.nonNull(orderLockFieldVO.getInvoiceFieldVO()) && orderLockFieldVO.getInvoiceFieldVO().getBusinesPerson().equals(loginUserName)){
-                                resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            if(Objects.nonNull(orderLockFieldVO.getInvoiceFieldVO()) && orderLockFieldVO.getInvoiceFieldVO().getBusinesPerson().equals(loginUserName) || Objects.nonNull(orderLockFieldVO.getDeductionUrlFieldVO()) && orderLockFieldVO.getDeductionUrlFieldVO().getBusinesPerson().equals(loginUserName)){
+                                resultVO.setFieldInfos(orderLockFieldVO);
                             }
                         } else if (RoleEnum.TRACKER_USER.getCode().equals(roleEnum.getCode())) {
-                            if(Objects.nonNull(orderLockFieldVO.getInvoiceFieldVO()) && orderLockFieldVO.getInvoiceFieldVO().getTrackerUser().equals(loginUserName)){
-                                resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            if(Objects.nonNull(orderLockFieldVO.getInvoiceFieldVO()) && orderLockFieldVO.getInvoiceFieldVO().getTrackerUser().equals(loginUserName)   || Objects.nonNull(orderLockFieldVO.getDeductionUrlFieldVO()) && orderLockFieldVO.getDeductionUrlFieldVO().getTrackerUser().equals(loginUserName)){
+                                resultVO.setFieldInfos(orderLockFieldVO);
                             }
                         } else{
-                            resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            resultVO.setFieldInfos(orderLockFieldVO);
                         }
                         if(Objects.isNull(resultVO.getFieldInfos())){
                            resultVO=null;
                         }
                     }
-                    if (ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(x.getType()) || ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(x.getType())) {
+                    if (ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(x.getType()) || ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(x.getType()) || ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(x.getType())) {
                         OrderLockFieldVO orderLockFieldVO = JSONObject.parseObject(fields, OrderLockFieldVO.class);
                         // 解决待审批列表中的应付款要显示内部编码。 这里开始
                         //这部分的目的是,对于跟单员和业务员他们也能查看到应收款和应付款中各自负责订单的审核情况。 而财务和admin则会执行else{},会看到所有的审核订单信息。
+                        if(ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(x.getType())){
+                            DeductionUrlFieldVO deductionUrlFieldVO = orderLockFieldVO.getDeductionUrlFieldVO();
+                            String checkDeductUrlKey= Constant.OSS_CHECK_DEDUCT_URL+deductionUrlFieldVO.getDeductUrl();
+                            String checkDeductUrl=(String)redisUtils.get(checkDeductUrlKey);
+                            if(StringUtils.isBlank(checkDeductUrl)){
+                                checkDeductUrl = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(deductionUrlFieldVO.getDeductUrl()), SplitUrlGetBucketName.getFileName(deductionUrlFieldVO.getDeductUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                                redisUtils.set(checkDeductUrlKey,checkDeductUrl,Constant.ONEPOINTNINE_HOURS, TimeUnit.SECONDS);
+                            }
+                            deductionUrlFieldVO.setDeductUrl(checkDeductUrl);
+                        }else if(ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(x.getType())){
+                            ProducePaymentCheckBillVO checkBillVO = orderLockFieldVO.getCheckBillVO();
+                            String invoiceUrlKey = Constant.OSS_INVOICE_URL + checkBillVO.getInvoiceUrl();
+                            String invoiceUrl =(String)redisUtils.get(invoiceUrlKey);
+                            if(StringUtils.isBlank(invoiceUrl)){
+                            invoiceUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(checkBillVO.getInvoiceUrl()), SplitUrlGetBucketName.getFileName(checkBillVO.getInvoiceUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                            redisUtils.set(invoiceUrlKey,invoiceUrl,Constant.ONEPOINTNINE_HOURS,TimeUnit.SECONDS);
+                            }
+                            checkBillVO.setInvoiceUrl(invoiceUrl);
+                        }
                         if(RoleEnum.BUSINESS_USER.getCode().equals(roleEnum.getCode())){
-                            if((Objects.nonNull(orderLockFieldVO.getProducePaymentCheckBillFieldVO()) && orderLockFieldVO.getProducePaymentCheckBillFieldVO().getBusinesPerson().equals(loginUserName))||(Objects.nonNull(orderLockFieldVO.getCheckBillVO()) && orderLockFieldVO.getCheckBillVO().getBusinesPerson().equals(loginUserName))){
-                                resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            if((Objects.nonNull(orderLockFieldVO.getProducePaymentCheckBillFieldVO()) && orderLockFieldVO.getProducePaymentCheckBillFieldVO().getBusinesPerson().equals(loginUserName))
+                                    ||(Objects.nonNull(orderLockFieldVO.getCheckBillVO()) && orderLockFieldVO.getCheckBillVO().getBusinesPerson().equals(loginUserName))
+                                    ||(Objects.nonNull(orderLockFieldVO.getDeductionUrlFieldVO()) && orderLockFieldVO.getDeductionUrlFieldVO().getBusinesPerson().equals(loginUserName))){
+                                resultVO.setFieldInfos(orderLockFieldVO);
                             }
                         } else if (RoleEnum.TRACKER_USER.getCode().equals(roleEnum.getCode())) {
-                            if((Objects.nonNull(orderLockFieldVO.getProducePaymentCheckBillFieldVO()) && orderLockFieldVO.getProducePaymentCheckBillFieldVO().getTrackerUser().equals(loginUserName))||(Objects.nonNull(orderLockFieldVO.getCheckBillVO()) && orderLockFieldVO.getCheckBillVO().getTrackerUser().equals(loginUserName))){
-                                resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            if((Objects.nonNull(orderLockFieldVO.getProducePaymentCheckBillFieldVO()) && orderLockFieldVO.getProducePaymentCheckBillFieldVO().getTrackerUser().equals(loginUserName))
+                                    ||(Objects.nonNull(orderLockFieldVO.getCheckBillVO()) && orderLockFieldVO.getCheckBillVO().getTrackerUser().equals(loginUserName))
+                                    ||(Objects.nonNull(orderLockFieldVO.getDeductionUrlFieldVO()) && orderLockFieldVO.getDeductionUrlFieldVO().getTrackerUser().equals(loginUserName))){
+                                resultVO.setFieldInfos(orderLockFieldVO);
                             }
                         } else{
-                            resultVO.setFieldInfos(JSONObject.parseObject(fields, OrderLockFieldVO.class));
+                            resultVO.setFieldInfos(orderLockFieldVO);
                         }
                         if(Objects.isNull(resultVO.getFieldInfos())){
                             resultVO=null;
@@ -172,7 +209,9 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             }).filter(result->result!=null).collect(Collectors.toList());
             if (resultVOList != null && resultVOList.stream().noneMatch(x -> ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(x.getType())
                     || ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(x.getType())
-                    || ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(x.getType()))) {
+                    || ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(x.getType())
+                    || ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(x.getType())
+                    || ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(x.getType()))) {
                 fillOrderInfo(resultVOList);
             }
         }
@@ -257,8 +296,20 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             if (orderBaseInfoDOMap.containsKey(x.getOrderId())) {
                 OrderBaseInfoDO orderBaseInfoDO = orderBaseInfoDOMap.get(x.getOrderId());
                 OrderBaseInfoVO orderBaseInfo = new OrderBaseInfoVO();
-                BeanUtils.copyProperties(orderBaseInfoDO, orderBaseInfo);
+                BeanUtils.copyProperties(orderBaseInfoDO, orderBaseInfo,"picUrl","smallPicUrl");
                 x.setOrderBaseInfo(orderBaseInfo);
+                String picUrlKey = Constant.OSS_PIC_URL + orderBaseInfoDO.getPicUrl();
+                String smallPicUrlKey = Constant.OSS_SMALL_PIC_URL + orderBaseInfoDO.getSmallPicUrl();
+                 String picUrl=(String)redisUtils.get(picUrlKey);
+                 String smallPicUrl=(String)redisUtils.get(smallPicUrlKey);
+                 if(StringUtils.isBlank(picUrl)){
+                    picUrl= AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderBaseInfoDO.getPicUrl()), SplitUrlGetBucketName.getFileName(orderBaseInfoDO.getPicUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                 }
+                 if(StringUtils.isBlank(smallPicUrl)){
+                   smallPicUrl=  AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(orderBaseInfoDO.getSmallPicUrl()), SplitUrlGetBucketName.getFileName(orderBaseInfoDO.getSmallPicUrl()), new DateTime().plusHours(Constant.TWO).toDate());
+                 }
+                x.getOrderBaseInfo().setSmallPicUrl(smallPicUrl);
+                x.getOrderBaseInfo().setPicUrl(picUrl);
             }
         });
     }
@@ -370,7 +421,8 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
         }
         Set<Long> orderIds = new HashSet<>();
         //由于下面是原始的代码,怕改出错了,所以我只对我需要的需求进行判断,我只针对我需要的这种情况,其他情况下就不走这种情况。   限制情况为跟单业务,对应收款,应付款,发票审核请求时。
-        if(queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050){
+//        queryVO.getType==Constant.SIXTY完全是为了跟单和业务对于应收账单类型请求时,屏蔽掉应收账单,只展示invoice扣款单申请数据。
+        if(queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050 || queryVO.getType()==Constant.SIXTY){
  
         }else{
             /** 这部分代码是之前的,每台看懂,就先不修改了,保留*/
@@ -403,7 +455,7 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             if(Constant.FOUR == String.valueOf(queryVO.getType()).length()){
                 int firstTwoDigits = queryVO.getType() / 100;
                 int lastTwoDigits = queryVO.getType() % 100;
-                queryWrapper.in(OrderFieldLockApplyDO::getType,firstTwoDigits,lastTwoDigits);
+                queryWrapper.in(OrderFieldLockApplyDO::getType,firstTwoDigits,lastTwoDigits,ApplyTypeEnum.CHECK_DEDUCT_URL.getType());
                 //目前是只能通过内部编号查询出应付款审核,无法查询出发票信息。
                 if(CollectionUtils.isNotEmpty(queryVO.getInnerNo())){
                     String queryInnerNo = queryVO.getInnerNo().get(0).trim();
@@ -411,23 +463,26 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
                             "(" +
                                     "JSON_CONTAINS(JSON_EXTRACT(fields, '$.producePaymentCheckBillFieldVO.innerNo'), JSON_QUOTE({0})) " +
                                     "OR JSON_UNQUOTE(JSON_EXTRACT(fields, '$.checkBillVO.innerNo')) = {0}" +
+                                    "OR JSON_UNQUOTE(JSON_EXTRACT(fields, '$.deductionUrlFieldVO.innerNo')) = {0}" +
                                     ")",
                             queryInnerNo
                     );
                 }
-            }else{
+            }else if(Objects.nonNull(queryVO.getType()) && queryVO.getType().equals(ApplyTypeEnum.INVOICE_BILL_APPLY.getType())){
                 //应收款审核。
-                if(Objects.nonNull(queryVO.getType()) && queryVO.getType().equals(ApplyTypeEnum.INVOICE_BILL_APPLY.getType())){
-                    queryWrapper.eq(Objects.nonNull(queryVO.getType()), OrderFieldLockApplyDO::getType, queryVO.getType());
+                    queryWrapper.in(Objects.nonNull(queryVO.getType()), OrderFieldLockApplyDO::getType, queryVO.getType(),ApplyTypeEnum.INVOICE_DEDUCT_URL.getType());
                     //这个内部编号单独针对于应付款申请设置的。
                     if(CollectionUtils.isNotEmpty(queryVO.getInnerNo())){
                         String queryInnerNo = queryVO.getInnerNo().get(0).trim();
                         queryWrapper.apply(
-                                "JSON_CONTAINS(JSON_EXTRACT(fields, '$.invoiceFieldVO.innerNo'), JSON_QUOTE({0}))",
+                                "(" +
+                                        "JSON_CONTAINS(JSON_EXTRACT(fields, '$.invoiceFieldVO.innerNo'), JSON_QUOTE({0})) " +
+                                        "OR JSON_UNQUOTE(JSON_EXTRACT(fields, '$.deductionUrlFieldVO.innerNo')) = {0}" +
+                                        ")",
                                 queryInnerNo
                         );
                     }
-                }
+            }else{
                 //其他审核类型。
                 queryWrapper.eq(Objects.nonNull(queryVO.getType()), OrderFieldLockApplyDO::getType, queryVO.getType());
             }
@@ -440,9 +495,11 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             if (!invoiceNos.isEmpty()) {
                 // 使用参数化查询避免 SQL 拼接问题
                 queryWrapper.apply(
-                         "JSON_UNQUOTE(JSON_EXTRACT(fields, '$.invoiceFieldVO.invoiceNo')) like {0}",
-                        "%"+invoiceNos+"%"
+                        "((JSON_UNQUOTE(JSON_EXTRACT(fields, '$.invoiceFieldVO.invoiceNo')) LIKE {0} " +
+                                "OR JSON_UNQUOTE(JSON_EXTRACT(fields, '$.deductionUrlFieldVO.invoiceNo')) LIKE {0}))",
+                        "%" + invoiceNos + "%"
                 );
+
             }
         }
  
@@ -455,15 +512,18 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
                 // 使用括号分组确保逻辑优先级正确
                 queryWrapper.apply(
                         "((JSON_UNQUOTE(JSON_EXTRACT(fields, '$.producePaymentCheckBillFieldVO.checkNo')) like {0}) " +
-                                "OR (JSON_UNQUOTE(JSON_EXTRACT(fields, '$.checkBillVO.checkNo')) like {0}))",
+                                "OR (JSON_UNQUOTE(JSON_EXTRACT(fields, '$.checkBillVO.checkNo')) like {0})" +
+                                "OR (JSON_UNQUOTE(JSON_EXTRACT(fields, '$.deductionUrlFieldVO.checkNo')) like {0})" +
+                                ")",
                         "%"+checkNos+"%"
                 );
             }
         }
         //由于不懂下面的代码,所以我只对我需要的需求进行判断,我只针对我需要的这种情况,其他情况下就不走这种情况。
-        if(RoleEnum.TRACKER_USER.getCode().equals(roleEnum.getCode()) && (queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050)){
+        //        queryVO.getType==Constant.SIXTY完全是为了跟单和业务对于应收账单类型请求时,屏蔽掉应收账单,只展示invoice扣款单申请数据。
+        if(RoleEnum.TRACKER_USER.getCode().equals(roleEnum.getCode()) && (queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050  || queryVO.getType() ==Constant.SIXTY)){
  
-        }else if(RoleEnum.BUSINESS_USER.getCode().equals(roleEnum.getCode()) && (queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050)){
+        }else if(RoleEnum.BUSINESS_USER.getCode().equals(roleEnum.getCode()) && (queryVO.getType()==Constant.THIRTY || queryVO.getType()==4050 || queryVO.getType() ==Constant.SIXTY)){
  
         }else{
             if (Objects.isNull(roleSelect)) {
@@ -512,6 +572,94 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
         return ServerResult.success();
     }
  
+    @Override
+    public ServerResult audit_detail(AuditDetailQueryVO auditDetailQueryVO) {
+        if(Objects.isNull(auditDetailQueryVO.getId())){
+           throw new BusinessException(ServerResultCode.PARAM_ERROR);
+        }
+        OrderFieldLockApplyDO orderFieldLockApplyDO = getById(auditDetailQueryVO.getId());
+        if(Objects.isNull(orderFieldLockApplyDO)){
+            throw new BusinessException(ServerResultCode.EMPTY_RESULT);
+        }
+        OrderLockFieldVO orderLockFieldVO = JSONObject.parseObject(orderFieldLockApplyDO.getFields(), OrderLockFieldVO.class);
+        //应付款类型。
+        if(ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(orderFieldLockApplyDO.getType()) || ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(orderFieldLockApplyDO.getType()) || ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(orderFieldLockApplyDO.getType())){
+            LambdaQueryWrapper<ProducePaymentCheckBillOrderDO> lambdaQueryWrapper = new LambdaQueryWrapper<ProducePaymentCheckBillOrderDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN);
+            if(ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(orderFieldLockApplyDO.getType())){
+                ProducePaymentCheckBillFieldVO producePaymentCheckBillFieldVO = orderLockFieldVO.getProducePaymentCheckBillFieldVO();
+                lambdaQueryWrapper.in(ProducePaymentCheckBillOrderDO::getId, producePaymentCheckBillFieldVO.getProducePaymentCheckBillId());
+            }else if(ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(orderFieldLockApplyDO.getType())){
+                ProducePaymentCheckBillVO producePaymentCheckBillVO = orderLockFieldVO.getCheckBillVO();
+                lambdaQueryWrapper.eq(ProducePaymentCheckBillOrderDO::getId,producePaymentCheckBillVO.getId());
+            }else if(ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(orderFieldLockApplyDO.getType())){
+                DeductionUrlFieldVO deductionUrlFieldVO = orderLockFieldVO.getDeductionUrlFieldVO();
+                lambdaQueryWrapper.eq(ProducePaymentCheckBillOrderDO::getId,deductionUrlFieldVO.getId());
+            }
+            List<ProducePaymentCheckBillOrderDO> producePaymentCheckBillOrderDOList = checkBillOrderService.list(lambdaQueryWrapper);
+            List<Long> orderIds = producePaymentCheckBillOrderDOList.stream().map(producePaymentCheckBillOrderDO -> producePaymentCheckBillOrderDO.getOrderId()).collect(Collectors.toList());
+            //查询基础信息
+            List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(orderIds);
+            Map<Long, OrderBaseInfoDO> orderBaseInfoDOMap = orderBaseInfoDOList.stream().collect(Collectors.toMap(OrderBaseInfoDO::getId, order -> order, (existing, duplicate) -> existing));
+            //查询价格。
+            List<OrderProfitAnalysisDO> orderProfitAnalysisDOList = profitAnalysisService.list( new LambdaQueryWrapper<OrderProfitAnalysisDO>().eq(BaseDO::getEnableFlag,Constant.ENABLE_TEN)
+                    .in(OrderProfitAnalysisDO::getOrderId,orderIds));
+            Map<Long, OrderProfitAnalysisDO> orderProfitAnalysisDOMap = orderProfitAnalysisDOList.stream().collect(Collectors.toMap(OrderProfitAnalysisDO::getOrderId, orderProfit -> orderProfit, (existing, duplicate) -> existing));
+            List<CheckBillResultVO> checkBillResultVOList = producePaymentCheckBillOrderDOList.stream().map(producePaymentCheckBillOrderDO -> {
+                CheckBillResultVO checkBillResultVO = new CheckBillResultVO();
+                if (orderBaseInfoDOMap.containsKey(producePaymentCheckBillOrderDO.getOrderId()) && orderProfitAnalysisDOMap.containsKey(producePaymentCheckBillOrderDO.getOrderId())) {
+                    BeanUtils.copyProperties(producePaymentCheckBillOrderDO, checkBillResultVO, "projectNo", "productionDepartment", "innerNo", "smallPicUrl", "orderCount", "modeleLo", "productionDepartmentPrice", "productionDepartmentTotalPrice");
+                    checkBillResultVO.setOrderId(producePaymentCheckBillOrderDO.getOrderId());
+                    checkBillResultVO.setProjectNo(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getProjectNo());
+                    checkBillResultVO.setProductionDepartment(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getProductionDepartment());
+                    checkBillResultVO.setInnerNo(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getInnerNo());
+                    checkBillResultVO.setSmallPicUrl(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getSmallPicUrl());
+                    checkBillResultVO.setOrderCount(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getOrderCount());
+                    checkBillResultVO.setModeleLo(orderBaseInfoDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getModeleLo());
+                    checkBillResultVO.setProductionDepartmentPrice(orderProfitAnalysisDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getProductionDepartmentPrice());
+                    checkBillResultVO.setProductionDepartmentTotalPrice(orderProfitAnalysisDOMap.get(producePaymentCheckBillOrderDO.getOrderId()).getProductionDepartmentTotalPrice());
+                }
+                return  checkBillResultVO;
+            }).collect(Collectors.toList());
+            return ServerResult.success(checkBillResultVOList);
+            //应收款类型
+        }else if(ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(orderFieldLockApplyDO.getType()) || ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(orderFieldLockApplyDO.getType())){
+            LambdaQueryWrapper<InvoiceBillOrderDO> invoiceBillOrderDOLambdaQueryWrapper = new LambdaQueryWrapper<InvoiceBillOrderDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN);
+            if(ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(orderFieldLockApplyDO.getType())){
+                InvoiceFieldVO invoiceFieldVO = orderLockFieldVO.getInvoiceFieldVO();
+                invoiceBillOrderDOLambdaQueryWrapper.in(InvoiceBillOrderDO::getId,invoiceFieldVO.getInvoiceId());
+            }else if(ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(orderFieldLockApplyDO.getType())){
+                DeductionUrlFieldVO deductionUrlFieldVO = orderLockFieldVO.getDeductionUrlFieldVO();
+                invoiceBillOrderDOLambdaQueryWrapper.eq(InvoiceBillOrderDO::getId,deductionUrlFieldVO.getId());
+            }
+            List<InvoiceBillOrderDO> invoiceBillOrderDOList = invoiceBillOrderService.list(invoiceBillOrderDOLambdaQueryWrapper);
+            List<Long> orderIds = invoiceBillOrderDOList.stream().map(invoiceBillOrderDO -> invoiceBillOrderDO.getOrderId()).collect(Collectors.toList());
+            //查询基础信息
+            List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(orderIds);
+            Map<Long, OrderBaseInfoDO> orderBaseInfoDOMap = orderBaseInfoDOList.stream().collect(Collectors.toMap(OrderBaseInfoDO::getId, order -> order, (existing, duplicate) -> existing));
+            //查询价格。
+            List<OrderProfitAnalysisDO> orderProfitAnalysisDOList = profitAnalysisService.list(new LambdaQueryWrapper<OrderProfitAnalysisDO>().eq(BaseDO::getEnableFlag,Constant.ENABLE_TEN)
+                    .in(OrderProfitAnalysisDO::getOrderId,orderIds));
+            Map<Long, OrderProfitAnalysisDO> orderProfitAnalysisDOMap = orderProfitAnalysisDOList.stream().collect(Collectors.toMap(OrderProfitAnalysisDO::getOrderId, orderProfit -> orderProfit, (existing, duplicate) -> existing));
+            List<InvoiceResultVO> invoiceResultVOList = invoiceBillOrderDOList.stream().map(invoiceBillOrderDO -> {
+                InvoiceResultVO invoiceResultVO = new InvoiceResultVO();
+                if (orderBaseInfoDOMap.containsKey(invoiceBillOrderDO.getOrderId()) && orderProfitAnalysisDOMap.containsKey(invoiceBillOrderDO.getOrderId())) {
+                    BeanUtils.copyProperties(invoiceBillOrderDO, invoiceResultVO, "projectNo", "productionDepartment", "innerNo", "smallPicUrl", "orderCount", "modeleLo", "customerPrice", "customerTotalPrice");
+                    invoiceResultVO.setOrderId(invoiceBillOrderDO.getOrderId());
+                    invoiceResultVO.setProjectNo(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getProjectNo());
+                    invoiceResultVO.setProductionDepartment(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getProductionDepartment());
+                    invoiceResultVO.setInnerNo(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getInnerNo());
+                    invoiceResultVO.setSmallPicUrl(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getSmallPicUrl());
+                    invoiceResultVO.setOrderCount(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getOrderCount());
+                    invoiceResultVO.setModeleLo(orderBaseInfoDOMap.get(invoiceBillOrderDO.getOrderId()).getModeleLo());
+                    invoiceResultVO.setCustomerPrice(orderProfitAnalysisDOMap.get(invoiceBillOrderDO.getOrderId()).getCustomerPrice());
+                    invoiceResultVO.setCustomerTotalPrice(orderProfitAnalysisDOMap.get(invoiceBillOrderDO.getOrderId()).getCustomerTotalPrice());
+                }
+                return  invoiceResultVO;
+            }).collect(Collectors.toList());
+            return ServerResult.success(invoiceResultVOList);
+        }
+        return ServerResult.success();
+    }
     @Transactional(rollbackFor = Exception.class)
     public void doRefuse(OrderFieldLockApplyDO applyDO, Long auditUserId, String refuseRemark) {
         applyDO.setAuditUserId(auditUserId);
@@ -519,7 +667,11 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
         applyDO.setRefuseRemark(refuseRemark);
         //应收款和应付款的申请,没有把orderId作为OrderFieldLockApplyDO的orderId,而是把InvoiceBillOrdeDO.getId()作为orderId来存储的。所以肯定查找不到。
         OrderBaseInfoDO orderBaseInfoDO = orderBaseInfoService.getById(applyDO.getOrderId());
-        if(!ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(applyDO.getType()) && !ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(applyDO.getType()) && !ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(applyDO.getType())){
+        if(!ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(applyDO.getType())
+                && !ApplyTypeEnum.CHECK_BILL_APPLY.getType().equals(applyDO.getType())
+                && !ApplyTypeEnum.DEPARTMENT_INVOICE_APPLY.getType().equals(applyDO.getType())
+                && !ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(applyDO.getType())
+                && !ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(applyDO.getType())){
             if (Objects.isNull(orderBaseInfoDO)) {
                 throw new BusinessException(ServerResultCode.ORDER_BASE_INFO_EMPTY);
             }
@@ -546,6 +698,15 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
         } else if (ApplyTypeEnum.INVOICE_BILL_APPLY.getType().equals(applyDO.getType())) {
             OrderLockFieldVO lockFieldVO =  JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
             InvoiceFieldVO invoiceBillOrderDO = lockFieldVO.getInvoiceFieldVO();
+            //查询是否存在未审核的扣款单。
+            List<OrderFieldLockApplyDO> InvoiceDeductUrlList = list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                    .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                    .in(OrderFieldLockApplyDO::getOrderId, invoiceBillOrderDO.getInvoiceId())
+                    .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.INVOICE_DEDUCT_URL.getType())
+                    .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT));
+            if(CollectionUtils.isNotEmpty(InvoiceDeductUrlList)){
+                throw new BusinessException("该Invoice存在未审批的扣款单,请先审批该对账单的扣款单!");
+            }
             List<InvoiceBillOrderDO> invoiceBillOrderDOList = invoiceBillOrderService.listByIds(invoiceBillOrderDO.getInvoiceId());
             if(CollectionUtils.isNotEmpty(invoiceBillOrderDOList)){
                 List<InvoiceBillOrderDO> invoiceBillOrderDOS = invoiceBillOrderDOList.stream().filter(Objects::nonNull).map(x -> {
@@ -586,6 +747,15 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             if(CollectionUtils.isNotEmpty(producePayCheckBillInvoiceUrlList)){
                 throw new BusinessException("该生产科对账单存在未审批的发票,请先审批该对账单的发票!");
             }
+            //查询是否存在未审核的扣款单。
+            List<OrderFieldLockApplyDO> InvoiceDeductUrlList = list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                    .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                    .in(OrderFieldLockApplyDO::getOrderId, producePaymentCheckBillId)
+                    .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.CHECK_DEDUCT_URL.getType())
+                    .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT));
+            if(CollectionUtils.isNotEmpty(InvoiceDeductUrlList)){
+                throw new BusinessException("该生产科对账单存在未审批的扣款单,请先审批该对账单的扣款单!");
+            }
             List<ProducePaymentCheckBillOrderDO> producePaymentCheckBillOrderDOList = checkBillOrderService.listByIds(producePaymentCheckBillId);
             if(CollectionUtils.isNotEmpty(producePaymentCheckBillOrderDOList)){
                 List<ProducePaymentCheckBillOrderDO>  producePaymentCheckBillOrderDOS= producePaymentCheckBillOrderDOList.stream().filter(Objects::nonNull).map(x -> {
@@ -642,6 +812,60 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             invoiceAndCheckBillSendEmailVO.setCheckBillOrderDO(invoiceInfoDO);
             invoiceAndCheckBillSendEmailVO.setRefuseRemark(refuseRemark);
             emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.CHECK_INVOICEURL_FAIL,invoiceAndCheckBillSendEmailVO,false);
+        }else if(ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(applyDO.getType())){
+            OrderLockFieldVO lockFieldVO = JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
+            DeductionUrlFieldVO deductionUrlFieldVO = lockFieldVO.getDeductionUrlFieldVO();
+            //得到旧的。
+            InvoiceBillOrderDO invoiceBillOrderDO=invoiceBillOrderService.getById(deductionUrlFieldVO.getId());
+            invoiceBillOrderDO.setInvoiceDeductUrlStatus(ApplyStatusEnum.AUDIT_REFUSE.getStatus());
+            //传递给审核一直都是最新的发票。
+            if(com.order.erp.common.utils.StringUtils.isNotBlank(invoiceBillOrderDO.getDeductUrl())){
+                if(Arrays.stream(invoiceBillOrderDO.getDeductUrl().split(",")).anyMatch(item->item.equals(deductionUrlFieldVO.getDeductUrl()))){
+                    // 将 invoiceUrls 分割成 List 并删除相同项
+                    List<String> urlList = new ArrayList<>(Arrays.asList(invoiceBillOrderDO.getDeductUrl().split(",")));
+                    urlList.removeIf(url -> url.equals(deductionUrlFieldVO.getDeductUrl()));
+
+                    // 将更新后的 List 转换回逗号分隔的字符串并重新设置
+                    String updatedInvoiceUrls = String.join(",", urlList);
+                    invoiceBillOrderDO.setDeductUrl(updatedInvoiceUrls);
+                }
+            }else{
+                invoiceBillOrderDO.setDeductUrl(null);
+            }
+            invoiceBillOrderService.updateById(invoiceBillOrderDO);
+            //发送邮件通知跟单员和业务员。
+            //发送邮箱通知财务。    这里这个邮箱通知财务,只能提示invoice号,因为一个invoice申请对应多个invoice号,所以会有多个内部编号和项目号等。
+            InvoiceAndCheckBillSendEmailVO invoiceAndCheckBillSendEmailVO = new InvoiceAndCheckBillSendEmailVO();
+            invoiceAndCheckBillSendEmailVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+            invoiceAndCheckBillSendEmailVO.setRefuseRemark(refuseRemark);
+            emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.INVOICE_FAIL,invoiceAndCheckBillSendEmailVO,false);
+        }else if(ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(applyDO.getType())){
+            OrderLockFieldVO lockFieldVO = JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
+            DeductionUrlFieldVO deductionUrlFieldVO = lockFieldVO.getDeductionUrlFieldVO();
+            //得到旧的。
+            ProducePaymentCheckBillOrderDO checkBillOrderDO=checkBillOrderService.getById(deductionUrlFieldVO.getId());
+            checkBillOrderDO.setCheckDeductUrlStatus(ApplyStatusEnum.AUDIT_REFUSE.getStatus());
+            //传递给审核一直都是最新的发票。
+            if(com.order.erp.common.utils.StringUtils.isNotBlank(checkBillOrderDO.getDeductUrl())){
+                if(Arrays.stream(checkBillOrderDO.getDeductUrl().split(",")).anyMatch(item->item.equals(deductionUrlFieldVO.getDeductUrl()))){
+                    // 将 invoiceUrls 分割成 List 并删除相同项
+                    List<String> urlList = new ArrayList<>(Arrays.asList(checkBillOrderDO.getDeductUrl().split(",")));
+                    urlList.removeIf(url -> url.equals(deductionUrlFieldVO.getDeductUrl()));
+
+                    // 将更新后的 List 转换回逗号分隔的字符串并重新设置
+                    String updatedInvoiceUrls = String.join(",", urlList);
+                    checkBillOrderDO.setDeductUrl(updatedInvoiceUrls);
+                }
+            }else{
+                checkBillOrderDO.setDeductUrl(null);
+            }
+            checkBillOrderService.updateById(checkBillOrderDO);
+            //发送邮件通知跟单员和业务员。
+            //发送邮箱通知财务。    这里这个邮箱通知财务,只能提示invoice号,因为一个invoice申请对应多个invoice号,所以会有多个内部编号和项目号等。
+            InvoiceAndCheckBillSendEmailVO invoiceAndCheckBillSendEmailVO = new InvoiceAndCheckBillSendEmailVO();
+            invoiceAndCheckBillSendEmailVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+            invoiceAndCheckBillSendEmailVO.setRefuseRemark(refuseRemark);
+            emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.CHECK_FAIL,invoiceAndCheckBillSendEmailVO,false);
         }
  
         OrderAuditLogDO auditLogDO = OrderAuditLogDO.builder().applyId(applyDO.getId()).orderId(applyDO.getOrderId()).optType(ApplyStatusEnum.AUDIT_REFUSE.getDesc()).build();
@@ -771,6 +995,15 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             OrderLockFieldVO lockFieldVO =  JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
             InvoiceFieldVO invoiceBillOrderDO = lockFieldVO.getInvoiceFieldVO();
             List<Long> invoiceId = invoiceBillOrderDO.getInvoiceId();
+            //查询是否存在未审核的扣款单。
+            List<OrderFieldLockApplyDO> InvoiceDeductUrlList = list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                    .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                    .in(OrderFieldLockApplyDO::getOrderId, invoiceId)
+                    .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.INVOICE_DEDUCT_URL.getType())
+                    .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT));
+            if(CollectionUtils.isNotEmpty(InvoiceDeductUrlList)){
+                throw new BusinessException("该Invoice存在未审批的扣款单,请先审批该对账单的扣款单!");
+            }
             List<InvoiceBillOrderDO> invoiceBillOrderDOS = invoiceBillOrderService.listByIds(invoiceId);
             if(CollectionUtils.isNotEmpty(invoiceBillOrderDOS)){
                 List<InvoiceBillOrderDO> invoiceeBillOrderDOs = invoiceBillOrderDOS.stream().filter(Objects::nonNull).map(x -> {
@@ -811,6 +1044,15 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             if(CollectionUtils.isNotEmpty(producePayCheckBillInvoiceUrlList)){
                 throw new BusinessException("该生产科对账单存在未审批的发票,请先审批该对账单的发票!");
             }
+            //查询是否存在未审核的扣款单。
+            List<OrderFieldLockApplyDO> checkDeductUrlList = list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                    .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                    .in(OrderFieldLockApplyDO::getOrderId, producePaymentCheckBillId)
+                    .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.CHECK_DEDUCT_URL.getType())
+                    .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT));
+            if(CollectionUtils.isNotEmpty(checkDeductUrlList)){
+                throw new BusinessException("该生产科对账单存在未审批的扣款单,请先审批该对账单的扣款单!");
+            }
             List<ProducePaymentCheckBillOrderDO> checkBillOrderDOS = checkBillOrderService.listByIds(producePaymentCheckBillId);
             if(CollectionUtils.isNotEmpty(checkBillOrderDOS)){
                 List<ProducePaymentCheckBillOrderDO> producePaymentCheckBillOrderDOS = checkBillOrderDOS.stream().filter(Objects::nonNull).map(x -> {
@@ -866,6 +1108,64 @@ public class OrderFieldLockApplyServiceImpl extends ServiceImpl&lt;OrderFieldLockAp
             InvoiceAndCheckBillSendEmailVO invoiceAndCheckBillSendEmailVO = new InvoiceAndCheckBillSendEmailVO();
             invoiceAndCheckBillSendEmailVO.setCheckBillOrderDO(invoiceInfoDO);
             emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.CHECK_INVOICEURL_PASS,invoiceAndCheckBillSendEmailVO,true);
+        }else if(ApplyTypeEnum.INVOICE_DEDUCT_URL.getType().equals(applyDO.getType())){
+            applyDO.setAuditUserId(auditUserId);
+            applyDO.setStatus(ApplyStatusEnum.AUDIT_PASS.getStatus());
+            OrderLockFieldVO lockFieldVO = JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
+            DeductionUrlFieldVO deductionUrlFieldVO = lockFieldVO.getDeductionUrlFieldVO();
+            //查询旧的。
+            InvoiceBillOrderDO invoiceBillOrderDO = invoiceBillOrderService.getById(deductionUrlFieldVO.getId());
+            invoiceBillOrderDO.setInvoiceDeductUrlStatus(ApplyStatusEnum.AUDIT_PASS.getStatus());
+            //传递给审核一直都是最新的发票。
+            if(com.order.erp.common.utils.StringUtils.isNotBlank(invoiceBillOrderDO.getDeductUrl())){
+                if(com.order.erp.common.utils.StringUtils.isNotBlank(deductionUrlFieldVO.getDeductUrl())){
+                    Set<String> deductUrlSet = new HashSet<>(Arrays.asList(
+                            org.apache.commons.lang3.StringUtils.defaultString(invoiceBillOrderDO.getDeductUrl()).split(",")));
+                    if(!deductUrlSet.contains(deductionUrlFieldVO.getDeductUrl())){
+                        deductUrlSet.add(deductionUrlFieldVO.getDeductUrl());
+                        String updateDeductUrl=String.join(",",deductUrlSet);
+                        invoiceBillOrderDO.setDeductUrl(updateDeductUrl);
+                    }
+                }
+            }else{
+                if(com.order.erp.common.utils.StringUtils.isNotBlank(deductionUrlFieldVO.getDeductUrl())){
+                    invoiceBillOrderDO.setDeductUrl(deductionUrlFieldVO.getDeductUrl());
+                }
+            }
+            invoiceBillOrderService.updateById(invoiceBillOrderDO);
+            //发送邮件通知跟单员和业务员以及财务。
+            InvoiceAndCheckBillSendEmailVO invoiceAndCheckBillSendEmailVO = new InvoiceAndCheckBillSendEmailVO();
+            invoiceAndCheckBillSendEmailVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+            emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.INVOICE_DEDUCTURL_PASS,invoiceAndCheckBillSendEmailVO,true);
+        }else if(ApplyTypeEnum.CHECK_DEDUCT_URL.getType().equals(applyDO.getType())){
+            applyDO.setAuditUserId(auditUserId);
+            applyDO.setStatus(ApplyStatusEnum.AUDIT_PASS.getStatus());
+            OrderLockFieldVO lockFieldVO = JSONObject.parseObject(applyDO.getFields(), OrderLockFieldVO.class);
+            DeductionUrlFieldVO deductionUrlFieldVO = lockFieldVO.getDeductionUrlFieldVO();
+            //查询旧的。
+            ProducePaymentCheckBillOrderDO checkBillOrderDO= checkBillOrderService.getById(deductionUrlFieldVO.getId());
+           checkBillOrderDO.setCheckDeductUrlStatus(ApplyStatusEnum.AUDIT_PASS.getStatus());
+            //传递给审核一直都是最新的发票。
+            if(com.order.erp.common.utils.StringUtils.isNotBlank(checkBillOrderDO.getDeductUrl())){
+                if(com.order.erp.common.utils.StringUtils.isNotBlank(deductionUrlFieldVO.getDeductUrl())){
+                    Set<String> deductUrlSet = new HashSet<>(Arrays.asList(
+                            org.apache.commons.lang3.StringUtils.defaultString(checkBillOrderDO.getDeductUrl()).split(",")));
+                    if(!deductUrlSet.contains(deductionUrlFieldVO.getDeductUrl())){
+                        deductUrlSet.add(deductionUrlFieldVO.getDeductUrl());
+                        String updateDeductUrl=String.join(",",deductUrlSet);
+                        checkBillOrderDO.setDeductUrl(updateDeductUrl);
+                    }
+                }
+            }else{
+                if(com.order.erp.common.utils.StringUtils.isNotBlank(deductionUrlFieldVO.getDeductUrl())){
+                    checkBillOrderDO.setDeductUrl(deductionUrlFieldVO.getDeductUrl());
+                }
+            }
+            checkBillOrderService.updateById(checkBillOrderDO);
+            //发送邮件通知跟单员和业务员以及财务。
+            InvoiceAndCheckBillSendEmailVO invoiceAndCheckBillSendEmailVO = new InvoiceAndCheckBillSendEmailVO();
+            invoiceAndCheckBillSendEmailVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+            emailSendUtils.sendInvoiceAndCheckEmail(FinanceOverEnum.CHECK_DEDUCTURL_PASS,invoiceAndCheckBillSendEmailVO,true);
         }
  
         OrderAuditLogDO auditLogDO = OrderAuditLogDO.builder().applyId(applyDO.getId()).orderId(applyDO.getOrderId()).optType(ApplyStatusEnum.AUDIT_PASS.getDesc()).build();
@@ -14,10 +14,7 @@ import com.order.erp.common.constant.Constant;
 import com.order.erp.common.constant.ServerResult;
 import com.order.erp.common.constant.ServerResultCode;
 import com.order.erp.common.exception.BusinessException;
-import com.order.erp.common.utils.DateUtils;
-import com.order.erp.common.utils.EmailSendUtils;
-import com.order.erp.common.utils.StringUtils;
-import com.order.erp.common.utils.TransactionHelper;
+import com.order.erp.common.utils.*;
 import com.order.erp.config.DataScope;
 import com.order.erp.domain.*;
 import com.order.erp.domain.dto.BaseDO;
@@ -33,6 +30,7 @@ import org.apache.poi.ss.usermodel.*;
 import org.apache.poi.ss.util.CellRangeAddress;
 import org.apache.poi.util.IOUtils;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.joda.time.DateTime;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
  
@@ -51,7 +49,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
  
 /**
- * 生产科对账单应收账单(ProducePaymentCheckBillOrder)表服务实现类
+ * 生产科对账单应付账单(ProducePaymentCheckBillOrder)表服务实现类
  *
  * @author makejava
  * @since 2024-08-05 16:26:35
@@ -818,7 +816,6 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
                     .orderId(x.getId())
                     .payedDate(createVO.getPayedDate())
                     .status(FinanceEnum.UNPAID_PAYMENTS.getStatus())
-                    .finishStatus(FinanceEnum.UNPAID_PAYMENTS.getStatus())
                     .productionName(x.getProductionDepartment())
                     .businesPerson(x.getBusinessPerson())
                     .trackerUser(x.getCreateBy())
@@ -898,6 +895,7 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
      */
     @Override
     public ServerResult updateDeductInfo(ProducePaymentCheckBillDeductInfoVO deductInfoVO) {
+        Long loginUserId = dataScope.getLoginUserId();
         if (Objects.isNull(deductInfoVO.getId())) {
             throw new BusinessException("id 不能为空");
         }
@@ -905,13 +903,57 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if (Objects.isNull(checkBillOrderDO)) {
             throw new BusinessException("应付款单据不存在");
         }
-        if(Objects.nonNull(checkBillOrderDO.getStatus()) && FinanceEnum.RECEIVED_PAYMENT.getStatus()==checkBillOrderDO.getStatus()){
+        if(Objects.nonNull(checkBillOrderDO.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())))){
             throw new BusinessException("应付款单据已审核通过,无法编辑");
         }
         //todo  已完成。
 //        checkCommitApply(deductInfoVO.getId());
         checkApply(new ArrayList<>(Arrays.asList(deductInfoVO.getId())));
-        //需要判断一下是否为空?不然知己以逗号分隔会报错。
+        //对扣款单进行审批。
+        checkCommitDeductionUrlApply(checkBillOrderDO.getId());
+        OrderLockFieldVO orderLockFieldVO = new OrderLockFieldVO();
+        DeductionUrlFieldVO deductionUrlFieldVO = new DeductionUrlFieldVO();
+        checkBillOrderDO.setDeductAmount((deductInfoVO.getDeductAmount()==null? BigDecimal.ZERO:deductInfoVO.getDeductAmount()).setScale(2, BigDecimal.ROUND_HALF_UP));
+        checkBillOrderDO.setActualPayedAmount((checkBillOrderDO.getTotalProductionAmount().subtract(deductInfoVO.getDeductAmount()==null? BigDecimal.ZERO:deductInfoVO.getDeductAmount())).setScale(2, BigDecimal.ROUND_HALF_UP));
+        checkBillOrderDO.setUnPayedAmount((checkBillOrderDO.getTotalProductionAmount().subtract(checkBillOrderDO.getDeductAmount()).subtract(checkBillOrderDO.getTotalActualPayedAmount())).setScale(2, BigDecimal.ROUND_HALF_UP));
+       if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
+           checkBillOrderDO.setCheckDeductUrlStatus(ApplyStatusEnum.WAIT_AUDIT.getStatus());
+       }
+       updateById(checkBillOrderDO);
+       if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
+           OrderBaseInfoDO orderBaseInfoDO = orderBaseInfoService.getById(checkBillOrderDO.getOrderId());
+           //以后对于文件类型,只存文件名,通过bucket每次实时访问。以前是设置过期时间很长,永久存在数据库中。
+           String urlFileName = SplitUrlGetBucketName.getUrlFileName(deductInfoVO.getDeductUrl());
+           //不保存,仅仅只是做一个审核,千万不要保存。目的是传递给审核最新的扣款单,审核通过后才保存,不通过则不保存。
+           checkBillOrderDO.setDeductUrl(urlFileName);
+           deductionUrlFieldVO.setCheckNo(checkBillOrderDO.getCheckNo());
+           if(Objects.nonNull(orderBaseInfoDO)){
+               deductionUrlFieldVO.setInnerNo(orderBaseInfoDO.getInnerNo());
+           }
+           deductionUrlFieldVO.setId(checkBillOrderDO.getId());
+           deductionUrlFieldVO.setBusinesPerson(checkBillOrderDO.getBusinesPerson());
+           deductionUrlFieldVO.setTrackerUser(checkBillOrderDO.getTrackerUser());
+           deductionUrlFieldVO.setFinancePerson(checkBillOrderDO.getFinancePerson());
+           deductionUrlFieldVO.setDeductUrl(urlFileName);
+           deductionUrlFieldVO.setProductionName(orderBaseInfoDO.getProductionDepartment());
+           orderLockFieldVO.setDeductionUrlFieldVO(deductionUrlFieldVO);
+           deductionUrlFieldVO.setDeductAmount(deductInfoVO.getDeductAmount());
+           OrderFieldLockApplyDO applyDO = OrderFieldLockApplyDO.builder()
+                   .applyUserId(loginUserId)
+                   .auditUserId(null)
+                   .fields(JSONObject.toJSONString(orderLockFieldVO))
+                   .orderId(checkBillOrderDO.getId())
+                   .type(ApplyTypeEnum.CHECK_DEDUCT_URL.getType())
+                   .remark(ApplyTypeEnum.CHECK_DEDUCT_URL.getDesc())
+                   .status(ApplyStatusEnum.WAIT_AUDIT.getStatus())
+                   .auditRoleCodes(RoleEnum.ADMIN.getCode() + Constant.COMMA_CHARACTER + RoleEnum.FINANCE_USER.getCode())
+                   .build();
+           orderFieldLockApplyService.save(applyDO);
+       }
+       return  ServerResult.success();
+
+        /*//需要判断一下是否为空?不然知己以逗号分隔会报错。
         if(StringUtils.isNotBlank(checkBillOrderDO.getDeductUrl())){
 //记住:需要修改数据表对应的字段deduct_url的varchar数据范围,修改为1000左右。
             if(StringUtils.isNotBlank(deductInfoVO.getDeductUrl())){
@@ -934,7 +976,7 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         checkBillOrderDO.setActualPayedAmount((checkBillOrderDO.getTotalProductionAmount().subtract(deductInfoVO.getDeductAmount()==null? BigDecimal.ZERO:deductInfoVO.getDeductAmount())).setScale(2, BigDecimal.ROUND_HALF_UP));
         checkBillOrderDO.setUnPayedAmount((checkBillOrderDO.getTotalProductionAmount().subtract(checkBillOrderDO.getDeductAmount()).subtract(checkBillOrderDO.getTotalActualPayedAmount())).setScale(2, BigDecimal.ROUND_HALF_UP));
         updateById(checkBillOrderDO);
-        return ServerResult.success();
+        return ServerResult.success();*/
     }
  
     /**
@@ -952,8 +994,9 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if (Objects.isNull(checkBillOrderDO)) {
             throw new BusinessException("应付款单据不存在");
         }
-        if(Objects.nonNull(checkBillOrderDO.getStatus()) && FinanceEnum.RECEIVED_PAYMENT.getStatus()==checkBillOrderDO.getStatus()){
-               throw new BusinessException("已完成付款,无法更新!");
+        if(Objects.nonNull(checkBillOrderDO.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())))){
+            throw new BusinessException("应付款单据已审核通过,无法编辑");
         }
         //todo  已完成。
 //        checkCommitApply(amountInfoVO.getId());
@@ -980,8 +1023,9 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if(Objects.isNull(checkBillOrderDO)){
             return ServerResult.fail("生产科对账单号不存在！");
         }
-        if(FinanceEnum.RECEIVED_PAYMENT.getStatus()==checkBillOrderDO.getStatus()){
-            throw new BusinessException("该订单已通过审核无法继续上传发票!");
+        if(Objects.nonNull(checkBillOrderDO.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())))){
+            throw new BusinessException("应付款单据已审核通过,无法编辑");
         }
         if(StringUtils.isBlank(invoiceInfoVO.getInvoiceUrl())){
             return ServerResult.success();
@@ -998,7 +1042,7 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
             checkBillOrderDO.setDepartmentInvoiceStatus(ApplyStatusEnum.WAIT_AUDIT.getStatus());
             updateById(checkBillOrderDO);
             //不保存,仅仅只是做一个审核,千万不要保存。目的是传递给审核的是最新的发票,审核通过才保存,不通过则不保存。
-            checkBillOrderDO.setInvoiceUrl(invoiceInfoVO.getInvoiceUrl());
+            checkBillOrderDO.setInvoiceUrl(SplitUrlGetBucketName.getUrlFileName(invoiceInfoVO.getInvoiceUrl()));
             //复制到producePaymentCheckBillVO。
             BeanUtils.copyProperties(checkBillOrderDO,producePaymentCheckBillVO);
             producePaymentCheckBillVO.setInnerNo(orderBaseInfoDO.getInnerNo());
@@ -1036,7 +1080,8 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if(!isTure){
             throw new BusinessException("勾选订单生产科需一致");
         }
-        boolean anyMatch = producePaymentCheckBillOrderDOList.stream().filter(Objects::nonNull).anyMatch(producePaymentCheckBillOrderDO -> FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus()));
+        boolean anyMatch = producePaymentCheckBillOrderDOList.stream().filter(Objects::nonNull).anyMatch(producePaymentCheckBillOrderDO -> ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())))
+                || (FinanceEnum.OK_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())));
         if(anyMatch){
             throw new BusinessException("订单中包含已付款的数据,无法提交！");
         }
@@ -1110,6 +1155,20 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
     }
  
     /**
+     * @param  id
+     *
+     */
+    private void checkCommitDeductionUrlApply(Long id){
+        List<OrderFieldLockApplyDO> orderFieldLockApplyDOList = orderFieldLockApplyService.list(new LambdaQueryWrapper<OrderFieldLockApplyDO>()
+                .eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
+                .eq(OrderFieldLockApplyDO::getType, ApplyTypeEnum.CHECK_DEDUCT_URL.getType())
+                .eq(OrderFieldLockApplyDO::getStatus, ApplyStatusEnum.WAIT_AUDIT.getStatus())
+                .eq(OrderFieldLockApplyDO::getOrderId, id));
+        if(CollectionUtils.isNotEmpty(orderFieldLockApplyDOList)){
+            throw new BusinessException("存在未审核的扣款单,请联系财务审批上一张扣款单再上传");
+        }
+    }
+    /**
      * @param producePaymentCheckBillFieldVO
      * @param userId
      * @return
@@ -1231,7 +1290,8 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if(!isTrue){
             throw new BusinessException("勾选订单的checkNo需一致");
         }
-        boolean anyPaid = checkBillOrderDOS.stream().anyMatch(checkBillOrderDO -> FinanceEnum.RECEIVED_PAYMENT.getStatus() == checkBillOrderDO.getStatus());
+        boolean anyPaid = checkBillOrderDOS.stream().anyMatch(checkBillOrderDO ->((FinanceEnum.  RECEIVED_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())))
+                || (FinanceEnum.OK_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())));
             if(anyPaid) {
                 throw new BusinessException("包含已付款的订单,无法删除!");
             }
@@ -1273,10 +1333,11 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         //获取每一个url的文件名称
         Arrays.stream(checkBillOrderDO.getDeductUrl().split(",")).forEach(x->{
             try{
-            String preUrl =  x.contains("?") ? x.split("\\?")[0] : x;
-            String fileName = preUrl.substring(preUrl.lastIndexOf("/") + 1);
+//            String preUrl =  x.contains("?") ? x.split("\\?")[0] : x;
+            String fileName = x.substring(x.lastIndexOf("/") + 1);
             String decodeUrl = URLDecoder.decode(fileName, StandardCharsets.UTF_8.name());
-            hashMap.put(decodeUrl,x);
+                String url = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x), decodeUrl, new DateTime().plusMinutes(Constant.TWO).toDate());
+                hashMap.put(decodeUrl,url);
         }catch(Exception e){
             throw  new BusinessException("文件名错误!");
         }
@@ -1304,10 +1365,11 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         //获取每一个url的文件名称
         Arrays.stream(checkBillOrderDO.getInvoiceUrl().split(",")).forEach(x->{
             try{
-                String preUrl =  x.contains("?") ? x.split("\\?")[0] : x;
-                String fileName = preUrl.substring(preUrl.lastIndexOf("/") + 1);
+//                String preUrl =  x.contains("?") ? x.split("\\?")[0] : x;
+                String fileName = x.substring(x.lastIndexOf("/") + 1);
                 String decodeUrl = URLDecoder.decode(fileName, StandardCharsets.UTF_8.name());
-                hashMap.put(decodeUrl,x);
+                String url = AliOssUtil.createUrl(SplitUrlGetBucketName.getBucket(x), decodeUrl, new DateTime().plusMinutes(Constant.TWO).toDate());
+                hashMap.put(decodeUrl,url);
             }catch(Exception e){
                 throw  new BusinessException("文件名错误!");
             }
@@ -1328,8 +1390,9 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
         if(Objects.isNull(checkBillOrderDO)){
             throw new BusinessException("生产科对账单不存在！");
         }
-        if(FinanceEnum.RECEIVED_PAYMENT.getStatus()==checkBillOrderDO.getStatus()){
-            throw new BusinessException("已完成付款,无法修改!");
+        if(Objects.nonNull(checkBillOrderDO.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(checkBillOrderDO.getStatus())))){
+            throw new BusinessException("生产科对账单据已审核通过,无法编辑");
         }
         //todo 要审核判断一下,判断是否处于审核状态。  已完成。
         checkApply(new ArrayList<>(Arrays.asList(createVO.getId())));
@@ -1363,8 +1426,9 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
             throw new BusinessException("生产科对账单不存在！");
         }
         checkApply(new ArrayList<>(Arrays.asList(deleteVo.getId())));
-        if(FinanceEnum.RECEIVED_PAYMENT.getStatus()==producePaymentCheckBillOrderDO.getStatus()){
-            throw new BusinessException("已完成付款,无法修改!");
+        if(Objects.nonNull(producePaymentCheckBillOrderDO.getStatus()) && ((FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())) ||
+                (FinanceEnum.OK_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())))){
+            throw new BusinessException("生产科对账单已审核通过,无法编辑");
         }
         producePaymentCheckBillOrderDO.setDeductUrl("");
         updateById(producePaymentCheckBillOrderDO);
@@ -1373,20 +1437,32 @@ public class ProducePaymentCheckBillOrderServiceImpl extends ServiceImpl&lt;Produce
  
     @Override
     public ServerResult isFinishStatus(ProducePaymentCheckBillInvoiceInfoVO producePaymentCheckBillInvoiceInfoVO) {
+        if(Objects.isNull(producePaymentCheckBillInvoiceInfoVO.getId())){
+            throw new BusinessException(ServerResultCode.PARAM_ERROR);
+        }
         ProducePaymentCheckBillOrderDO producePaymentCheckBillOrderDO = getById(producePaymentCheckBillInvoiceInfoVO.getId());
         if(Objects.nonNull(producePaymentCheckBillOrderDO)){
-            if(!FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())){
-                throw new BusinessException("该订单还没有完成最终付款,无法设置最终状态为已完成!");
+            if((!FinanceEnum.RECEIVED_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus())) && (!FinanceEnum.OK_PAYMENT.getStatus().equals(producePaymentCheckBillOrderDO.getStatus()))){
+                throw new BusinessException("该订单还没有审核通过,你无法设置最终状态为已付款!");
             }
             List<ProducePaymentCheckBillOrderDO> producePaymentCheckBillOrderDOList = list(new LambdaQueryWrapper<ProducePaymentCheckBillOrderDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
                     .eq(ProducePaymentCheckBillOrderDO::getStatus, FinanceEnum.RECEIVED_PAYMENT.getStatus())
                     .eq(ProducePaymentCheckBillOrderDO::getCheckNo, producePaymentCheckBillOrderDO.getCheckNo()));
             if(CollectionUtils.isNotEmpty(producePaymentCheckBillOrderDOList)){
                 List<ProducePaymentCheckBillOrderDO> producePaymentCheckBillOrderDOS = producePaymentCheckBillOrderDOList.stream().map(x -> {
-                    x.setFinishStatus(FinanceEnum.RECEIVED_PAYMENT.getStatus());
+                    x.setStatus(FinanceEnum.OK_PAYMENT.getStatus());
                     return x;
                 }).collect(Collectors.toList());
-                updateBatchById(producePaymentCheckBillOrderDOS);
+                List<Long> orderIds = producePaymentCheckBillOrderDOList.stream().map(ProducePaymentCheckBillOrderDO::getOrderId).collect(Collectors.toList());
+                List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(orderIds);
+                List<OrderBaseInfoDO> orderBaseInfoDOS = orderBaseInfoDOList.stream().map(order -> {
+                    order.setCheckStatus(FinanceEnum.OK_PAYMENT.getStatus());
+                    return order;
+                }).collect(Collectors.toList());
+                transactionHelper.run(() ->{
+                    updateBatchById(producePaymentCheckBillOrderDOS);
+                    orderBaseInfoService.updateBatchById(orderBaseInfoDOS);
+                });
             }
         }
         return ServerResult.success();
@@ -59,7 +59,7 @@ spring:
     testOnReturn: true
     password: eJ8(bD6]wN6=gI5=
     time-between-eviction-runs-millis: 1000
-    url: jdbc:mysql://47.104.8.35:3307/order-erp-test-real?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&useSSL=false&autoReconnect=true&failOverReadOnly=false&maxReconnects=10&allowMultiQueries=true&useAffectedRows=true&autoReconnectForPools=true
+    url: jdbc:mysql://47.104.8.35:3307/order-erp?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&useSSL=false&autoReconnect=true&failOverReadOnly=false&maxReconnects=10&allowMultiQueries=true&useAffectedRows=true&autoReconnectForPools=true
     username: root
   redis:
     database: 10
@@ -71,7 +71,7 @@ spring:
         max-wait: -1
         min-idle: 3
         time-between-eviction-runs: 100
-    password: ''
+    password: 445042a788dd
     port: 6380
     timeout: 2000
   mail:
@@ -176,8 +176,8 @@ file:
 # 阿里pss图片服务
 oss:
   endpoint: https://oss-cn-qingdao.aliyuncs.com
-  accessKeyId: LTAI5t7u1gXR2vm82sd6CkVz
-  accessKeySecret: m4NzHZZsZiauKmRO8y7DihmcGNdQk4
+  accessKeyId: LTAI5tHKVvrz1xxExYD7E3mo
+  accessKeySecret: q0m2RjNuzL4GGlUhK3P9qc2R0hZvIh
   bucket: test-alterego
  
  
@@ -80,7 +80,8 @@ spring:
     # 发送者邮箱，已开通POP3/SMTP服务的邮箱，也就是你自己的
     username: information@alterego.xin
     # 配置密码，注意不是真正的密码，而是刚刚申请到的授权码
-    password: AlterEgo1608ITf31
+#    password: AlterEgo1608ITf31
+    password: Y7AvfSJ1bcjYWXqF
     # 邮件接收者
     mailRecipient: #邮件接收者邮箱
     # 端口号465或587（QQ邮箱发送邮件仅支持587端口协议）
@@ -174,8 +175,8 @@ file:
 # 阿里pss图片服务
 oss:
   endpoint: https://oss-cn-qingdao.aliyuncs.com
-  accessKeyId: LTAI5t7u1gXR2vm82sd6CkVz
-  accessKeySecret: m4NzHZZsZiauKmRO8y7DihmcGNdQk4
+  accessKeyId: LTAI5tHKVvrz1xxExYD7E3mo
+  accessKeySecret: q0m2RjNuzL4GGlUhK3P9qc2R0hZvIh
   bucket: alterego
  
  
@@ -175,8 +175,8 @@ file:
 # 阿里pss图片服务
 oss:
   endpoint: https://oss-cn-qingdao.aliyuncs.com
-  accessKeyId: LTAI5t7u1gXR2vm82sd6CkVz
-  accessKeySecret: m4NzHZZsZiauKmRO8y7DihmcGNdQk4
+  accessKeyId: LTAI5tHKVvrz1xxExYD7E3mo
+  accessKeySecret: q0m2RjNuzL4GGlUhK3P9qc2R0hZvIh
   bucket: test-alterego
  
  
@@ -98,7 +98,7 @@
         i.status AS invoiceStatus,  -- invoice状态
         i.deduct_amount AS invoiceDeductAmount, -- 扣款金额
         i.notes AS invoiceNotes,   -- invoice备注
-        i.finish_status AS invoiceFinishStatus,
+        i.invoice_deduct_url_status AS invoiceDeductUrlStatus,
         -- 生产科付款信息
         p.id AS checkId,
         p.check_no AS checkNo,  -- checkNo编号
@@ -115,7 +115,7 @@
         p.deduct_url AS checkDeductUrl,    -- 扣款单
         p.notes AS checkNotes,             -- checkNo备注
         p.invoice_url AS checkInvoiceUrl,   -- 发票
-        p.finish_status AS checkFinishStatus
+        p.check_deduct_url_status AS checkDeductUrlStatus
         FROM order_base_info o
         LEFT JOIN invoice_bill_order AS i
         ON o.id = i.order_id AND i.enable_flag = 10
@@ -136,12 +136,6 @@
         <if test="queryVO.checkNoStatus != null">
             AND o.check_status = #{queryVO.checkNoStatus}
         </if>
-        <if test="queryVO.invoiceFinishStatus != null">
-            AND i.finish_status = #{queryVO.invoiceFinishStatus}
-        </if>
-        <if test="queryVO.checkFinishStatus != null">
-            AND p.finish_status = #{queryVO.checkFinishStatus}
-        </if>
         <if test="queryVO.customerCode != null and queryVO.customerCode.size > 0 ">
             AND o.customer_code IN
             <foreach collection="queryVO.customerCode" item="customerCode" open="(" separator="," close=")">
@@ -235,12 +229,6 @@
         <if test="queryVO.checkNoStatus != null">
             AND o.check_status = #{queryVO.checkNoStatus}
         </if>
-        <if test="queryVO.invoiceFinishStatus != null">
-            AND i.finish_status = #{queryVO.invoiceFinishStatus}
-        </if>
-        <if test="queryVO.checkFinishStatus != null">
-            AND p.finish_status = #{queryVO.checkFinishStatus}
-        </if>
         <if test="queryVO.customerCode != null and queryVO.customerCode.size > 0 ">
             AND o.customer_code IN
             <foreach collection="queryVO.customerCode" item="customerCode" open="(" separator="," close=")">
@@ -133,4 +133,83 @@
         opa.mid_check_result IS  NULL)
     </select>
  
+    <select id="countRecentYearByOrderInit" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (SELECT project_no, inner_no
+        FROM order_base_info
+        WHERE enable_flag = 10
+        AND (return_order != '1' OR return_order IS NULL)
+        GROUP BY project_no, inner_no) AS unique_combinations;
+    </select>
+
+    <select id="countRecentMonthValueByOrderInit" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (
+        SELECT project_no, inner_no
+        FROM order_base_info
+        WHERE enable_flag = 10
+        AND (return_order != '1' OR return_order IS NULL)  -- 处理 NULL 值
+        AND inner_no LIKE CONCAT('_____', #{dataYear}, '%')  -- 直接匹配年份
+        GROUP BY project_no, inner_no
+        ) AS unique_combinations;
+
+    </select>
+
+    <select id="countRecentDayByOrderInit" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (
+        SELECT project_no, inner_no
+        FROM order_base_info
+        WHERE enable_flag = 10
+        AND (return_order != '1' OR return_order IS NULL)
+        AND create_time >= #{startDate}
+        AND create_time <![CDATA[ < ]]> #{endDate}
+        AND inner_no LIKE CONCAT('_____', #{year}, '%')
+        GROUP BY project_no, inner_no
+        ) AS unique_combinations;
+
+    </select>
+
+    <select id="countAllYearByOrderStatus" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (
+                 SELECT project_no, inner_no
+                 FROM order_base_info
+                 WHERE enable_flag = 10
+                 AND (return_order != '1' OR return_order IS NULL)
+                 AND order_status=#{orderStatus}
+                 GROUP BY project_no, inner_no
+             ) AS unique_combinations;
+
+    </select>
+
+    <select id="countAllMonthByOrderStatus" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (
+                 SELECT project_no, inner_no
+                 FROM order_base_info
+                 WHERE enable_flag = 10
+                 AND (return_order != '1' OR return_order IS NULL)
+                 AND order_status=#{orderStatus}
+                 AND inner_no LIKE CONCAT('_____', #{dataYear}, '%')  -- 直接匹配年份
+                 GROUP BY project_no, inner_no
+             ) AS unique_combinations;
+
+    </select>
+
+    <select id="countAllDayvalueByOrderStatus" resultType="java.lang.Long">
+        SELECT COUNT(*)
+        FROM (
+                 SELECT project_no, inner_no
+                 FROM order_base_info
+                 WHERE enable_flag = 10
+                   AND (return_order != '1' OR return_order IS NULL)
+                   AND create_time >= #{startDate}
+                   AND create_time <![CDATA[ < ]]> #{endDate}
+                   AND order_status=#{orderStatus}
+                   AND inner_no LIKE CONCAT('_____', #{year}, '%')
+                 GROUP BY project_no, inner_no
+             ) AS unique_combinations;
+
+    </select>
 </mapper>