Merge remote-tracking branch 'origin/master'

src/main/java/com/jeeplus/modules/ruralprojectrecords/web/RuralProjectSignatureOldMessageDisposeController.java

@@ -40,16 +40,21 @@ import com.jeeplus.modules.workinvoice.entity.OMS.InvoiceDown.OMSInvoiceDetailIn
 import com.jeeplus.modules.workinvoice.entity.OMS.InvoiceOMSImportInfo;
 import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
 import com.jeeplus.modules.workinvoice.entity.OMS.OMSInvoiceResultDownloadData;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSRedInvoiceConfirmInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSRedInvoiceConfirmResponse;
 import com.jeeplus.modules.workinvoice.entity.TemporaryInvoiceInfo;
+import com.jeeplus.modules.workinvoice.service.OMS.OMSDisposeService;
 import com.jeeplus.modules.workinvoice.service.WorkInvoiceService;
 import com.jeeplus.modules.workinvoice.utils.HttpPostJsonUtil;
 import com.jeeplus.modules.workinvoice.utils.OMSNationUtil;
+import com.jeeplus.modules.workinvoice.utils.RedInvoiceScheduledTask;
 import com.jeeplus.modules.workinvoice.utils.ThreadPoolUtil;
 import com.jeeplus.modules.workreimbursement.service.WorkReimbursementService;
 import com.jeeplus.modules.workstaff.service.WorkStaffBasicInfoService;
 import freemarker.template.Configuration;
 import freemarker.template.Template;
 import org.activiti.engine.HistoryService;
+import org.apache.ibatis.annotations.Param;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.transaction.annotation.Transactional;
@@ -125,6 +130,8 @@ public class RuralProjectSignatureOldMessageDisposeController extends BaseContro
     private MilitaryIndustryConfidentialityService militaryIndustryConfidentialityService;
     @Autowired
     private WorkStaffBasicInfoService workStaffBasicInfoService;
+    @Autowired
+    private OMSDisposeService omsDisposeService;
 
     private static final String HTTPTOP = Global.getConfig("signature_http_top");
 
@@ -942,207 +949,56 @@ public class RuralProjectSignatureOldMessageDisposeController extends BaseContro
 
 
     /**
+     * 给accessToken查询的有效时间设置为1天
+     */
+    private final String appId = "hyc1";
+    private final String appKey = "hyc1";
+    private final String deptCode = "500102204228315131";
+
+    /**
+     * 开具蓝票
      * OMS发票测试 完整最终版【最终最终定稿，完全匹配你的所有要求】
      * 精准码值规则：
      * 0000=成功执行下载 | 9998=5次重试/30秒 | 0003=清token从头执行 | 0001/0002/其他码=直接执行兜底方法修改系统信息
+     * @param workInvoiceId   对应的应该是发票管理中的 id  即 work_invoice表中需要开票的id（这个id应该被传到redis中进行记录，方便后期回调的时候进行处理）
+     * @return
      */
     @RequestMapping(value = "/invoiceOMSView")
     @ResponseBody
     @Transactional(readOnly = false)
