bugfix：三方一对多his场景处理

src/main/java/com/saye/hospitalgd/mapper/TransactionDetailMapper.java

@@ -76,6 +76,16 @@ public interface TransactionDetailMapper {
 
     void deleteThirdUnilateralByIddh(HashMap<Object, Object> map) throws Exception;
 
+    /**
+     * 根据订单号删除third_join_his中所有相关记录（用于一对多场景）
+     */
+    void deleteThirdJoinDataByI_DDH(HashMap<Object, Object> map) throws Exception;
+
+    /**
+     * 更新third_join_his中的银行单边记录，补充HIS数据（用于一对多场景）
+     */
+    void updateThirdJoinDataWithHisData(HashMap<Object, Object> map) throws Exception;
+
     void addNotUniqueData(List<HashMap<Object, Object>> list) throws Exception;
     
     /**

src/main/java/com/saye/hospitalgd/scheduler/jobMethod/ReconciliationMethod.java

@@ -288,6 +288,121 @@ public class ReconciliationMethod {
                             }
                         }
                     } else if ("1".equals(check_result) && "2".equals(err_type)) {
+                        //三方单边账 先检查是否是一对多的情况（HIS端有多条记录，金额累加等于银行金额）
+                        boolean isManyToOneMatched = false;
+                        if (!"".equals(i_ddh)) {
+                            // 查询HIS端是否有相同订单号的记录（使用PlatformTransId查询）
+                            HashMap<Object, Object> manyToOneSearchMap = new HashMap<>();
+                            manyToOneSearchMap.put("platformTransId", i_ddh); // 使用银行订单号作为PlatformTransId查询HIS记录
+                            manyToOneSearchMap.put("h_jylx", i_jylx);
+                            manyToOneSearchMap.put("trade_date", thistrade_date);
+                            manyToOneSearchMap.put("orderby_je", "true");
+                            
+                            List<HashMap<Object, Object>> hisList = hisbillsHistoryService.findHisDetailByParam(manyToOneSearchMap);
+                            
+                            // 如果HIS端有多条记录，检查金额累加是否等于银行金额
+                            if (hisList != null && hisList.size() > 1) {
+                                System.out.println("找到一对多场景：银行订单号=" + i_ddh + ", HIS记录数=" + hisList.size());
+                                java.math.BigDecimal hisTotal = java.math.BigDecimal.ZERO;
+                                for (HashMap<Object, Object> hisItem : hisList) {
+                                    String amountStr = StringDUtil.changeNullToEmpty(hisItem.get("AMOUNT"));
+                                    if (!"".equals(amountStr)) {
+                                        try {
+                                            hisTotal = hisTotal.add(AmountUtil.toBigDecimal(amountStr));
+                                        } catch (Exception e) {
+                                            hisTotal = null;
+                                            break;
+                                        }
+                                    }
+                                }
+                                
+                                if (hisTotal != null) {
+                                    java.math.BigDecimal hisTotalDecimal = AmountUtil.toBigDecimal(hisTotal.toString());
+                                    java.math.BigDecimal bankAmtDecimal = AmountUtil.toBigDecimal(i_jyje);
+                                    
+                                    if (AmountUtil.isAmountEqual(hisTotalDecimal, bankAmtDecimal)) {
+                                        System.out.println("一对多金额匹配成功：银行金额=" + i_jyje + ", HIS总金额=" + hisTotal.toString());
+                                        // 找到一对多匹配，构造完整记录并更新third_join_his
+                                        HashMap<Object, Object> firstHisRecord = hisList.get(0);
+                                        
+                                        String aggregatedAmount = hisTotal.toString();
+                                        String hJylx = StringDUtil.changeNullToEmpty(firstHisRecord.get("TRADINGSTATUS"));
+                                        String tradeTimeForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("TRADETIME"));
+                                        String payTypeForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("PAYTYPE"));
+                                        String hisopernumForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("HISOPERCODE"));
+                                        String bizTypeForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("BIZTYPE"));
+                                        String patientidForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("PATIENTID"));
+                                        String patientnameForManyToOne = StringDUtil.changeNullToEmpty(firstHisRecord.get("PATIENTNAME"));
+                                        
+                                        HashMap<Object, Object> addMap = new HashMap<>();
+                                        addMap.put("jysj", jysj);
+                                        addMap.put("i_ddh", i_ddh);
+                                        addMap.put("i_jyje", i_jyje);
+                                        addMap.put("i_jylx", i_jylx);
+                                        addMap.put("i_jyqd", i_jyqd);
+                                        addMap.put("tradeTime", tradeTimeForManyToOne);
+                                        addMap.put("tranID", i_ddh); // 使用银行订单号作为TranID
+                                        addMap.put("BizType", bizTypeForManyToOne);
+                                        addMap.put("h_jylx", hJylx);
+                                        addMap.put("amount", aggregatedAmount);
+                                        addMap.put("payType", payTypeForManyToOne);
+                                        addMap.put("hisOperNum", hisopernumForManyToOne);
+                                        addMap.put("patientid", patientidForManyToOne);
+                                        addMap.put("patientname", patientnameForManyToOne);
+                                        addMap.put("sort_date", tradeTimeForManyToOne);
+                                        addMap.put("trade_date", thistrade_date);
+                                        // 更新现有记录，补充HIS数据（不删除，保持记录ID不变，不影响统计）
+                                        HashMap<Object, Object> updateMap = new HashMap<>();
+                                        updateMap.put("trade_date", thistrade_date);
+                                        updateMap.put("i_ddh", i_ddh);
+                                        updateMap.put("tradeTime", tradeTimeForManyToOne);
+                                        updateMap.put("tranID", i_ddh);
+                                        updateMap.put("BizType", bizTypeForManyToOne);
+                                        updateMap.put("h_jylx", hJylx);
+                                        updateMap.put("amount", aggregatedAmount);
+                                        updateMap.put("payType", payTypeForManyToOne);
+                                        updateMap.put("hisOperNum", hisopernumForManyToOne);
+                                        updateMap.put("patientid", patientidForManyToOne);
+                                        updateMap.put("patientname", patientnameForManyToOne);
+                                        updateMap.put("sort_date", tradeTimeForManyToOne);
+                                        updateMap.put("err_type", "");
+                                        updateMap.put("check_result", "0");
+                                        
+                                        System.out.println("主循环：更新third_join_his记录，补充HIS数据：trade_date=" + thistrade_date + ", i_ddh=" + i_ddh + ", amount=" + aggregatedAmount + ", check_result=0");
+                                        // 先查询是否存在该记录
+                                        HashMap<Object, Object> checkBeforeUpdate = new HashMap<>();
+                                        checkBeforeUpdate.put("trade_date", thistrade_date);
+                                        checkBeforeUpdate.put("i_ddh", i_ddh);
+                                        List<HashMap<Object, Object>> beforeUpdate = transactionDetailService.findHisAndThirdJoinDataByParam(checkBeforeUpdate);
+                                        System.out.println("主循环：更新前查询到记录数=" + (beforeUpdate != null ? beforeUpdate.size() : 0));
+                                        
+                                        transactionDetailService.updateThirdJoinDataWithHisData(updateMap);
+                                        
+                                        // 更新后再次查询确认
+                                        List<HashMap<Object, Object>> afterUpdate = transactionDetailService.findHisAndThirdJoinDataByParam(checkBeforeUpdate);
+                                        System.out.println("主循环：更新后查询到记录数=" + (afterUpdate != null ? afterUpdate.size() : 0));
+                                        if (afterUpdate != null && afterUpdate.size() > 0) {
+                                            String checkResult = StringDUtil.changeNullToEmpty(afterUpdate.get(0).get("CHECK_RESULT"));
+                                            System.out.println("主循环：更新后check_result=" + checkResult);
+                                        }
+                                        
+                                        // 清除单边账表中的记录
+                                        HashMap<Object, Object> delBankUnilateralMap = new HashMap<>();
+                                        delBankUnilateralMap.put("trade_date", thistrade_date);
+                                        delBankUnilateralMap.put("i_ddh", i_ddh);
+                                        unilateralService.deleteBankUnilateralByI_DDH(delBankUnilateralMap);
+                                        
+                                        isManyToOneMatched = true;
+                                    }
+                                }
+                            }
+                        }
+                        
+                        // 如果已经处理了一对多的情况，跳过后续的单边账处理
+                        if (isManyToOneMatched) {
+                            continue;
+                        }
+                        
                         //三方单边账 查询历史单边账表是否已有记录 有不动 没有添加
 
                         List<HashMap<Object, Object>> unilateralList = null;
@@ -600,14 +715,45 @@ public class ReconciliationMethod {
                                 addMap.put("is_active", "1");
                                 addMap.put("join_id", "");
 
-                                // 删除第三方单边账记录（third_join_his 中 err_type = '2'）
+                                // 先检查是否已经有对平的记录（check_result='0'），如果有则只更新，不删除
+                                HashMap<Object, Object> checkMap = new HashMap<>();
+                                checkMap.put("trade_date", trade_date);
+                                checkMap.put("i_ddh", i_ddh);
+                                checkMap.put("check_result", "0");
+                                List<HashMap<Object, Object>> existingRecords = transactionDetailService.findHisAndThirdJoinDataByParam(checkMap);
+                                
+                                System.out.println("notUniqueList循环：检查已对平记录，i_ddh=" + i_ddh + ", 找到记录数=" + (existingRecords != null ? existingRecords.size() : 0));
+                                
+                                if (existingRecords != null && existingRecords.size() > 0) {
+                                    // 如果已经有对平的记录，只更新它（确保数据完整，不删除记录）
+                                    System.out.println("notUniqueList循环：发现已对平记录，只更新不删除：i_ddh=" + i_ddh);
+                                    HashMap<Object, Object> updateMap = new HashMap<>();
+                                    updateMap.put("trade_date", trade_date);
+                                    updateMap.put("i_ddh", i_ddh);
+                                    updateMap.put("tradeTime", tradeTime);
+                                    updateMap.put("tranID", tranid);
+                                    updateMap.put("BizType", bizType);
+                                    updateMap.put("h_jylx", hJylx);
+                                    updateMap.put("amount", amount);
+                                    updateMap.put("payType", payType);
+                                    updateMap.put("hisOperNum", hisopernum);
+                                    updateMap.put("patientid", patientid);
+                                    updateMap.put("patientname", patientname);
+                                    updateMap.put("sort_date", tradeTime);
+                                    updateMap.put("err_type", "");
+                                    updateMap.put("check_result", "0");
+                                    transactionDetailService.updateThirdJoinDataWithHisData(updateMap);
+                                } else {
+                                    // 如果没有已对平的记录，才删除并重新插入（这种情况不应该发生，因为主循环应该已经处理了）
+                                    System.out.println("notUniqueList循环：未找到已对平记录，删除并重新插入：i_ddh=" + i_ddh);
                                     HashMap<Object, Object> delThirdMap = new HashMap<>();
                                     delThirdMap.put("trade_date", trade_date);
                                     delThirdMap.put("i_ddh", i_ddh);
-                                transactionDetailService.deleteThirdUnilateralByIddh(delThirdMap);
+                                    transactionDetailService.deleteThirdJoinDataByI_DDH(delThirdMap);
                                     
-                                // 立即写入聚合后的正常对账记录
+                                    // 立即写入聚合后的正常对账记录（包含完整的HIS和银行数据）
                                     transactionDetailService.addNotUniqueData(Collections.singletonList(addMap));
+                                }
 
                                 // 清除因银行单边账先生成而残留的记录
                                 HashMap<Object, Object> delBankUnilateralMap = new HashMap<>();

src/main/java/com/saye/hospitalgd/service/TransactionDetailService.java

@@ -73,6 +73,16 @@ public interface TransactionDetailService {
 
     void deleteThirdUnilateralByIddh(HashMap<Object, Object> map) throws Exception;
 
+    /**
+     * 根据订单号删除third_join_his中所有相关记录（用于一对多场景）
+     */
+    void deleteThirdJoinDataByI_DDH(HashMap<Object, Object> map) throws Exception;
+
+    /**
+     * 更新third_join_his中的银行单边记录，补充HIS数据（用于一对多场景）
+     */
+    void updateThirdJoinDataWithHisData(HashMap<Object, Object> map) throws Exception;
+
     /**
      * @description: 添加处理后的非唯一记录回数据
      * @author thuang

src/main/java/com/saye/hospitalgd/service/impl/TransactionDetailServiceImpl.java

@@ -164,6 +164,16 @@ public class TransactionDetailServiceImpl implements TransactionDetailService {
         transactionDetailMapper.deleteThirdUnilateralByIddh(map);
     }
 
+    @Override
+    public void deleteThirdJoinDataByI_DDH(HashMap<Object, Object> map) throws Exception {
+        transactionDetailMapper.deleteThirdJoinDataByI_DDH(map);
+    }
+
+    @Override
+    public void updateThirdJoinDataWithHisData(HashMap<Object, Object> map) throws Exception {
+        transactionDetailMapper.updateThirdJoinDataWithHisData(map);
+    }
+
     @Override
     public void addNotUniqueData(List<HashMap<Object, Object>> list) throws Exception {
         transactionDetailMapper.addNotUniqueData(list);

src/main/resources/mapper/HisbillsHistoryMapper.xml

@@ -48,14 +48,12 @@
         ,TradeTime
         ,Amount
         ,PlatformTransId
-        ,HisTransId
+        ,PatientId as PatientID
-        ,PatientID
         ,PatientName
-        ,source
         ,trade_date
 
 
-        from hisbills_history
+        from hisbill_history
         where trade_date=#{trade_date}
         and PayMethod != '2'  <!-- 排除PayMethod=2的记录，不参与对账 -->
         <if test="military_code != null and military_code != ''">
@@ -73,6 +71,9 @@
         <if test="tranID!=null and tranID!=''">
             and HisTransId=#{tranID}
         </if>
+        <if test="platformTransId!=null and platformTransId!=''">
+            and PlatformTransId=#{platformTransId}
+        </if>
         <if test="h_jylx!=null and h_jylx!=''">
             and TradingStatus=#{h_jylx}
         </if>

src/main/resources/mapper/TransactionDetailMapper.xml

@@ -601,6 +601,7 @@
         from third_join_his
         where trade_date = #{trade_date}
           and TranID != ''
+          and check_result != '0'  <!-- 排除已对平的记录，这些记录不应该被删除 -->
         group by TranID, H_JYLX
         having count(TranID) > 1
     </select>
@@ -612,6 +613,7 @@
         where trade_date = #{trade_date}
           and TranID = #{tranID}
           and H_JYLX = #{h_jylx}
+          and check_result != '0'  <!-- 不删除已对平的记录 -->
     </delete>
 
     <delete id="deleteThirdUnilateralByIddh" parameterType="HashMap">
@@ -622,6 +624,33 @@
           and err_type = '2'
     </delete>
 
+    <!-- 根据订单号删除third_join_his中所有相关记录（用于一对多场景） -->
+    <delete id="deleteThirdJoinDataByI_DDH" parameterType="HashMap">
+        delete
+        from third_join_his
+        where trade_date = #{trade_date}
+          and I_DDH = #{i_ddh}
+    </delete>
+
+    <!-- 更新third_join_his中的银行单边记录，补充HIS数据（用于一对多场景） -->
+    <update id="updateThirdJoinDataWithHisData" parameterType="HashMap">
+        update third_join_his
+        set TradeTime = #{tradeTime},
+            TranID = #{tranID},
+            BizType = #{BizType},
+            H_JYLX = #{h_jylx},
+            Amount = #{amount},
+            PayType = #{payType},
+            HisOperNum = #{hisOperNum},
+            PatientID = #{patientid},
+            PatientName = #{patientname},
+            sort_date = #{sort_date},
+            err_type = #{err_type},
+            check_result = #{check_result}
+        where trade_date = #{trade_date}
+          and I_DDH = #{i_ddh}
+    </update>
+
     <!--添加修改后的重复记录回数据库-->
     <insert id="addNotUniqueData" parameterType="java.util.List">
         insert into third_join_his(JYSJ