-    public Map<String,Object> invoiceOMSView(){
+    public Map<String,Object> invoiceOMSView(@Param("orderno") String workInvoiceId){
         Map<String,Object> map = new HashMap<>();
         // 调用抽离后的核心业务方法，实现流程复用（0003时可重新调用）
-        doInvoiceBusiness(map);
+        omsDisposeService.doInvoiceBusiness(map, workInvoiceId);
         return map;
     }
 
-    // ======================== 抽离核心业务流程：方便0003时从头重新调用 =========================
-    private void doInvoiceBusiness(Map<String,Object> map) {
-        int seconds = 86400;
-        Jedis jedis = null;
-        String accessToken = null;
-        try {
-            jedis = JedisUtils.getResource();
-            accessToken = jedis.get("OMSAccessToken");
-            if(StringUtils.isBlank(accessToken)){
-                // 获取AccessToken 9998重试5次
-                accessToken = getOmsAccessTokenWithRetry(5);
-                if(StringUtils.isNotBlank(accessToken)){
-                    jedis.setex("OMSAccessToken", seconds, accessToken);
-                    map.put("token状态", "重新获取token成功，存入Redis");
-                } else {
-                    accessToken = "";
-                    map.put("token状态", "获取token失败");
-                    return;
-                }
-            } else {
-                map.put("token状态", "从Redis获取token成功");
-            }
 
-            OMSNationUtil util = new OMSNationUtil();
-            String string = util.neatenData();
-
-            OMSAccessTokenInfo InvoiceTokenInfo = new OMSAccessTokenInfo();
-            InvoiceTokenInfo.setAppId("sscs");
-            InvoiceTokenInfo.setAppKey("sscs");
-            InvoiceTokenInfo.setExchangeId(UUID.randomUUID().toString());
-            InvoiceTokenInfo.setAccessToken(accessToken);
-            InvoiceTokenInfo.setData(string);
-            String jsonInvoiceStr = JSON.toJSONString(InvoiceTokenInfo);
-
-            String jsonInvoicResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/order/upload", jsonInvoiceStr);
-            System.out.println("✅ 订单提交接口返回值：" + jsonInvoicResultStr);
-            map.put("订单接口信息", jsonInvoicResultStr);
-
-            // 调用订单上传重试方法（包含所有码值规则）
-            if(StringUtils.isNotBlank(jsonInvoicResultStr)){
-                String finalAccessToken = accessToken;
-                String finalJsonInvoiceStr = jsonInvoiceStr;
-                executeOrderUploadRetry(5, jsonInvoicResultStr, finalJsonInvoiceStr, finalAccessToken, map);
-            }
 
-        } catch (Exception e) {
-            e.printStackTrace();
-            map.put("errorMsg", "系统异常：" + e.getMessage());
-        } finally {
-            if(jedis != null){
-                jedis.close();
-            }
-        }
-    }
 
-    // ======================== 原有方法1：获取AccessToken 9998重试5次【无修改】 =========================
-    private String getOmsAccessTokenWithRetry(int remainRetryTimes) {
-        try {
-            OMSAccessTokenInfo tokenInfo = new OMSAccessTokenInfo();
-            tokenInfo.setAppId("sscs");
-            tokenInfo.setAppKey("sscs");
-            tokenInfo.setExchangeId(UUID.randomUUID().toString());
-            String jsonStr = JSON.toJSONString(tokenInfo);
-            String accessTokenStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/server/accessToken", jsonStr);
-
-            if(StringUtils.isBlank(accessTokenStr)){
-                System.err.println("获取AccessToken失败：接口返回空，剩余重试次数："+remainRetryTimes);
-                return "";
-            }
 
-            OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(accessTokenStr, OMSAccessTokenInfo.class);
-            if(null == resultTokenInfo || null == resultTokenInfo.getResult()){
-                System.err.println("获取AccessToken失败：返回结果解析异常，剩余重试次数："+remainRetryTimes);
-                return "";
-            }
-
-            String code = resultTokenInfo.getResult().getCode();
-            if ("0000".equals(code)) {
-                String token = OMSNationUtil.extractAccessTokenFromBase64(resultTokenInfo.getData().toString());
-                System.out.println("✅ 获取AccessToken成功，重试次数剩余："+remainRetryTimes);
-                return token;
-            } else if ("9998".equals(code)) {
-                if (remainRetryTimes > 1) {
-                    int nextRetry = remainRetryTimes - 1;
-                    System.err.println("⚠️ 获取AccessToken返回9998接口波动，30秒后重试，剩余次数："+nextRetry);
-                    Thread.sleep(30 * 1000);
-                    return getOmsAccessTokenWithRetry(nextRetry);
-                } else {
-                    System.err.println("❌ 获取AccessToken失败：连续5次返回9998，重试次数耗尽！");
-                    return "";
-                }
-            } else {
-                System.err.println("❌ 获取AccessToken失败：返回业务错误码，code="+code);
-                return "";
-            }
-        } catch (InterruptedException e) {
-            System.err.println("❌ 获取AccessToken失败：重试延迟被中断");
-            Thread.currentThread().interrupt();
-            return "";
-        } catch (Exception e) {
-            e.printStackTrace();
-            System.err.println("❌ 获取AccessToken失败：调用接口异常，剩余重试次数："+remainRetryTimes);
-            return "";
-        }
-    }
-
-    // ======================== 核心修改【仅这一处，完美匹配你的最新要求】 =========================
-    private void executeOrderUploadRetry(int remainRetryTimes, String jsonInvoicResultStr, String jsonInvoiceStr, String accessToken, Map<String,Object> map) {
-        String jsonInvoicResult = "";
-        try {
-            OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(jsonInvoicResultStr, OMSAccessTokenInfo.class);
-            if(null == resultTokenInfo || null == resultTokenInfo.getResult()){
-                System.err.println("❌ 订单上传解析失败，剩余重试次数："+remainRetryTimes);
-                handleInvoiceRetryAllFail(accessToken); // 解析失败也执行兜底方法
-                return;
-            }
-            String code = resultTokenInfo.getResult().getCode();
-
-            // ======================== 所有码值规则 全部在这里【最终定稿】=========================
-            if ("0000".equals(code)) {
-                // ✅ 0000 成功：解析数据+存入map+触发30秒后异步下载发票
-                jsonInvoicResult = OMSNationUtil.extractAccessTokenFromBase64(resultTokenInfo.getData().toString());
-                map.put("订单接口返回值",jsonInvoicResult);
-                System.out.println("✅ 订单上传返回0000成功，触发发票下载接口");
-                ThreadPoolUtil.executeDelay(30, () -> {
-                    executeInvoiceDownloadWithRetry(5, accessToken);
-                });
-            } else if ("9998".equals(code)) {
-                // ✅ 9998 接口波动：延迟30秒+重新调用接口+重试次数-1，最多5次
-                if (remainRetryTimes > 1) {
-                    int nextRetry = remainRetryTimes - 1;
-                    System.err.println("⚠️ 订单上传返回9998接口波动，30秒后重试，剩余次数："+nextRetry);
-                    Thread.sleep(30 * 1000);
-                    String newResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/order/upload", jsonInvoiceStr);
-                    map.put("订单接口信息-重试"+(6-nextRetry), newResultStr);
-                    executeOrderUploadRetry(nextRetry, newResultStr, jsonInvoiceStr, accessToken, map);
-                } else {
-                    System.err.println("❌ 订单上传失败：连续5次9998，重试次数耗尽！");
-                    handleInvoiceRetryAllFail(accessToken); // 5次9998耗尽也执行兜底方法
-                    map.put("订单状态", "失败：接口波动次数超限");
-                }
-            } else if ("0003".equals(code)) {
-                // ✅ 0003 token失效：清除旧token → 重新获取token → 从头完整执行所有流程
-                System.err.println("⚠️ 订单上传返回0003（token失效），开始重新获取token并从头执行流程");
-                Jedis jedis = null;
-                try {
-                    jedis = JedisUtils.getResource();
-                    jedis.del("OMSAccessToken");
-                    map.put("0003处理", "已清除旧token，准备重新获取");
-                } catch (Exception e) {
-                    e.printStackTrace();
-                } finally {
-                    if(jedis != null) jedis.close();
-                }
-                doInvoiceBusiness(map);
-            } else {
-                // ✅ ✅ ✅ 核心修正：0001/0002/其他任意错误码 → 直接调用handleInvoiceRetryAllFail执行修改系统信息逻辑 ✅ ✅ ✅
-                System.err.println("❌ 订单上传返回业务错误码："+code+"(0001/0002等)，立即执行失败兜底逻辑修改系统信息！");
-                map.put("订单状态", "失败，错误码："+code);
-                handleInvoiceRetryAllFail(accessToken); // 关键：直接执行你的修改逻辑，不抛异常、不重试
-            }
-        } catch (InterruptedException e) {
-            System.err.println("❌ 订单上传重试被中断");
-            Thread.currentThread().interrupt();
-            handleInvoiceRetryAllFail(accessToken); // 中断也执行兜底方法
-        } catch (Exception e) {
-            e.printStackTrace();
-            System.err.println("❌ 订单上传重试异常，剩余次数："+remainRetryTimes);
-            handleInvoiceRetryAllFail(accessToken); // 异常也执行兜底方法
-        }
-    }
 
-    // ======================== 原有方法2：发票下载接口重试5次【无任何修改，一行未动】 =========================
-    private void executeInvoiceDownloadWithRetry(int remainingRetryTimes, String accessToken) {
+    /**
+     * 临时访问接口
+     * @param accessToken
+     * @param orderno
+     */
+    @RequestMapping(value = "/executeInvoiceDownload")
+    @ResponseBody
+    @Transactional(readOnly = false)
+    public void executeInvoiceDownload(String accessToken, String orderno) {
         try {
-            System.out.println("✅ 延迟执行成功，剩余重试次数：" + remainingRetryTimes + "，开始调用发票下载接口");
 
             OMSInvoiceResultDownloadData getInvoiceInfo = new OMSInvoiceResultDownloadData();
-            getInvoiceInfo.setDeptCode("7777");
-            getInvoiceInfo.setOrderno("fff79669f3774c2a8be557e909a746d5");
+            getInvoiceInfo.setDeptCode(deptCode);
+            getInvoiceInfo.setOrderno(orderno);
             getInvoiceInfo.setIsDetail("1");
             String jsonInvoiceInfoStr = JSON.toJSONString(getInvoiceInfo);
             String base64Str = Base64.getEncoder().encodeToString(jsonInvoiceInfoStr.getBytes(StandardCharsets.UTF_8));
 
             OMSAccessTokenInfo invoiceDownInfo = new OMSAccessTokenInfo();
-            invoiceDownInfo.setAppId("sscs");
-            invoiceDownInfo.setAppKey("sscs");
+            invoiceDownInfo.setAppId(appId);
+            invoiceDownInfo.setAppKey(appKey);
             invoiceDownInfo.setExchangeId(UUID.randomUUID().toString());
             invoiceDownInfo.setAccessToken(accessToken);
             invoiceDownInfo.setData(base64Str);
@@ -1152,7 +1008,6 @@ public class RuralProjectSignatureOldMessageDisposeController extends BaseContro
             System.out.println("发票开票结果invoiceResultStr：" + invoiceResultStr);
 
             String invoceDownJsonStr = null;
-            boolean isSuccess = false;
             if(StringUtils.isNotBlank(invoiceResultStr)){
                 OMSAccessTokenInfo resultDownInfo = JSON.parseObject(invoiceResultStr, OMSAccessTokenInfo.class);
                 if(null != resultDownInfo.getResult() && "0000".equals(resultDownInfo.getResult().getCode())){
@@ -1160,72 +1015,58 @@ public class RuralProjectSignatureOldMessageDisposeController extends BaseContro
                     if(StringUtils.isNotBlank(invoceDownJsonStr)){
                         OMSInvoiceDetailInfo invoiceInfo = JSONObject.parseObject(invoceDownJsonStr, OMSInvoiceDetailInfo.class);
                         if (invoiceInfo != null) {
-                            System.out.println("✅ 第"+(6-remainingRetryTimes)+"次调用发票接口成功，拿到有效数据！");
-                            System.out.println("getOfdUrl" + invoiceInfo.getOfdUrl());
-                            System.out.println("getPdfUrl" + invoiceInfo.getPdfUrl());
-                            System.out.println("getXmlUrl" + invoiceInfo.getXmlUrl());
-                            isSuccess = true;
+                            System.out.println("✅ 第1次调用发票接口成功，拿到有效数据！");
+                            System.out.println("allEinVno：" + invoiceInfo.getAllEinVno());  //数电票号码
+                            System.out.println("getOfdUrl：" + invoiceInfo.getOfdUrl());
+                            System.out.println("getPdfUrl：" + invoiceInfo.getPdfUrl());
+                            System.out.println("getXmlUrl：" + invoiceInfo.getXmlUrl());
                         }
                     }
                 }
             }
 
-            if (isSuccess) {
-                System.out.println("✅ 发票接口调用成功，重试流程结束，执行后续业务");
-                return;
-            } else {
-                if (remainingRetryTimes > 1) {
-                    int nextRetryTimes = remainingRetryTimes - 1;
-                    System.out.println("❌ 发票接口返回结果异常/数据未就绪，准备重试！剩余重试次数：" + nextRetryTimes);
-                    ThreadPoolUtil.executeDelay(30, () -> {
-                        executeInvoiceDownloadWithRetry(nextRetryTimes, accessToken);
-                    });
-                } else {
-                    System.err.println("❌ 发票接口调用失败，已重试5次全部失败，触发系统信息修改逻辑！");
-                    handleInvoiceRetryAllFail(accessToken);
-                }
-            }
+
 
         } catch (Exception e) {
             e.printStackTrace();
-            System.err.println("❌ 调用发票接口抛出异常，剩余重试次数：" + remainingRetryTimes);
-            if (remainingRetryTimes > 1) {
-                int nextRetryTimes = remainingRetryTimes - 1;
-                ThreadPoolUtil.executeDelay(30, () -> {
-                    executeInvoiceDownloadWithRetry(nextRetryTimes, accessToken);
-                });
-            } else {
-                System.err.println("❌ 发票接口调用抛出异常，已重试5次全部失败，触发系统信息修改逻辑！");
-                handleInvoiceRetryAllFail(accessToken);
-            }
         }
     }
 
-    // ======================== 原有方法3：失败兜底修改系统信息【无任何修改，你的业务逻辑写这里即可】 =========================
-    private void handleInvoiceRetryAllFail(String accessToken) {
-        // ============ 你的所有【修改系统信息/更新订单状态/写失败日志】逻辑 全部写在这里！！！ ============
-        try {
-            System.err.println("============ 开始执行【失败兜底-系统信息修改逻辑】 ============");
 
-            // 示例1：更新订单表的发票状态为【开票失败】
-            // orderService.updateInvoiceStatusByToken(accessToken, "99");
 
-            // 示例2：写入失败日志到数据库，方便人工排查和补偿处理
-            // invoiceFailLogService.saveFailLog(accessToken, "开票失败，错误码非0000/9998/0003", new Date());
 
-            // 示例3：标记该单据为异常，方便后台运维查看
-            // abnormalOrderService.saveAbnormalOrder(accessToken, "开票失败");
+    /**
+     * 开具红票(快速红冲)
+     * OMS发票测试 完整最终版【最终最终定稿，完全匹配你的所有要求】
+     * 精准码值规则：
+     * 0000=成功执行下载 | 9998=5次重试/30秒 | 0003=清token从头执行 | 0001/0002/其他码=直接执行兜底方法修改系统信息
+     */
+    @RequestMapping(value = "/invoiceFastRedOMSView")
+    @ResponseBody
+    @Transactional(readOnly = false)
+    public Map<String,Object> invoiceFastRedOMSView(String allEinvno){
+        Map<String,Object> map = new HashMap<>();
+        // 调用抽离后的核心业务方法，实现流程复用（0003时可重新调用）
+        omsDisposeService.doFastRedInvoiceBusiness(map, allEinvno);
+        return map;
+    }
 
-            // 示例4：调用其他系统接口，同步失败状态
-            // otherSystemApi.notifyInvoiceFail(accessToken);
 
-            System.err.println("============ 【失败兜底-系统信息修改逻辑】执行完成 ============");
 
-        } catch (Exception e) {
-            // 必加：捕获这个方法的异常，避免兜底方法报错导致线程异常
-            e.printStackTrace();
-            System.err.println("❌ 执行失败兜底方法时抛出异常：" + e.getMessage());
-        }
+
+    /**
+     * 开具红票(全场景红冲，包含已入账红冲处理。我方发起)
+     * @param applyNo   申请单号
+     * @return
+     */
+    @RequestMapping(value = "/invoiceAllScenarioRedOMSView")
+    @ResponseBody
+    @Transactional(readOnly = false)
+    public Map<String,Object> invoiceAllScenarioRedOMSView(String applyNo, String originalInvno){
+        Map<String,Object> map = new HashMap<>();
+        // 调用抽离后的核心业务方法，实现流程复用（0003时可重新调用）
+        omsDisposeService.doAllScenarioRedInvoiceBusiness(map, applyNo, originalInvno);
+        return map;
     }
 
 }

src/main/java/com/jeeplus/modules/workcalendar/service/WorkCalendarTaskService.java

@@ -13,6 +13,9 @@ import com.jeeplus.modules.sys.service.UserService;
 import com.jeeplus.modules.sys.utils.UserUtils;
 import com.jeeplus.modules.workcalendar.entity.WorkCalendar;
 import com.jeeplus.modules.workinvoice.entity.WorkInvoice;
+import com.jeeplus.modules.workinvoice.service.OMS.InvoiceDownloadService;
+import com.jeeplus.modules.workinvoice.service.OMS.RedInvoiceRetryScheduledService;
+import com.jeeplus.modules.workinvoice.service.OMS.RedInvoiceScheduledService;
 import com.jeeplus.modules.workinvoice.service.WorkInvoiceService;
 import com.jeeplus.modules.workstaff.service.WorkStaffBasicInfoService;
 import org.slf4j.Logger;
@@ -62,6 +65,15 @@ public class WorkCalendarTaskService  {
     @Autowired
     private MilitaryIndustryConfidentialityService militaryIndustryConfidentialityService;
 
+    @Autowired
+    private InvoiceDownloadService invoiceDownloadService;
+
+    @Autowired
+    private RedInvoiceScheduledService redInvoiceScheduledService;
+
+    @Autowired
+    private RedInvoiceRetryScheduledService redInvoiceRetryScheduledService;
+
     //@Scheduled(cron= "0 0/1 * * * ?")
     public void notifyTask() {
         logger.info("-----------定时任务开始------------------");
@@ -482,4 +494,34 @@ public class WorkCalendarTaskService  {
         System.out.println("文件清理完成，保留 handSignature 文件夹");
     }
 
+
+    // ========== 定时扫描Redis：每5分钟执行一次解析任务 ==========
+
+    /**
+     * 用于发票开票获取数电票信息处理
+     * 和开票系统相关的定时任务
+     */
+    //@Scheduled(cron = "0 */1 * * * ?")
+    public void processInvoiceDownloadTasks() {
+        invoiceDownloadService.processInvoiceDownloadTasks();
+    }
+
+    /**
+     * 用于发票开票红冲定时任务信息处理
+     * 和开票系统相关的定时任务
+     */
+    //@Scheduled(cron = "0 */3 * * * ?")
+    public void processRedInvoiceScheduledTask() {
+        redInvoiceScheduledService.processAllRedInvoiceTasks();
+    }
+
+    /**
+     * 用于发票开票时报9998错误时进行重新处理的方法
+     * 和开票系统相关的定时任务
+     */
+    //@Scheduled(cron = "0 */2 * * * ?")
+    public void redInvoiceRetryScheduledTask() {
+        redInvoiceRetryScheduledService.handleInvoice9998RetryTask();
+    }
+
 }

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSAllScenarioRedInvoiceInfo.java

@@ -0,0 +1,443 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import com.google.common.collect.Lists;
+
+import javax.validation.constraints.Pattern;
+import java.util.List;
+
+/**
+ * OMS全场景红票信息实体类
+ * 对应业务场景：全场景发票冲红操作的参数封装
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSAllScenarioRedInvoiceInfo {
+
+    /**
+     * 组织代码（必填）
+     * 所属组织唯一标识，长度1-20位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "组织代码deptCode为必填项，长度不能超过20位")
+    private String deptCode;
+
+    /**
+     * 申请单号（必填）
+     * 唯一标识，长度1-32位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,32}$", message = "申请单号applyNo为必填项，长度不能超过32位")
+    private String applyNo;
+
+    /**
+     * 申请方身份（必填）
+     * 0:销方 1:购方
+     */
+    @Pattern(regexp = "0|1", message = "申请方身份applyIdentity为必填项，只能传入0或1")
+    private String applyIdentity;
+
+    /**
+     * 销售方纳税人识别号（必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "销售方纳税人识别号sellerTaxno为必填项，长度不能超过20位")
+    private String sellerTaxno;
+
+    /**
+     * 销售方名称（必填）
+     * 长度1-100位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,100}$", message = "销售方名称sellerName为必填项，长度不能超过100位")
+    private String sellerName;
+
+    /**
+     * 购买方纳税人识别号（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "购买方纳税人识别号buyerTaxno只能传入：空 或 长度不超过20位的任意字符")
+    private String buyerTaxno;
+
+    /**
+     * 购买方名称（必填）
+     * 长度1-100位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,100}$", message = "购买方名称buyerName为必填项，长度不能超过100位")
+    private String buyerName;
+
+    /**
+     * 原蓝票发票代码（非必填）
+     * 原蓝票为增值税发票时必传，空或12位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{12}$", message = "原蓝票发票代码originalInvcode只能传入：空 或 12位纯数字")
+    private String originalInvcode;
+
+    /**
+     * 原蓝票发票号码（必填）
+     * 数电票传20位，增值税票传8位纯数字
+     */
+    @Pattern(regexp = "^\\d{8}$|^\\d{20}$", message = "原蓝票发票号码originalInvno为必填项，只能传入8位或20位纯数字")
+    private String originalInvno;
+
+    /**
+     * 原蓝票发票类型（必填）
+     * 可选值：01-数电票(增值税专用发票)、02-数电票(普通发票)、03-数电纸质发票(增值税专用发票)、04-数电纸质发票(普通发票)、
+     * 83-数电票(机动车销售统一发票)、84-数电票(二手车销售统一发票)、87-数电纸质发票(机动车销售统一发票)、
+     * 88-数电纸质发票(二手车销售统一发票)、05-增值税电子普通发票、06-增值税普通发票、07-增值税专用发票、
+     * 08-增值税电子专用发票、09-机动车统一销售发票、15-二手车统一销售发票
+     */
+    @Pattern(regexp = "01|02|03|04|83|84|87|88|05|06|07|08|09|15",
+            message = "原蓝票发票类型originalInvType为必填项，只能传入指定枚举值")
+    private String originalInvType;
+
+    /**
+     * 原蓝票金额（必填）
+     * 正数，保留两位小数
+     */
+    @Pattern(regexp = "^\\d+(\\.\\d{1,2})?$", message = "原蓝票金额originalInvAmount为必填项，只能传入正数且保留两位小数")
+    private String originalInvAmount;
+
+    /**
+     * 原蓝票税额（必填）
+     * 正数，保留两位小数
+     */
+    @Pattern(regexp = "^\\d+(\\.\\d{1,2})?$", message = "原蓝票税额originalInvTax为必填项，只能传入正数且保留两位小数")
+    private String originalInvTax;
+
+    /**
+     * 原蓝票开票日期（非必填）
+     * 格式：yyyy-MM-dd HH:mm:ss 或 yyyy-MM-dd
+     */
+    @Pattern(regexp = "^$|^\\d{4}-\\d{2}-\\d{2}( \\d{2}:\\d{2}:\\d{2})?$",
+            message = "原蓝票开票日期originalInvDate只能传入：空 或 格式为yyyy-MM-dd HH:mm:ss/yyyy-MM-dd的日期")
+    private String originalInvDate;
+
+    /**
+     * 冲红原因（必填）
+     * 01:开票有误 02:销货退回 03:服务中止 04:销售折让
+     */
+    @Pattern(regexp = "01|02|03|04", message = "冲红原因redReason为必填项，只能传入01/02/03/04")
+    private String redReason;
+
+    /**
+     * 合计金额（不含税）（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{1,2})?$", message = "合计金额（不含税）totalAmount为必填项，只能传入负数且保留两位小数")
+    private String totalAmount;
+
+    /**
+     * 合计税额（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{1,2})?$", message = "合计税额totalTax为必填项，只能传入负数且保留两位小数")
+    private String totalTax;
+
+    /**
+     * 价税合计（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{1,2})?$", message = "价税合计totalTaxamount为必填项，只能传入负数且保留两位小数")
+    private String totalTaxamount;
+
+    /**
+     * 原蓝票特定要素类型（非必填）
+     * 可选值：01-成品油发票、02-稀土发票、03-建筑服务发票、04-货物运输服务发票、05-不动产销售服务发票、
+     * 06-不动产租赁服务发票、07-代收车船税、08-通行费、09-旅客运输服务发票、10-医疗服务（住院）发票、
+     * 11-医疗服务（门诊）发票、12-自产农产品销售发票、13-拖拉机和联合收割机发票、14-机动车、15-二手车、
+     * 16-农产品收购发票、17-光伏收购发票、18-卷烟发票、31-二手车*、32-电子烟、51-二手车正向开具、52-二手车反向开具
+     */
+    @Pattern(regexp = "^$|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|31|32|51|52",
+            message = "原蓝票特定要素类型oriSpecificFactor只能传入：空 或 指定枚举值")
+    private String oriSpecificFactor;
+
+    /**
+     * 备用1（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "备用1spare1只能传入：空 或 长度不超过100位的任意字符")
+    private String spare1;
+
+    /**
+     * 备用2（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "备用2spare2只能传入：空 或 长度不超过100位的任意字符")
+    private String spare2;
+
+    /**
+     * 备用3（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "备用3spare3只能传入：空 或 长度不超过100位的任意字符")
+    private String spare3;
+
+    /**
+     * 备用4（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "备用4spare4只能传入：空 或 长度不超过100位的任意字符")
+    private String spare4;
+
+    /**
+     * 备用5（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "备用5spare5只能传入：空 或 长度不超过100位的任意字符")
+    private String spare5;
+
+    /**
+     * 开票人（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "开票人drawer只能传入：空 或 长度不超过20位的任意字符")
+    private String drawer;
+
+    /**
+     * 操作员（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "操作员operator只能传入：空 或 长度不超过20位的任意字符")
+    private String operator;
+
+    /**
+     * 是否自动开票（非必填）
+     * N:否 Y:是，默认N
+     */
+    @Pattern(regexp = "^$|N|Y", message = "是否自动开票autoMakeInv只能传入：空 或 N 或 Y")
+    private String autoMakeInv;
+
+    /**
+     * 红字发票类型（非必填）
+     * 原蓝票为增值税纸质发票时选填，可选值：01-数电票(增值税专用发票)、02-数电票(普通发票)、
+     * 03-数电纸质发票(增值税专用发票)、04-数电纸质发票(普通发票)、83-数电票(机动车销售统一发票)、
+     * 84-数电票(二手车销售统一发票)、87-数电纸质发票(机动车销售统一发票)、88-数电纸质发票(二手车销售统一发票)
+     */
+    @Pattern(regexp = "^$|01|02|03|04|83|84|87|88",
+            message = "红字发票类型redInvType只能传入：空 或 指定枚举值")
+    private String redInvType;
+
+    /**
+     * 红字发票详情信息
+     */
+    List<OMSApplyItem> applyItems = Lists.newArrayList();
+
+    public String getDeptCode() {
+        return deptCode;
+    }
+
+    public void setDeptCode(String deptCode) {
+        this.deptCode = deptCode;
+    }
+
+    public String getApplyNo() {
+        return applyNo;
+    }
+
+    public void setApplyNo(String applyNo) {
+        this.applyNo = applyNo;
+    }
+
+    public String getApplyIdentity() {
+        return applyIdentity;
+    }
+
+    public void setApplyIdentity(String applyIdentity) {
+        this.applyIdentity = applyIdentity;
+    }
+
+    public String getSellerTaxno() {
+        return sellerTaxno;
+    }
+
+    public void setSellerTaxno(String sellerTaxno) {
+        this.sellerTaxno = sellerTaxno;
+    }
+
+    public String getSellerName() {
+        return sellerName;
+    }
+
+    public void setSellerName(String sellerName) {
+        this.sellerName = sellerName;
+    }
+
+    public String getBuyerTaxno() {
+        return buyerTaxno;
+    }
+
+    public void setBuyerTaxno(String buyerTaxno) {
+        this.buyerTaxno = buyerTaxno;
+    }
+
+    public String getBuyerName() {
+        return buyerName;
+    }
+
+    public void setBuyerName(String buyerName) {
+        this.buyerName = buyerName;
+    }
+
+    public String getOriginalInvcode() {
+        return originalInvcode;
+    }
+
+    public void setOriginalInvcode(String originalInvcode) {
+        this.originalInvcode = originalInvcode;
+    }
+
+    public String getOriginalInvno() {
+        return originalInvno;
+    }
+
+    public void setOriginalInvno(String originalInvno) {
+        this.originalInvno = originalInvno;
+    }
+
+    public String getOriginalInvType() {
+        return originalInvType;
+    }
+
+    public void setOriginalInvType(String originalInvType) {
+        this.originalInvType = originalInvType;
+    }
+
+    public String getOriginalInvAmount() {
+        return originalInvAmount;
+    }
+
+    public void setOriginalInvAmount(String originalInvAmount) {
+        this.originalInvAmount = originalInvAmount;
+    }
+
+    public String getOriginalInvTax() {
+        return originalInvTax;
+    }
+
+    public void setOriginalInvTax(String originalInvTax) {
+        this.originalInvTax = originalInvTax;
+    }
+
+    public String getOriginalInvDate() {
+        return originalInvDate;
+    }
+
+    public void setOriginalInvDate(String originalInvDate) {
+        this.originalInvDate = originalInvDate;
+    }
+
+    public String getRedReason() {
+        return redReason;
+    }
+
+    public void setRedReason(String redReason) {
+        this.redReason = redReason;
+    }
+
+    public String getTotalAmount() {
+        return totalAmount;
+    }
+
+    public void setTotalAmount(String totalAmount) {
+        this.totalAmount = totalAmount;
+    }
+
+    public String getTotalTax() {
+        return totalTax;
+    }
+
+    public void setTotalTax(String totalTax) {
+        this.totalTax = totalTax;
+    }
+
+    public String getTotalTaxamount() {
+        return totalTaxamount;
+    }
+
+    public void setTotalTaxamount(String totalTaxamount) {
+        this.totalTaxamount = totalTaxamount;
+    }
+
+    public String getOriSpecificFactor() {
+        return oriSpecificFactor;
+    }
+
+    public void setOriSpecificFactor(String oriSpecificFactor) {
+        this.oriSpecificFactor = oriSpecificFactor;
+    }
+
+    public String getSpare1() {
+        return spare1;
+    }
+
+    public void setSpare1(String spare1) {
+        this.spare1 = spare1;
+    }
+
+    public String getSpare2() {
+        return spare2;
+    }
+
+    public void setSpare2(String spare2) {
+        this.spare2 = spare2;
+    }
+
+    public String getSpare3() {
+        return spare3;
+    }
+
+    public void setSpare3(String spare3) {
+        this.spare3 = spare3;
+    }
+
+    public String getSpare4() {
+        return spare4;
+    }
+
+    public void setSpare4(String spare4) {
+        this.spare4 = spare4;
+    }
+
+    public String getSpare5() {
+        return spare5;
+    }
+
+    public void setSpare5(String spare5) {
+        this.spare5 = spare5;
+    }
+
+    public String getDrawer() {
+        return drawer;
+    }
+
+    public void setDrawer(String drawer) {
+        this.drawer = drawer;
+    }
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    public String getAutoMakeInv() {
+        return autoMakeInv;
+    }
+
+    public void setAutoMakeInv(String autoMakeInv) {
+        this.autoMakeInv = autoMakeInv;
+    }
+
+    public String getRedInvType() {
+        return redInvType;
+    }
+
+    public void setRedInvType(String redInvType) {
+        this.redInvType = redInvType;
+    }
+
+    public List<OMSApplyItem> getApplyItems() {
+        return applyItems;
+    }
+
+    public void setApplyItems(List<OMSApplyItem> applyItems) {
+        this.applyItems = applyItems;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSApplyItem.java

@@ -0,0 +1,298 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import javax.validation.constraints.Pattern;
+import java.math.BigDecimal;
+
+/**
+ * OMS发票冲红申请明细实体类
+ * 对应业务场景：发票冲红申请的商品明细参数封装
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSApplyItem {
+
+    /**
+     * 行号（必填）
+     * 明细行号，仅作为唯一标识使用；最终确认单中的明细顺序以请求报文中的明细顺序为准
+     * 长度8位，支持数字或字符
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,8}$", message = "行号lineCode为必填项，长度不能超过8位")
+    private String lineCode;
+
+    /**
+     * 商品名称（必填）
+     * 长度1-90位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,90}$", message = "商品名称goodsName为必填项，长度不能超过90位")
+    private String goodsName;
+
+    /**
+     * 规格型号（非必填）
+     * 原蓝票类型为机动车销售统一发票或特定要素为14、15、31时必传车架号；长度1-40位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,40}$", message = "规格型号model只能传入：空 或 长度不超过40位的任意字符（特定场景下需传车架号）")
+    private String model;
+
+    /**
+     * 计量单位（非必填）
+     * 特定要素为14、15、31时，填写“辆”；长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "计量单位unit只能传入：空 或 长度不超过20位的任意字符（特定场景下需填“辆”）")
+    private String unit;
+
+    /**
+     * 数量（非必填）
+     * 负数，最大12位整数（小数最多4位）或整数最多3位（小数最多13位）；特定要素为14、15、31时填写-1
+     */
+    @Pattern(regexp = "^$|-\\d+(\\.\\d{1,13})?$", message = "数量qty只能传入：空 或 负数（格式如-123.45，整数最多12位/小数最多13位，特定场景下填-1）")
+    private BigDecimal qty;
+
+    /**
+     * 单价（非必填）
+     * 数字，最大12位整数（小数最多4位）或整数最多3位（小数最多13位）
+     */
+    @Pattern(regexp = "^$|\\d+(\\.\\d{1,13})?$", message = "单价price只能传入：空 或 数字（格式如123.45，整数最多12位/小数最多13位）")
+    private BigDecimal price;
+
+    /**
+     * 含税单价（非必填）
+     * 数字，最大12位整数（小数最多4位）或整数最多3位（小数最多13位）
+     */
+    @Pattern(regexp = "^$|\\d+(\\.\\d{1,13})?$", message = "含税单价taxprice只能传入：空 或 数字（格式如123.45，整数最多12位/小数最多13位）")
+    private BigDecimal taxprice;
+
+    /**
+     * 金额（不含税）（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "金额（不含税）amount为必填项，只能传入负数且保留两位小数（如-123.45）")
+    private BigDecimal amount;
+
+    /**
+     * 税率（必填）
+     * 最多3位小数，格式如0.13、13.00
+     */
+    @Pattern(regexp = "^\\d+(\\.\\d{1,3})$", message = "税率taxrate为必填项，最多保留3位小数（如0.13、13.00）")
+    private BigDecimal taxrate;
+
+    /**
+     * 税额（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "税额tax为必填项，只能传入负数且保留两位小数（如-12.34）")
+    private BigDecimal tax;
+
+    /**
+     * 含税金额（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "含税金额taxamount为必填项，只能传入负数且保留两位小数（如-135.79）")
+    private BigDecimal taxamount;
+
+    /**
+     * 优惠政策标识（非必填）
+     * 可选值：01-简易征收;02-稀土产品;03-免税;04-不征税;05-先征后退;06-100%先征后退;07-50%先征后退;08-按3%简易征收;09-按5%简易征收;10-按5%简易征收减按1.5%计征;11-即征即退30%;12-即征即退50%;13-即征即退70%;14-即征即退100%;15-超税负3%即征即退;16-超税负8%即征即退;17-超税负12%即征即退;18-超税负6%即征即退
+     */
+    @Pattern(regexp = "^$|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18",
+            message = "优惠政策标识taxpre只能传入：空 或 指定枚举值（如01-简易征收）")
+    private String taxpre;
+
+    /**
+     * 税收分类编码（必填）
+     * 长度1-19位，纯数字
+     */
+    @Pattern(regexp = "^\\d{1,19}$", message = "税收分类编码goodstaxno为必填项，只能传入1-19位纯数字")
+    private String goodstaxno;
+
+    /**
+     * 对应蓝票明细行序号（必填）
+     * 长度8位，纯数字
+     */
+    @Pattern(regexp = "^\\d{8}$", message = "对应蓝票明细行序号oriLineCode为必填项，只能传入8位纯数字")
+    private String oriLineCode;
+
+    /**
+     * 明细备用1（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "明细备用1itemspare1只能传入：空 或 长度不超过100位的任意字符")
+    private String itemspare1;
+
+    /**
+     * 明细备用2（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "明细备用2itemspare2只能传入：空 或 长度不超过100位的任意字符")
+    private String itemspare2;
+
+    /**
+     * 明细备用3（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "明细备用3itemspare3只能传入：空 或 长度不超过100位的任意字符")
+    private String itemspare3;
+
+    /**
+     * 明细备用4（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "明细备用4itemspare4只能传入：空 或 长度不超过100位的任意字符")
+    private String itemspare4;
+
+    /**
+     * 明细备用5（非必填）
+     * 预留字段，长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "明细备用5itemspare5只能传入：空 或 长度不超过100位的任意字符")
+    private String itemspare5;
+
+    public String getLineCode() {
+        return lineCode;
+    }
+
+    public void setLineCode(String lineCode) {
+        this.lineCode = lineCode;
+    }
+
+    public String getGoodsName() {
+        return goodsName;
+    }
+
+    public void setGoodsName(String goodsName) {
+        this.goodsName = goodsName;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public String getUnit() {
+        return unit;
+    }
+
+    public void setUnit(String unit) {
+        this.unit = unit;
+    }
+
+    public BigDecimal getQty() {
+        return qty;
+    }
+
+    public void setQty(BigDecimal qty) {
+        this.qty = qty;
+    }
+
+    public BigDecimal getPrice() {
+        return price;
+    }
+
+    public void setPrice(BigDecimal price) {
+        this.price = price;
+    }
+
+    public BigDecimal getTaxprice() {
+        return taxprice;
+    }
+
+    public void setTaxprice(BigDecimal taxprice) {
+        this.taxprice = taxprice;
+    }
+
+    public BigDecimal getAmount() {
+        return amount;
+    }
+
+    public void setAmount(BigDecimal amount) {
+        this.amount = amount;
+    }
+
+    public BigDecimal getTaxrate() {
+        return taxrate;
+    }
+
+    public void setTaxrate(BigDecimal taxrate) {
+        this.taxrate = taxrate;
+    }
+
+    public BigDecimal getTax() {
+        return tax;
+    }
+
+    public void setTax(BigDecimal tax) {
+        this.tax = tax;
+    }
+
+    public BigDecimal getTaxamount() {
+        return taxamount;
+    }
+
+    public void setTaxamount(BigDecimal taxamount) {
+        this.taxamount = taxamount;
+    }
+
+    public String getTaxpre() {
+        return taxpre;
+    }
+
+    public void setTaxpre(String taxpre) {
+        this.taxpre = taxpre;
+    }
+
+    public String getGoodstaxno() {
+        return goodstaxno;
+    }
+
+    public void setGoodstaxno(String goodstaxno) {
+        this.goodstaxno = goodstaxno;
+    }
+
+    public String getOriLineCode() {
+        return oriLineCode;
+    }
+
+    public void setOriLineCode(String oriLineCode) {
+        this.oriLineCode = oriLineCode;
+    }
+
+    public String getItemspare1() {
+        return itemspare1;
+    }
+
+    public void setItemspare1(String itemspare1) {
+        this.itemspare1 = itemspare1;
+    }
+
+    public String getItemspare2() {
+        return itemspare2;
+    }
+
+    public void setItemspare2(String itemspare2) {
+        this.itemspare2 = itemspare2;
+    }
+
+    public String getItemspare3() {
+        return itemspare3;
+    }
+
+    public void setItemspare3(String itemspare3) {
+        this.itemspare3 = itemspare3;
+    }
+
+    public String getItemspare4() {
+        return itemspare4;
+    }
+
+    public void setItemspare4(String itemspare4) {
+        this.itemspare4 = itemspare4;
+    }
+
+    public String getItemspare5() {
+        return itemspare5;
+    }
+
+    public void setItemspare5(String itemspare5) {
+        this.itemspare5 = itemspare5;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSFastRedInvoiceInfo.java

@@ -0,0 +1,131 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import javax.validation.constraints.Pattern;
+
+/**
+ * OMS快捷红票信息实体类
+ * 对应业务场景：发票冲红操作的参数封装
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSFastRedInvoiceInfo {
+
+    /**
+     * 组织代码（必填）
+     * 规则：非空 + 最大长度20位，支持任意字符
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "组织代码deptCode为必填项，且长度不能超过20位")
+    private String deptCode;
+
+    /**
+     * 发票代码
+     * 规则：可为空，若传值则为12位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{12}$", message = "发票代码invcode只能传入：空 或 12位纯数字")
+    private String invcode;
+
+    /**
+     * 发票号码
+     * 规则：可为空，若传值则为8位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{8}$", message = "发票号码invno只能传入：空 或 8位纯数字")
+    private String invno;
+
+    /**
+     * 数电发票号码
+     * 规则：可为空，若传值则为20位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{20}$", message = "数电发票号码allEinvno只能传入：空 或 20位纯数字")
+    private String allEinvno;
+
+    /**
+     * 冲红原因
+     * 规则：可为空，若传值只能是 01/02/03/04
+     * 可选值：01-开票有误，02-销货退回，03-服务中止，04-销售折让
+     */
+    @Pattern(regexp = "^$|01|02|03|04", message = "冲红原因redReason只能传入：空 或 01 或 02 或 03 或 04")
+    private String redReason;
+
+    /**
+     * 红字确认信息单编号
+     * 规则：可为空，若传值则为32位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{32}$", message = "红字确认信息单编号redNo只能传入：空 或 32位纯数字")
+    private String redNo;
+
+    /**
+     * 红字发票类型
+     * 规则：可为空，若传值为指定枚举值
+     */
+    @Pattern(regexp = "^$|01|02|03|04|83|84|87|88", message = "红字发票类型redInvType只能传入：空 或 01 或 02 或 03 或 04 或 83 或 84 或 87 或 88")
+    private String redInvType;
+
+    /**
+     * 开票员
+     * 规则：可为空，若传值则最大长度20位，支持任意字符
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "开票员drawer只能传入：空 或 长度不超过20位的任意字符")
+    private String drawer;
+
+    public String getDeptCode() {
+        return deptCode;
+    }
+
+    public void setDeptCode(String deptCode) {
+        this.deptCode = deptCode;
+    }
+
+    public String getInvcode() {
+        return invcode;
+    }
+
+    public void setInvcode(String invcode) {
+        this.invcode = invcode;
+    }
+
+    public String getInvno() {
+        return invno;
+    }
+
+    public void setInvno(String invno) {
+        this.invno = invno;
+    }
+
+    public String getAllEinvno() {
+        return allEinvno;
+    }
+
+    public void setAllEinvno(String allEinvno) {
+        this.allEinvno = allEinvno;
+    }
+
+    public String getRedReason() {
+        return redReason;
+    }
+
+    public void setRedReason(String redReason) {
+        this.redReason = redReason;
+    }
+
+    public String getRedNo() {
+        return redNo;
+    }
+
+    public void setRedNo(String redNo) {
+        this.redNo = redNo;
+    }
+
+    public String getRedInvType() {
+        return redInvType;
+    }
+
+    public void setRedInvType(String redInvType) {
+        this.redInvType = redInvType;
+    }
+
+    public String getDrawer() {
+        return drawer;
+    }
+
+    public void setDrawer(String drawer) {
+        this.drawer = drawer;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSRedInvoiceConfirmApplyItem.java

@@ -0,0 +1,254 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import javax.validation.constraints.Pattern;
+
+/**
+ * OMS红字确认单返回接口的商品明细子类
+ * 对应业务场景：红字确认单返回数据中的商品明细信息
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSRedInvoiceConfirmApplyItem {
+
+    /**
+     * 商品名称（必填）
+     * 长度1-90位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,90}$", message = "商品名称goodsName为必填项，长度不能超过90位")
+    private String goodsName;
+
+    /**
+     * 规格型号（非必填）
+     * 特定要素为14、15、31时，此字段为车辆识别代号/车架号码；长度1-40位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,40}$", message = "规格型号model只能传入：空 或 长度不超过40位的任意字符（特定场景下为车架号）")
+    private String model;
+
+    /**
+     * 计量单位（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "计量单位unit只能传入：空 或 长度不超过20位的任意字符")
+    private String unit;
+
+    /**
+     * 数量（非必填）
+     * 整数最多20位，小数最多10位；冲红场景下可为负数
+     */
+    @Pattern(regexp = "^$|^-?\\d+(\\.\\d{1,10})?$", message = "数量qty只能传入：空 或 整数最多20位、小数最多10位的数字（可正可负）")
+    private String qty;
+
+    /**
+     * 单价（非必填）
+     * 整数最多20位，小数最多10位
+     */
+    @Pattern(regexp = "^$|^\\d+(\\.\\d{1,10})?$", message = "单价price只能传入：空 或 整数最多20位、小数最多10位的数字")
+    private String price;
+
+    /**
+     * 金额（不含税）（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "金额（不含税）amount为必填项，只能传入负数且保留两位小数（如-123.45）")
+    private String amount;
+
+    /**
+     * 税率（必填）
+     * 整数最多16位，小数最多3位
+     */
+    @Pattern(regexp = "^\\d+(\\.\\d{1,3})$", message = "税率taxrate为必填项，最多保留3位小数（如0.13、13.00）")
+    private String taxrate;
+
+    /**
+     * 税额（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "税额tax为必填项，只能传入负数且保留两位小数（如-12.34）")
+    private String tax;
+
+    /**
+     * 优惠政策标识（非必填）
+     * 可选值：01-简易征收;02-稀土产品;03-免税;04-不征税;05-先征后退;06-100%先征后退;07-50%先征后退;
+     * 08-按3%简易征收;09-按5%简易征收;10-按5%简易征收减按1.5%计征;11-即征即退30%;12-即征即退50%;
+     * 13-即征即退70%;14-即征即退100%;15-超税负3%即征即退;16-超税负8%即征即退;17-超税负12%即征即退;18-超税负6%即征即退
+     */
+    @Pattern(regexp = "^$|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18",
+            message = "优惠政策标识taxpre只能传入：空 或 指定枚举值（如01-简易征收）")
+    private String taxpre;
+
+    /**
+     * 税收分类编码（必填）
+     * 长度1-19位，纯数字
+     */
+    @Pattern(regexp = "^\\d{1,19}$", message = "税收分类编码goodstaxno为必填项，只能传入1-19位纯数字")
+    private String goodstaxno;
+
+    /**
+     * 税收分类编码简称（非必填）
+     * 长度1-100位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,100}$", message = "税收分类编码简称codeAbb只能传入：空 或 长度不超过100位的任意字符")
+    private String codeAbb;
+
+    /**
+     * 项目名称（非必填）
+     * 不定长，最多1000位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,1000}$", message = "项目名称detailGoodsName只能传入：空 或 长度不超过1000位的任意字符")
+    private String detailGoodsName;
+
+    /**
+     * 行号（非必填）
+     * 长度1-8位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,8}$", message = "行号lineCode只能传入：空 或 长度不超过8位的任意字符")
+    private String lineCode;
+
+    /**
+     * 对应蓝字发票明细行号（非必填）
+     * 长度8位，纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{8}$", message = "对应蓝字发票明细行号oriLineCode只能传入：空 或 8位纯数字")
+    private String oriLineCode;
+
+    /**
+     * 原蓝票开票日期（非必填）
+     * 格式：yyyy-mm-dd hh:mm:ss
+     */
+    @Pattern(regexp = "^$|^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$",
+            message = "原蓝票开票日期originalInvDate只能传入：空 或 格式为yyyy-mm-dd hh:mm:ss的日期")
+    private String originalInvDate;
+
+    /**
+     * 开票失败原因（非必填）
+     * 不定长，最多1000位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,1000}$", message = "开票失败原因failCause只能传入：空 或 长度不超过1000位的任意字符")
+    private String failCause;
+
+    public String getGoodsName() {
+        return goodsName;
+    }
+
+    public void setGoodsName(String goodsName) {
+        this.goodsName = goodsName;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public String getUnit() {
+        return unit;
+    }
+
+    public void setUnit(String unit) {
+        this.unit = unit;
+    }
+
+    public String getQty() {
+        return qty;
+    }
+
+    public void setQty(String qty) {
+        this.qty = qty;
+    }
+
+    public String getPrice() {
+        return price;
+    }
+
+    public void setPrice(String price) {
+        this.price = price;
+    }
+
+    public String getAmount() {
+        return amount;
+    }
+
+    public void setAmount(String amount) {
+        this.amount = amount;
+    }
+
+    public String getTaxrate() {
+        return taxrate;
+    }
+
+    public void setTaxrate(String taxrate) {
+        this.taxrate = taxrate;
+    }
+
+    public String getTax() {
+        return tax;
+    }
+
+    public void setTax(String tax) {
+        this.tax = tax;
+    }
+
+    public String getTaxpre() {
+        return taxpre;
+    }
+
+    public void setTaxpre(String taxpre) {
+        this.taxpre = taxpre;
+    }
+
+    public String getGoodstaxno() {
+        return goodstaxno;
+    }
+
+    public void setGoodstaxno(String goodstaxno) {
+        this.goodstaxno = goodstaxno;
+    }
+
+    public String getCodeAbb() {
+        return codeAbb;
+    }
+
+    public void setCodeAbb(String codeAbb) {
+        this.codeAbb = codeAbb;
+    }
+
+    public String getDetailGoodsName() {
+        return detailGoodsName;
+    }
+
+    public void setDetailGoodsName(String detailGoodsName) {
+        this.detailGoodsName = detailGoodsName;
+    }
+
+    public String getLineCode() {
+        return lineCode;
+    }
+
+    public void setLineCode(String lineCode) {
+        this.lineCode = lineCode;
+    }
+
+    public String getOriLineCode() {
+        return oriLineCode;
+    }
+
+    public void setOriLineCode(String oriLineCode) {
+        this.oriLineCode = oriLineCode;
+    }
+
+    public String getOriginalInvDate() {
+        return originalInvDate;
+    }
+
+    public void setOriginalInvDate(String originalInvDate) {
+        this.originalInvDate = originalInvDate;
+    }
+
+    public String getFailCause() {
+        return failCause;
+    }
+
+    public void setFailCause(String failCause) {
+        this.failCause = failCause;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSRedInvoiceConfirmInfo.java

@@ -0,0 +1,52 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import javax.validation.constraints.Pattern;
+
+/**
+ * OMS红字确认单信息实体类
+ * 对应业务场景：红字确认单的状态处理与信息封装
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSRedInvoiceConfirmInfo {
+
+    /**
+     * 组织代码（必填）
+     * 所属组织唯一标识，长度1-20位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "组织代码deptCode为必填项，长度不能超过20位")
+    private String deptCode;
+
+    /**
+     * 红字确认单uuid（必填）
+     * 申请成功后返回的流水号，长度1-32位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,32}$", message = "红字确认单uuid redUuid为必填项，长度不能超过32位")
+    private String redUuid;
+
+    /**
+     * 红字确认信息表状态（必填）
+     * 01:同意 02:不同意 03:撤销
+     */
+    @Pattern(regexp = "01|02|03", message = "红字确认信息表状态confirmStatus为必填项，只能传入01（同意）、02（不同意）、03（撤销）")
+    private String confirmStatus;
+
+    /**
+     * 处理理由（非必填）
+     * 长度1-200位，填写处理的原因说明
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,200}$", message = "处理理由confirmReason只能传入：空 或 长度不超过200位的任意字符")
+    private String confirmReason;
+
+    /**
+     * 请求方身份（必填）
+     * 0:销方 1:购方
+     */
+    @Pattern(regexp = "0|1", message = "请求方身份applyIdentity为必填项，只能传入0（销方）或1（购方）")
+    private String applyIdentity;
+
+    /**
+     * 开票员（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "开票员drawer只能传入：空 或 长度不超过20位的任意字符")
+    private String drawer;
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSRedInvoiceConfirmQueryRequest.java

@@ -0,0 +1,86 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+
+import javax.validation.constraints.Pattern;
+
+/**
+ * OMS红字确认单查询接口请求实体类
+ * 对应业务场景：业务系统从OMS系统查询申请的红字确认单数据
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSRedInvoiceConfirmQueryRequest {
+
+    /**
+     * 组织代码（必填）
+     * 所属组织唯一标识，长度1-20位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "组织代码deptCode为必填项，长度不能超过20位")
+    private String deptCode;
+
+    /**
+     * 申请单号（非必填）
+     * 申请单号、红字确认单id、红字确认信息单编号不可同时为空；长度1-50位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,50}$", message = "申请单号applyNo只能传入：空 或 长度不超过50位的任意字符（需与redUuid/redNo至少一个同时传值）")
+    private String applyNo;
+
+    /**
+     * 红字确认单id（非必填）
+     * 申请单号、红字确认单id、红字确认信息单编号不可同时为空；长度1-32位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,32}$", message = "红字确认单id redUuid只能传入：空 或 长度不超过32位的任意字符（需与applyNo/redNo至少一个同时传值）")
+    private String redUuid;
+
+    /**
+     * 红字确认信息单编号（非必填）
+     * 申请单号、红字确认单id、红字确认信息单编号不可同时为空；长度1-32位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,32}$", message = "红字确认信息单编号redNo只能传入：空 或 长度不超过32位的任意字符（需与applyNo/redUuid至少一个同时传值）")
+    private String redNo;
+
+    /**
+     * 请求方身份（必填）
+     * 0:销方 1:购方
+     */
+    @Pattern(regexp = "0|1", message = "请求方身份applyIdentity为必填项，只能传入0（销方）或1（购方）")
+    private String applyIdentity;
+
+    public String getDeptCode() {
+        return deptCode;
+    }
+
+    public void setDeptCode(String deptCode) {
+        this.deptCode = deptCode;
+    }
+
+    public String getApplyNo() {
+        return applyNo;
+    }
+
+    public void setApplyNo(String applyNo) {
+        this.applyNo = applyNo;
+    }
+
+    public String getRedUuid() {
+        return redUuid;
+    }
+
+    public void setRedUuid(String redUuid) {
+        this.redUuid = redUuid;
+    }
+
+    public String getRedNo() {
+        return redNo;
+    }
+
+    public void setRedNo(String redNo) {
+        this.redNo = redNo;
+    }
+
+    public String getApplyIdentity() {
+        return applyIdentity;
+    }
+
+    public void setApplyIdentity(String applyIdentity) {
+        this.applyIdentity = applyIdentity;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/entity/OMS/fastRed/OMSRedInvoiceConfirmResponse.java

@@ -0,0 +1,355 @@
+package com.jeeplus.modules.workinvoice.entity.OMS.fastRed;
+import javax.validation.constraints.Pattern;
+import java.util.List;
+
+/**
+ * OMS红字确认单返回接口信息实体类
+ * 对应业务场景：红字确认单查询接口的返回数据封装
+ * 所有字段均采用 @Pattern 正则校验，规则：^$ 表示允许为空，| 分隔所有合法有效值
+ */
+public class OMSRedInvoiceConfirmResponse {
+
+    /**
+     * 红字确认信息单编号（非必填）
+     * 长度1-32位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,32}$", message = "红字确认信息单编号redNo只能传入：空 或 长度不超过32位的任意字符")
+    private String redNo;
+
+    /**
+     * 红字确认单Id（非必填）
+     * 长度1-32位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,32}$", message = "红字确认单Id redUuid只能传入：空 或 长度不超过32位的任意字符")
+    private String redUuid;
+
+    /**
+     * 申请方身份（必填）
+     * 0:销方 1:购方
+     */
+    @Pattern(regexp = "0|1", message = "申请方身份applyIdentity为必填项，只能传入0（销方）或1（购方）")
+    private String applyIdentity;
+
+    /**
+     * 销售方纳税人识别号（必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,20}$", message = "销售方纳税人识别号sellerTaxNo为必填项，长度不能超过20位")
+    private String sellerTaxNo;
+
+    /**
+     * 销售方名称（必填）
+     * 长度1-100位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,100}$", message = "销售方名称sellerName为必填项，长度不能超过100位")
+    private String sellerName;
+
+    /**
+     * 购买方纳税人识别号（非必填）
+     * 长度1-20位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,20}$", message = "购买方纳税人识别号buyerTaxno只能传入：空 或 长度不超过20位的任意字符")
+    private String buyerTaxno;
+
+    /**
+     * 购买方名称（必填）
+     * 长度1-100位
+     */
+    @Pattern(regexp = "^[\\s\\S]{1,100}$", message = "购买方名称buyerName为必填项，长度不能超过100位")
+    private String buyerName;
+
+    /**
+     * 冲红原因（必填）
+     * 01:开票有误 02:销货退回 03:服务中止 04:销售折让
+     */
+    @Pattern(regexp = "01|02|03|04", message = "冲红原因redReason为必填项，只能传入01/02/03/04")
+    private String redReason;
+
+    /**
+     * 红字确认单状态（必填）
+     * 01-无需确认、02-销方录入待购方确认、03-购方录入待销方确认、04-购销双方已确认
+     * 05-作废(销方录入购方否认)、06-作废(购方录入销方否认)、07-作废(超72小时未确认)
+     * 08-作废(发起方已撤销)、09-作废(确认后撤销)、10-作废(异常凭证)、15-申请中、16-申请失败
+     */
+    @Pattern(regexp = "01|02|03|04|05|06|07|08|09|10|15|16",
+            message = "红字确认单状态confirmStatus为必填项，只能传入指定枚举值")
+    private String confirmStatus;
+
+    /**
+     * 红字发票开具状态（必填）
+     * 1:未开票 2:开票失败 3:已开票 4:开票中
+     */
+    @Pattern(regexp = "1|2|3|4", message = "红字发票开具状态makeStatus为必填项，只能传入1/2/3/4")
+    private String makeStatus;
+
+    /**
+     * 合计金额（不含税）（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "合计金额（不含税）totalAmount为必填项，只能传入负数且保留两位小数（如-123.45）")
+    private String totalAmount;
+
+    /**
+     * 合计税额（必填）
+     * 负数，保留两位小数
+     */
+    @Pattern(regexp = "^-\\d+(\\.\\d{2})$", message = "合计税额totalTax为必填项，只能传入负数且保留两位小数（如-12.34）")
+    private String totalTax;
+
+    /**
+     * 原蓝票发票类型（必填）
+     * 01-数电票(增值税专用发票)、02-数电票(普通发票)、03-数电纸质发票(增值税专用发票)
+     * 04-数电纸质发票(普通发票)、83-数电票(机动车销售统一发票)、84-数电票(二手车销售统一发票)
+     * 87-数电纸质发票(机动车销售统一发票)、88-数电纸质发票(二手车销售统一发票)
+     * 05-增值税电子普通发票、06-增值税普通发票、07-增值税专用发票、08-增值税电子专用发票
+     * 09-机动车统一销售发票、15-二手车统一销售发票
+     */
+    @Pattern(regexp = "01|02|03|04|83|84|87|88|05|06|07|08|09|15",
+            message = "原蓝票发票类型originalInvType为必填项，只能传入指定枚举值")
+    private String originalInvType;
+
+    /**
+     * 原蓝票发票代码（非必填）
+     * 12位或10位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{10}$|^\\d{12}$", message = "原蓝票发票代码originalInvcode只能传入：空 或 10位/12位纯数字")
+    private String originalInvcode;
+
+    /**
+     * 原蓝票发票号码（非必填）
+     * 20位或8位纯数字
+     */
+    @Pattern(regexp = "^$|^\\d{8}$|^\\d{20}$", message = "原蓝票发票号码originalInvno只能传入：空 或 8位/20位纯数字")
+    private String originalInvno;
+
+    /**
+     * 原蓝票开票日期（非必填）
+     * 格式：yyyy-MM-dd HH:mm:ss
+     */
+    @Pattern(regexp = "^$|^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$",
+            message = "原蓝票开票日期originalInvDate只能传入：空 或 格式为yyyy-MM-dd HH:mm:ss的日期")
+    private String originalInvDate;
+
+    /**
+     * 原蓝票特定要素（非必填）
+     * 01-成品油发票、02-稀土发票、03-建筑服务发票、04-货物运输服务发票、05-不动产销售服务发票
+     * 06-不动产租赁服务发票、07-代收车船税、08-通行费、09-旅客运输服务发票、10-医疗服务（住院）发票
+     * 11-医疗服务（门诊）发票、12-自产农产品销售发票、13-拖拉机和联合收割机发票、14-机动车
+     * 15-二手车、16-农产品收购发票、17-光伏收购发票、18-卷烟发票、31-二手车*、32-电子烟
+     * 51-二手车正向开具、52-二手车反向开具
+     */
+    @Pattern(regexp = "^$|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|31|32|51|52",
+            message = "原蓝票特定要素oriSpecificFactor只能传入：空 或 指定枚举值")
+    private String oriSpecificFactor;
+
+    /**
+     * 红字发票订单号（非必填）
+     * 当请求方身份为0(销方)且红字确认单已开票时有值；长度1-50位
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,50}$", message = "红字发票订单号redInvOrderNo只能传入：空 或 长度不超过50位的任意字符")
+    private String redInvOrderNo;
+
+    /**
+     * 开票失败原因（非必填）
+     * 不定长，填写开票失败的具体原因
+     */
+    @Pattern(regexp = "^$|^[\\s\\S]{1,1000}$", message = "开票失败原因failCause只能传入：空 或 长度不超过1000位的任意字符")
+    private String failCause;
+
+    /**
+     * 红字确认单申请时间（非必填）
+     * 格式：yyyy-MM-dd HH:mm:ss
+     */
+    @Pattern(regexp = "^$|^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$",
+            message = "红字确认单申请时间applyTime只能传入：空 或 格式为yyyy-MM-dd HH:mm:ss的日期")
+    private String applyTime;
+
+    /**
+     * 确认时间（非必填）
+     * 格式：yyyy-MM-dd HH:mm:ss
+     */
+    @Pattern(regexp = "^$|^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$",
+            message = "确认时间confirmTime只能传入：空 或 格式为yyyy-MM-dd HH:mm:ss的日期")
+    private String confirmTime;
+
+    /**
+     * 商品类
+     */
+    private List<OMSRedInvoiceConfirmApplyItem> applyItems;
+
+    public String getRedNo() {
+        return redNo;
+    }
+
+    public void setRedNo(String redNo) {
+        this.redNo = redNo;
+    }
+
+    public String getRedUuid() {
+        return redUuid;
+    }
+
+    public void setRedUuid(String redUuid) {
+        this.redUuid = redUuid;
+    }
+
+    public String getApplyIdentity() {
+        return applyIdentity;
+    }
+
+    public void setApplyIdentity(String applyIdentity) {
+        this.applyIdentity = applyIdentity;
+    }
+
+    public String getSellerTaxNo() {
+        return sellerTaxNo;
+    }
+
+    public void setSellerTaxNo(String sellerTaxNo) {
+        this.sellerTaxNo = sellerTaxNo;
+    }
+
+    public String getSellerName() {
+        return sellerName;
+    }
+
+    public void setSellerName(String sellerName) {
+        this.sellerName = sellerName;
+    }
+
+    public String getBuyerTaxno() {
+        return buyerTaxno;
+    }
+
+    public void setBuyerTaxno(String buyerTaxno) {
+        this.buyerTaxno = buyerTaxno;
+    }
+
+    public String getBuyerName() {
+        return buyerName;
+    }
+
+    public void setBuyerName(String buyerName) {
+        this.buyerName = buyerName;
+    }
+
+    public String getRedReason() {
+        return redReason;
+    }
+
+    public void setRedReason(String redReason) {
+        this.redReason = redReason;
+    }
+
+    public String getConfirmStatus() {
+        return confirmStatus;
+    }
+
+    public void setConfirmStatus(String confirmStatus) {
+        this.confirmStatus = confirmStatus;
+    }
+
+    public String getMakeStatus() {
+        return makeStatus;
+    }
+
+    public void setMakeStatus(String makeStatus) {
+        this.makeStatus = makeStatus;
+    }
+
+    public String getTotalAmount() {
+        return totalAmount;
+    }
+
+    public void setTotalAmount(String totalAmount) {
+        this.totalAmount = totalAmount;
+    }
+
+    public String getTotalTax() {
+        return totalTax;
+    }
+
+    public void setTotalTax(String totalTax) {
+        this.totalTax = totalTax;
+    }
+
+    public String getOriginalInvType() {
+        return originalInvType;
+    }
+
+    public void setOriginalInvType(String originalInvType) {
+        this.originalInvType = originalInvType;
+    }
+
+    public String getOriginalInvcode() {
+        return originalInvcode;
+    }
+
+    public void setOriginalInvcode(String originalInvcode) {
+        this.originalInvcode = originalInvcode;
+    }
+
+    public String getOriginalInvno() {
+        return originalInvno;
+    }
+
+    public void setOriginalInvno(String originalInvno) {
+        this.originalInvno = originalInvno;
+    }
+
+    public String getOriginalInvDate() {
+        return originalInvDate;
+    }
+
+    public void setOriginalInvDate(String originalInvDate) {
+        this.originalInvDate = originalInvDate;
+    }
+
+    public String getOriSpecificFactor() {
+        return oriSpecificFactor;
+    }
+
+    public void setOriSpecificFactor(String oriSpecificFactor) {
+        this.oriSpecificFactor = oriSpecificFactor;
+    }
+
+    public String getRedInvOrderNo() {
+        return redInvOrderNo;
+    }
+
+    public void setRedInvOrderNo(String redInvOrderNo) {
+        this.redInvOrderNo = redInvOrderNo;
+    }
+
+    public String getFailCause() {
+        return failCause;
+    }
+
+    public void setFailCause(String failCause) {
+        this.failCause = failCause;
+    }
+
+    public String getApplyTime() {
+        return applyTime;
+    }
+
+    public void setApplyTime(String applyTime) {
+        this.applyTime = applyTime;
+    }
+
+    public String getConfirmTime() {
+        return confirmTime;
+    }
+
+    public void setConfirmTime(String confirmTime) {
+        this.confirmTime = confirmTime;
+    }
+
+    public List<OMSRedInvoiceConfirmApplyItem> getApplyItems() {
+        return applyItems;
+    }
+
+    public void setApplyItems(List<OMSRedInvoiceConfirmApplyItem> applyItems) {
+        this.applyItems = applyItems;
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/service/OMS/InvoiceDownloadService.java

@@ -0,0 +1,165 @@
+package com.jeeplus.modules.workinvoice.service.OMS;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.jeeplus.common.utils.JedisUtils;
+import com.jeeplus.modules.workinvoice.entity.OMS.InvoiceDown.OMSInvoiceDetailInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSInvoiceResultDownloadData;
+import com.jeeplus.modules.workinvoice.utils.HttpPostJsonUtil;
+import com.jeeplus.modules.workinvoice.utils.OMSNationUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import redis.clients.jedis.Jedis;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Set;
+import java.util.UUID;
+
+@Service
+@Transactional(readOnly = true)
+@Lazy
+public class InvoiceDownloadService {
+
+
+    private final String appId = "hyc1";
+    private final String appKey = "hyc1";
+    private final String deptCode = "500102204228315131";
+
+
+    @Autowired
+    private OMSDisposeService omsDisposeService;
+
+
+    public void processInvoiceDownloadTasks() {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            Set<String> downloadTaskKeys = jedis.keys("OMS_invoice_download:*");
+            if (downloadTaskKeys.isEmpty()) {
+                System.out.println("[InvoiceDownloadTask] 暂无待解析的发票任务");
+                return;
+            }
+
+            // 遍历所有解析任务
+            for (String taskKey : downloadTaskKeys) {
+                String orderno = taskKey.replace("OMS_invoice_download:", "");
+                String accessToken = jedis.hget(taskKey, "accessToken");
+                //获取当前redis中的accessToken
+                //如果有值，则使用当前redis中的accessToken，否则重新生成一个新的accessToken
+
+
+                String firstExecTimeStr = jedis.hget(taskKey, "firstExecTime");
+
+                // 参数校验
+                if (StringUtils.isAnyBlank(accessToken, firstExecTimeStr)) {
+                    jedis.del(taskKey);
+                    continue;
+                }
+
+                long firstExecTime = Long.parseLong(firstExecTimeStr);
+                // ========== 改动1：超时判断改为23小时（82800000毫秒） ==========
+                // 23*60*60*1000 = 82800000 ms（原86400000是24小时）
+                if (System.currentTimeMillis() - firstExecTime > 82800000L) {
+                    System.err.println("[InvoiceDownloadTask] 任务["+orderno+"]已重试23小时，触发兜底");
+                    omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                    //需要修改项目相关信息
+
+
+
+                    jedis.del(taskKey); // 兜底后删除Redis，保证数据一致
+                    continue;
+                }
+
+                // ========== 核心：调用原始解析方法（移至此） ==========
+                executeInvoiceDownloadWithRetry(accessToken, orderno);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+    // ========== 原始解析方法（完全保留核心逻辑，仅调整重试规则） ==========
+    private void executeInvoiceDownloadWithRetry(String accessToken, String orderno) {
+        try {
+            System.out.println("✅ [InvoiceDownloadTask] 开始解析发票，订单号：" + orderno);
+
+            // ========== 原始解析逻辑 —— 完全不变 ==========
+            OMSInvoiceResultDownloadData getInvoiceInfo = new OMSInvoiceResultDownloadData();
+            getInvoiceInfo.setDeptCode(deptCode);
+            getInvoiceInfo.setOrderno(orderno);
+            getInvoiceInfo.setIsDetail("1");
+            String jsonInvoiceInfoStr = JSON.toJSONString(getInvoiceInfo);
+            String base64Str = Base64.getEncoder().encodeToString(jsonInvoiceInfoStr.getBytes(StandardCharsets.UTF_8));
+
+            OMSAccessTokenInfo invoiceDownInfo = new OMSAccessTokenInfo();
+            invoiceDownInfo.setAppId(appId);
+            invoiceDownInfo.setAppKey(appKey);
+            invoiceDownInfo.setExchangeId(UUID.randomUUID().toString());
+            invoiceDownInfo.setAccessToken(accessToken);
+            invoiceDownInfo.setData(base64Str);
+            String jsonInvoiceDownStr = JSON.toJSONString(invoiceDownInfo);
+
+            String invoiceResultStr = HttpPostJsonUtil.doPost(
+                    "https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/invoice/download",
+                    jsonInvoiceDownStr
+            );
+            System.out.println("[InvoiceDownloadTask] 发票解析结果：" + invoiceResultStr);
+
+            String invoceDownJsonStr = null;
+            boolean isSuccess = false;
+            if (StringUtils.isNotBlank(invoiceResultStr)) {
+                OMSAccessTokenInfo resultDownInfo = JSON.parseObject(invoiceResultStr, OMSAccessTokenInfo.class);
+                if (null != resultDownInfo.getResult() && "0000".equals(resultDownInfo.getResult().getCode())) {
+                    invoceDownJsonStr = OMSNationUtil.getDownFromBase64(resultDownInfo.getData().toString());
+                    if (StringUtils.isNotBlank(invoceDownJsonStr)) {
+                        OMSInvoiceDetailInfo invoiceInfo = JSONObject.parseObject(invoceDownJsonStr, OMSInvoiceDetailInfo.class);
+                        if (invoiceInfo != null) {
+                            System.out.println("✅ [InvoiceDownloadTask] 解析成功！");
+                            System.out.println("allEinVno：" + invoiceInfo.getAllEinVno());
+                            System.out.println("ofdUrl：" + invoiceInfo.getOfdUrl());
+                            System.out.println("pdfUrl：" + invoiceInfo.getPdfUrl());
+                            System.out.println("xmlUrl：" + invoiceInfo.getXmlUrl());
+                            isSuccess = true;
+                        }
+                    }
+                }
+            }
+
+            // ========== 重试规则调整：去掉次数限制，改为23小时超时（由定时任务控制） ==========
+            if (isSuccess) {
+                System.out.println("✅ [InvoiceDownloadTask] 任务["+orderno+"]解析成功，删除Redis任务");
+                deleteInvoiceDownloadTaskFromRedis(orderno); // 成功删除Redis，保证数据一致
+                return;
+            } else {
+                System.out.println("❌ [InvoiceDownloadTask] 任务["+orderno+"]解析失败，5分钟后重试");
+                // 无需手动延迟，由定时任务每5分钟扫描即可
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("❌ [InvoiceDownloadTask] 任务["+orderno+"]解析抛出异常，5分钟后重试");
+            // 异常不删除Redis，由定时任务继续重试
+        }
+    }
+
+    // ========== 辅助方法：删除Redis解析任务 ==========
+    private void deleteInvoiceDownloadTaskFromRedis(String orderno) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            jedis.del("OMS_invoice_download:" + orderno);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+}

src/main/java/com/jeeplus/modules/workinvoice/service/OMS/OMSDisposeService.java

@@ -0,0 +1,493 @@
+package com.jeeplus.modules.workinvoice.service.OMS;
+
+import com.alibaba.fastjson.JSON;
+import com.jeeplus.common.utils.JedisUtils;
+import com.jeeplus.common.utils.StringUtils;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
+import com.jeeplus.modules.workinvoice.utils.HttpPostJsonUtil;
+import com.jeeplus.modules.workinvoice.utils.OMSNationUtil;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import redis.clients.jedis.Jedis;
+
+import java.util.Map;
+import java.util.UUID;
+
+@Service
+@Transactional(readOnly = true)
+@Lazy
+public class OMSDisposeService {
+
+    /**
+     * 给accessToken查询的有效时间设置为1天
+     */
+    private final int seconds = 86400;
+    private final String appId = "hyc1";
+    private final String appKey = "hyc1";
+    private final String deptCode = "500102204228315131";
+    //如果接口访问不正确，可以循环访问的次数
+    private final int remainRetryTimes = 20;
+
+    /**
+     * 用于生成开蓝票信息
+     * @param map
+     * @param workInvoiceId
+     */
+    public void doInvoiceBusiness(Map<String,Object> map, String workInvoiceId) {
+        Jedis jedis = null;
+        String accessToken = null;
+        try {
+            jedis = JedisUtils.getResource();
+            accessToken = jedis.get("OMSAccessToken");
+            if(StringUtils.isBlank(accessToken)){
+                // 获取AccessToken 9998重试5次
+                accessToken = getOmsAccessTokenWithRetry(5, "accessToken");
+                if(StringUtils.isNotBlank(accessToken)){
+                    jedis.setex("OMSAccessToken", seconds, accessToken);
+                    map.put("token状态", "重新获取token成功，存入Redis");
+                } else {
+                    accessToken = "";
+                    map.put("token状态", "获取token失败");
+                    return;
+                }
+            } else {
+                map.put("token状态", "从Redis获取token成功");
+            }
+
+            OMSNationUtil util = new OMSNationUtil();
+            //生成开票基础信息
+            String string = util.neatenData(workInvoiceId);
+
+            OMSAccessTokenInfo InvoiceTokenInfo = new OMSAccessTokenInfo();
+            InvoiceTokenInfo.setAppId(appId);
+            InvoiceTokenInfo.setAppKey(appKey);
+            InvoiceTokenInfo.setExchangeId(UUID.randomUUID().toString());
+            InvoiceTokenInfo.setAccessToken(accessToken);
+            InvoiceTokenInfo.setData(string);
+            String jsonInvoiceStr = JSON.toJSONString(InvoiceTokenInfo);
+
+            String jsonInvoicResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/order/upload", jsonInvoiceStr);
+            System.out.println("✅ 订单提交接口返回值：" + jsonInvoicResultStr);
+            map.put("订单接口信息", jsonInvoicResultStr);
+
+            // 调用订单上传重试方法（包含所有码值规则）
+            if(StringUtils.isNotBlank(jsonInvoicResultStr)){
+                String finalAccessToken = accessToken;
+                String finalJsonInvoiceStr = jsonInvoiceStr;
+                executeOrderUploadRetry(remainRetryTimes, jsonInvoicResultStr, finalJsonInvoiceStr, finalAccessToken, workInvoiceId, map,"accessToken", "blueTicket");
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("errorMsg", "系统异常：" + e.getMessage());
+        } finally {
+            if(jedis != null){
+                jedis.close();
+            }
+        }
+    }
+
+    /**
+     * 用于调用accessToken
+     * @param remainRetryTimes
+     * @param getKey
+     * @return
+     */
+    public String getOmsAccessTokenWithRetry(int remainRetryTimes, String getKey) {
+        try {
+            OMSAccessTokenInfo tokenInfo = new OMSAccessTokenInfo();
+            tokenInfo.setAppId(appId);
+            tokenInfo.setAppKey(appKey);
+            tokenInfo.setExchangeId(UUID.randomUUID().toString());
+            String jsonStr = JSON.toJSONString(tokenInfo);
+            String accessTokenStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/server/accessToken", jsonStr);
+
+            if(StringUtils.isBlank(accessTokenStr)){
+                System.err.println("获取AccessToken失败：接口返回空，剩余重试次数："+remainRetryTimes);
+                return "";
+            }
+
+            OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(accessTokenStr, OMSAccessTokenInfo.class);
+            if(null == resultTokenInfo || null == resultTokenInfo.getResult()){
+                System.err.println("获取AccessToken失败：返回结果解析异常，剩余重试次数："+remainRetryTimes);
+                return "";
+            }
+
+            String code = resultTokenInfo.getResult().getCode();
+            if ("0000".equals(code)) {
+                String token = OMSNationUtil.extractAccessTokenFromBase64(getKey, resultTokenInfo.getData().toString());
+                System.out.println("✅ 获取AccessToken成功，重试次数剩余："+remainRetryTimes);
+                return token;
+            } else if ("9998".equals(code)) {
+                if (remainRetryTimes > 1) {
+                    int nextRetry = remainRetryTimes - 1;
+                    System.err.println("⚠️ 获取AccessToken返回9998接口波动，30秒后重试，剩余次数："+nextRetry);
+                    Thread.sleep(30 * 1000);
+                    return getOmsAccessTokenWithRetry(nextRetry,getKey);
+                } else {
+                    System.err.println("❌ 获取AccessToken失败：连续5次返回9998，重试次数耗尽！");
+                    return "";
+                }
+            } else {
+                System.err.println("❌ 获取AccessToken失败：返回业务错误码，code="+code);
+                return "";
+            }
+        } catch (InterruptedException e) {
+            System.err.println("❌ 获取AccessToken失败：重试延迟被中断");
+            Thread.currentThread().interrupt();
+            return "";
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("❌ 获取AccessToken失败：调用接口异常，剩余重试次数："+remainRetryTimes);
+            return "";
+        }
+    }
+
+
+    /**
+     * 对方法进行发起并进行处理
+     * @param remainRetryTimes
+     * @param jsonInvoicResultStr
+     * @param jsonInvoiceStr
+     * @param accessToken
+     * @param orderno
+     * @param map
+     * @param getKey
+     * @param initiationType    用来判定是什么类型的，比如蓝票、全类型红票、还是快捷红票
+     */
+    public void executeOrderUploadRetry(int remainRetryTimes, String jsonInvoicResultStr, String jsonInvoiceStr, String accessToken, String orderno, Map<String,Object> map, String getKey, String initiationType) {
+        String jsonInvoicResult = "";
+        try {
+            OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(jsonInvoicResultStr, OMSAccessTokenInfo.class);
+            if(null == resultTokenInfo || null == resultTokenInfo.getResult()){
+                System.err.println("❌ 订单上传解析失败，剩余重试次数："+remainRetryTimes);
+                handleInvoiceRetryAllFail(accessToken); // 解析失败也执行兜底方法
+                return;
+            }
+            String code = resultTokenInfo.getResult().getCode();
+            String message = resultTokenInfo.getResult().getMessage();
+
+            // ======================== 所有码值规则 全部在这里【最终定稿】=========================
+            if ("0000".equals(code)) {
+                // ✅ 0000 成功：解析数据+存入map+触发30秒后异步下载发票
+                jsonInvoicResult = OMSNationUtil.extractAccessTokenFromBase64(getKey, resultTokenInfo.getData().toString());
+                map.put("订单接口返回值",jsonInvoicResult);
+                System.out.println("✅ 订单上传返回0000成功，触发发票下载接口");
+                if(StringUtils.isNotBlank(jsonInvoicResult)){
+                    if(initiationType.equals("fastRed")){
+                        orderno = jsonInvoicResult;
+                    }
+                }
+                String finalOrderno = orderno;
+                // 存入Redis，由InvoiceDownloadTask接管
+                saveInvoiceDownloadTaskToRedis(accessToken, finalOrderno);
+                System.out.println("✅ 解析开票数据任务["+finalOrderno+"]已存入Redis，由InvoiceDownloadTask接管重试");
+
+            } else if ("9998".equals(code)) {
+                // 通过redis调用 方式系统崩溃导致的数据丢失
+                // ✅ 9998 接口波动，放入redis中 用于定时任务进行处理
+                saveInvoiceRetryScheduledTaskToRedis(jsonInvoiceStr, accessToken, orderno, getKey, initiationType);
+
+            } else if ("0003".equals(code)) {
+                // ✅ 0003 token失效：清除旧token → 重新获取token → 从头完整执行所有流程
+                System.err.println("⚠️ 订单上传返回0003（token失效），开始重新获取token并从头执行流程");
+                Jedis jedis = null;
+                try {
+                    jedis = JedisUtils.getResource();
+                    jedis.del("OMSAccessToken");
+                    map.put("0003处理", "已清除旧token，准备重新获取");
+                } catch (Exception e) {
+                    e.printStackTrace();
+                } finally {
+                    if(jedis != null) jedis.close();
+                }
+                doInvoiceBusiness(map, orderno);
+            } else {
+                // ✅ ✅ ✅ 核心修正：0001/0002/其他任意错误码 → 直接调用handleInvoiceRetryAllFail执行修改系统信息逻辑 ✅ ✅ ✅
+                System.err.println("❌ 订单上传返回业务错误码："+code+"(0001/0002等)，立即执行失败兜底逻辑修改系统信息！");
+                System.err.println("❌ 订单上传返回业务错误原因："+message);
+                map.put("订单状态", "失败，错误码："+code);
+                handleInvoiceRetryAllFail(accessToken); // 关键：直接执行你的修改逻辑，不抛异常、不重试
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("❌ 订单上传重试异常，剩余次数："+remainRetryTimes);
+            handleInvoiceRetryAllFail(accessToken); // 异常也执行兜底方法
+        }
+    }
+
+    /**
+     * 用于访问接口返回9998时使用，存入Redis供定时任务处理
+     * 硬编码配置：初始重试次数20次，Redis过期时间1天（86400秒）
+     * @param jsonInvoiceStr 订单上传的JSON参数
+     * @param accessToken    AccessToken
+     * @param orderno        订单号
+     * @param getKey         获取token的key
+     * @param initiationType 开票类型（蓝票/红票）
+     */
+    public void saveInvoiceRetryScheduledTaskToRedis(String jsonInvoiceStr ,String accessToken, String orderno, String getKey, String initiationType) {
+        Jedis jedis = null;
+        // 硬编码：初始重试次数20次
+        final int INIT_RETRY_COUNT = 20;
+        // 硬编码：Redis任务过期时间1天（86400秒）
+        final int REDIS_EXPIRE_SECONDS = 86400;
+
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_invoice_retry_scheduled:" + orderno;
+
+            // 先检查是否已存在，存在则复用原有重试次数，不存在则初始化20次
+            String retryTimes = jedis.hget(redisKey, "retryTimes");
+            if (StringUtils.isBlank(retryTimes)) {
+                retryTimes = String.valueOf(INIT_RETRY_COUNT); // 初始20次
+            }
+
+            // 存储所有需要的字段
+            jedis.hset(redisKey, "jsonInvoiceStr", jsonInvoiceStr);
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "orderno", orderno);
+            jedis.hset(redisKey, "getKey", getKey);
+            jedis.hset(redisKey, "initiationType", initiationType);
+            jedis.hset(redisKey, "firstExecTime", String.valueOf(System.currentTimeMillis()));
+            jedis.hset(redisKey, "retryTimes", retryTimes); // 重试次数
+
+            jedis.expire(redisKey, REDIS_EXPIRE_SECONDS); // 1天过期
+            System.out.println("✅ 9998重试任务已存入Redis，订单号：" + orderno + "，剩余重试次数：" + retryTimes);
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("❌ 存入9998重试任务到Redis失败，订单号：" + orderno + "，原因：" + e.getMessage());
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+    /**
+     * 新增开蓝票生成的下载用的redis
+     * @param accessToken
+     * @param orderno
+     */
+    public void saveInvoiceDownloadTaskToRedis(String accessToken, String orderno) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_invoice_download:" + orderno;
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "orderno", orderno);
+            jedis.hset(redisKey, "firstExecTime", String.valueOf(System.currentTimeMillis()));
+            jedis.expire(redisKey, seconds); // 1天过期
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+    /**
+     * 兜底方法
+     * @param accessToken
+     */
+    public void handleInvoiceRetryAllFail(String accessToken) {
+        // ============ 你的所有【修改系统信息/更新订单状态/写失败日志】逻辑 全部写在这里！！！ ============
+        try {
+            System.err.println("============ 开始执行【失败兜底-系统信息修改逻辑】 ============");
+
+            // 示例1：更新订单表的发票状态为【开票失败】
+            // orderService.updateInvoiceStatusByToken(accessToken, "99");
+
+            // 示例2：写入失败日志到数据库，方便人工排查和补偿处理
+            // invoiceFailLogService.saveFailLog(accessToken, "开票失败，错误码非0000/9998/0003", new Date());
+
+            // 示例3：标记该单据为异常，方便后台运维查看
+            // abnormalOrderService.saveAbnormalOrder(accessToken, "开票失败");
+
+            // 示例4：调用其他系统接口，同步失败状态
+            // otherSystemApi.notifyInvoiceFail(accessToken);
+
+            System.err.println("============ 【失败兜底-系统信息修改逻辑】执行完成 ============");
+
+        } catch (Exception e) {
+            // 必加：捕获这个方法的异常，避免兜底方法报错导致线程异常
+            e.printStackTrace();
+            System.err.println("❌ 执行失败兜底方法时抛出异常：" + e.getMessage());
+        }
+    }
+
+
+    /**
+     * 快速开红票的调用方法
+     * @param map
+     * @param allEinvno
+     */
+    public void doFastRedInvoiceBusiness(Map<String,Object> map, String allEinvno) {
+        Jedis jedis = null;
+        String accessToken = null;
+        try {
+            jedis = JedisUtils.getResource();
+            accessToken = jedis.get("OMSAccessToken");
+            if(StringUtils.isBlank(accessToken)){
+                // 获取AccessToken 9998重试5次
+                accessToken = getOmsAccessTokenWithRetry(5, "accessToken");
+                if(StringUtils.isNotBlank(accessToken)){
+                    jedis.setex("OMSAccessToken", seconds, accessToken);
+                    map.put("token状态", "重新获取token成功，存入Redis");
+                } else {
+                    accessToken = "";
+                    map.put("token状态", "获取token失败");
+                    return;
+                }
+            } else {
+                map.put("token状态", "从Redis获取token成功");
+            }
+
+            OMSNationUtil util = new OMSNationUtil();
+            String string = util.neatenFastRedInvoiceData(allEinvno);
+
+            OMSAccessTokenInfo InvoiceTokenInfo = new OMSAccessTokenInfo();
+            InvoiceTokenInfo.setAppId(appId);
+            InvoiceTokenInfo.setAppKey(appKey);
+            InvoiceTokenInfo.setExchangeId(UUID.randomUUID().toString());
+            InvoiceTokenInfo.setAccessToken(accessToken);
+            InvoiceTokenInfo.setData(string);
+            String jsonInvoiceStr = JSON.toJSONString(InvoiceTokenInfo);
+
+            String jsonInvoicResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/invoice/makeredinv", jsonInvoiceStr);
+            System.out.println("✅ 快速红冲订单提交接口返回值：" + jsonInvoicResultStr);
+            map.put("快速红冲订单接口信息", jsonInvoicResultStr);
+
+            // 调用订单上传重试方法（包含所有码值规则）
+            if(StringUtils.isNotBlank(jsonInvoicResultStr)){
+                String finalAccessToken = accessToken;
+                String finalJsonInvoiceStr = jsonInvoiceStr;
+                executeOrderUploadRetry(5, jsonInvoicResultStr, finalJsonInvoiceStr, finalAccessToken, allEinvno, map, "orderno", "fastRed");
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("errorMsg", "系统异常：" + e.getMessage());
+        } finally {
+            if(jedis != null){
+                jedis.close();
+            }
+        }
+    }
+
+
+    /**
+     * 调用生成红字确认申请单
+     * @param map
+     * @param applyNo
+     * @param originalInvno
+     */
+    public void doAllScenarioRedInvoiceBusiness(Map<String,Object> map, String applyNo, String originalInvno) {
+        int seconds = 86400;
+        Jedis jedis = null;
+        String accessToken = null;
+        try {
+            jedis = JedisUtils.getResource();
+            accessToken = jedis.get("OMSAccessToken");
+            if(StringUtils.isBlank(accessToken)){
+                // 获取AccessToken 9998重试5次
+                accessToken = getOmsAccessTokenWithRetry(5, "accessToken");
+                if(StringUtils.isNotBlank(accessToken)){
+                    jedis.setex("OMSAccessToken", seconds, accessToken);
+                    map.put("token状态", "重新获取token成功，存入Redis");
+                } else {
+                    accessToken = "";
+                    map.put("token状态", "获取token失败");
+                    return;
+                }
+            } else {
+                map.put("token状态", "从Redis获取token成功");
+            }
+
+            OMSNationUtil util = new OMSNationUtil();
+            //生成红冲的数据
+            String string = util.neatenAllScenarioRedInvoiceData(applyNo, originalInvno);
+
+            OMSAccessTokenInfo InvoiceTokenInfo = new OMSAccessTokenInfo();
+            InvoiceTokenInfo.setAppId(appId);
+            InvoiceTokenInfo.setAppKey(appKey);
+            InvoiceTokenInfo.setExchangeId(UUID.randomUUID().toString());
+            InvoiceTokenInfo.setAccessToken(accessToken);
+            InvoiceTokenInfo.setData(string);
+            String jsonInvoiceStr = JSON.toJSONString(InvoiceTokenInfo);
+
+            String jsonInvoicResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/redApply/apply", jsonInvoiceStr);
+            System.out.println("✅ 全场景红冲订单提交接口返回值：" + jsonInvoicResultStr);
+            map.put("全场景红冲订单接口信息", jsonInvoicResultStr);
+
+            // 调用订单上传重试方法（包含所有码值规则）
+            if(StringUtils.isNotBlank(jsonInvoicResultStr)){
+                String finalAccessToken = accessToken;
+                queryRedInvoiceConfirm (5, jsonInvoicResultStr, finalAccessToken, applyNo);
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("errorMsg", "系统异常：" + e.getMessage());
+        } finally {
+            if(jedis != null){
+                jedis.close();
+            }
+        }
+    }
+
+    /**
+     * 全类型红冲--红字确认单查询接口（仅存Redis，不执行业务）
+     * @param remainRetryTimes  剩余重试次数
+     * @param jsonInvoicResultStr   需要解析的返回值密文
+     * @param accessToken   accessToken
+     * @param applyNo
+     */
+    public void queryRedInvoiceConfirm (int remainRetryTimes, String jsonInvoicResultStr, String accessToken, String applyNo) {
+        try {
+            OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(jsonInvoicResultStr, OMSAccessTokenInfo.class);
+            if(null == resultTokenInfo || null == resultTokenInfo.getResult()){
+                System.err.println("❌ 全场景红冲订单提交接口返回值解析失败，剩余重试次数："+remainRetryTimes);
+                handleInvoiceRetryAllFail(accessToken); // 解析失败直接兜底
+                return;
+            }
+            String code = resultTokenInfo.getResult().getCode();
+
+            if ("0000".equals(code)) {
+                // 仅存入Redis，删除所有业务执行逻辑
+                saveRedInvoiceTaskToRedis(remainRetryTimes, jsonInvoicResultStr, accessToken, applyNo, System.currentTimeMillis());
+                System.out.println("✅ 红冲任务["+applyNo+"]已存入Redis，由定时任务接管执行");
+            } else {
+                String message = resultTokenInfo.getResult().getMessage();
+                System.err.println("❌ 订单上传返回业务错误码："+code+"，触发兜底逻辑！");
+                handleInvoiceRetryAllFail(accessToken);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            handleInvoiceRetryAllFail(accessToken);
+        }
+    }
+
+    /**
+     * 存储红冲任务到Redis（供原有业务代码调用，参数完整）
+     */
+    public void saveRedInvoiceTaskToRedis(int remainRetryTimes, String jsonInvoicResultStr, String accessToken, String applyNo, long startTime) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_red_invoice_task:" + applyNo;
+            // 存储所有执行所需的参数（确保定时任务能独立执行）
+            jedis.hset(redisKey, "remainRetryTimes", String.valueOf(remainRetryTimes));
+            jedis.hset(redisKey, "jsonInvoicResultStr", jsonInvoicResultStr);
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "applyNo", applyNo);
+            jedis.hset(redisKey, "startTime", String.valueOf(startTime));
+            jedis.expire(redisKey, 259200 + 3600); // 3天+1小时过期
+        } catch (Exception e) {
+            e.printStackTrace();
+            handleInvoiceRetryAllFail(accessToken);
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+}

src/main/java/com/jeeplus/modules/workinvoice/service/OMS/RedInvoiceRetryScheduledService.java

@@ -0,0 +1,143 @@
+package com.jeeplus.modules.workinvoice.service.OMS;
+
+import com.alibaba.fastjson.JSON;
+import com.jeeplus.common.utils.JedisUtils;
+import com.jeeplus.modules.ruralprojectrecords.web.RuralProjectSignatureOldMessageDisposeController;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
+import com.jeeplus.modules.workinvoice.utils.HttpPostJsonUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import redis.clients.jedis.Jedis;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 用于开发票都用订单接口推送时使用，用来当返回值时9998时进行处理
+ * 核心规则：
+ * 1. 每2分钟执行一次定时任务（无时段限制）
+ * 2. 单个任务最多重试20次（每次间隔2分钟，由定时任务频率控制）
+ * 3. 仅判断Redis中是否有任务：有则执行，无则跳过
+ * 4. 9998错误纳入重试计数，次数用尽后按失败处理+删除Redis任务
+ */
+@Service
+@Transactional(readOnly = true)
+@Lazy(false) // 非懒加载，项目启动即初始化
+public class RedInvoiceRetryScheduledService {
+
+    // 原业务类中的核心方法需要能被定时任务调用，建议将executeOrderUploadRetry、handleInvoiceRetryAllFail等方法改为public，
+    // 或通过@Autowired注入业务类实例（假设你的业务类叫InvoiceOMSService）
+    @Autowired
+    private OMSDisposeService invoiceOMSService; // 替换为你实际的业务类名
+
+    /**
+     * 定时任务：每5分钟执行一次（硬编码300000毫秒=5分钟）
+     * fixedRate：固定间隔执行，直接写死5分钟
+     */
+    public void handleInvoice9998RetryTask() {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            // 1. 扫描所有9998重试任务的Redis Key
+            Set<String> redisKeys = jedis.keys("OMS_invoice_retry_scheduled:*");
+            if (redisKeys == null || redisKeys.isEmpty()) {
+                System.out.println("ℹ️ 暂无9998重试任务需要处理");
+                return;
+            }
+            System.out.println("ℹ️ 发现" + redisKeys.size() + "个9998重试任务，开始处理");
+
+            // 2. 遍历每个任务Key，逐个处理
+            for (String redisKey : redisKeys) {
+                String orderNo = redisKey.split(":")[1];
+                try {
+                    // 3. 获取Redis中的任务数据
+                    Map<String, String> taskMap = jedis.hgetAll(redisKey);
+                    String jsonInvoiceStr = taskMap.get("jsonInvoiceStr");
+                    String accessToken = taskMap.get("accessToken");
+                    String getKey = taskMap.get("getKey");
+                    String initiationType = taskMap.get("initiationType");
+                    String retryTimesStr = taskMap.get("retryTimes");
+
+                    // 校验必要参数
+                    if (StringUtils.isBlank(jsonInvoiceStr) || StringUtils.isBlank(orderNo) || StringUtils.isBlank(retryTimesStr)) {
+                        System.err.println("❌ 订单" + orderNo + "任务数据不完整，删除无效任务");
+                        jedis.del(redisKey);
+                        continue;
+                    }
+
+                    // 4. 核心：重试次数扣减（先减1，再判断逻辑）
+                    int remainRetryTimes = Integer.parseInt(retryTimesStr);
+                    int newRemainTimes = remainRetryTimes - 1; // 每次处理减1
+
+                    // 5. 判断是否耗尽次数（第20次，newRemainTimes=0）
+                    if (newRemainTimes <= 0) {
+                        System.err.println("❌ 订单" + orderNo + "重试次数已耗尽（累计20次），执行兜底逻辑handleInvoiceRetryAllFail");
+                        invoiceOMSService.handleInvoiceRetryAllFail(accessToken);
+                        jedis.del(redisKey); // 删除Redis任务，不再重试
+                        continue;
+                    }
+
+                    // 6. 次数未耗尽：更新Redis中的重试次数，再调用接口重试
+                    jedis.hset(redisKey, "retryTimes", String.valueOf(newRemainTimes));
+                    System.out.println("ℹ️ 订单" + orderNo + "剩余重试次数更新为：" + newRemainTimes);
+
+                    // 7. 调用OMS订单上传接口重试
+                    String newResultStr = HttpPostJsonUtil.doPost(
+                            "https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/order/upload",
+                            jsonInvoiceStr
+                    );
+                    System.out.println("✅ 订单" + orderNo + "9998重试调用接口返回：" + newResultStr);
+
+                    // 8. 调用核心重试逻辑处理返回结果
+                    Map<String, Object> resultMap = new HashMap<>();
+                    invoiceOMSService.executeOrderUploadRetry(
+                            newRemainTimes, // 传入扣减后的剩余次数
+                            newResultStr,
+                            jsonInvoiceStr,
+                            accessToken,
+                            orderNo,
+                            resultMap,
+                            getKey,
+                            initiationType
+                    );
+
+                    // 9. 根据接口返回码处理Redis任务
+                    OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(newResultStr, OMSAccessTokenInfo.class);
+                    if (resultTokenInfo != null && resultTokenInfo.getResult() != null) {
+                        String code = resultTokenInfo.getResult().getCode();
+                        if ("0000".equals(code)) {
+                            // 0000成功：删除Redis任务，结束重试
+                            System.out.println("✅ 订单" + orderNo + "9998重试成功，删除Redis任务");
+                            jedis.del(redisKey);
+                        } else if (!"9998".equals(code)) {
+                            // 非9998错误码（如0001/0002等）：执行兜底+删除任务
+                            System.err.println("❌ 订单" + orderNo + "9998重试返回错误码：" + code + "，执行兜底逻辑");
+                            invoiceOMSService.handleInvoiceRetryAllFail(accessToken);
+                            jedis.del(redisKey);
+                        }
+                        // 仍返回9998：不删除Redis任务（已更新次数，下次定时任务继续重试）
+                    } else {
+                        // 解析返回结果失败：执行兜底+删除任务
+                        System.err.println("❌ 订单" + orderNo + "9998重试返回结果解析失败，执行兜底逻辑");
+                        invoiceOMSService.handleInvoiceRetryAllFail(accessToken);
+                        jedis.del(redisKey);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    System.err.println("❌ 处理订单" + orderNo + "9998重试任务异常：" + e.getMessage());
+                    // 异常时不删除任务，下次继续重试（避免因临时异常丢失任务）
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("❌ 9998重试定时任务执行异常：" + e.getMessage());
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/service/OMS/RedInvoiceScheduledService.java

@@ -0,0 +1,290 @@
+package com.jeeplus.modules.workinvoice.service.OMS;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.jeeplus.common.utils.JedisUtils;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSRedInvoiceConfirmResponse;
+import com.jeeplus.modules.workinvoice.utils.HttpPostJsonUtil;
+import com.jeeplus.modules.workinvoice.utils.OMSNationUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import redis.clients.jedis.Jedis;
+
+import java.util.Calendar;
+import java.util.Set;
+import java.util.UUID;
+
+@Service
+@Transactional(readOnly = true)
+@Lazy
+public class RedInvoiceScheduledService {
+
+    private final String appId = "hyc1";
+    private final String appKey = "hyc1";
+
+    @Autowired
+    private OMSDisposeService omsDisposeService;
+
+    public void processAllRedInvoiceTasks() {
+        // 时间窗口校验
+        Calendar now = Calendar.getInstance();
+        int hour = now.get(Calendar.HOUR_OF_DAY);
+        if (hour < 8 || hour >= 18) {
+            System.out.println("[定时任务] 非业务时段，跳过");
+            return;
+        }
+
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            Set<String> taskKeys = jedis.keys("OMS_red_invoice_task:*");
+            if (taskKeys.isEmpty()) {
+                System.out.println("[定时任务] 暂无待处理任务");
+                return;
+            }
+
+            // 遍历处理所有Redis任务
+            for (String taskKey : taskKeys) {
+                String applyNo = taskKey.replace("OMS_red_invoice_task:", "");
+                // 读取Redis参数
+                String remainRetryTimesStr = jedis.hget(taskKey, "remainRetryTimes");
+                String jsonInvoicResultStr = jedis.hget(taskKey, "jsonInvoicResultStr");
+                String accessToken = jedis.hget(taskKey, "accessToken");
+                String startTimeStr = jedis.hget(taskKey, "startTime");
+
+                // 参数校验
+                if (StringUtils.isAnyBlank(remainRetryTimesStr, accessToken, startTimeStr)) {
+                    jedis.del(taskKey);
+                    continue;
+                }
+
+                // 转换参数并执行任务
+                int remainRetryTimes = Integer.parseInt(remainRetryTimesStr);
+                long startTime = Long.parseLong(startTimeStr);
+                executeRedInvoiceTask(applyNo, remainRetryTimes, jsonInvoicResultStr, accessToken, startTime);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+    // ========== 1. 封装所有需要的业务逻辑（独立执行，不依赖原有业务类） ==========
+    /**
+     * 核心：执行单个红冲任务的全流程逻辑
+     */
+    private void executeRedInvoiceTask(String applyNo, int remainRetryTimes, String jsonInvoicResultStr, String accessToken, long startTime) {
+        try {
+            // 步骤1：3天超时判断
+            if (System.currentTimeMillis() - startTime > 259200000L) {
+                System.err.println("❌ 任务["+applyNo+"]超时，触发兜底逻辑");
+                omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+                return;
+            }
+
+            // 步骤2：首次执行（有jsonInvoicResultStr）→ 解析结果，触发查询
+            if (StringUtils.isNotBlank(jsonInvoicResultStr)) {
+                OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(jsonInvoicResultStr, OMSAccessTokenInfo.class);
+                if (null == resultTokenInfo || null == resultTokenInfo.getResult() || !"0000".equals(resultTokenInfo.getResult().getCode())) {
+                    System.err.println("❌ 任务["+applyNo+"]解析失败，触发兜底");
+                    omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                    deleteRedInvoiceTaskFromRedis(applyNo);
+                    return;
+                }
+                // 解析成功，调用查询接口
+                callRedInvoiceConfirmQuery(remainRetryTimes, accessToken, applyNo, startTime);
+                return;
+            }
+
+            // 步骤3：后续重试（无jsonInvoicResultStr）→ 直接调用查询接口
+            callRedInvoiceConfirmQuery(remainRetryTimes, accessToken, applyNo, startTime);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            // 异常后重试次数-1，重新存入Redis
+            if (remainRetryTimes > 1) {
+                saveRedInvoiceTaskToRedis(remainRetryTimes - 1, jsonInvoicResultStr, accessToken, applyNo, startTime);
+            } else {
+                omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+            }
+        }
+    }
+
+    /**
+     * 调用红字确认单查询接口（核心业务逻辑）
+     */
+    private void callRedInvoiceConfirmQuery(int remainRetryTimes, String accessToken, String applyNo, long startTime) {
+        try {
+            // 组装查询参数
+            OMSNationUtil util = new OMSNationUtil();
+            String queryData = util.neatenAllScenarioRedInvoiceConfirmQueryData(applyNo);
+            OMSAccessTokenInfo invoiceDownInfo = new OMSAccessTokenInfo();
+            invoiceDownInfo.setAppId(appId);
+            invoiceDownInfo.setAppKey(appKey);
+            invoiceDownInfo.setExchangeId(UUID.randomUUID().toString());
+            invoiceDownInfo.setAccessToken(accessToken);
+            invoiceDownInfo.setData(queryData);
+            String jsonInvoiceDownStr = JSON.toJSONString(invoiceDownInfo);
+
+            // 调用查询接口
+            String invoiceResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/redApply/query", jsonInvoiceDownStr);
+            if (StringUtils.isBlank(invoiceResultStr)) {
+                throw new RuntimeException("查询接口返回空");
+            }
+
+            // 解析查询结果
+            OMSAccessTokenInfo resultDownInfo = JSON.parseObject(invoiceResultStr, OMSAccessTokenInfo.class);
+            if (null == resultDownInfo.getResult() || !"0000".equals(resultDownInfo.getResult().getCode())) {
+                throw new RuntimeException("查询接口返回错误码：" + (resultDownInfo.getResult() != null ? resultDownInfo.getResult().getCode() : "NULL"));
+            }
+
+            String invoceDownJsonStr = OMSNationUtil.extractFromBase64OnClassStr(resultDownInfo.getData().toString());
+            OMSRedInvoiceConfirmResponse invoiceInfo = JSONObject.parseObject(invoceDownJsonStr, OMSRedInvoiceConfirmResponse.class);
+            String confirmStatus = invoiceInfo.getConfirmStatus();
+
+
+            System.out.println("invoiceInfo的值是："+ invoiceInfo);
+            System.out.println("开票确认单接口查询，返回状态值是："+ invoiceInfo.getConfirmStatus());
+            System.out.println("开票确认单接口查询，返回失败原因是："+ invoiceInfo.getFailCause());
+            System.out.println("开票确认单接口查询，返回开票状态是："+ invoiceInfo.getMakeStatus());
+            System.out.println("开票确认单接口查询，返回红字发票订单号是："+ invoiceInfo.getRedInvOrderNo());
+            // 你原有注释和代码：判断开票接口查询返回值，
+            // 如果是01、04 则表示可直接通过
+            // 如果是02、03、15 则需要每30秒重新访问一次 查询红字确认单查询接口 。理论上应该持续3天（即双方确认最终时间节点）
+            // 如果是其他的，直接告诉发起人 让其确认后重新发起
+
+            // 你原有注释和代码：01 无需确认
+            // 02 销方录入待购方确认
+            // 03 购方录入待销方确认
+            // 04 购销双方已确认
+            // 05 作废（销方录入购方否认）
+            // 06 作废（购方录入销方否认）
+            // 07 作废（超 72 小时未确认）
+            // 08 作废（发起方已撤销）
+            // 09 作废（确认后撤销）
+            // 10 作废（异常凭证）
+            // 15  申请中
+            // 16  申请失败
+            // 判断状态，处理不同分支
+
+            switch (confirmStatus) {
+
+                case "01":
+                case "04":
+
+                    // 你原有注释和代码：访问成功后的后续方法
+                    // 整体默认是自动开票
+                    // 判定 开票状态是否是已开票（03）
+                    if ("3".equals(invoiceInfo.getMakeStatus())) {
+
+                        String redInvOrderNo = invoiceInfo.getRedInvOrderNo();
+                        // 存入Redis，由InvoiceDownloadTask接管
+                        saveInvoiceDownloadTaskToRedis(accessToken, redInvOrderNo);
+                        System.out.println("✅ 解析开票数据任务["+redInvOrderNo+"]已存入Redis，由InvoiceDownloadTask接管重试");
+
+                        deleteRedInvoiceTaskFromRedis(applyNo); // 成功后删除Redis
+                    } else if ("1".equals(invoiceInfo.getMakeStatus()) || "4".equals(invoiceInfo.getMakeStatus())) {
+                        // 开票中，重新存入Redis等待下次重试
+                        saveRedInvoiceTaskToRedis(remainRetryTimes, "", accessToken, applyNo, startTime);
+                    } else {
+                        omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                        deleteRedInvoiceTaskFromRedis(applyNo);
+                    }
+                    break;
+                case "02":
+                case "03":
+                case "15":
+                    // 待确认，重新存入Redis等待下次重试
+                    saveRedInvoiceTaskToRedis(remainRetryTimes, "", accessToken, applyNo, startTime);
+                    break;
+
+                case "05":
+                case "06":
+                case "07":
+                case "08":
+                case "09":
+                case "10":
+                case "16":
+                    // 终止本次红冲操作，通知发起人确认后重新处理
+                    omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                    // 失败后删除Redis任务
+                    deleteRedInvoiceTaskFromRedis(applyNo);
+                    break;
+                default:
+                    break;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            // 接口调用失败，重试次数-1后重新存入Redis
+            if (remainRetryTimes > 1) {
+                saveRedInvoiceTaskToRedis(remainRetryTimes - 1, "", accessToken, applyNo, startTime);
+            } else {
+                omsDisposeService.handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+            }
+        }
+    }
+
+    /**
+     * 存入Redis（定时任务内部使用）
+     */
+    private void saveRedInvoiceTaskToRedis(int remainRetryTimes, String jsonInvoicResultStr, String accessToken, String applyNo, long startTime) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_red_invoice_task:" + applyNo;
+            jedis.hset(redisKey, "remainRetryTimes", String.valueOf(remainRetryTimes));
+            jedis.hset(redisKey, "jsonInvoicResultStr", jsonInvoicResultStr);
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "applyNo", applyNo);
+            jedis.hset(redisKey, "startTime", String.valueOf(startTime));
+            jedis.expire(redisKey, 259200 + 3600);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+    /**
+     * 删除Redis任务
+     */
+    private void deleteRedInvoiceTaskFromRedis(String applyNo) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            jedis.del("OMS_red_invoice_task:" + applyNo);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+
+    // ========== 新增：解析开票数据Redis操作（仅新增，不修改原有） ==========
+    private void saveInvoiceDownloadTaskToRedis(String accessToken, String orderno) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_invoice_download:" + orderno;
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "orderno", orderno);
+            jedis.hset(redisKey, "firstExecTime", String.valueOf(System.currentTimeMillis()));
+            jedis.expire(redisKey, 86400); // 1天过期
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+}

src/main/java/com/jeeplus/modules/workinvoice/utils/OMSNationUtil.java

@@ -6,6 +6,10 @@ import com.alibaba.fastjson.JSONObject;
 import com.google.common.collect.Lists;
 import com.jeeplus.modules.workinvoice.entity.OMS.InvoiceOMSImportInfo;
 import com.jeeplus.modules.workinvoice.entity.OMS.OrderItem;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSAllScenarioRedInvoiceInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSApplyItem;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSFastRedInvoiceInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSRedInvoiceConfirmQueryRequest;
 import org.apache.commons.lang3.StringUtils;
 
 import java.math.BigDecimal;
@@ -15,19 +19,10 @@ import java.util.List;
 
 public class OMSNationUtil {
 
-    public static void main(String[] args) {
-        OMSNationUtil util = new OMSNationUtil();
-        String string = util.neatenData();
-        String accessToken = extractAccessTokenFromBase64(string);
-        String string1 = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/order/upload", accessToken);
-        System.out.println("✅ 提取到的accessToken：" + accessToken);
-        System.out.println("✅ 提取到的string1：" + string1);
-    }
-
     /**
      * 从Base64编码的JSON响应中提取accessToken
      */
-    public static String extractAccessTokenFromBase64(String base64Str) {
+    public static String extractAccessTokenFromBase64(String getKey, String base64Str) {
         if (base64Str == null || com.jeeplus.common.utils.StringUtils.isBlank(base64Str)) {
             return "";
         }
@@ -36,28 +31,22 @@ public class OMSNationUtil {
         String jsonStr = new String(decodeBytes, StandardCharsets.UTF_8);
         // 2. 解析JSON提取accessToken
         JSONObject jsonObject = JSONObject.parseObject(jsonStr);
-        return jsonObject.getString("accessToken");
+        return jsonObject.getString(getKey);
     }
 
-    public static InvoiceOMSImportInfo getInvoiceInfo(String base64Str) {
-        // 1. 调用你的解码方法，获取JSON字符串
-        String jsonResult = getDownFromBase64(base64Str);
-
-        // 2. 非空校验
-        if (StringUtils.isBlank(jsonResult)) {
-            System.err.println("解码后返回的JSON字符串为空，无法转换实体类");
-            return null;
-        }
-
-        // 3. 转换实体类+异常捕获
-        InvoiceOMSImportInfo invoiceInfo = null;
-        try {
-            invoiceInfo = JSONObject.parseObject(jsonResult, InvoiceOMSImportInfo.class);
-        } catch (Exception e) {
-            System.err.println("JSON字符串转InvoiceOMSImportInfo实体类失败：" + e.getMessage());
-            e.printStackTrace();
+    /**
+     * 从Base64编码的JSON响应中提取accessToken
+     */
+    public static String extractFromBase64OnClassStr(String base64Str) {
+        if (base64Str == null || com.jeeplus.common.utils.StringUtils.isBlank(base64Str)) {
+            return "";
         }
-        return invoiceInfo;
+        // 1. 解码Base64得到JSON字符串
+        byte[] decodeBytes = Base64.getDecoder().decode(base64Str);
+        String jsonStr = new String(decodeBytes, StandardCharsets.UTF_8);
+        // 2. 解析JSON提取accessToken
+        JSONObject jsonObject = JSONObject.parseObject(jsonStr);
+        return jsonObject.toJSONString();
     }
 
     // ========== 你的原方法（无需修改，保持不变） ==========
@@ -94,59 +83,70 @@ public class OMSNationUtil {
         }
     }
 
-    /**
-     * Base64加密(编码)方法 - 配套上面的解码方法
-     * 入参：原始JSON字符串
-     * 出参：Base64编码后的字符串 (UTF-8编码，防中文乱码，和解码逻辑完全匹配)
-     */
-    public static String encryptJsonToBase64(String jsonStr) {
-        if (jsonStr == null || com.jeeplus.common.utils.StringUtils.isBlank(jsonStr)) {
-            return "";
-        }
-        // 1. JSON字符串转字节数组(必须指定UTF-8，你的JSON有中文，防止乱码)
-        byte[] jsonBytes = jsonStr.getBytes(StandardCharsets.UTF_8);
-        // 2. 进行Base64编码（加密）
-        return Base64.getEncoder().encodeToString(jsonBytes);
-    }
+
+    private final String deptCode = "500102204228315131";
+    private final String sellerTaxno = "500102204228315131";
+    private final String goodstaxno = "109050901"; //税收分类编码(电脑)
+    //private final String goodstaxno = "3070401"; //税收分类编码(餐饮)
+    private final String goodsName = "电脑配件"; //税收分类编码(餐饮)
 
 
     /**
+     * 开蓝票
      * 整理数据明文
      */
-    public String neatenData() {
+    public String neatenData(String orderno) {
         List<OrderItem> orderItems = Lists.newArrayList();
 
         InvoiceOMSImportInfo omsImportInfo = new InvoiceOMSImportInfo();
-        omsImportInfo.setDeptCode("7777");
-        omsImportInfo.setOrderno("fff79669f3774c2a8be557e909a746d5");
+        omsImportInfo.setDeptCode(deptCode);
+        omsImportInfo.setOrderno(orderno);
         omsImportInfo.setSellerName("深圳市松胜电子有限公司");
-        omsImportInfo.setSellerTaxno("500102204228315131");
+        omsImportInfo.setSellerTaxno(sellerTaxno); //销方纳税人识别号，必填
         omsImportInfo.setInvKind("02");
         omsImportInfo.setInvType("01");
 
         //添加购买方信息
-        omsImportInfo.setBuyerName("江苏兴光项目管理有限公司");
-        omsImportInfo.setBuyerTaxno("91320000746823994F");
+        omsImportInfo.setBuyerName("深圳市爱人人餐饮服务有限公司");
+        omsImportInfo.setBuyerTaxno("500102203117204029");
+        //omsImportInfo.setRemarks("zzsytdm01,xfsytdm01");
 
 
         OrderItem orderItem = new OrderItem();
         orderItem.setLineCode("1");
         orderItem.setLineType("00");
-        orderItem.setLineType("00");
         //添加商品名称
         //orderItem.setGoodsCode("1001");
-        orderItem.setGoodsName("电脑");
+        orderItem.setGoodsName(goodsName);
         orderItem.setQty(BigDecimal.valueOf(1));
-        orderItem.setPrice(BigDecimal.valueOf(100000.00));
-        orderItem.setPriceTaxFlag("0"); //含税状态
+        //orderItem.setPrice(BigDecimal.valueOf(100.00));
+        orderItem.setPriceTaxFlag("1"); //含税状态 0不含税；1含税
         orderItem.setTaxrate(BigDecimal.valueOf(0.01)); //税率
-        orderItem.setAmount(BigDecimal.valueOf(100000.00)); //金额
-        orderItem.setTax(BigDecimal.valueOf(1000.00));//税额
-        orderItem.setTaxamount(BigDecimal.valueOf(101000.00));//含税金额
-        orderItem.setGoodstaxno("109050901");//税收分类编码
-
+        //orderItem.setAmount(BigDecimal.valueOf(100.00)); //金额
+        //orderItem.setTax(BigDecimal.valueOf(1.00));//税额
+        orderItem.setTaxamount(BigDecimal.valueOf(101.00));//含税金额
+        //orderItem.setGoodstaxno("109050901");//税收分类编码(电脑)
+        orderItem.setGoodstaxno(goodstaxno);//税收分类编码(餐饮)
 
         orderItems.add(orderItem);
+
+
+        /*OrderItem orderItem2 = new OrderItem();
+        orderItem2.setLineCode("2");
+        orderItem2.setLineType("00");
+        //添加商品名称
+        orderItem2.setGoodsName("电脑固态硬盘256G");
+        orderItem2.setQty(BigDecimal.valueOf(1));
+        orderItem2.setPrice(BigDecimal.valueOf(50.00));
+        orderItem2.setPriceTaxFlag("0"); //含税状态
+        orderItem2.setTaxrate(BigDecimal.valueOf(0.01)); //税率
+        orderItem2.setAmount(BigDecimal.valueOf(50.00)); //金额
+        orderItem2.setTax(BigDecimal.valueOf(0.5));//税额
+        orderItem2.setTaxamount(BigDecimal.valueOf(50.5));//含税金额
+        orderItem2.setGoodstaxno(goodstaxno);//税收分类编码
+
+
+        orderItems.add(orderItem2);*/
         omsImportInfo.setOrderItems(orderItems);
         // 核心一行代码：Java对象 转 JSON格式字符串
         String jsonStr = JSON.toJSONString(omsImportInfo);
@@ -158,4 +158,114 @@ public class OMSNationUtil {
     }
 
 
+
+    /**
+     * 开红票
+     * 整理数据明文
+     */
+    public String neatenFastRedInvoiceData(String allEinvno) {
+
+        OMSFastRedInvoiceInfo omsImportInfo = new OMSFastRedInvoiceInfo();
+        omsImportInfo.setDeptCode(deptCode);
+        omsImportInfo.setAllEinvno(allEinvno);
+        omsImportInfo.setRedReason("02");
+
+        // 核心一行代码：Java对象 转 JSON格式字符串
+        String jsonStr = JSON.toJSONString(omsImportInfo);
+
+        // 2. 核心新增：JSON字符串 转 标准Base64编码字符串【解决你的核心问题】
+        String base64Str = Base64.getEncoder().encodeToString(jsonStr.getBytes(StandardCharsets.UTF_8));
+
+        return base64Str;
+    }
+
+
+    /**
+     * 开红票（全类型）
+     * 整理数据明文
+     */
+    public String neatenAllScenarioRedInvoiceData(String applyNo, String originalInvno) {
+        List<OMSApplyItem> orderItems = Lists.newArrayList();
+
+        OMSAllScenarioRedInvoiceInfo omsAllScenarioRedInvoiceInfo = new OMSAllScenarioRedInvoiceInfo();
+        omsAllScenarioRedInvoiceInfo.setDeptCode(deptCode);
+        omsAllScenarioRedInvoiceInfo.setApplyNo(applyNo);   //红字发票申请单号
+        omsAllScenarioRedInvoiceInfo.setApplyIdentity("0");
+        omsAllScenarioRedInvoiceInfo.setSellerTaxno(sellerTaxno);
+        omsAllScenarioRedInvoiceInfo.setSellerName("深圳市松胜电子有限公司");
+        //添加购买方信息
+        omsAllScenarioRedInvoiceInfo.setBuyerName("深圳市爱人人餐饮服务有限公司");
+        omsAllScenarioRedInvoiceInfo.setBuyerTaxno("500102203117204029");
+        //原蓝票发票号码
+        omsAllScenarioRedInvoiceInfo.setOriginalInvno(originalInvno);
+        //原蓝票发票类型
+        omsAllScenarioRedInvoiceInfo.setOriginalInvType("01");
+        //原蓝票金额
+        omsAllScenarioRedInvoiceInfo.setOriginalInvAmount("100");
+        //原蓝票税额
+        omsAllScenarioRedInvoiceInfo.setOriginalInvTax("1");
+        //合计金额（不含税）
+        omsAllScenarioRedInvoiceInfo.setTotalAmount("-100");
+        //合计税额
+        omsAllScenarioRedInvoiceInfo.setTotalTax("-1.00");
+        //价税合计
+        omsAllScenarioRedInvoiceInfo.setTotalTaxamount("-101.00");
+
+        //* 冲红原因（必填）
+        //* 01:开票有误 02:销货退回 03:服务中止 04:销售折让
+
+        omsAllScenarioRedInvoiceInfo.setRedReason("01");
+        //是否自动开票
+        omsAllScenarioRedInvoiceInfo.setAutoMakeInv("Y");
+
+
+        OMSApplyItem orderItem = new OMSApplyItem();
+        orderItem.setLineCode("1");
+        //添加商品名称
+        orderItem.setGoodsName(goodsName);
+
+        //orderItem.setQty(BigDecimal.valueOf(1));
+        //orderItem.setPrice(BigDecimal.valueOf(100.00));
+
+        orderItem.setAmount(BigDecimal.valueOf(-100)); //金额
+        orderItem.setTax(BigDecimal.valueOf(-1.00));//税额
+        orderItem.setTaxrate(BigDecimal.valueOf(0.01)); //税率
+        orderItem.setTaxamount(BigDecimal.valueOf(-101.00));//含税金额
+        orderItem.setGoodstaxno(goodstaxno);//税收分类编码
+        orderItem.setOriLineCode("1");//对应蓝票明细序号
+
+        orderItems.add(orderItem);
+        omsAllScenarioRedInvoiceInfo.setApplyItems(orderItems);
+
+        // 核心一行代码：Java对象 转 JSON格式字符串
+        String jsonStr = JSON.toJSONString(omsAllScenarioRedInvoiceInfo);
+
+        // 2. 核心新增：JSON字符串 转 标准Base64编码字符串【解决你的核心问题】
+        String base64Str = Base64.getEncoder().encodeToString(jsonStr.getBytes(StandardCharsets.UTF_8));
+
+        return base64Str;
+    }
+
+
+    /**
+     * 查询红字确认单查询接口结果的参数
+     * @param applyNo
+     * @return
+     */
+    public String neatenAllScenarioRedInvoiceConfirmQueryData(String applyNo) {
+
+        OMSRedInvoiceConfirmQueryRequest omsImportInfo = new OMSRedInvoiceConfirmQueryRequest();
+        omsImportInfo.setDeptCode(deptCode);
+        omsImportInfo.setApplyNo(applyNo);
+        omsImportInfo.setApplyIdentity("0");
+
+        // 核心一行代码：Java对象 转 JSON格式字符串
+        String jsonStr = JSON.toJSONString(omsImportInfo);
+
+        // 2. 核心新增：JSON字符串 转 标准Base64编码字符串【解决你的核心问题】
+        String base64Str = Base64.getEncoder().encodeToString(jsonStr.getBytes(StandardCharsets.UTF_8));
+
+        return base64Str;
+    }
+
 }

src/main/java/com/jeeplus/modules/workinvoice/utils/RedInvoiceScheduledTask.java

@@ -0,0 +1,276 @@
+package com.jeeplus.modules.workinvoice.utils;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.jeeplus.modules.workinvoice.entity.OMS.OMSAccessTokenInfo;
+import com.jeeplus.modules.workinvoice.entity.OMS.fastRed.OMSRedInvoiceConfirmResponse;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.apache.commons.lang3.StringUtils;
+import redis.clients.jedis.Jedis;
+
+import java.util.Calendar;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * 红冲任务独立执行器（仅从Redis取数，全量执行业务逻辑，8:00-18:00每小时执行）
+ */
+@Component
+public class RedInvoiceScheduledTask {
+
+    private final String appId = "hyc1";
+    private final String appKey = "hyc1";
+
+
+    // ========== 2. 定时任务入口（8:00-18:00每小时执行） ==========
+    @Scheduled(cron = "0 0 */1 * * ?")
+    public void processAllRedInvoiceTasks() {
+        // 时间窗口校验
+        Calendar now = Calendar.getInstance();
+        int hour = now.get(Calendar.HOUR_OF_DAY);
+        if (hour < 8 || hour >= 18) {
+            System.out.println("[定时任务] 非业务时段，跳过");
+            return;
+        }
+
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            Set<String> taskKeys = jedis.keys("OMS_red_invoice_task:*");
+            if (taskKeys.isEmpty()) {
+                System.out.println("[定时任务] 暂无待处理任务");
+                return;
+            }
+
+            // 遍历处理所有Redis任务
+            for (String taskKey : taskKeys) {
+                String applyNo = taskKey.replace("OMS_red_invoice_task:", "");
+                // 读取Redis参数
+                String remainRetryTimesStr = jedis.hget(taskKey, "remainRetryTimes");
+                String jsonInvoicResultStr = jedis.hget(taskKey, "jsonInvoicResultStr");
+                String accessToken = jedis.hget(taskKey, "accessToken");
+                String startTimeStr = jedis.hget(taskKey, "startTime");
+
+                // 参数校验
+                if (StringUtils.isAnyBlank(remainRetryTimesStr, accessToken, startTimeStr)) {
+                    jedis.del(taskKey);
+                    continue;
+                }
+
+                // 转换参数并执行任务
+                int remainRetryTimes = Integer.parseInt(remainRetryTimesStr);
+                long startTime = Long.parseLong(startTimeStr);
+                executeRedInvoiceTask(applyNo, remainRetryTimes, jsonInvoicResultStr, accessToken, startTime);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+    // ========== 1. 封装所有需要的业务逻辑（独立执行，不依赖原有业务类） ==========
+    /**
+     * 核心：执行单个红冲任务的全流程逻辑
+     */
+    private void executeRedInvoiceTask(String applyNo, int remainRetryTimes, String jsonInvoicResultStr, String accessToken, long startTime) {
+        try {
+            // 步骤1：3天超时判断
+            if (System.currentTimeMillis() - startTime > 259200000L) {
+                System.err.println("❌ 任务["+applyNo+"]超时，触发兜底逻辑");
+                handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+                return;
+            }
+
+            // 步骤2：首次执行（有jsonInvoicResultStr）→ 解析结果，触发查询
+            if (StringUtils.isNotBlank(jsonInvoicResultStr)) {
+                OMSAccessTokenInfo resultTokenInfo = JSON.parseObject(jsonInvoicResultStr, OMSAccessTokenInfo.class);
+                if (null == resultTokenInfo || null == resultTokenInfo.getResult() || !"0000".equals(resultTokenInfo.getResult().getCode())) {
+                    System.err.println("❌ 任务["+applyNo+"]解析失败，触发兜底");
+                    handleInvoiceRetryAllFail(accessToken);
+                    deleteRedInvoiceTaskFromRedis(applyNo);
+                    return;
+                }
+                // 解析成功，调用查询接口
+                callRedInvoiceConfirmQuery(remainRetryTimes, accessToken, applyNo, startTime);
+                return;
+            }
+
+            // 步骤3：后续重试（无jsonInvoicResultStr）→ 直接调用查询接口
+            callRedInvoiceConfirmQuery(remainRetryTimes, accessToken, applyNo, startTime);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            // 异常后重试次数-1，重新存入Redis
+            if (remainRetryTimes > 1) {
+                saveRedInvoiceTaskToRedis(remainRetryTimes - 1, jsonInvoicResultStr, accessToken, applyNo, startTime);
+            } else {
+                handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+            }
+        }
+    }
+
+    /**
+     * 调用红字确认单查询接口（核心业务逻辑）
+     */
+    private void callRedInvoiceConfirmQuery(int remainRetryTimes, String accessToken, String applyNo, long startTime) {
+        try {
+            // 组装查询参数
+            OMSNationUtil util = new OMSNationUtil();
+            String queryData = util.neatenAllScenarioRedInvoiceConfirmQueryData(applyNo);
+            OMSAccessTokenInfo invoiceDownInfo = new OMSAccessTokenInfo();
+            invoiceDownInfo.setAppId(appId);
+            invoiceDownInfo.setAppKey(appKey);
+            invoiceDownInfo.setExchangeId(UUID.randomUUID().toString());
+            invoiceDownInfo.setAccessToken(accessToken);
+            invoiceDownInfo.setData(queryData);
+            String jsonInvoiceDownStr = JSON.toJSONString(invoiceDownInfo);
+
+            // 调用查询接口
+            String invoiceResultStr = HttpPostJsonUtil.doPost("https://oms-sandbox.einvoice.js.cn:7079/prod-api/output/server/redApply/query", jsonInvoiceDownStr);
+            if (StringUtils.isBlank(invoiceResultStr)) {
+                throw new RuntimeException("查询接口返回空");
+            }
+
+            // 解析查询结果
+            OMSAccessTokenInfo resultDownInfo = JSON.parseObject(invoiceResultStr, OMSAccessTokenInfo.class);
+            if (null == resultDownInfo.getResult() || !"0000".equals(resultDownInfo.getResult().getCode())) {
+                throw new RuntimeException("查询接口返回错误码：" + (resultDownInfo.getResult() != null ? resultDownInfo.getResult().getCode() : "NULL"));
+            }
+
+            String invoceDownJsonStr = OMSNationUtil.extractFromBase64OnClassStr(resultDownInfo.getData().toString());
+            OMSRedInvoiceConfirmResponse invoiceInfo = JSONObject.parseObject(invoceDownJsonStr, OMSRedInvoiceConfirmResponse.class);
+            String confirmStatus = invoiceInfo.getConfirmStatus();
+
+            // 判断状态，处理不同分支
+            switch (confirmStatus) {
+                case "01":
+                case "04":
+                    if ("3".equals(invoiceInfo.getMakeStatus())) {
+                        // ========== 仅此处微调：删除直接调用，改为存入Redis ==========
+                        // 原代码 ↓
+                        // ThreadPoolUtil.executeDelay(30, () -> {
+                        //     executeInvoiceDownloadWithRetry(5, accessToken, invoiceInfo.getRedInvOrderNo());
+                        // });
+                        // 新代码 ↑
+                        String redInvOrderNo = invoiceInfo.getRedInvOrderNo();
+                        // 存入Redis，由InvoiceDownloadTask接管
+                        saveInvoiceDownloadTaskToRedis(accessToken, redInvOrderNo);
+                        System.out.println("✅ 解析开票数据任务["+redInvOrderNo+"]已存入Redis，由InvoiceDownloadTask接管重试");
+
+                        deleteRedInvoiceTaskFromRedis(applyNo); // 成功后删除Redis
+                    } else if ("1".equals(invoiceInfo.getMakeStatus()) || "4".equals(invoiceInfo.getMakeStatus())) {
+                        // 开票中，重新存入Redis等待下次重试
+                        saveRedInvoiceTaskToRedis(remainRetryTimes, "", accessToken, applyNo, startTime);
+                    } else {
+                        handleInvoiceRetryAllFail(accessToken);
+                        deleteRedInvoiceTaskFromRedis(applyNo);
+                    }
+                    break;
+                case "02":
+                case "03":
+                case "15":
+                    // 待确认，重新存入Redis等待下次重试
+                    saveRedInvoiceTaskToRedis(remainRetryTimes, "", accessToken, applyNo, startTime);
+                    break;
+                default:
+                    // 失败状态，兜底+删除Redis
+                    handleInvoiceRetryAllFail(accessToken);
+                    deleteRedInvoiceTaskFromRedis(applyNo);
+                    break;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            // 接口调用失败，重试次数-1后重新存入Redis
+            if (remainRetryTimes > 1) {
+                saveRedInvoiceTaskToRedis(remainRetryTimes - 1, "", accessToken, applyNo, startTime);
+            } else {
+                handleInvoiceRetryAllFail(accessToken);
+                deleteRedInvoiceTaskFromRedis(applyNo);
+            }
+        }
+    }
+
+    /**
+     * 兜底逻辑
+     */
+    public void handleInvoiceRetryAllFail(String accessToken) {
+        System.err.println("📢 执行失败兜底逻辑：更新系统状态 + 通知发起人");
+        // 此处替换为你的实际兜底逻辑（如更新数据库、发送通知等）
+    }
+
+    /**
+     * 存入Redis（定时任务内部使用）
+     */
+    private void saveRedInvoiceTaskToRedis(int remainRetryTimes, String jsonInvoicResultStr, String accessToken, String applyNo, long startTime) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "OMS_red_invoice_task:" + applyNo;
+            jedis.hset(redisKey, "remainRetryTimes", String.valueOf(remainRetryTimes));
+            jedis.hset(redisKey, "jsonInvoicResultStr", jsonInvoicResultStr);
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "applyNo", applyNo);
+            jedis.hset(redisKey, "startTime", String.valueOf(startTime));
+            jedis.expire(redisKey, 259200 + 3600);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+    /**
+     * 删除Redis任务
+     */
+    private void deleteRedInvoiceTaskFromRedis(String applyNo) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            jedis.del("OMS_red_invoice_task:" + applyNo);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+    // ========== 3. 工具类依赖（替换为你的实际工具类） ==========
+    // 此处仅为占位，需替换为你项目中实际的工具类实例/注入
+    public static class JedisUtils {
+        public static Jedis getResource() {
+            // 替换为你的Redis连接获取逻辑
+            return null;
+        }
+    }
+
+    private static class ThreadPoolUtil {
+        public static void executeDelay(int seconds, Runnable runnable) {
+            // 替换为你的线程池延迟执行逻辑
+            new Thread(runnable).start();
+        }
+    }
+
+    // ========== 新增：解析开票数据Redis操作（仅新增，不修改原有） ==========
+    private void saveInvoiceDownloadTaskToRedis(String accessToken, String orderno) {
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtils.getResource();
+            String redisKey = "red_invoice_download:" + orderno;
+            jedis.hset(redisKey, "accessToken", accessToken);
+            jedis.hset(redisKey, "orderno", orderno);
+            jedis.hset(redisKey, "firstExecTime", String.valueOf(System.currentTimeMillis()));
+            jedis.expire(redisKey, 86400); // 1天过期
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (jedis != null) jedis.close();
+        }
+    }
+
+
+    // 其他实体类（OMSNationUtil、OMSAccessTokenInfo等）替换为你项目中的实际类
+}

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectMessageList.jsp

@@ -1553,11 +1553,11 @@
 						}
 						if(paperNoArchivedDays != null && paperNoArchivedDays != undefined && '' != paperNoArchivedDays){
 							if (d.submitMoney=="1"){
-								if(5 != d.downProjectReportRecordStatus){
+								if(5 != d.downProjectReportRecordStatus && "10" != d.downProjectReportRecordStatus){
 									xml+="<span style='margin-left: 5px;' title='超期天数'>" + paperNoArchivedDays + "天" + "</span>";
 								}
 							}else if (d.submitMoney=="2"){
-								if(5 != d.paperFilingStatus){
+								if(5 != d.paperFilingStatus && "10" != d.paperFilingStatus){
 									xml+="<span style='margin-left: 5px;' title='超期天数'>" + paperNoArchivedDays + "天" + "</span>";
 								}
 							}