Merge branch 'dev' into master

# Conflicts:
#	mhd-auth/src/main/resources/bootstrap.yml
#	mhd-gateway/src/main/resources/bootstrap.yml
#	mhd-user-center/src/main/resources/bootstrap.yml
#	mhd_finance/src/main/java/com/linke/finance/domain/reconciliation/repository/persistence/ReconciliationImpl.java

mhd_finance/src/main/java/com/linke/finance/application/server/businessDocument/BusinessDocumentApplicationService.java

@@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
 import com.linke.finance.domain.accountManage.entity.AccountCashWallet;
 import com.linke.finance.domain.accountManage.service.AccountCashWalletDomainService;
 import com.linke.finance.domain.auditConfiguration.repository.todo.AuditConfigurationDO;
@@ -124,11 +125,51 @@ public class BusinessDocumentApplicationService {
 
     public List<BusinessDocumentPO> queryList(BusinessDocumentDO businessDocumentDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("运单管理查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            return businessDocumentDomainService.queryList(businessDocumentDO);
+        }
+        
         UserPo userPo = loginUser.getUserPo();
-        if (userPo.getUserAccountType() == 3){
-            businessDocumentDO.setTopOrganizationId(userPo.getTopOrganizationId());
-        }else {
-            businessDocumentDO.setOrganizationId(userPo.getOrganizationId());
+        Long loginUserOrganizationId = userPo.getOrganizationId();
+        Long topOrganizationId = userPo.getTopOrganizationId();
+        
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = businessDocumentDO.getOrganizationId();
+        
+        // 数据权限：根据organizationId来设置查询权限
+        // organizationId等于2827时查询全部，其他仅查询各自组织的信息
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                businessDocumentDO.setOrganizationId(frontendOrganizationId);
+                businessDocumentDO.setTopOrganizationId(null);
+            } else {
+                businessDocumentDO.setOrganizationId(null);
+                businessDocumentDO.setTopOrganizationId(null);
+            }
+        } else {
+            // 其他组织：根据userAccountType设置组织过滤
+            if (userPo.getUserAccountType() == 3){
+                // 租户管理员：使用topOrganizationId
+                if (topOrganizationId != null) {
+                    businessDocumentDO.setTopOrganizationId(topOrganizationId);
+                }
+                businessDocumentDO.setOrganizationId(null);
+            } else {
+                // 其他用户：使用organizationId
+                if (frontendOrganizationId != null && !frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    log.warn("运单管理查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤",
+                        frontendOrganizationId, loginUserOrganizationId);
+                    businessDocumentDO.setOrganizationId(loginUserOrganizationId);
+                } else if (frontendOrganizationId == null) {
+                    businessDocumentDO.setOrganizationId(loginUserOrganizationId);
+                }
+                businessDocumentDO.setTopOrganizationId(null);
+            }
         }
         return businessDocumentDomainService.queryList(businessDocumentDO);
     }
@@ -550,6 +591,10 @@ public class BusinessDocumentApplicationService {
         return businessDocumentDomainService.queryList(businessDocumentDO);
     }
 
+    public List<Map<String,Object>> getFeeList(String invoiceId) {
+        return businessDocumentDomainService.getFeeList(invoiceId);
+    }
+
     /**
      * 修改业务单据支付状态，同步网货修改支付状态
      */
@@ -1285,12 +1330,43 @@ public class BusinessDocumentApplicationService {
         List<BusinessDocumentDetali> businessDocumentDetaliUpdateList = new ArrayList<>();
         List<BusinessDocumentDetaliDTO> businessDocumentDetailDtoList = new ArrayList<>();
         List<Verification> verificationList = new ArrayList<>();
+        log.info("批量审核开始，审核状态：{}，待审核数据条数：{}", businessDocumentDetaliDO.getAuditStatus(), detailList.size());
+        
+        // 先设置审核人的组织信息，确保在生成应付账单时能够正确获取组织信息
+        Long loginUserOrganizationId = null;
+        String loginUserOrganizationName = null;
+        Long loginUserTopOrganizationId = null;
+        if (loginUser.getUserPo() != null) {
+            loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+            loginUserOrganizationName = loginUser.getUserPo().getOrganizationName();
+            loginUserTopOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        }
+        
         for (BusinessDocumentDetali detail:detailList) {
+            log.debug("处理业务单据详情：businessDocumentDetaliId={}, 当前审核状态={}, 目标审核状态={}", 
+                detail.getBusinessDocumentDetaliId(), detail.getAuditStatus(), businessDocumentDetaliDO.getAuditStatus());
+            
             if(detail.getAuditStatus()==2||detail.getAuditStatus()==3){
+                log.warn("业务单据详情 businessDocumentDetaliId={} 的审核状态已经是 {}（2=已同意，3=已拒绝），跳过处理", 
+                    detail.getBusinessDocumentDetaliId(), detail.getAuditStatus());
                 continue;
             }
+            
+            // 在生成应付账单之前，先设置审核人的组织信息，确保 packVerication 能够正确获取组织信息
+            if (loginUserOrganizationId != null) {
+                detail.setOrganizationId(loginUserOrganizationId);
+            }
+            if (loginUserOrganizationName != null) {
+                detail.setOrganizationName(loginUserOrganizationName);
+            }
+            if (loginUserTopOrganizationId != null) {
+                detail.setTopOrganizationId(loginUserTopOrganizationId);
+            }
+            
             //只有同意的才生成应付账单
             if(businessDocumentDetaliDO.getAuditStatus()==ApproveStatusEnum.AGREE.getKey()){
+                log.info("审核通过，开始生成应付账单：businessDocumentDetaliId={}, firstSubject={}", 
+                    detail.getBusinessDocumentDetaliId(), detail.getFirstSubject());
                 if(SubjectCodeEnum.first_zycl_clhs.getCode().equals(detail.getFirstSubject())){//车辆核算的单独处理
                     //查询要自有车辆费用明细
                     R<List<SecondSubjectPO>> secondSubjectList = wlhyServiceFeign.getZyclClhsSecondSubjectList(detail.getBusinessCocumentId());
@@ -1308,6 +1384,14 @@ public class BusinessDocumentApplicationService {
                             verification.setAuditRemark(businessDocumentDetaliDO.getAuditRemark());
                             verification.setCreateBy(loginUser.getUserid());
                             verification.setCreateByName(loginUser.getUsername());
+                            verification.setCreateTime(now);
+                            verification.setUpdateTime(now);
+                            verification.setUpdateBy(loginUser.getUserid());
+                            verification.setUpdateByName(loginUser.getUsername());
+                            // 确保 delFlag 被设置（1=正常，2=已删除）
+                            if (verification.getDelFlag() == null) {
+                                verification.setDelFlag(1);
+                            }
                             verification.setPayType(secondSubjectPO.getPayType());
                             verification.setBillRemarks(detail.getRemark());
                             verification.setPaymentMethod(detail.getPaymentMethod());
@@ -1318,6 +1402,10 @@ public class BusinessDocumentApplicationService {
                                 verification.setPayName(secondSubjectPO.getPayName());
                             }
                             verificationList.add(verification);
+                            log.debug("车辆核算二级科目应付账单已添加到列表：businessDocumentDetaliId={}, secondSubject={}, verificationMoney={}, innerNumber={}, delFlag={}, organizationId={}, organizationName={}", 
+                                detail.getBusinessDocumentDetaliId(), secondSubjectPO.getSecondSubject(), 
+                                secondSubjectPO.getAmount(), innerNumber, verification.getDelFlag(), 
+                                verification.getOrganizationId(), verification.getOrganizationName());
                         }
                     }else{
                         throw new ServiceException("查询车辆核算二级科目异常！");
@@ -1332,12 +1420,27 @@ public class BusinessDocumentApplicationService {
                     verification.setAuditRemark(businessDocumentDetaliDO.getAuditRemark());
                     verification.setCreateBy(loginUser.getUserid());
                     verification.setCreateByName(loginUser.getUsername());
+                    verification.setCreateTime(now);
+                    verification.setUpdateTime(now);
+                    verification.setUpdateBy(loginUser.getUserid());
+                    verification.setUpdateByName(loginUser.getUsername());
+                    // 确保 delFlag 被设置（1=正常，2=已删除）
+                    if (verification.getDelFlag() == null) {
+                        verification.setDelFlag(1);
+                    }
                     verification.setPayType(detail.getSecondSubjectName());//付款方式：油卡借款/现金借款=>与二级科目保持一致
                     verification.setBillRemarks(detail.getRemark());
                     verification.setPaymentMethod(detail.getPaymentMethod());
                     verification.setFuelCardNumber(detail.getFuelCardNumber());
                     verificationList.add(verification);
+                    log.debug("普通科目应付账单已添加到列表：businessDocumentDetaliId={}, firstSubject={}, secondSubject={}, verificationMoney={}, innerNumber={}, delFlag={}, organizationId={}, organizationName={}", 
+                        detail.getBusinessDocumentDetaliId(), detail.getFirstSubject(), detail.getSecondSubject(), 
+                        detail.getAmount(), innerNumber, verification.getDelFlag(), 
+                        verification.getOrganizationId(), verification.getOrganizationName());
                 }
+            } else {
+                log.info("审核状态不是已同意（当前状态：{}），不生成应付账单：businessDocumentDetaliId={}", 
+                    businessDocumentDetaliDO.getAuditStatus(), detail.getBusinessDocumentDetaliId());
             }
 
             detail.setAuditStatus(businessDocumentDetaliDO.getAuditStatus());//审批结果
@@ -1347,11 +1450,25 @@ public class BusinessDocumentApplicationService {
             detail.setUpdateBy(loginUser.getUserid());
             detail.setUpdateByName(loginUser.getUsername());
             detail.setUpdateTime(now);
+            // 组织信息已经在生成应付账单之前设置，这里不需要重复设置
             businessDocumentDetaliUpdateList.add(detail);
 
             BusinessDocumentDetaliDTO detailDto = new BusinessDocumentDetaliDTO();
             BeanUtils.copyProperties(detail,detailDto);
-            detailDto.setAuditRemark(businessDocumentDetaliDO.getAuditRemark());
+            
+            // 确保关键字段的类型正确，避免 TMS 端类型转换错误
+            // 确保 auditRemark 是字符串类型，不为 null（使用最新的审核备注）
+            String auditRemark = businessDocumentDetaliDO.getAuditRemark();
+            if (auditRemark == null) {
+                auditRemark = "";
+            }
+            // 显式设置为字符串类型，确保类型正确
+            detailDto.setAuditRemark(auditRemark);
+            
+            // 确保其他关键字段也是正确的类型（虽然已经通过 copyProperties 复制，但显式设置更安全）
+            detailDto.setAuditStatus(detail.getAuditStatus());
+            detailDto.setAuditType(detail.getAuditType());
+            
             businessDocumentDetailDtoList.add(detailDto);
             //车辆维修单同步工时费申请状态
             if(businessDocumentDetaliDO.getAuditStatus()==2||businessDocumentDetaliDO.getAuditStatus()==3){
@@ -1380,14 +1497,72 @@ public class BusinessDocumentApplicationService {
             }
         }
         //应付账单
+        log.info("准备保存应付账单，应付账单数量：{}", verificationList.size());
         if (!verificationList.isEmpty()){
+            // 记录应付账单详细信息，便于排查
+            for (int i = 0; i < Math.min(verificationList.size(), 3); i++) {
+                Verification v = verificationList.get(i);
+                log.info("应付账单示例[{}]：businessDocumentDetaliId={}, innerNumber={}, verificationMoney={}, firstSubject={}, secondSubject={}", 
+                    i, v.getBusinessDocumentDetaliId(), v.getInnerNumber(), v.getVerificationMoney(), 
+                    v.getFirstSubject(), v.getSecondSubject());
+            }
+            
             boolean saveFlag = verificationDomainService.batchAddVerification(verificationList);
+            log.info("保存应付账单结果：saveFlag={}, 应付账单数量={}", saveFlag, verificationList.size());
             if(!saveFlag){
+                log.error("保存应付账单失败！应付账单数量：{}", verificationList.size());
                 throw new ServiceException("保存应付账单失败！");
             }
+            log.info("应付账单保存成功，共保存 {} 条记录", verificationList.size());
+        } else {
+            log.warn("应付账单列表为空，未生成任何应付账单。审核状态：{}，业务单据详情数量：{}", 
+                businessDocumentDetaliDO.getAuditStatus(), detailList.size());
         }
         //推送数据到tms:审核通过修改单据状态为【待付款】，审核拒绝修改状态为【已拒绝】并处理相关逻辑
         if(businessDocumentDetailDtoList.size()>0){
+            // 记录传递给 TMS 的数据，便于调试
+            log.info("准备同步TMS业务单据信息，数据条数：{}", businessDocumentDetailDtoList.size());
+            for (int i = 0; i < Math.min(businessDocumentDetailDtoList.size(), 3); i++) {
+                BusinessDocumentDetaliDTO dto = businessDocumentDetailDtoList.get(i);
+                log.info("同步TMS业务单据信息示例[{}]：businessDocumentDetaliId={}, auditStatus={}, auditStatus类型={}, auditRemark={}, auditRemark类型={}, auditRemark值={}", 
+                    i, dto.getBusinessDocumentDetaliId(), dto.getAuditStatus(), 
+                    dto.getAuditStatus() != null ? dto.getAuditStatus().getClass().getName() : "null",
+                    dto.getAuditRemark(), dto.getAuditRemark() != null ? dto.getAuditRemark().getClass().getName() : "null",
+                    dto.getAuditRemark());
+            }
+            
+            // 最后一次验证：确保所有 auditRemark 都是字符串类型
+            for (BusinessDocumentDetaliDTO dto : businessDocumentDetailDtoList) {
+                if (dto.getAuditRemark() == null) {
+                    dto.setAuditRemark("");
+                } else if (!(dto.getAuditRemark() instanceof String)) {
+                    // 如果不是字符串类型，转换为字符串
+                    log.warn("发现 auditRemark 不是字符串类型：{}，类型：{}，将转换为字符串", 
+                        dto.getAuditRemark(), dto.getAuditRemark().getClass().getName());
+                    dto.setAuditRemark(String.valueOf(dto.getAuditRemark()));
+                }
+            }
+            
+            // 通过 JSON 序列化和反序列化确保类型正确，避免类型转换问题
+            try {
+                String jsonString = JSON.toJSONString(businessDocumentDetailDtoList);
+                log.debug("同步TMS业务单据信息，JSON序列化结果长度：{}", jsonString.length());
+                List<BusinessDocumentDetaliDTO> deserializedList = JSON.parseArray(jsonString, BusinessDocumentDetaliDTO.class);
+                log.debug("JSON反序列化后，数据条数：{}", deserializedList.size());
+                // 验证反序列化后的 auditRemark 类型
+                for (int i = 0; i < Math.min(deserializedList.size(), 3); i++) {
+                    BusinessDocumentDetaliDTO dto = deserializedList.get(i);
+                    if (dto.getAuditRemark() != null && !(dto.getAuditRemark() instanceof String)) {
+                        log.warn("JSON反序列化后，auditRemark 类型不正确：{}，将强制转换为字符串", 
+                            dto.getAuditRemark().getClass().getName());
+                        dto.setAuditRemark(String.valueOf(dto.getAuditRemark()));
+                    }
+                }
+                businessDocumentDetailDtoList = deserializedList;
+            } catch (Exception e) {
+                log.warn("JSON序列化/反序列化失败，使用原始数据：{}", e.getMessage());
+            }
+            
             AjaxResult ajaxResult = wlhyServiceFeign.syncBusinessDocumentInfo(businessDocumentDetailDtoList);
             if (null != ajaxResult && !"200".equals(String.valueOf(ajaxResult.get("code")))) {
                 log.error("同步TMS业务单据信息失败:" + ajaxResult.get("msg"));
@@ -1401,6 +1576,7 @@ public class BusinessDocumentApplicationService {
         Verification verification = new Verification();
         verification.setOrganizationId(businessDocumentDetaliDTO.getOrganizationId());
         verification.setTopOrganizationId(businessDocumentDetaliDTO.getTopOrganizationId());
+        verification.setOrganizationName(businessDocumentDetaliDTO.getOrganizationName());
         verification.setVerificationStatus(1);//未支付
         verification.setBusinessDocumentDetaliId(businessDocumentDetaliDTO.getBusinessDocumentDetaliId());
         verification.setBusinessDocumentDetaliNumber(businessDocumentDetaliDTO.getBusinessDocumentDetaliNumber());
@@ -1487,4 +1663,4 @@ public class BusinessDocumentApplicationService {
 
         return true;
     }
-}
+}

mhd_finance/src/main/java/com/linke/finance/application/server/businessDocumentDetali/BusinessDocumentDetaliApplicationService.java

@@ -111,9 +111,46 @@ public class BusinessDocumentDetaliApplicationService {
         if (StringUtils.isNotBlank(businessDocumentDetaliDO.getWaybillNumbers())){
             businessDocumentDetaliDO.setWaybillNumberList(Arrays.asList(businessDocumentDetaliDO.getWaybillNumbers().split(",")));
         }
-        businessDocumentDetaliDO.setOrganizationId(loginUser.getOrganizationPo().getOrganizationId());
+        
+        // 数据权限：根据组织ID实现数据隔离
+        // organizationId=2827（南光）时，可以查询所有组织的数据，也可以条件查询特定组织；其他组织只查询自己的数据
+        Long loginUserOrganizationId = loginUser.getOrganizationPo().getOrganizationId();
+        // 保存前端传递的 organizationId（如果有的话）
+        Long frontendOrganizationId = businessDocumentDetaliDO.getOrganizationId();
+        
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤（条件查询特定组织）
+            // 如果前端没有传递 organizationId，设置为 null 查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，使用前端传递的值进行过滤
+                businessDocumentDetaliDO.setOrganizationId(frontendOrganizationId);
+            } else {
+                // 前端没有传递 organizationId，设置为 null 查询所有组织的数据
+                businessDocumentDetaliDO.setOrganizationId(null);
+            }
+        } else {
+            // 其他组织：只查询自己组织的数据，忽略前端传递的 organizationId（安全考虑）
+            businessDocumentDetaliDO.setOrganizationId(loginUserOrganizationId);
+        }
+        
         //businessDocumentDetaliDO.setAuditStatus(0);//查询未审核的
         List<BusinessDocumentDetaliAuditPO> businessDocumentDetaliAuditPOS = businessDocumentDetaliDomainService.auditList(businessDocumentDetaliDO);
+        
+        // 前端回显：根据 organizationId 设置对应的 organizationName
+        businessDocumentDetaliAuditPOS.forEach(e -> {
+            if (e.getOrganizationId() != null) {
+                Long orgId = e.getOrganizationId();
+                if (java.util.Objects.equals(orgId, 2827L)) {
+                    e.setOrganizationName("南光");
+                } else if (java.util.Objects.equals(orgId, 2830L)) {
+                    e.setOrganizationName("通宇");
+                } else if (java.util.Objects.equals(orgId, 2839L)) {
+                    e.setOrganizationName("南岐");
+                }
+            }
+        });
+        
 //        businessDocumentDetaliAuditPOS.forEach(e->{
 //            if (e.getService() != null && e.getAmount() != null){
 //                e.setTotalAmount(e.getAmount().add(e.getService()));

mhd_finance/src/main/java/com/linke/finance/application/server/receivingAccount/ReceivingAccountApplicationService.java

@@ -5,6 +5,8 @@ import com.linke.finance.domain.receivingAccount.repository.persistence.Receivin
 import com.linke.finance.domain.receivingAccount.repository.po.ReceivingAccountPO;
 import com.linke.finance.domain.receivingAccount.repository.todo.ReceivingAccountDO;
 import com.mhd.common.core.utils.bean.BeanUtils;
+import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -46,8 +48,42 @@ public class ReceivingAccountApplicationService {
      */
     public Boolean insert(ReceivingAccountDO receivingAccountDTO) {
         log.info("新增收款账户，参数：{}", receivingAccountDTO);
+        
+        // 获取当前登录用户信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.error("新增收款账户失败：未获取到登录用户信息");
+            throw new RuntimeException("未获取到登录用户信息");
+        }
+        
+        // 获取当前登录用户的组织ID
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        String organizationId = null;
+        String topOrganizationId = null;
+        if (loginUserOrganizationId != null) {
+            organizationId = String.valueOf(loginUserOrganizationId);
+        }
+        if (loginUser.getUserPo().getTopOrganizationId() != null) {
+            topOrganizationId = String.valueOf(loginUser.getUserPo().getTopOrganizationId());
+        }
+        
         ReceivingAccount receivingAccount = new ReceivingAccount();
         BeanUtils.copyProperties(receivingAccountDTO, receivingAccount);
+        
+        // 立即清空从DTO复制过来的组织ID，防止其他组织的数据被添加
+        receivingAccount.setOrganizationId(null);
+        receivingAccount.setTopOrganizationId(null);
+        
+        // 强制使用当前登录用户的组织ID，不允许添加其他组织的数据
+        receivingAccount.setOrganizationId(organizationId);
+        
+        // 如果organizationId为2827（南光组织），不设置topOrganizationId（设为null）
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            receivingAccount.setTopOrganizationId(null);
+        } else {
+            receivingAccount.setTopOrganizationId(topOrganizationId);
+        }
+        
         receivingAccount.setDelFlag(1); // 1-正常
         receivingAccount.setCreateTime(new Date());
         receivingAccount.setUpdateTime(new Date());
@@ -56,31 +92,148 @@ public class ReceivingAccountApplicationService {
     }
 
     /**
-     * 批量新增收款账户（先删除所有，再新增）
+     * 批量新增收款账户（新增，删除旧数据）
      * 
      * @param receivingAccountDTOList 收款账户DTO列表
      * @return 是否成功
      */
     @Transactional
     public Boolean batchInsert(List<ReceivingAccountDO> receivingAccountDTOList) {
-        log.info("批量新增收款账户，数量：{}", receivingAccountDTOList.size());
+//        log.info("批量新增收款账户，数量：{}", receivingAccountDTOList.size());
+
+        // 获取当前登录用户信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.error("批量新增收款账户失败：未获取到登录用户信息");
+            throw new RuntimeException("未获取到登录用户信息");
+        }
         
-        // 先删除所有现有数据
-        int deleteCount = receivingAccountRepository.deleteAll();
-        log.info("已删除现有收款账户数量：{}", deleteCount);
+        // 获取当前登录用户的组织ID
+        String organizationId = null;
+        if (loginUser.getUserPo().getOrganizationId() != null) {
+            organizationId = String.valueOf(loginUser.getUserPo().getOrganizationId());
+        }
+        
+        if (organizationId == null || organizationId.isEmpty()) {
+            log.error("当前登录用户的organizationId为空，无法执行批量新增操作");
+            throw new RuntimeException("当前登录用户的organizationId为空，无法执行批量新增操作");
+        }
+        
+        log.info("批量新增收款账户 - 当前登录用户organizationId={}", organizationId);
+        
+        // 根据当前登录用户的组织ID删除该组织的所有收款账户
+        int deleteCount = receivingAccountRepository.deleteByOrganization(null, organizationId);
+        log.info("已删除当前登录用户组织（organizationId={}）的收款账户数量：{}", organizationId, deleteCount);
         
         List<ReceivingAccount> receivingAccountList = new ArrayList<>();
         Date now = new Date();
+        int skippedCount = 0; // 跳过的数据条数
         
         for (ReceivingAccountDO dto : receivingAccountDTOList) {
+            // 验证：只检查organizationId字段
+            // 1. 如果DTO中没有organizationId，跳过该条数据（不设置默认值，完全保留DTO中的原始数据）
+            // 2. 如果DTO中的organizationId与当前登录用户的organizationId不一致，跳过该条数据
+            String dtoOrganizationId = dto.getOrganizationId();
+            
+            log.info("处理DTO数据：accountName={}, dtoOrganizationId={}, 当前登录用户organizationId={}", 
+                dto.getAccountName(), dtoOrganizationId, organizationId);
+            
+            if (dtoOrganizationId == null || dtoOrganizationId.isEmpty()) {
+                log.warn("【跳过】DTO中没有organizationId，跳过该条数据");
+                skippedCount++;
+                continue;
+            }
+            
+            try {
+                Long dtoOrgId = Long.parseLong(dtoOrganizationId);
+                Long currentOrgId = Long.parseLong(organizationId);
+                
+                // 如果DTO中的organizationId与当前登录用户的organizationId不一致，跳过该条数据
+                if (!dtoOrgId.equals(currentOrgId)) {
+                    log.error("【跳过】DTO中的organizationId（{}）与当前登录用户的organizationId（{}）不一致，跳过该条数据", 
+                        dtoOrgId, currentOrgId);
+                    skippedCount++;
+                    continue;
+                }
+                
+                log.info("【通过验证】DTO中的organizationId（{}）与当前登录用户的organizationId（{}）一致，继续处理", 
+                    dtoOrgId, currentOrgId);
+            } catch (NumberFormatException e) {
+                log.warn("【跳过】解析DTO中的organizationId失败：{}，跳过该条数据", dtoOrganizationId);
+                skippedCount++;
+                continue;
+            }
+            
             ReceivingAccount receivingAccount = new ReceivingAccount();
             BeanUtils.copyProperties(dto, receivingAccount);
+            
+            // 复制属性后，再次验证organizationId，确保没有被覆盖
+            String finalOrgId = receivingAccount.getOrganizationId();
+            if (finalOrgId == null || finalOrgId.isEmpty()) {
+                log.error("【跳过】复制属性后，organizationId为空，跳过该条数据");
+                skippedCount++;
+                continue;
+            }
+            
+            try {
+                Long finalOrgIdLong = Long.parseLong(finalOrgId);
+                Long currentOrgIdLong = Long.parseLong(organizationId);
+                
+                // 再次验证：确保复制后的organizationId与当前登录用户的organizationId一致
+                if (!finalOrgIdLong.equals(currentOrgIdLong)) {
+                    log.error("【跳过】复制属性后，organizationId（{}）与当前登录用户的organizationId（{}）不一致，跳过该条数据", 
+                        finalOrgIdLong, currentOrgIdLong);
+                    skippedCount++;
+                    continue;
+                }
+            } catch (NumberFormatException e) {
+                log.warn("【跳过】解析复制后的organizationId失败：{}，跳过该条数据", finalOrgId);
+                skippedCount++;
+                continue;
+            }
+            
             receivingAccount.setDelFlag(1); // 1-正常
             receivingAccount.setCreateTime(now);
             receivingAccount.setUpdateTime(now);
+            
+            // 添加到列表前的最终验证：确保organizationId与当前登录用户的organizationId完全一致
+            // 这是最后一道防线，确保不会将不符合条件的数据添加到列表
+            String finalCheckOrgId = receivingAccount.getOrganizationId();
+            if (finalCheckOrgId == null || finalCheckOrgId.isEmpty()) {
+                log.error("【清除】添加到列表前验证失败：organizationId为空，清除该条数据");
+                skippedCount++;
+                continue;
+            }
+            
+            try {
+                Long finalCheckOrgIdLong = Long.parseLong(finalCheckOrgId);
+                Long currentOrgIdLong = Long.parseLong(organizationId);
+                
+                // 最终验证：确保organizationId与当前登录用户的organizationId完全一致
+                if (!finalCheckOrgIdLong.equals(currentOrgIdLong)) {
+                    log.error("【清除】添加到列表前验证失败：organizationId（{}）与当前登录用户的organizationId（{}）不一致，清除该条数据，不添加到列表", 
+                        finalCheckOrgIdLong, currentOrgIdLong);
+                    skippedCount++;
+                    continue; // 清除该条数据，不添加到列表
+                }
+            } catch (NumberFormatException e) {
+                log.error("【清除】添加到列表前验证失败：解析organizationId失败：{}，清除该条数据", finalCheckOrgId);
+                skippedCount++;
+                continue;
+            }
+            
+            log.info("【添加】准备新增收款账户：accountName={}, organizationId={}, 当前登录用户organizationId={}", 
+                receivingAccount.getAccountName(), receivingAccount.getOrganizationId(), organizationId);
+            
             receivingAccountList.add(receivingAccount);
         }
         
+        if (skippedCount > 0) {
+            log.info("批量新增收款账户 - 已跳过 {} 条包含其他组织organizationId的数据", skippedCount);
+        }
+        
+        log.info("批量新增收款账户 - 准备插入的数据条数：{}, 所有数据的organizationId={}", receivingAccountList.size(), organizationId);
+        
         int result = receivingAccountRepository.batchInsert(receivingAccountList);
         log.info("新增收款账户数量：{}", result);
         return result > 0;

mhd_finance/src/main/java/com/linke/finance/application/server/reconciliation/ReconciliationApplicationService.java

@@ -3,27 +3,37 @@ package com.linke.finance.application.server.reconciliation;
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.aliyun.dingtalkworkflow_1_0.models.StartProcessInstanceResponse;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.linke.finance.domain.businessDocument.entity.BusinessDocument;
 import com.linke.finance.domain.businessDocument.service.BusinessDocumentDomainService;
 import com.linke.finance.domain.reconciliation.entity.Reconciliation;
-import com.linke.finance.domain.reconciliation.entity.ReconciliationBusinessDocument;
 import com.linke.finance.domain.reconciliation.entity.ReconciliationOrderDetail;
 import com.linke.finance.domain.reconciliation.repository.po.FinacialReconciliationListVO;
 import com.linke.finance.domain.reconciliation.repository.po.ReconciliationOrderDetailPO;
 import com.linke.finance.domain.reconciliation.repository.po.ReconciliationPO;
 import com.linke.finance.domain.reconciliation.repository.todo.ReconciliationDO;
 import com.linke.finance.domain.reconciliation.service.ReconciliationDomainService;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
+import com.linke.finance.domain.reconciliationAccount.repository.mapper.ReconciliationAccountMapper;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import com.linke.finance.domain.reconciliationAccount.service.ReconciliationAccountDomainService;
 import com.linke.finance.domain.revenueExpensesRecord.entity.RevenueExpensesRecord;
 import com.linke.finance.domain.revenueExpensesRecord.service.RevenueExpensesRecordDomainService;
-import com.linke.finance.domain.tmsReceipt.entity.TmsReceipt;
 import com.linke.finance.domain.tmsReceipt.repository.mapper.TmsReceiptMapper;
 import com.linke.finance.domain.tmsReceipt.repository.po.TmsReceiptPO;
 import com.linke.finance.domain.tmsReceipt.service.TmsReceiptDomainService;
 import com.linke.finance.domain.verification.service.VerificationDomainService;
 import com.linke.finance.infrastructure.feign.ProductServiceFeign;
 import com.linke.finance.infrastructure.feign.WlhyServiceFeign;
+import com.linke.finance.interfaces.assembler.reconciliationAccount.ReconciliationAccountAssembler;
 import com.mhd.common.core.constant.SubjectConstants;
+import com.mhd.common.core.domain.dto.ReconciliationAccountDTO;
 import com.mhd.common.core.domain.dto.ReconciliationDTO;
+import com.mhd.common.core.domain.entity.TmsOrder;
 import com.mhd.common.core.domain.entity.Verification;
 import com.mhd.common.core.domain.po.OrganizationPo;
 import com.mhd.common.core.domain.po.UserPo;
@@ -32,6 +42,7 @@ import com.mhd.common.core.exception.ServiceException;
 import com.mhd.common.core.utils.OrderSequence;
 import com.mhd.common.core.utils.StringUtils;
 import com.mhd.common.core.utils.bean.BeanUtils;
+import com.mhd.common.core.utils.sms.Result;
 import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.common.security.utils.SecurityUtils;
 import com.mhd.system.api.model.LoginUser;
@@ -39,7 +50,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.bind.annotation.RequestParam;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
@@ -47,7 +57,6 @@ import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -76,6 +85,14 @@ public class ReconciliationApplicationService {
     @Resource
     private TmsReceiptMapper tmsReceiptMapper;
 
+    @Autowired
+    private ReconciliationAccountDomainService reconciliationAccountDomainService;
+
+    @Resource
+    private ReconciliationAccountAssembler reconciliationAccountAssembler;
+
+    @Autowired
+    private ReconciliationAccountMapper reconciliationAccountMapper;
 
 
     /**
@@ -85,18 +102,68 @@ public class ReconciliationApplicationService {
     public List<ReconciliationPO> queryList(ReconciliationDO reconciliationDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         UserPo userPo = loginUser.getUserPo();
-        if (userPo.getUserAccountType() == 3) {
-            reconciliationDO.setTopOrganizationId(userPo.getTopOrganizationId());
-        } else if (userPo.getUserAccountType() == 2){
-            reconciliationDO.setOrganizationId(userPo.getOrganizationId());
+
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = reconciliationDO.getOrganizationId();
+
+        // 获取当前登录用户的组织信息
+        Long loginUserOrganizationId = userPo.getOrganizationId();
+        Long topOrganizationId = userPo.getTopOrganizationId();
+
+        // 数据权限：根据organizationId来设置查询权限
+        // organizationId等于2827时查询全部，其他仅查询各自组织的信息
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤（包括2827）
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，使用前端传递的值进行过滤
+                reconciliationDO.setOrganizationId(frontendOrganizationId);
+                reconciliationDO.setTopOrganizationId(null);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                reconciliationDO.setOrganizationId(null);
+                reconciliationDO.setTopOrganizationId(null);
+            }
         } else {
-            if (loginUser.getRoleList().contains(RoleEnum.SHIPPER.getCode()) || loginUser.getRoleList().contains(RoleEnum.COMPANY.getCode())){
-                reconciliationDO.setUserId(userPo.getUserId());
-            }else {
-                reconciliationDO.setOrganizationId(userPo.getOrganizationId());
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织（包括南光）的数据
+            // 如果其他组织尝试查询南光（organizationId=2827）的数据，返回空数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId.equals(2827L)) {
+                    // 其他组织尝试查询南光的数据，设置一个不存在的 organizationId，返回空数据
+                    reconciliationDO.setOrganizationId(-1L);
+                    reconciliationDO.setTopOrganizationId(null);
+                } else if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    reconciliationDO.setOrganizationId(loginUserOrganizationId);
+                    if (topOrganizationId != null) {
+                        reconciliationDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    reconciliationDO.setOrganizationId(frontendOrganizationId);
+                    if (topOrganizationId != null) {
+                        reconciliationDO.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            } else {
+                // 前端没有传递 organizationId，根据用户账号类型设置组织过滤条件
+                if (userPo.getUserAccountType() == 3) {
+                    reconciliationDO.setTopOrganizationId(topOrganizationId);
+                } else if (userPo.getUserAccountType() == 2){
+                    reconciliationDO.setOrganizationId(loginUserOrganizationId);
+                } else {
+                    if (loginUser.getRoleList().contains(RoleEnum.SHIPPER.getCode()) || loginUser.getRoleList().contains(RoleEnum.COMPANY.getCode())){
+                        reconciliationDO.setUserId(userPo.getUserId());
+                    }else {
+                        reconciliationDO.setOrganizationId(loginUserOrganizationId);
+                    }
+                }
             }
         }
-        List<ReconciliationPO> reconciliationPOS = reconciliationDomainService.queryList(reconciliationDO);
+       /* List<ReconciliationPO> reconciliationPOS = reconciliationDomainService.queryList(reconciliationDO);
         for (ReconciliationPO reconciliationPO : reconciliationPOS) {
             Long reconciliationId = reconciliationPO.getReconciliationId();
             AjaxResult tmsOrderSettlementDetails = wlhyServiceFeign.getById(reconciliationId);
@@ -110,6 +177,39 @@ public class ReconciliationApplicationService {
                 }
             }
         }
+        return reconciliationPOS;*/
+        List<ReconciliationPO> reconciliationPOS = reconciliationDomainService.queryList(reconciliationDO);
+        for (ReconciliationPO reconciliationPO : reconciliationPOS) {
+            String innerNumber = reconciliationPO.getInnerNumber();
+            if (innerNumber != null && !innerNumber.trim().isEmpty()) {
+                ReconciliationDTO reconciliationDTO = new ReconciliationDTO();
+                reconciliationDTO.setInnerNumber(innerNumber);
+                Result<Page<TmsOrder>> orderListByReconciliation = wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO, 1, 10);
+                if (orderListByReconciliation != null && orderListByReconciliation.getResult() != null) {
+                    Page<TmsOrder> result = orderListByReconciliation.getResult();
+                    List<TmsOrder> records = result.getRecords();
+                    if (records != null && !records.isEmpty()) {
+                        TmsOrder tmsOrder = records.get(0);
+                        reconciliationPO.setSettlementCurrency(tmsOrder.getSettlementCurrency());
+                    }
+                }
+            }
+            List<ReconciliationAccount> reconciliationAccountList=reconciliationAccountMapper.selectList(new QueryWrapper<ReconciliationAccount>()
+                    .lambda().eq(ReconciliationAccount::getReconciliationId,reconciliationPO.getReconciliationId()).eq(ReconciliationAccount::getDelFlag,1));
+            if(ObjectUtil.isNotNull(reconciliationAccountList)&&reconciliationAccountList.size()>0){
+                reconciliationPO.setReconciliationAccountDTOList(reconciliationAccountList);
+                ObjectMapper objectMapper = new ObjectMapper();
+                String jsonString = null;
+                try {
+                    jsonString = objectMapper.writeValueAsString(reconciliationAccountList);
+                    reconciliationPO.setReconciliationAccountDTOListJsonStr(jsonString);
+                } catch (JsonProcessingException e) {
+                    e.printStackTrace();
+                }
+
+            }
+        }
+
         return reconciliationPOS;
     }
 
@@ -170,6 +270,11 @@ public class ReconciliationApplicationService {
     public ReconciliationPO getInfo(Long reconciliationId) {
         ReconciliationPO info = reconciliationDomainService.getInfo(reconciliationId);
         List<BusinessDocument> list = reconciliationDomainService.selectBusinessByReconciliationId(reconciliationId);
+        List<ReconciliationAccount> reconciliationAccountList=reconciliationAccountMapper.selectList(new QueryWrapper<ReconciliationAccount>()
+                .lambda().eq(ReconciliationAccount::getReconciliationId,reconciliationId).eq(ReconciliationAccount::getDelFlag,1));
+        if(ObjectUtil.isNotNull(reconciliationAccountList)&&reconciliationAccountList.size()>0){
+            info.setReconciliationAccountDTOList(reconciliationAccountList);
+        }
         info.setBusinessDocumentList(list);
         return info;
     }
@@ -259,6 +364,25 @@ public class ReconciliationApplicationService {
         if(!flag){
             throw new ServiceException("订单出账-生成应收账单明细失败！");
         }
+        List<ReconciliationAccountDTO> reconciliationAccountDTOList=reconciliationDO.getReconciliationAccountDTOList();
+        if(ObjectUtil.isNotNull(reconciliationAccountDTOList)&&reconciliationAccountDTOList.size()>0){
+            for (ReconciliationAccountDTO reconciliationAccountDTO:reconciliationAccountDTOList){
+                reconciliationAccountDTO.setReconciliationId(reconciliationDO.getReconciliationId());
+                reconciliationAccountDTO.setDelFlag(1);
+                reconciliationAccountDTO.setCreateTime(new Date());
+                reconciliationAccountDTO.setCreateBy(loginUser.getUserid());
+                reconciliationAccountDTO.setOrganizationId(reconciliationDO.getOrganizationId());
+                reconciliationAccountDTO.setTopOrganizationId(reconciliationDO.getTopOrganizationId());
+                //转换实体
+                ReconciliationAccountDO reconciliationAccountDO = reconciliationAccountAssembler.toDO(reconciliationAccountDTO);
+                reconciliationAccountDO.setDelFlag(1);
+                reconciliationAccountDO.setCreateTime(new Date());
+                reconciliationAccountDO.setCreateBy(loginUser.getUserid());
+                reconciliationAccountDO.setOrganizationId(reconciliationDO.getOrganizationId());
+                reconciliationAccountDO.setTopOrganizationId(reconciliationDO.getTopOrganizationId());
+                reconciliationAccountDomainService.insert(reconciliationAccountDO);
+            }
+        }
     }
 
 

mhd_finance/src/main/java/com/linke/finance/application/server/reconciliationAccount/ReconciliationAccountApplicationService.java

@@ -0,0 +1,72 @@
+package com.linke.finance.application.server.reconciliationAccount;
+
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import com.linke.finance.domain.reconciliationAccount.service.ReconciliationAccountDomainService;
+import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.util.List;
+/**
+ * 【请填写功能名称】ApplicationService
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+@Service
+@Slf4j
+public class ReconciliationAccountApplicationService {
+    @Autowired
+    private ReconciliationAccountDomainService reconciliationAccountDomainService;
+
+
+    /**
+     * 分页查询【请填写功能名称】列表
+     */
+
+    public List<ReconciliationAccountPO> queryList(ReconciliationAccountDO reconciliationAccountDO) {
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null){
+            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            if (topOrganizationId != null && topOrganizationId != 1){
+                reconciliationAccountDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+            }
+        }
+        return reconciliationAccountDomainService.queryList(reconciliationAccountDO);
+    }
+
+
+    /**
+     * 新增【请填写功能名称】
+     */
+    public Boolean insert(ReconciliationAccountDO reconciliationAccountDO) {
+
+        return reconciliationAccountDomainService.insert(reconciliationAccountDO);
+    }
+
+    /**
+     * 修改【请填写功能名称】
+     */
+    public Boolean update(ReconciliationAccountDO reconciliationAccountDO) {
+        return reconciliationAccountDomainService.update(reconciliationAccountDO);
+    }
+
+    /**
+     * 批量删除【请填写功能名称】
+     */
+    public boolean delete(Long[] ids) {
+        return reconciliationAccountDomainService.delete(ids);
+    }
+
+    /**
+     * 获取【请填写功能名称】详细信息
+     */
+    public ReconciliationAccountPO getInfo(Long id)
+    {
+        return reconciliationAccountDomainService.getInfo(id);
+    }
+
+
+}

mhd_finance/src/main/java/com/linke/finance/application/server/tmsReceipt/TmsReceiptApplicationService.java

@@ -16,7 +16,9 @@ import com.mhd.common.core.exception.digitalLogisticsException.UserError;
 import com.mhd.common.core.utils.IgnoreNullUtil;
 import com.mhd.common.core.utils.OrderSequence;
 import com.mhd.common.core.utils.bean.BeanUtils;
+import com.mhd.common.core.utils.sms.Result;
 import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.WlhyServiceFeign;
 import com.mhd.system.api.model.LoginUser;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -27,6 +29,8 @@ import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
+
 /**
  * 收款单ApplicationService
  *
@@ -42,6 +46,8 @@ public class TmsReceiptApplicationService {
     private ITmsReceiptService tmsReceiptService;
     @Autowired
     private RevenueExpensesRecordDomainService revenueExpensesRecordDomainService;
+    @Autowired
+    private WlhyServiceFeign wlhyServiceFeign;
 
 
     /**
@@ -50,13 +56,90 @@ public class TmsReceiptApplicationService {
 
     public List<TmsReceiptPO> queryList(TmsReceiptDO tmsReceiptDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1){
-                tmsReceiptDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("收款单查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            return tmsReceiptDomainService.queryList(tmsReceiptDO);
+        }
+        
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = tmsReceiptDO.getOrganizationId();
+        
+        // 获取当前登录用户的组织信息
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        
+        log.info("收款单查询 - 开始数据权限处理 - 登录用户组织ID: {}, topOrganizationId: {}, 前端传递组织ID: {}", 
+            loginUserOrganizationId, topOrganizationId, frontendOrganizationId);
+        
+        // 数据权限：根据organizationId来设置查询权限
+        // organizationId等于2827时查询全部，其他仅查询各自组织的信息
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤（包括2827）
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，使用前端传递的值进行过滤
+                tmsReceiptDO.setOrganizationId(frontendOrganizationId);
+                tmsReceiptDO.setTopOrganizationId(null);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                tmsReceiptDO.setOrganizationId(null);
+                tmsReceiptDO.setTopOrganizationId(null);
+            }
+        } else {
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织（包括南光）的数据
+            // 如果其他组织尝试查询南光（organizationId=2827）的数据，返回空数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId.equals(2827L)) {
+                    // 其他组织尝试查询南光的数据，设置一个不存在的 organizationId，返回空数据
+                    tmsReceiptDO.setOrganizationId(-1L);
+                    tmsReceiptDO.setTopOrganizationId(null);
+                } else if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    tmsReceiptDO.setOrganizationId(loginUserOrganizationId);
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        tmsReceiptDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    tmsReceiptDO.setOrganizationId(frontendOrganizationId);
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        tmsReceiptDO.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            } else {
+                // 前端没有传递 organizationId，根据用户组织信息设置过滤条件
+                // 优先使用 topOrganizationId（如果存在且不等于1），否则使用 organizationId
+                if (topOrganizationId != null && topOrganizationId != 1) {
+                    tmsReceiptDO.setTopOrganizationId(topOrganizationId);
+                    tmsReceiptDO.setOrganizationId(null);
+                } else if (loginUserOrganizationId != null) {
+                    tmsReceiptDO.setOrganizationId(loginUserOrganizationId);
+                    tmsReceiptDO.setTopOrganizationId(null);
+                }
             }
         }
-        return tmsReceiptDomainService.queryList(tmsReceiptDO);
+        
+        // 调试日志：打印设置的查询条件
+        log.info("收款单查询 - 数据权限处理完成 - 登录用户组织ID: {}, 前端传递组织ID: {}, 最终查询条件 - organizationId: {}, topOrganizationId: {}, 是否为南光组织: {}", 
+            loginUserOrganizationId, frontendOrganizationId, tmsReceiptDO.getOrganizationId(), tmsReceiptDO.getTopOrganizationId(),
+            (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)));
+        
+        List<TmsReceiptPO> result = tmsReceiptDomainService.queryList(tmsReceiptDO);
+        for (TmsReceiptPO tmsReceiptPO : result) {
+            String settlementCurrency = tmsReceiptPO.getSettlementCurrency();
+            if (settlementCurrency != null) {
+                Result<?> res = wlhyServiceFeign.queryById(settlementCurrency);
+                if(ObjectUtil.isNotEmpty(res)&&res.getCode() == 200) {
+                    Map<String, Object> map = (Map<String, Object>) res.getResult();
+                    tmsReceiptPO.setSettlementCurrency(map.get("englishName").toString());
+                }
+            }
+        }
+        log.info("收款单查询 - 查询完成，返回数据条数: {}", result != null ? result.size() : 0);
+        return result;
     }
 
 
@@ -142,4 +225,4 @@ public class TmsReceiptApplicationService {
     {
         return tmsReceiptDomainService.synchronousNc(businessDocumentDetaliIds);
     }
-}
+}

mhd_finance/src/main/java/com/linke/finance/application/service/invoice/InvoiceInfoManageApplicationService.java

@@ -351,6 +351,12 @@ public class InvoiceInfoManageApplicationService {
 
         //数据装配
         InvoiceInfo invoiceInfo = new InvoiceAssembler().toDo(invoiceInfoDto);
+        // 设置当前登录用户的组织信息
+        com.mhd.system.api.model.LoginUser loginUser = com.mhd.common.security.utils.SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            invoiceInfo.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            invoiceInfo.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        }
         invoiceInfo.setInvoiceStatus(1);
         invoiceInfo.setInvoiceHeader(invoiceInfoManagePo.getInvoiceHeader());
         invoiceInfo.setWaybillAmount(new BigDecimal(invoiceInfoDto.getInvoiceOrderIds().length));

mhd_finance/src/main/java/com/linke/finance/application/service/revenueExpensesRecord/RevenueExpensesRecordApplicationService.java

@@ -137,6 +137,12 @@ public class RevenueExpensesRecordApplicationService
             throw new DigitalLogisticsException(UserError.TIMEOUT);
         }
 
+        // 设置当前登录用户的组织信息
+        if (loginUser.getUserPo() != null) {
+            revenueExpensesRecord.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            revenueExpensesRecord.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        }
+
         //支付通道
         if(StringUtils.isNotEmpty(revenueExpensesRecord.getPayChannel())){
             List<SysDictDataVo> timeTagEndVos = selectListByDictType(DictCode.pay_channel.getCode());

mhd_finance/src/main/java/com/linke/finance/application/service/verification/VerificationApplicationService.java

@@ -151,44 +151,66 @@ public class VerificationApplicationService
      * @return 收入核销集合
      */
     public List<VerificationPo> selectVerificationList(VerificationPo verificationPo){
-        List<VerificationPo> list = new ArrayList<>();
-        List<Long> organizationIdList = new ArrayList<>();
         //获取登录人信息
         LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("应付账单查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            return verificationDomainService.selectVerificationList(verificationPo);
+        }
+        
         UserPo userPo = loginUser.getUserPo();
-        //当前组织id
-        Long organizationId = new Long("2");
-        OrganizationPo organizationPo = loginUser.getOrganizationPo();
-        if (organizationPo == null){
-            organizationIdList.add(userPo.getOrganizationId());
-        }else {
-            List<Long> organizationIdList1 = organizationPo.getOrganizationIdList();
-            if (organizationIdList1 != null && organizationIdList1.size() > 0){
-                organizationIdList.addAll(organizationIdList1);
-            }else {
-                organizationIdList.add(organizationPo.getOrganizationId());
+        
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = verificationPo.getOrganizationId();
+        
+        // 获取当前登录用户的组织信息
+        Long loginUserOrganizationId = userPo.getOrganizationId();
+        Long topOrganizationId = userPo.getTopOrganizationId();
+        
+        // 数据权限：根据organizationId来设置查询权限
+        // organizationId=2827（南光组织）时，可查全部组织数据；其他组织只能查自己
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，使用前端传递的值进行过滤
+                // 设置 topOrganizationId 为 -1，作为标记，表示南光组织查询指定组织（不是查询所有）
+                verificationPo.setOrganizationId(frontendOrganizationId);
+                verificationPo.setTopOrganizationId(-1L);
+                log.info("应付账单查询 - 南光组织查询指定组织：organizationId={}", frontendOrganizationId);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                verificationPo.setOrganizationId(null);
+                verificationPo.setTopOrganizationId(null);
+                log.info("应付账单查询 - 南光组织查询所有组织：不设置组织过滤条件");
+            }
+        } else {
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    log.warn("应付账单查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                        frontendOrganizationId, loginUserOrganizationId);
+                    verificationPo.setOrganizationId(loginUserOrganizationId);
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    verificationPo.setOrganizationId(frontendOrganizationId);
+                }
+                verificationPo.setTopOrganizationId(topOrganizationId);
+            } else {
+                // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                verificationPo.setOrganizationId(loginUserOrganizationId);
+                verificationPo.setTopOrganizationId(topOrganizationId);
             }
         }
-        if(loginUser != null){
-//            if(loginUser.getUserPo() != null && loginUser.getUserPo().getOrganizationId() != null){
-//                organizationId = loginUser.getUserPo().getOrganizationId();
-//                AjaxResult info = specialLogisticsServiceFeign.getBranchByOrganizationId(organizationId);
-//                if("200".equals(String.valueOf(info.get("code")))){
-//                    BranchPo branchPo = JSONObject.parseObject(JSONObject.toJSONString(info.get("data")), BranchPo.class);
-//                    verificationPo.setBranchId(branchPo.getBranchId());
-//                }
-//            }
-        }
-        if (organizationIdList != null && organizationIdList.size() > 0){
-            organizationIdList.add(userPo.getOrganizationId());
-        }
-//        verificationPo.setOrganizationIdList(organizationIdList);
-//        verificationPo.setVerificationType(2);
-//        if (StringUtils.isNotBlank(verificationPo.getWaybillNumbers())){
-//            verificationPo.setWaybillNumberList(CollectionUtil.toList(verificationPo.getWaybillNumbers().split(",")));
-//        }
+        
+        log.info("应付账单查询 - 设置组织ID后，查询参数：organizationId={}, topOrganizationId={}", 
+            verificationPo.getOrganizationId(), verificationPo.getTopOrganizationId());
+        
         return verificationDomainService.selectOutVerificationList(verificationPo);
-//        return verificationDomainService.selectVerificationList(verificationPo);
     }
 
     /**

mhd_finance/src/main/java/com/linke/finance/domain/approvalDocument/repository/persistence/ApprovalDocumentImpl.java

@@ -487,6 +487,7 @@ public class ApprovalDocumentImpl extends ServiceImpl<ApprovalDocumentMapper, Ap
         Verification verification = new Verification();
         verification.setOrganizationId(businessDocumentDetaliDTO.getOrganizationId());
         verification.setTopOrganizationId(businessDocumentDetaliDTO.getTopOrganizationId());
+        verification.setOrganizationName(businessDocumentDetaliDTO.getOrganizationName());// 设置组织名称，确保查询时能够正确过滤
         verification.setVerificationStatus(1);//未支付
         verification.setBusinessDocumentDetaliId(businessDocumentDetaliDTO.getBusinessDocumentDetaliId());
         verification.setBusinessDocumentDetaliNumber(businessDocumentDetaliDTO.getBusinessDocumentDetaliNumber());

mhd_finance/src/main/java/com/linke/finance/domain/businessDocument/repository/facade/IBusinessDocumentService.java

@@ -10,6 +10,7 @@ import com.linke.finance.domain.businessDocumentDetali.repository.po.BusinessDoc
 import com.linke.finance.domain.reconciliation.repository.po.ReconciliationPO;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * 业务单据Service接口
@@ -24,6 +25,8 @@ public interface IBusinessDocumentService extends IService<BusinessDocument>
      */
     public List<BusinessDocumentPO> queryList(BusinessDocumentDO businessDocumentDO);
 
+    public List<Map<String,Object>> getFeeList(String invoiceId);
+
     /**
      * 新增业务单据
      */
@@ -60,4 +63,4 @@ public interface IBusinessDocumentService extends IService<BusinessDocument>
     List<BusinessDocumentDetaliPO> querySettlementList(BusinessDocumentDO businessDocumentDO);
 
     BusinessDocument getByWaybillNo(String waybillNo);
-}
+}

mhd_finance/src/main/java/com/linke/finance/domain/businessDocument/repository/mapper/BusinessDocumentMapper.java

@@ -1,6 +1,8 @@
 package com.linke.finance.domain.businessDocument.repository.mapper;
 
 import java.util.List;
+import java.util.Map;
+
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.linke.finance.domain.businessDocument.entity.BusinessDocument;
 import com.linke.finance.domain.businessDocument.repository.po.AccountsReceivableAppPO;
@@ -24,6 +26,8 @@ public interface BusinessDocumentMapper extends BaseMapper<BusinessDocument>
      */
     public List<BusinessDocumentPO> queryList(BusinessDocumentDO businessDocumentDO);
 
+    List<Map<String,Object>> getFeeList(@Param("invoiceId")String invoiceId);
+
     /**
      * 查询申请开票业务单据列表
      */
@@ -38,4 +42,4 @@ public interface BusinessDocumentMapper extends BaseMapper<BusinessDocument>
     List<BusinessDocumentPO> queryListByReconciliation(BusinessDocumentDO businessDocumentDO);
 
     List<BusinessDocumentDetaliPO> querySettlementList(@Param("businessDocumentDO") BusinessDocumentDO businessDocumentDO);
-}
+}

mhd_finance/src/main/java/com/linke/finance/domain/businessDocument/repository/persistence/BusinessDocumentImpl.java

@@ -17,6 +17,7 @@ import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 业务单据Service业务层处理
@@ -39,6 +40,12 @@ public class BusinessDocumentImpl extends ServiceImpl<BusinessDocumentMapper, Bu
         return businessDocumentMapper.queryList(businessDocumentDO);
     }
 
+    @Override
+    public List<Map<String,Object>> getFeeList(String invoiceId)
+    {
+        return businessDocumentMapper.getFeeList(invoiceId);
+    }
+
     /**
      * 新增业务单据
      */
@@ -130,4 +137,4 @@ public class BusinessDocumentImpl extends ServiceImpl<BusinessDocumentMapper, Bu
 
         return businessDocument;
     }
-}
+}

mhd_finance/src/main/java/com/linke/finance/domain/businessDocument/service/BusinessDocumentDomainService.java

@@ -21,10 +21,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * 业务单据
@@ -50,6 +47,10 @@ public class BusinessDocumentDomainService {
         return businessDocumentService.queryList(businessDocumentDO);
     }
 
+    public List<Map<String,Object>> getFeeList(String invoiceId) {
+        return businessDocumentService.getFeeList(invoiceId);
+    }
+
 
     /**
      * 新增业务单据
@@ -202,4 +203,4 @@ public class BusinessDocumentDomainService {
 
 
 
-}
+}

mhd_finance/src/main/java/com/linke/finance/domain/invoice/service/InvoiceOrderDomainService.java

@@ -58,6 +58,11 @@ public class InvoiceOrderDomainService
      */
     public int insertInvoiceOrder(InvoiceOrder invoiceOrder)
     {
+        // 设置当前登录用户的组织信息
+        com.mhd.system.api.model.LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            invoiceOrder.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+        }
         invoiceOrder.setCreateTime(new Date());
         invoiceOrder.setCreateBy(SecurityUtils.getUserId());
         invoiceOrder.setCreateByName(SecurityUtils.getUsername());

mhd_finance/src/main/java/com/linke/finance/domain/receivingAccount/repository/mapper/ReceivingAccountMapper.java

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.linke.finance.domain.receivingAccount.entity.ReceivingAccount;
 import com.linke.finance.domain.receivingAccount.repository.po.ReceivingAccountPO;
 import com.linke.finance.domain.receivingAccount.repository.todo.ReceivingAccountDO;
+import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
@@ -46,6 +47,15 @@ public interface ReceivingAccountMapper extends BaseMapper<ReceivingAccount> {
      */
     int deleteAll();
 
+    /**
+     * 根据组织ID删除收款账户（删除当前组织的所有收款账户）
+     * 
+     * @param topOrganizationId 一级组织ID
+     * @param organizationId 组织ID
+     * @return 影响行数
+     */
+    int deleteByOrganization(@Param("topOrganizationId") String topOrganizationId, @Param("organizationId") String organizationId);
+
     /**
      * 根据ID删除收款账户
      * 

mhd_finance/src/main/java/com/linke/finance/domain/receivingAccount/repository/persistence/ReceivingAccountRepository.java

@@ -60,6 +60,17 @@ public class ReceivingAccountRepository {
         return receivingAccountMapper.deleteAll();
     }
 
+    /**
+     * 根据组织ID删除收款账户（删除当前组织的所有收款账户）
+     * 
+     * @param topOrganizationId 一级组织ID
+     * @param organizationId 组织ID
+     * @return 影响行数
+     */
+    public int deleteByOrganization(String topOrganizationId, String organizationId) {
+        return receivingAccountMapper.deleteByOrganization(topOrganizationId, organizationId);
+    }
+
     /**
      * 根据ID删除收款账户
      * 

mhd_finance/src/main/java/com/linke/finance/domain/reconciliation/repository/persistence/ReconciliationImpl.java

@@ -22,6 +22,8 @@ import com.linke.finance.domain.reconciliation.repository.facade.IReconciliation
 import com.linke.finance.domain.reconciliation.repository.mapper.ReconciliationMapper;
 import com.linke.finance.domain.reconciliation.repository.po.ReconciliationPO;
 import com.linke.finance.domain.reconciliation.repository.todo.ReconciliationDO;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
+import com.linke.finance.domain.reconciliationAccount.repository.mapper.ReconciliationAccountMapper;
 import com.mhd.common.core.domain.dto.ReconciliationDTO;
 import com.mhd.common.core.domain.dto.nc.*;
 import com.mhd.common.core.domain.entity.R;
@@ -38,6 +40,8 @@ import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.common.security.utils.SecurityUtils;
 import com.mhd.system.api.UserServiceFeign;
 import com.mhd.system.api.WlhyServiceFeign;
+import com.mhd.system.api.domain.TmsInvoiceList;
+import com.mhd.system.api.domain.TmsInvoiceListDetailsVO;
 import com.mhd.system.api.domain.TmsTransportNote;
 import com.mhd.system.api.model.LoginUser;
 import org.apache.http.client.methods.CloseableHttpResponse;
@@ -49,11 +53,18 @@ import org.apache.http.util.EntityUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
 
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
 import java.io.IOException;
+import java.io.StringReader;
 import java.io.StringWriter;
 import java.math.BigDecimal;
 import java.sql.NClob;
@@ -89,11 +100,13 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
     private ApprovalDocumentMapper approvalDocumentMapper;
     @Autowired
     private ApprovalDocumentDomainService approvalDocumentDomainService;
+    @Autowired
+    private ReconciliationAccountMapper reconciliationAccountMapper;
     //nc测试环境地址
-    //private String url="http://10.0.0.212/service/XChangeServlet?account=NKNC&groupcode=CNK";
+    private String url="http://10.0.0.212/service/XChangeServlet?account=NKNC&groupcode=CNK";
 
     //nc正式环境地址
-    private String url="http://10.0.0.202/service/XChangeServlet?account=NKNC&groupcode=CNK";
+    //private String url="http://10.0.0.202/service/XChangeServlet?account=NKNC&groupcode=CNK";
     /**
      * 查询对账单列表
      */
@@ -399,11 +412,6 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                 throw new ServiceException("该记录已同步，不需要再次同步");
             }
 
-
-         /*   if(reconciliation.getIsInvoice()!=2){
-                throw new ServiceException("该记录还未开票，不允许同步");
-            }*/
-
             try {
                 Date date = reconciliation.getCreateTime();
                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@@ -415,23 +423,24 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                 reconciliationDTO.setInnerNumber(reconciliation.getInnerNumber());
                 R<List<TmsOrder>> result=wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO);
                 String makerCodeNc="";
-                if(result.getCode()==200){
-                    List<TmsOrder> list=result.getData();
-                    if(ObjectUtil.isNotNull(list)){
-                        for(TmsOrder tmsOrder:list){
-                            R<TmsTransportNote> ajaxResult1=wlhyServiceFeign.selectByOrderNum(tmsOrder.getGoodsNumber());
-                            if(ajaxResult1.getCode()==200){
-                                TmsTransportNote tmsTransportNote= ajaxResult1.getData();
-                                if(ObjectUtil.isNotNull(tmsTransportNote.getIsPaper())){
-                                    date=tmsTransportNote.getConfirmReceiptTime();
-                                    if(null==date){
-                                        date=new Date();
+                if(reconciliation.getOrganizationName().contains("南歧")){
+                    if(result.getCode()==200){
+                        List<TmsOrder> list=result.getData();
+                        if(ObjectUtil.isNotNull(list)){
+                            for(TmsOrder tmsOrder:list){
+                                R<TmsTransportNote> ajaxResult1=wlhyServiceFeign.selectByOrderNum(tmsOrder.getGoodsNumber());
+                                if(ajaxResult1.getCode()==200){
+                                    TmsTransportNote tmsTransportNote= ajaxResult1.getData();
+                                    if(ObjectUtil.isNotNull(tmsTransportNote.getIsPaper())){
+                                        date=tmsTransportNote.getConfirmReceiptTime();
+                                        if(null==date){
+                                            date=new Date();
+                                        }
+                                        dateString = sdf.format(date);
+                                    }else{
+                                        throw new ServiceException("运单还没签收， 先签收");
                                     }
-                                    dateString = sdf.format(date);
-                                }else{
-                                    throw new ServiceException("运单还没签收， 先签收");
                                 }
-                            }
                          /*   if(null==reconciliation.getSettlementPartyId()){
                                 throw new ServiceException("没有结算方，请核对");
                             }*/
@@ -444,114 +453,360 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                             if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getCustomsCodeNc())) {
                                 throw new ServiceException("请先维护制单员编码");
                             }*/
-                            makerCodeNc=tmsOrder.getMakerCodeNc();
-                            Ysitem item=new Ysitem();
-                            item.setSo_deptid("NG040104");
-                            item.setPk_deptid("NG040104");
-                            item.setPk_psndoc(tmsOrder.getSalesmanCodeNc());
-                            item.setCustomer(tmsOrder.getCustomerCodeNc());
-                            item.setObjtype("0");
-                            item.setDirection("1");
-                            item.setScomment(tmsOrder.getAppointShipper());
-                           // item.setPk_currtype("CNY");
-                            item.setPk_currtype(tmsOrder.getSettlementCurrency());
-                            item.setPurchaseorder(tmsOrder.getGoodsNumber());
-                            item.setTaxrate("0");
-                            item.setQuantity_de("0");
-                            item.setMoney_de(String.valueOf(tmsOrder.getDeliveryFreight()));
-                            item.setMoney_bal(String.valueOf(tmsOrder.getDeliveryFreight()));
-                            BigDecimal tax_de=tmsOrder.getDeliveryFreight().multiply(tmsOrder.getTaxRate().divide(BigDecimal.valueOf(100))).setScale(2,BigDecimal.ROUND_HALF_UP);
-                            BigDecimal notax_de=tmsOrder.getDeliveryFreight().subtract(tax_de);
-                            item.setNotax_de(String.valueOf(notax_de));
-                            item.setLocal_tax_de(String.valueOf(notax_de));
-                            item.setTax_de(String.valueOf(tax_de));
-                            item.setPrice(String.valueOf(tmsOrder.getDeliveryFreight()));
-                            item.setTaxprice(String.valueOf(tmsOrder.getDeliveryFreight()));
-                            item.setDef75("T10");
-                            item.setInvoiceno("");
-                            ysitemList.add(item);
-                        }
-                        Ysbodys bodys=new Ysbodys();
-                        bodys.setItem(ysitemList);
-                        Ysbillhead billhead=new Ysbillhead();
-                        billhead.setPk_group("CNK");
-                        billhead.setPk_org("NG0401");
-                        billhead.setSett_org("NG0401");
-                        billhead.setCreationtime(dateString);
-                        billhead.setCreator(makerCodeNc);
-                        billhead.setPk_billtype("F0");
-                        billhead.setPk_tradetype("D0");
-                        billhead.setBillclass("ys");
-                        billhead.setIsinit("N");
-                        date=reconciliation.getCreateTime();
-                        dateString = sdf.format(date);
-                        billhead.setBilldate(dateString);
-                        billhead.setSyscode("0");
-                        billhead.setBillno("");
-                        billhead.setDef59("");
-                        billhead.setSrc_syscode("0");
-                        billhead.setBillstatus("0");
-                        billhead.setBillmaker(makerCodeNc);
-                        billhead.setPk_busitype("");
-                        billhead.setBillyear(sdf1.format(date));
-                        billhead.setBillperiod(sdf2.format(date));
-                        billhead.setEffectstatus("0");
-                        billhead.setDef28("nqyw");
-                        billhead.setDef29(reconciliation.getInnerNumber());
-                        billhead.setBodys(bodys);
-                        Ysbill bill=new Ysbill();
-                        bill.setId("ys"+String.valueOf(reconciliation.getReconciliationId()));
-                        bill.setBillhead(billhead);
-                        Ysufinterface ufinterface=new Ysufinterface();
-                        ufinterface.setAccount("NKNC");
-                        ufinterface.setBilltype("F0");
-                        ufinterface.setBusinessunitcode("");
-                        ufinterface.setFilename("");
-                        ufinterface.setIsexchange("Y");
-                        ufinterface.setOrgcode("NG0401");
-                        ufinterface.setReceiver("NG0401");
-                        ufinterface.setReplace("Y");
-                        ufinterface.setRoottag("");
-                        ufinterface.setSender("nqyw");
-                        ufinterface.setBill(bill);
-                        JAXBContext jaxbContext = JAXBContext.newInstance(Ysufinterface.class);
-                        Marshaller marshaller = jaxbContext.createMarshaller();
-                        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
-                        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
-                        StringWriter sw = new StringWriter();
-                        marshaller.marshal(ufinterface, sw);
-                        String  xmlString = sw.toString(); // 这是要发送的XML字符串
-                        System.out.println(xmlString);
-                        NcLog ncLog=new NcLog();
-                        ncLog.setOrderId(reconciliation.getReconciliationId());
-                        ncLog.setRequestBody(xmlString);
-                        ncLog.setResponeBody("");
-                        ncLog.setType(0L);
-                        ncLog.setOrganizationId(reconciliation.getOrganizationId());
-                        ncLog.setOrganizationName(reconciliation.getOrganizationName());
-                        ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
-                        ncLogMapper.insert(ncLog);
-                        reconciliation.setSynchronousStatus(1);
-                        reconciliation.setSynchronousTime(new Date());
-                        reconciliation.setNcId("ys"+String.valueOf(reconciliation.getReconciliationId()));
-                        reconciliationMapper.updateById(reconciliation);
-                        CloseableHttpClient httpClient = HttpClients.createDefault();
-                        HttpPost httpPost = new HttpPost(url);
-                        StringEntity postingString = new StringEntity(xmlString, "UTF-8");
-                        httpPost.setEntity(postingString);
-                        httpPost.setHeader("Content-type", "application/xml");
-                        try {
-                            CloseableHttpResponse response = httpClient.execute(httpPost);
-                            String responseString = EntityUtils.toString(response.getEntity());
-                            System.out.println(responseString);
-                            response.close();
-                        } catch (Exception e) {
-                            e.printStackTrace();
-                        } finally {
+                                makerCodeNc=tmsOrder.getMakerCodeNc();
+                                Ysitem item=new Ysitem();
+                                item.setSo_deptid("NG040104");
+                                item.setPk_deptid("NG040104");
+                                item.setPk_psndoc(tmsOrder.getSalesmanCodeNc());
+                                item.setCustomer(tmsOrder.getCustomerCodeNc());
+                                item.setObjtype("0");
+                                item.setDirection("1");
+                                item.setScomment(tmsOrder.getAppointShipper());
+                                // item.setPk_currtype("CNY");
+                                item.setPk_currtype(tmsOrder.getSettlementCurrency());
+                                item.setPurchaseorder(tmsOrder.getGoodsNumber());
+                                item.setTaxrate("0");
+                                item.setQuantity_de("0");
+                                item.setMoney_de(String.valueOf(tmsOrder.getDeliveryFreight()));
+                                item.setMoney_bal(String.valueOf(tmsOrder.getDeliveryFreight()));
+                                BigDecimal tax_de=tmsOrder.getDeliveryFreight().multiply(tmsOrder.getTaxRate().divide(BigDecimal.valueOf(100))).setScale(2,BigDecimal.ROUND_HALF_UP);
+                                BigDecimal notax_de=tmsOrder.getDeliveryFreight().subtract(tax_de);
+                                item.setNotax_de(String.valueOf(notax_de));
+                                item.setLocal_tax_de(String.valueOf(notax_de));
+                                item.setTax_de(String.valueOf(tax_de));
+                                item.setPrice(String.valueOf(tmsOrder.getDeliveryFreight()));
+                                item.setTaxprice(String.valueOf(tmsOrder.getDeliveryFreight()));
+                                item.setDef75("T10");
+                                item.setInvoiceno("");
+                                ysitemList.add(item);
+                            }
+                            Ysbodys bodys=new Ysbodys();
+                            bodys.setItem(ysitemList);
+                            Ysbillhead billhead=new Ysbillhead();
+                            billhead.setPk_group("CNK");
+                            billhead.setPk_org("NG0401");
+                            billhead.setSett_org("NG0401");
+                            billhead.setCreationtime(dateString);
+                            billhead.setCreator(makerCodeNc);
+                            billhead.setPk_billtype("F0");
+                            billhead.setPk_tradetype("D0");
+                            billhead.setBillclass("ys");
+                            billhead.setIsinit("N");
+                            date=reconciliation.getCreateTime();
+                            dateString = sdf.format(date);
+                            billhead.setBilldate(dateString);
+                            billhead.setSyscode("0");
+                            billhead.setBillno("");
+                            billhead.setDef59("");
+                            billhead.setSrc_syscode("0");
+                            billhead.setBillstatus("0");
+                            billhead.setBillmaker(makerCodeNc);
+                            billhead.setPk_busitype("");
+                            billhead.setBillyear(sdf1.format(date));
+                            billhead.setBillperiod(sdf2.format(date));
+                            billhead.setEffectstatus("0");
+                            billhead.setDef28("nqyw");
+                            billhead.setDef29(reconciliation.getInnerNumber());
+                            billhead.setBodys(bodys);
+                            Ysbill bill=new Ysbill();
+                            bill.setId("ys"+String.valueOf(reconciliation.getReconciliationId()));
+                            bill.setBillhead(billhead);
+                            Ysufinterface ufinterface=new Ysufinterface();
+                            ufinterface.setAccount("NKNC");
+                            ufinterface.setBilltype("F0");
+                            ufinterface.setBusinessunitcode("");
+                            ufinterface.setFilename("");
+                            ufinterface.setIsexchange("Y");
+                            ufinterface.setOrgcode("NG0401");
+                            ufinterface.setReceiver("NG0401");
+                            ufinterface.setReplace("Y");
+                            ufinterface.setRoottag("");
+                            ufinterface.setSender("nqyw");
+                            ufinterface.setBill(bill);
+                            JAXBContext jaxbContext = JAXBContext.newInstance(Ysufinterface.class);
+                            Marshaller marshaller = jaxbContext.createMarshaller();
+                            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
+                            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
+                            StringWriter sw = new StringWriter();
+                            marshaller.marshal(ufinterface, sw);
+                            String  xmlString = sw.toString(); // 这是要发送的XML字符串
+                            System.out.println(xmlString);
+                            NcLog ncLog=new NcLog();
+                            ncLog.setOrderId(reconciliation.getReconciliationId());
+                            ncLog.setRequestBody(xmlString);
+                            ncLog.setResponeBody("");
+                            ncLog.setType(0L);
+                            ncLog.setOrganizationId(reconciliation.getOrganizationId());
+                            ncLog.setOrganizationName(reconciliation.getOrganizationName());
+                            ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
+                            ncLogMapper.insert(ncLog);
+                            reconciliation.setSynchronousStatus(1);
+                            reconciliation.setSynchronousTime(new Date());
+                            reconciliation.setNcId("ys"+String.valueOf(reconciliation.getReconciliationId()));
+                            //reconciliationMapper.updateById(reconciliation);
+                            CloseableHttpClient httpClient = HttpClients.createDefault();
+                            HttpPost httpPost = new HttpPost(url);
+                            StringEntity postingString = new StringEntity(xmlString, "UTF-8");
+                            httpPost.setEntity(postingString);
+                            httpPost.setHeader("Content-type", "application/xml");
                             try {
-                                httpClient.close();
-                            } catch (IOException e) {
+                                CloseableHttpResponse response = httpClient.execute(httpPost);
+                                String responseString = EntityUtils.toString(response.getEntity());
+                                System.out.println(responseString);
+                                ncLog.setResponeBody(responseString);
+                                // 创建DOM解析器
+                                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                                DocumentBuilder builder = factory.newDocumentBuilder();
+                                Document document = builder.parse(new InputSource(new StringReader(responseString)));
+
+                                // 获取根元素
+                                Element root = document.getDocumentElement();
+
+                                // 获取ufinterface元素的属性
+                                String billtype = root.getAttribute("billtype");
+                                String filename = root.getAttribute("filename");
+                                System.out.println("billtype: " + billtype);
+                                System.out.println("filename: " + filename);
+
+                                // 获取sendresult节点
+                                NodeList sendResultList = root.getElementsByTagName("sendresult");
+                                if (sendResultList.getLength() > 0) {
+                                    Element sendResult = (Element) sendResultList.item(0);
+
+                                    // 获取子元素内容
+                                    String bdocid = sendResult.getElementsByTagName("bdocid").item(0).getTextContent();
+                                    String resultcode = sendResult.getElementsByTagName("resultcode").item(0).getTextContent();
+                                    String content = sendResult.getElementsByTagName("content").item(0).getTextContent();
+
+                                    System.out.println("bdocid: " + bdocid);
+                                    System.out.println("resultcode: " + resultcode);
+                                    System.out.println("content: " + content);
+                                    if(resultcode.equals("1")){
+                                        reconciliation.setSynchronousStatus(1);
+                                    }else{
+                                        reconciliation.setSynchronousStatus(2);
+                                    }
+                                }
+                                ncLogMapper.updateById(ncLog);
+                                reconciliationMapper.updateById(reconciliation);
+                                response.close();
+                            } catch (Exception e) {
                                 e.printStackTrace();
+                            } finally {
+                                try {
+                                    httpClient.close();
+                                } catch (IOException e) {
+                                    e.printStackTrace();
+                                }
+                            }
+                        }
+                    }
+                }else if(reconciliation.getOrganizationName().contains("通宇")){
+                    if (reconciliation.getIsInvoice() != 2) {
+                        throw new ServiceException("该记录还未开票，不允许同步");
+                    }
+                    if(result.getCode()==200){
+                        List<TmsOrder> list=result.getData();
+                        if(ObjectUtil.isNotNull(list)){
+                            makerCodeNc=list.get(0).getMakerCodeNc();
+                            String salesmanCodeNc=list.get(0).getSalesmanCodeNc();
+                            String customerCodeNc=list.get(0).getCustomerCodeNc();
+                            String appointShipper=list.get(0).getAppointShipper();
+                            String settlementCurrency=list.get(0).getSettlementCurrency();
+                            makerCodeNc=list.get(0).getMakerCodeNc();
+                            String goodsNumber=list.get(0).getGoodsName();
+                            for(TmsOrder tmsOrder:list){
+                                R<TmsTransportNote> ajaxResult1=wlhyServiceFeign.selectByOrderNum(tmsOrder.getGoodsNumber());
+                                if(ajaxResult1.getCode()==200){
+                                    TmsTransportNote tmsTransportNote= ajaxResult1.getData();
+                                    if(ObjectUtil.isNotNull(tmsTransportNote)){
+                                        if(ObjectUtil.isNotNull(tmsTransportNote.getIsPaper())){
+                                            date=tmsTransportNote.getConfirmReceiptTime();
+                                            if(null==date){
+                                                date=new Date();
+                                            }
+                                            dateString = sdf.format(date);
+                                        }else{
+                                            throw new ServiceException("运单还没签收， 先签收");
+                                        }
+                                    }else{
+                                        throw new ServiceException("未查询到关联运单， 请核对");
+                                    }
+
+                                }
+
+                            }
+                            String invoiceNumber=reconciliation.getApplyNumber();
+                            R<TmsInvoiceListDetailsVO> ajaxResult2=wlhyServiceFeign.selectInvoiceListById(reconciliation.getInvoiceId());
+                            if(ajaxResult2.getCode()==200){
+                                TmsInvoiceListDetailsVO tmsInvoiceListDetailsVO= ajaxResult2.getData();
+                                if(ObjectUtil.isNotNull(tmsInvoiceListDetailsVO)) {
+                                    invoiceNumber=tmsInvoiceListDetailsVO.getTmsMakeOutInvoices().get(0).getInvoiceNumber();
+                                }
+
+                            }
+                            List<ReconciliationAccount> reconciliationAccountList=reconciliationAccountMapper.selectList(new QueryWrapper<ReconciliationAccount>().lambda()
+                                    .eq(ReconciliationAccount::getReconciliationId,businessDocumentDetaliId)
+                                    .eq(ReconciliationAccount::getDelFlag,1));
+                            if (ObjectUtil.isNotNull(reconciliationAccountList)&&reconciliationAccountList.size()>0){
+                                for (ReconciliationAccount reconciliationAccount:reconciliationAccountList){
+                                    Ysitem item=new Ysitem();
+                                    item.setSo_deptid("NG0408");
+                                    item.setPk_deptid("NG0408");
+                                    item.setPk_psndoc(salesmanCodeNc);
+                                    item.setCustomer(customerCodeNc);
+                                    item.setObjtype("0");
+                                    item.setDirection("1");
+                                    item.setScomment("业务部：应收"+appointShipper+reconciliationAccount.getSubjectName()+invoiceNumber);
+                                    // item.setPk_currtype("CNY");
+                                    item.setPk_currtype(settlementCurrency);
+                                    item.setPurchaseorder("");
+                                    item.setTaxrate("0");
+                                    item.setQuantity_de("0");
+                                    item.setMoney_de(String.valueOf(reconciliationAccount.getAmount()));
+                                    item.setMoney_bal(String.valueOf(reconciliationAccount.getAmount()));
+                                    if(reconciliationAccount.getRate().compareTo(BigDecimal.ZERO)>0){
+                                        BigDecimal tax_de=reconciliationAccount.getAmount().multiply(reconciliationAccount.getRate().divide(BigDecimal.valueOf(100))).setScale(2,BigDecimal.ROUND_HALF_UP);
+                                        BigDecimal notax_de=reconciliationAccount.getAmount().subtract(tax_de);
+                                        item.setNotax_de(String.valueOf(notax_de));
+                                        item.setLocal_tax_de(String.valueOf(notax_de));
+                                        item.setTax_de(String.valueOf(tax_de));
+                                    }else{
+                                        BigDecimal tax_de=BigDecimal.ZERO;
+                                        BigDecimal notax_de=reconciliationAccount.getAmount().subtract(tax_de);
+                                        item.setNotax_de(String.valueOf(notax_de));
+                                        item.setLocal_tax_de(String.valueOf(notax_de));
+                                        item.setTax_de(String.valueOf(tax_de));
+                                    }
+
+                                    item.setPrice(String.valueOf(reconciliationAccount.getAmount()));
+                                    item.setTaxprice(String.valueOf(reconciliationAccount.getAmount()));
+                                    item.setDef75("T10");
+                                    item.setInvoiceno(invoiceNumber);
+                                    ysitemList.add(item);
+                                }
+                            }else{
+                                throw  new ServiceException("未查询到账单的费用科目信息， 请核对");
+                            }
+
+                            Ysbodys bodys=new Ysbodys();
+                            bodys.setItem(ysitemList);
+                            Ysbillhead billhead=new Ysbillhead();
+                            billhead.setPk_group("CNK");
+                            billhead.setPk_org("NG04");
+                            billhead.setSett_org("NG04");
+                            billhead.setCreationtime(dateString);
+                            billhead.setCreator(makerCodeNc);
+                            billhead.setPk_billtype("F0");
+                            billhead.setPk_tradetype("D0");
+                            billhead.setBillclass("ys");
+                            billhead.setIsinit("N");
+                            date=reconciliation.getCreateTime();
+                            dateString = sdf.format(date);
+                            billhead.setBilldate(dateString);
+                            billhead.setSyscode("0");
+                            billhead.setBillno("");
+                            billhead.setDef59(list.get(0).getContractNo());
+                            billhead.setSrc_syscode("0");
+                            billhead.setBillstatus("0");
+                            billhead.setBillmaker(makerCodeNc);
+                            billhead.setPk_busitype("");
+                            billhead.setBillyear(sdf1.format(date));
+                            billhead.setBillperiod(sdf2.format(date));
+                            billhead.setEffectstatus("0");
+                            billhead.setDef28("nqyw");
+                            billhead.setDef29(reconciliation.getInnerNumber());
+                            billhead.setBodys(bodys);
+                            Ysbill bill=new Ysbill();
+                            bill.setId("ys"+String.valueOf(reconciliation.getReconciliationId()));
+                            bill.setBillhead(billhead);
+                            Ysufinterface ufinterface=new Ysufinterface();
+                            ufinterface.setAccount("NKNC");
+                            ufinterface.setBilltype("F0");
+                            ufinterface.setBusinessunitcode("");
+                            ufinterface.setFilename("");
+                            ufinterface.setIsexchange("Y");
+                            ufinterface.setOrgcode("NG04");
+                            ufinterface.setReceiver("NG04");
+                            ufinterface.setReplace("Y");
+                            ufinterface.setRoottag("");
+                            ufinterface.setSender("nqyw");
+                            ufinterface.setBill(bill);
+                            JAXBContext jaxbContext = JAXBContext.newInstance(Ysufinterface.class);
+                            Marshaller marshaller = jaxbContext.createMarshaller();
+                            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
+                            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
+                            StringWriter sw = new StringWriter();
+                            marshaller.marshal(ufinterface, sw);
+                            String  xmlString = sw.toString(); // 这是要发送的XML字符串
+                            System.out.println(xmlString);
+                            NcLog ncLog=new NcLog();
+                            ncLog.setOrderId(reconciliation.getReconciliationId());
+                            ncLog.setRequestBody(xmlString);
+                            ncLog.setResponeBody("");
+                            ncLog.setType(0L);
+                            ncLog.setOrganizationId(reconciliation.getOrganizationId());
+                            ncLog.setOrganizationName(reconciliation.getOrganizationName());
+                            ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
+                            ncLogMapper.insert(ncLog);
+                            reconciliation.setSynchronousStatus(1);
+                            reconciliation.setSynchronousTime(new Date());
+                            reconciliation.setNcId("ys"+String.valueOf(reconciliation.getReconciliationId()));
+                            //reconciliationMapper.updateById(reconciliation);
+                            CloseableHttpClient httpClient = HttpClients.createDefault();
+                            HttpPost httpPost = new HttpPost(url);
+                            StringEntity postingString = new StringEntity(xmlString, "UTF-8");
+                            httpPost.setEntity(postingString);
+                            httpPost.setHeader("Content-type", "application/xml");
+                            try {
+                                CloseableHttpResponse response = httpClient.execute(httpPost);
+                                String responseString = EntityUtils.toString(response.getEntity());
+                                System.out.println(responseString);
+                                ncLog.setResponeBody(responseString);
+                                // 创建DOM解析器
+                                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                                DocumentBuilder builder = factory.newDocumentBuilder();
+                                Document document = builder.parse(new InputSource(new StringReader(responseString)));
+
+                                // 获取根元素
+                                Element root = document.getDocumentElement();
+
+                                // 获取ufinterface元素的属性
+                                String billtype = root.getAttribute("billtype");
+                                String filename = root.getAttribute("filename");
+                                System.out.println("billtype: " + billtype);
+                                System.out.println("filename: " + filename);
+
+                                // 获取sendresult节点
+                                NodeList sendResultList = root.getElementsByTagName("sendresult");
+                                if (sendResultList.getLength() > 0) {
+                                    Element sendResult = (Element) sendResultList.item(0);
+
+                                    // 获取子元素内容
+                                    String bdocid = sendResult.getElementsByTagName("bdocid").item(0).getTextContent();
+                                    String resultcode = sendResult.getElementsByTagName("resultcode").item(0).getTextContent();
+                                    String content = sendResult.getElementsByTagName("content").item(0).getTextContent();
+
+                                    System.out.println("bdocid: " + bdocid);
+                                    System.out.println("resultcode: " + resultcode);
+                                    System.out.println("content: " + content);
+                                    if(resultcode.equals("1")){
+                                        reconciliation.setSynchronousStatus(1);
+                                    }else{
+                                        reconciliation.setSynchronousStatus(2);
+                                    }
+                                }
+                                ncLogMapper.updateById(ncLog);
+                                reconciliationMapper.updateById(reconciliation);
+                                response.close();
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            } finally {
+                                try {
+                                    httpClient.close();
+                                } catch (IOException e) {
+                                    e.printStackTrace();
+                                }
                             }
                         }
                     }
@@ -595,37 +850,29 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                     throw new ServiceException("没有结算方，请核对");
                 }*/
                 String makerCodeNc="";
-                R<List<TmsOrder>> result=wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO);
-                if(result.getCode()==200){
-                    List<TmsOrder> list=result.getData();
-                    if(ObjectUtil.isNotNull(list)){
-                        for(TmsOrder tmsOrder:list){
-                       /*     if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getSalesmanCodeNc())) {
-                                throw new ServiceException("请先维护业务员编码");
-                            }
-                            if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getMakerCodeNc())) {
-                                throw new ServiceException("请先维护制单员编码");
-                            }
-                            if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getCustomerCodeNc())) {
-                                throw new ServiceException("请先维护制单员编码");
-                            }*/
+                if(reconciliation.getOrganizationName().contains("南歧")){
+                    R<List<TmsOrder>> result=wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO);
+                    if(result.getCode()==200){
+                        List<TmsOrder> list=result.getData();
+                        if(ObjectUtil.isNotNull(list)){
+                            for(TmsOrder tmsOrder:list){
 
-                            makerCodeNc=tmsOrder.getMakerCodeNc();
-                            makerCodeNc="xiangna";
-                            SKitem item=new SKitem();
-                            item.setSo_deptid("NG040104");
-                            item.setPk_deptid("NG040104");
-                            item.setCheckdirection("ar");
-                            item.setPk_psndoc(tmsOrder.getSalesmanCodeNc());
-                            item.setCustomer(tmsOrder.getCustomerCodeNc());
-                            item.setPurchaseorder(tmsOrder.getGoodsNumber());
-                            item.setObjtype("0");
-                            item.setDirection("1");
-                            item.setScomment(tmsOrder.getAppointShipper());
-                            item.setPk_currtype(tmsOrder.getSettlementCurrency());
-                            item.setMoney_cr(String.valueOf(tmsOrder.getCollectedFreight()));
-                            item.setMoney_bal(String.valueOf(tmsOrder.getCollectedFreight()));
-                            ysitemList.add(item);
+                                makerCodeNc=tmsOrder.getMakerCodeNc();
+                                makerCodeNc="xiangna";
+                                SKitem item=new SKitem();
+                                item.setSo_deptid("NG040104");
+                                item.setPk_deptid("NG040104");
+                                item.setCheckdirection("ar");
+                                item.setPk_psndoc(tmsOrder.getSalesmanCodeNc());
+                                item.setCustomer(tmsOrder.getCustomerCodeNc());
+                                item.setPurchaseorder(tmsOrder.getGoodsNumber());
+                                item.setObjtype("0");
+                                item.setDirection("1");
+                                item.setScomment(tmsOrder.getAppointShipper());
+                                item.setPk_currtype(tmsOrder.getSettlementCurrency());
+                                item.setMoney_cr(String.valueOf(tmsOrder.getCollectedFreight()));
+                                item.setMoney_bal(String.valueOf(tmsOrder.getCollectedFreight()));
+                                ysitemList.add(item);
                      /*       AjaxResult ajaxResult=userServiceFeign.getShipperSummaryData(Long.valueOf(reconciliation.getSettlementPartyId()));
                             if(ajaxResult.get("code").toString().equals("200")){
                                 Object userShipperPo= ajaxResult.get("data");
@@ -637,89 +884,281 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
 
                             }*/
 
+                            }
                         }
                     }
-                }
-                SKbodys bodys=new SKbodys();
-                bodys.setItem(ysitemList);
-                SKbillhead billhead=new SKbillhead();
-                billhead.setPk_group("CNK");
-                billhead.setPk_org("NG0401");
-                billhead.setSett_org("NG0401");
-                billhead.setCreationtime(dateString);
-                billhead.setPk_billtype("F2");
-                billhead.setCreator(makerCodeNc);
-                billhead.setPk_tradetype("D2");
-                billhead.setBillclass("sk");
-                billhead.setBilldate(dateString);
-                billhead.setSyscode("0");
-                billhead.setBillno("");
-                billhead.setDef59("");
-                billhead.setSrc_syscode("0");
-                billhead.setBillstatus("0");
-                billhead.setBillmaker(makerCodeNc);
-                billhead.setPk_busitype("");
-                billhead.setBillyear(sdf1.format(date));
-                billhead.setBillperiod(sdf2.format(date));
-                billhead.setEffectstatus("0");
-                billhead.setDef28("nqyw");
-                billhead.setDef29(reconciliation.getInnerNumber());
-                billhead.setBodys(bodys);
-                SKbill bill=new SKbill();
-                bill.setId("sk"+String.valueOf(reconciliation.getReconciliationId()));
-                bill.setBillhead(billhead);
-                SKufinterface ufinterface=new SKufinterface();
-                ufinterface.setAccount("NKNC");
-                ufinterface.setBilltype("F2");
-                ufinterface.setBusinessunitcode("");
-                ufinterface.setFilename("");
-                ufinterface.setIsexchange("Y");
-                ufinterface.setOrgcode("NG0401");
-                ufinterface.setReceiver("NG0401");
-                ufinterface.setReplace("Y");
-                ufinterface.setRoottag("");
-                ufinterface.setSender("nqyw");
-                ufinterface.setBill(bill);
-                JAXBContext jaxbContext = null;
-                //String xmlString ="<ufinterface account=\"NKNC\" billtype=\"F0\" businessunitcode=\"\" filename=\"\" groupcode=\"CNK\" isexchange=\"Y\" orgcode=\"NG10\" receiver=\"NG10\" replace=\"Y\" roottag=\"\" sender=\"NKT_MY\">";
-                jaxbContext = JAXBContext.newInstance(SKufinterface.class);
-                Marshaller marshaller = jaxbContext.createMarshaller();
-                marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
-                marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
-                StringWriter sw = new StringWriter();
-                marshaller.marshal(ufinterface, sw);
-                String xmlString = sw.toString(); // 这是要发送的XML字符串
-                System.out.println(xmlString);
-                NcLog ncLog=new NcLog();
-                ncLog.setOrderId(reconciliation.getReconciliationId());
-                ncLog.setRequestBody(xmlString);
-                ncLog.setResponeBody("");
-                ncLog.setType(1L);
-                ncLog.setOrganizationId(reconciliation.getOrganizationId());
-                ncLog.setOrganizationName(reconciliation.getOrganizationName());
-                ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
-                ncLogMapper.insert(ncLog);
-                reconciliation.setSkSynchronousStatus(1);
-                reconciliation.setSkSynchronousTime(new Date());
-                reconciliation.setSkNcId("sk"+String.valueOf(reconciliation.getReconciliationId()));
-                reconciliationMapper.updateById(reconciliation);
-                CloseableHttpClient httpClient = HttpClients.createDefault();
-                HttpPost httpPost = new HttpPost(url);
-                StringEntity postingString = new StringEntity(xmlString, "UTF-8");
-                httpPost.setEntity(postingString);
-                httpPost.setHeader("Content-type", "application/xml");
-                try {
-                    CloseableHttpResponse response = httpClient.execute(httpPost);
-                    String responseString = EntityUtils.toString(response.getEntity());
-                    System.out.println(responseString);
-                    response.close();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                } finally {
+                    SKbodys bodys=new SKbodys();
+                    bodys.setItem(ysitemList);
+                    SKbillhead billhead=new SKbillhead();
+                    billhead.setPk_group("CNK");
+                    billhead.setPk_org("NG0401");
+                    billhead.setSett_org("NG0401");
+                    billhead.setCreationtime(dateString);
+                    billhead.setPk_billtype("F2");
+                    billhead.setCreator(makerCodeNc);
+                    billhead.setPk_tradetype("D2");
+                    billhead.setBillclass("sk");
+                    billhead.setBilldate(dateString);
+                    billhead.setSyscode("0");
+                    billhead.setBillno("");
+                    billhead.setDef59("");
+                    billhead.setSrc_syscode("0");
+                    billhead.setBillstatus("0");
+                    billhead.setBillmaker(makerCodeNc);
+                    billhead.setPk_busitype("");
+                    billhead.setBillyear(sdf1.format(date));
+                    billhead.setBillperiod(sdf2.format(date));
+                    billhead.setEffectstatus("0");
+                    billhead.setDef28("nqyw");
+                    billhead.setDef29(reconciliation.getInnerNumber());
+                    billhead.setBodys(bodys);
+                    SKbill bill=new SKbill();
+                    bill.setId("sk"+String.valueOf(reconciliation.getReconciliationId()));
+                    bill.setBillhead(billhead);
+                    SKufinterface ufinterface=new SKufinterface();
+                    ufinterface.setAccount("NKNC");
+                    ufinterface.setBilltype("F2");
+                    ufinterface.setBusinessunitcode("");
+                    ufinterface.setFilename("");
+                    ufinterface.setIsexchange("Y");
+                    ufinterface.setOrgcode("NG0401");
+                    ufinterface.setReceiver("NG0401");
+                    ufinterface.setReplace("Y");
+                    ufinterface.setRoottag("");
+                    ufinterface.setSender("nqyw");
+                    ufinterface.setBill(bill);
+                    JAXBContext jaxbContext = null;
+                    //String xmlString ="<ufinterface account=\"NKNC\" billtype=\"F0\" businessunitcode=\"\" filename=\"\" groupcode=\"CNK\" isexchange=\"Y\" orgcode=\"NG10\" receiver=\"NG10\" replace=\"Y\" roottag=\"\" sender=\"NKT_MY\">";
+                    jaxbContext = JAXBContext.newInstance(SKufinterface.class);
+                    Marshaller marshaller = jaxbContext.createMarshaller();
+                    marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
+                    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
+                    StringWriter sw = new StringWriter();
+                    marshaller.marshal(ufinterface, sw);
+                    String xmlString = sw.toString(); // 这是要发送的XML字符串
+                    System.out.println(xmlString);
+                    NcLog ncLog=new NcLog();
+                    ncLog.setOrderId(reconciliation.getReconciliationId());
+                    ncLog.setRequestBody(xmlString);
+                    ncLog.setResponeBody("");
+                    ncLog.setType(1L);
+                    ncLog.setOrganizationId(reconciliation.getOrganizationId());
+                    ncLog.setOrganizationName(reconciliation.getOrganizationName());
+                    ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
+                    ncLogMapper.insert(ncLog);
+                    reconciliation.setSkSynchronousStatus(1);
+                    reconciliation.setSkSynchronousTime(new Date());
+                    reconciliation.setSkNcId("sk"+String.valueOf(reconciliation.getReconciliationId()));
+                    //reconciliationMapper.updateById(reconciliation);
+                    CloseableHttpClient httpClient = HttpClients.createDefault();
+                    HttpPost httpPost = new HttpPost(url);
+                    StringEntity postingString = new StringEntity(xmlString, "UTF-8");
+                    httpPost.setEntity(postingString);
+                    httpPost.setHeader("Content-type", "application/xml");
                     try {
-                        httpClient.close();
-                    } catch (IOException e) {
+                        CloseableHttpResponse response = httpClient.execute(httpPost);
+                        String responseString = EntityUtils.toString(response.getEntity());
+                        System.out.println(responseString);
+                        ncLog.setResponeBody(responseString);
+                        // 创建DOM解析器
+                        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                        DocumentBuilder builder = factory.newDocumentBuilder();
+                        Document document = builder.parse(new InputSource(new StringReader(responseString)));
+
+                        // 获取根元素
+                        Element root = document.getDocumentElement();
+
+                        // 获取ufinterface元素的属性
+                        String billtype = root.getAttribute("billtype");
+                        String filename = root.getAttribute("filename");
+                        System.out.println("billtype: " + billtype);
+                        System.out.println("filename: " + filename);
+
+                        // 获取sendresult节点
+                        NodeList sendResultList = root.getElementsByTagName("sendresult");
+                        if (sendResultList.getLength() > 0) {
+                            Element sendResult = (Element) sendResultList.item(0);
+
+                            // 获取子元素内容
+                            String bdocid = sendResult.getElementsByTagName("bdocid").item(0).getTextContent();
+                            String resultcode = sendResult.getElementsByTagName("resultcode").item(0).getTextContent();
+                            String content = sendResult.getElementsByTagName("content").item(0).getTextContent();
+
+                            System.out.println("bdocid: " + bdocid);
+                            System.out.println("resultcode: " + resultcode);
+                            System.out.println("content: " + content);
+                            if(resultcode.equals("1")){
+                                reconciliation.setSkSynchronousStatus(1);
+                            }else{
+                                reconciliation.setSkSynchronousStatus(2);
+                            }
+                        }
+                        ncLogMapper.updateById(ncLog);
+                        reconciliationMapper.updateById(reconciliation);
+                        response.close();
+                    } catch (Exception e) {
                         e.printStackTrace();
+                    } finally {
+                        try {
+                            httpClient.close();
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }else if(reconciliation.getOrganizationName().contains("通宇")){
+                    R<List<TmsOrder>> result=wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO);
+                    if(result.getCode()==200){
+                        List<TmsOrder> list=result.getData();
+                        if(ObjectUtil.isNotNull(list)){
+                            for(TmsOrder tmsOrder:list){
+
+                                makerCodeNc=tmsOrder.getMakerCodeNc();
+                                makerCodeNc="luoyx";
+                                SKitem item=new SKitem();
+                                item.setSo_deptid("NG0408");
+                                item.setPk_deptid("NG0408");
+                                item.setCheckdirection("ar");
+                                item.setPk_psndoc(tmsOrder.getSalesmanCodeNc());
+                                item.setCustomer(tmsOrder.getCustomerCodeNc());
+                                item.setPurchaseorder(tmsOrder.getGoodsNumber());
+                                item.setObjtype("0");
+                                item.setDirection("1");
+                                item.setScomment("业务部："+tmsOrder.getAppointShipper()+"物流费");
+                                item.setPk_currtype(tmsOrder.getSettlementCurrency());
+                                item.setMoney_cr(String.valueOf(tmsOrder.getCollectedFreight()));
+                                item.setMoney_bal(String.valueOf(tmsOrder.getCollectedFreight()));
+                                ysitemList.add(item);
+                     /*       AjaxResult ajaxResult=userServiceFeign.getShipperSummaryData(Long.valueOf(reconciliation.getSettlementPartyId()));
+                            if(ajaxResult.get("code").toString().equals("200")){
+                                Object userShipperPo= ajaxResult.get("data");
+                                JSONObject jsonObject = new JSONObject((Map) userShipperPo);
+                                if(org.apache.commons.lang.StringUtils.isBlank(jsonObject.get("customerNcCode").toString())){
+                                    throw new ServiceException("请先维护客户编码");
+                                }
+
+
+                            }*/
+
+                            }
+                        }
+                    }
+                    SKbodys bodys=new SKbodys();
+                    bodys.setItem(ysitemList);
+                    SKbillhead billhead=new SKbillhead();
+                    billhead.setPk_group("CNK");
+                    billhead.setPk_org("NG04");
+                    billhead.setSett_org("NG04");
+                    billhead.setCreationtime(dateString);
+                    billhead.setPk_billtype("F2");
+                    billhead.setCreator(makerCodeNc);
+                    billhead.setPk_tradetype("D2");
+                    billhead.setBillclass("sk");
+                    billhead.setBilldate(dateString);
+                    billhead.setSyscode("0");
+                    billhead.setBillno("");
+                    billhead.setDef59("");
+                    billhead.setSrc_syscode("0");
+                    billhead.setBillstatus("0");
+                    billhead.setBillmaker(makerCodeNc);
+                    billhead.setPk_busitype("");
+                    billhead.setBillyear(sdf1.format(date));
+                    billhead.setBillperiod(sdf2.format(date));
+                    billhead.setEffectstatus("0");
+                    billhead.setDef28("nqyw");
+                    billhead.setDef29(reconciliation.getInnerNumber());
+                    billhead.setBodys(bodys);
+                    SKbill bill=new SKbill();
+                    bill.setId("sk"+String.valueOf(reconciliation.getReconciliationId()));
+                    bill.setBillhead(billhead);
+                    SKufinterface ufinterface=new SKufinterface();
+                    ufinterface.setAccount("NKNC");
+                    ufinterface.setBilltype("F2");
+                    ufinterface.setBusinessunitcode("");
+                    ufinterface.setFilename("");
+                    ufinterface.setIsexchange("Y");
+                    ufinterface.setOrgcode("NG04");
+                    ufinterface.setReceiver("NG04");
+                    ufinterface.setReplace("Y");
+                    ufinterface.setRoottag("");
+                    ufinterface.setSender("nqyw");
+                    ufinterface.setBill(bill);
+                    JAXBContext jaxbContext = null;
+                    //String xmlString ="<ufinterface account=\"NKNC\" billtype=\"F0\" businessunitcode=\"\" filename=\"\" groupcode=\"CNK\" isexchange=\"Y\" orgcode=\"NG10\" receiver=\"NG10\" replace=\"Y\" roottag=\"\" sender=\"NKT_MY\">";
+                    jaxbContext = JAXBContext.newInstance(SKufinterface.class);
+                    Marshaller marshaller = jaxbContext.createMarshaller();
+                    marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
+                    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); // 格式化输出，可选
+                    StringWriter sw = new StringWriter();
+                    marshaller.marshal(ufinterface, sw);
+                    String xmlString = sw.toString(); // 这是要发送的XML字符串
+                    System.out.println(xmlString);
+                    NcLog ncLog=new NcLog();
+                    ncLog.setOrderId(reconciliation.getReconciliationId());
+                    ncLog.setRequestBody(xmlString);
+                    ncLog.setResponeBody("");
+                    ncLog.setType(1L);
+                    ncLog.setOrganizationId(reconciliation.getOrganizationId());
+                    ncLog.setOrganizationName(reconciliation.getOrganizationName());
+                    ncLog.setTopOrganizationId(reconciliation.getTopOrganizationId());
+                    ncLogMapper.insert(ncLog);
+                    reconciliation.setSkSynchronousStatus(1);
+                    reconciliation.setSkSynchronousTime(new Date());
+                    reconciliation.setSkNcId("sk"+String.valueOf(reconciliation.getReconciliationId()));
+                    //reconciliationMapper.updateById(reconciliation);
+                    CloseableHttpClient httpClient = HttpClients.createDefault();
+                    HttpPost httpPost = new HttpPost(url);
+                    StringEntity postingString = new StringEntity(xmlString, "UTF-8");
+                    httpPost.setEntity(postingString);
+                    httpPost.setHeader("Content-type", "application/xml");
+                    try {
+                        CloseableHttpResponse response = httpClient.execute(httpPost);
+                        String responseString = EntityUtils.toString(response.getEntity());
+                        System.out.println(responseString);
+                        ncLog.setResponeBody(responseString);
+                        // 创建DOM解析器
+                        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                        DocumentBuilder builder = factory.newDocumentBuilder();
+                        Document document = builder.parse(new InputSource(new StringReader(responseString)));
+
+                        // 获取根元素
+                        Element root = document.getDocumentElement();
+
+                        // 获取ufinterface元素的属性
+                        String billtype = root.getAttribute("billtype");
+                        String filename = root.getAttribute("filename");
+                        System.out.println("billtype: " + billtype);
+                        System.out.println("filename: " + filename);
+
+                        // 获取sendresult节点
+                        NodeList sendResultList = root.getElementsByTagName("sendresult");
+                        if (sendResultList.getLength() > 0) {
+                            Element sendResult = (Element) sendResultList.item(0);
+
+                            // 获取子元素内容
+                            String bdocid = sendResult.getElementsByTagName("bdocid").item(0).getTextContent();
+                            String resultcode = sendResult.getElementsByTagName("resultcode").item(0).getTextContent();
+                            String content = sendResult.getElementsByTagName("content").item(0).getTextContent();
+
+                            System.out.println("bdocid: " + bdocid);
+                            System.out.println("resultcode: " + resultcode);
+                            System.out.println("content: " + content);
+                            if(resultcode.equals("1")){
+                                reconciliation.setSkSynchronousStatus(1);
+                            }else{
+                                reconciliation.setSkSynchronousStatus(2);
+                            }
+                        }
+                        ncLogMapper.updateById(ncLog);
+                        reconciliationMapper.updateById(reconciliation);
+                        response.close();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    } finally {
+                        try {
+                            httpClient.close();
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
                     }
                 }
             } catch (JAXBException e) {

mhd_finance/src/main/java/com/linke/finance/domain/reconciliation/repository/po/ReconciliationPO.java

@@ -1,7 +1,9 @@
 package com.linke.finance.domain.reconciliation.repository.po;
 
 import com.linke.finance.domain.businessDocument.entity.BusinessDocument;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
 import com.mhd.common.core.annotation.Excel;
+import com.mhd.common.core.domain.dto.ReconciliationAccountDTO;
 import lombok.Data;
 import java.util.Date;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -242,4 +244,10 @@ public class ReconciliationPO extends BaseVOEntity{
     @ApiModelProperty("结算币种")
     private String settlementCurrency;
 
+    @ApiModelProperty(value = "账单科目明细")
+    public List<ReconciliationAccount> reconciliationAccountDTOList;
+
+    @ApiModelProperty("账单科目明细")
+    private String reconciliationAccountDTOListJsonStr;
+
 }

mhd_finance/src/main/java/com/linke/finance/domain/reconciliation/repository/todo/ReconciliationDO.java

@@ -2,6 +2,7 @@ package com.linke.finance.domain.reconciliation.repository.todo;
 
 import com.linke.finance.domain.reconciliation.entity.ReconciliationOrderDetail;
 import com.mhd.common.core.annotation.Excel;
+import com.mhd.common.core.domain.dto.ReconciliationAccountDTO;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import java.util.Date;
@@ -270,4 +271,8 @@ public class ReconciliationDO extends BaseVOEntity{
 
     @ApiModelProperty(value = "nc唯一标识")
     private String skNcId;
+
+
+    @ApiModelProperty(value = "账单科目明细")
+    public List<ReconciliationAccountDTO> reconciliationAccountDTOList;
 }

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/entity/ReconciliationAccount.java

@@ -0,0 +1,74 @@
+package com.linke.finance.domain.reconciliationAccount.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.mhd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModelProperty;
+import com.mhd.common.core.web.domain.BaseVOEntity;
+import java.math.BigDecimal;
+import lombok.Data;
+import java.util.Date;
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+
+/**
+ * 【请填写功能名称】对象 reconciliation_account
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+
+@Data
+public class ReconciliationAccount extends BaseVOEntity{
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty("$column.columnComment")
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    @ApiModelProperty("所属组织")
+    @Excel(name = "所属组织")
+    private String orgName;
+
+    @ApiModelProperty("组织ID")
+    @Excel(name = "组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty("一级组织ID")
+    @Excel(name = "一级组织ID")
+    private Long topOrganizationId;
+
+    @ApiModelProperty("组织名称")
+    @Excel(name = "组织名称")
+    private String organizationName;
+
+    @ApiModelProperty("应收账单id")
+    @Excel(name = "应收账单id")
+    private Long reconciliationId;
+
+    @ApiModelProperty("科目id")
+    @Excel(name = "科目id")
+    private Long accountId;
+
+    @ApiModelProperty("科目收支类型（1-应收，2-应付")
+    @Excel(name = "科目收支类型", readConverterExp = "科目收支类型（1-应收，2-应付")
+    private Long accountType;
+
+    @ApiModelProperty("科目编码")
+    @Excel(name = "科目编码")
+    private String subjectCode;
+
+    @ApiModelProperty("科目名称")
+    @Excel(name = "科目名称")
+    private String subjectName;
+
+    @ApiModelProperty("科目费率")
+    @Excel(name = "科目费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty("金额")
+    @Excel(name = "金额")
+    private BigDecimal amount;
+
+
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/repository/facade/IReconciliationAccountService.java

@@ -0,0 +1,43 @@
+package com.linke.finance.domain.reconciliationAccount.repository.facade;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+
+import java.util.List;
+
+/**
+ * 【请填写功能名称】Service接口
+ * 
+ * @author gen
+ * @date 2026-01-14
+ */
+public interface IReconciliationAccountService extends IService<ReconciliationAccount>
+{
+    /**
+     * 分页查询【请填写功能名称】列表
+     */
+    public List<ReconciliationAccountPO> queryList(ReconciliationAccountDO reconciliationAccountDO);
+
+    /**
+     * 新增【请填写功能名称】
+     */
+    public Boolean insert(ReconciliationAccountDO reconciliationAccountDO);
+
+    /**
+     * 修改【请填写功能名称】
+     */
+    public Boolean update(ReconciliationAccountDO reconciliationAccountDO);
+
+    /**
+     * 批量删除【请填写功能名称】
+     */
+    public Boolean delete(Long[] ids);
+
+
+    /**
+     * 查询【请填写功能名称】
+     */
+    public ReconciliationAccountPO getInfo(Long id);
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/repository/mapper/ReconciliationAccountMapper.java

@@ -0,0 +1,22 @@
+package com.linke.finance.domain.reconciliationAccount.repository.mapper;
+
+import java.util.List;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import org.apache.ibatis.annotations.Param;
+/**
+ * 【请填写功能名称】Mapper接口
+ * 
+ * @author gen
+ * @date 2026-01-14
+ */
+public interface ReconciliationAccountMapper extends BaseMapper<ReconciliationAccount>
+{
+    /**
+     * 查询【请填写功能名称】列表
+     */
+    public List<ReconciliationAccountPO> queryList(ReconciliationAccountDO reconciliationAccountDO);
+
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/repository/persistence/ReconciliationAccountImpl.java

@@ -0,0 +1,81 @@
+package com.linke.finance.domain.reconciliationAccount.repository.persistence;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.linke.finance.domain.reconciliationAccount.entity.ReconciliationAccount;
+import com.linke.finance.domain.reconciliationAccount.repository.facade.IReconciliationAccountService;
+import com.linke.finance.domain.reconciliationAccount.repository.mapper.ReconciliationAccountMapper;
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 【请填写功能名称】Service业务层处理
+ * 
+ * @author gen
+ * @date 2026-01-14
+ */
+@Service
+public class ReconciliationAccountImpl extends ServiceImpl<ReconciliationAccountMapper, ReconciliationAccount> implements IReconciliationAccountService{
+    @Autowired
+    private ReconciliationAccountMapper reconciliationAccountMapper;
+
+    /**
+     * 查询【请填写功能名称】列表
+     */
+    @Override
+    public List<ReconciliationAccountPO> queryList(ReconciliationAccountDO reconciliationAccountDO)
+    {
+        return reconciliationAccountMapper.queryList(reconciliationAccountDO);
+    }
+
+    /**
+     * 新增【请填写功能名称】
+     */
+    @Override
+    public Boolean insert(ReconciliationAccountDO reconciliationAccountDO) {
+        ReconciliationAccount reconciliationAccount = new ReconciliationAccount();
+        BeanUtils.copyProperties(reconciliationAccountDO,reconciliationAccount);
+        return this.save(reconciliationAccount);
+    }
+
+    /**
+     * 修改【请填写功能名称】
+     */
+    @Override
+    public Boolean update(ReconciliationAccountDO reconciliationAccountDO) {
+        ReconciliationAccount reconciliationAccount = new ReconciliationAccount();
+        BeanUtils.copyProperties(reconciliationAccountDO,reconciliationAccount);
+        return this.updateById(reconciliationAccount);
+    }
+
+    /**
+     * 批量删除【请填写功能名称】
+     */
+    @Override
+    public Boolean delete(Long[] ids ) {
+        List<ReconciliationAccount> list = new ArrayList<>();
+        for (Long id : ids) {
+            ReconciliationAccount reconciliationAccount = new ReconciliationAccount();
+            reconciliationAccount.setId(id);
+            reconciliationAccount.setDelFlag(2);
+            list.add(reconciliationAccount);
+        }
+        return this.updateBatchById(list);
+    }
+
+    /**
+     * 修改【请填写功能名称】
+     */
+    @Override
+    public ReconciliationAccountPO getInfo(Long id) {
+        ReconciliationAccount reconciliationAccount = this.getById(id);
+        ReconciliationAccountPO reconciliationAccountPO = new ReconciliationAccountPO();
+        BeanUtils.copyProperties(reconciliationAccount,reconciliationAccountPO);
+        return reconciliationAccountPO;
+    }
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/repository/po/ReconciliationAccountPO.java

@@ -0,0 +1,74 @@
+package com.linke.finance.domain.reconciliationAccount.repository.po;
+
+import com.mhd.common.core.annotation.Excel;
+import lombok.Data;
+import java.util.Date;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import java.math.BigDecimal;
+import com.mhd.common.core.web.domain.BaseVOEntity;
+
+
+/**
+ * 【请填写功能名称】对象 reconciliation_account
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+
+@Data
+@ApiModel(value = "【请填写功能名称】对象", description = "【请填写功能名称】响应对象")
+public class ReconciliationAccountPO extends BaseVOEntity{
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty("$column.columnComment")
+    private Long id;
+
+    @ApiModelProperty("所属组织")
+    @Excel(name = "所属组织")
+    private String orgName;
+
+    @ApiModelProperty("组织ID")
+    @Excel(name = "组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty("一级组织ID")
+    @Excel(name = "一级组织ID")
+    private Long topOrganizationId;
+
+    @ApiModelProperty("组织名称")
+    @Excel(name = "组织名称")
+    private String organizationName;
+
+    @ApiModelProperty("应收账单id")
+    @Excel(name = "应收账单id")
+    private String reconciliationId;
+
+    @ApiModelProperty("科目id")
+    @Excel(name = "科目id")
+    private Long accountId;
+
+    @ApiModelProperty("科目收支类型（1-应收，2-应付")
+    @Excel(name = "科目收支类型", readConverterExp = "科目收支类型（1-应收，2-应付")
+    private Long accountType;
+
+    @ApiModelProperty("科目编码")
+    @Excel(name = "科目编码")
+    private String subjectCode;
+
+    @ApiModelProperty("科目名称")
+    @Excel(name = "科目名称")
+    private String subjectName;
+
+    @ApiModelProperty("科目费率")
+    @Excel(name = "科目费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty("金额")
+    @Excel(name = "金额")
+    private BigDecimal amount;
+
+
+
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/repository/todo/ReconciliationAccountDO.java

@@ -0,0 +1,77 @@
+package com.linke.finance.domain.reconciliationAccount.repository.todo;
+
+import com.mhd.common.core.annotation.Excel;
+import lombok.Data;
+import java.util.Date;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.math.BigDecimal;
+import io.swagger.annotations.ApiModelProperty;
+import com.mhd.common.core.web.domain.BaseVOEntity;
+
+import java.util.List;
+
+
+/**
+ * 【请填写功能名称】对象 reconciliation_account
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+
+@Data
+public class ReconciliationAccountDO extends BaseVOEntity{
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty("$column.columnComment")
+    private Long id;
+
+    @ApiModelProperty("所属组织")
+    @Excel(name = "所属组织")
+    private String orgName;
+
+    @ApiModelProperty("组织ID")
+    @Excel(name = "组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty("一级组织ID")
+    @Excel(name = "一级组织ID")
+    private Long topOrganizationId;
+
+    @ApiModelProperty("组织名称")
+    @Excel(name = "组织名称")
+    private String organizationName;
+
+    @ApiModelProperty("应收账单id")
+    @Excel(name = "应收账单id")
+    private Long reconciliationId;
+
+    @ApiModelProperty("科目id")
+    @Excel(name = "科目id")
+    private Long accountId;
+
+    @ApiModelProperty("科目收支类型（1-应收，2-应付")
+    @Excel(name = "科目收支类型", readConverterExp = "科目收支类型（1-应收，2-应付")
+    private Long accountType;
+
+    @ApiModelProperty("科目编码")
+    @Excel(name = "科目编码")
+    private String subjectCode;
+
+    @ApiModelProperty("科目名称")
+    @Excel(name = "科目名称")
+    private String subjectName;
+
+    @ApiModelProperty("科目费率")
+    @Excel(name = "科目费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty("金额")
+    @Excel(name = "金额")
+    private BigDecimal amount;
+
+    @ApiModelProperty(name = "组织ID集合")
+    private List<Long> organizationIdList;
+
+    @ApiModelProperty(name = "权限菜单ID")
+    private Long permissionMenuId;
+}

mhd_finance/src/main/java/com/linke/finance/domain/reconciliationAccount/service/ReconciliationAccountDomainService.java

@@ -0,0 +1,64 @@
+package com.linke.finance.domain.reconciliationAccount.service;
+
+import com.linke.finance.domain.reconciliationAccount.repository.facade.IReconciliationAccountService;
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+/**
+ * 【请填写功能名称】
+ * 
+ * @author gen
+ * @date 2026-01-14
+ */
+@Service
+@Slf4j
+public class ReconciliationAccountDomainService {
+
+    @Autowired
+    private IReconciliationAccountService reconciliationAccountService;
+
+
+    /**
+     * 分页查询【请填写功能名称】列表
+     */
+    public List<ReconciliationAccountPO> queryList(ReconciliationAccountDO reconciliationAccountDO) {
+        return reconciliationAccountService.queryList(reconciliationAccountDO);
+    }
+
+
+    /**
+     * 新增【请填写功能名称】
+     */
+    public Boolean insert(ReconciliationAccountDO reconciliationAccountDO) {
+
+        return reconciliationAccountService.insert(reconciliationAccountDO);
+    }
+
+    /**
+     * 修改【请填写功能名称】
+     */
+    public Boolean update(ReconciliationAccountDO reconciliationAccountDO) {
+        return reconciliationAccountService.update(reconciliationAccountDO);
+    }
+
+    /**
+     * 批量删除【请填写功能名称】
+     */
+    public Boolean delete(Long[] ids) {
+        return reconciliationAccountService.delete(ids);
+    }
+
+    /**
+     * 获取【请填写功能名称】详细信息
+     */
+    public ReconciliationAccountPO getInfo(Long id)
+    {
+        return reconciliationAccountService.getInfo(id);
+    }
+
+
+}

mhd_finance/src/main/java/com/linke/finance/domain/tmsReceipt/entity/TmsReceipt.java

@@ -2,15 +2,16 @@ package com.linke.finance.domain.tmsReceipt.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
-import com.mhd.common.core.annotation.Excel;
-import io.swagger.annotations.ApiModelProperty;
-import com.mhd.common.core.web.domain.BaseVOEntity;
-import java.math.BigDecimal;
-import lombok.Data;
-import java.util.Date;
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.mhd.common.core.annotation.Excel;
+import com.mhd.common.core.web.domain.BaseVOEntity;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
 import org.springframework.format.annotation.DateTimeFormat;
 
+import java.math.BigDecimal;
+import java.util.Date;
+
 
 /**
  * 收款单对象 tms_receipt
@@ -43,9 +44,9 @@ public class TmsReceipt extends BaseVOEntity{
     @Excel(name = "收款单号")
     private String receivePaymentNumber;
 
-//    @ApiModelProperty("结算方id")
-//    @Excel(name = "结算方id")
-//    private String settlementPartyId;
+    @ApiModelProperty("结算方id")
+    @Excel(name = "结算方id")
+    private String settlementPartyId;
     @ApiModelProperty("结算方名称")
     @Excel(name = "结算方名称")
     private String settlementPartyName;
@@ -118,4 +119,4 @@ public class TmsReceipt extends BaseVOEntity{
     @ApiModelProperty("结算币种")
     private String settlementCurrency;
 
-}
+}

mhd_finance/src/main/java/com/linke/finance/domain/verification/service/VerificationDomainService.java

@@ -134,7 +134,14 @@ public class VerificationDomainService
      * @return 结果
      */
     public boolean batchAddVerification(List<Verification> list){
-        return verificationRepositoryImpl.saveBatch(list);
+        if (list == null || list.isEmpty()) {
+            return false;
+        }
+        // 使用自定义的批量插入方法，而不是 MyBatis-Plus 的 saveBatch
+        // 因为自定义的 batchAddVerification 使用了完整的 SQL 插入语句，包含所有必要字段
+        int result = verificationRepositoryImpl.batchAddVerification(list);
+        // 返回 true 表示成功插入（插入行数大于0）
+        return result > 0;
     }
 
     /**

mhd_finance/src/main/java/com/linke/finance/infrastructure/feign/WlhyServiceFeign.java

@@ -1,6 +1,11 @@
 package com.linke.finance.infrastructure.feign;
 
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.mhd.common.core.domain.dto.ReconciliationDTO;
 import com.mhd.common.core.domain.dto.UserDriverDTO;
+import com.mhd.common.core.domain.entity.TmsOrder;
+import com.mhd.common.core.utils.sms.Result;
 import com.mhd.common.core.web.domain.AjaxResult;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -16,4 +21,9 @@ public interface WlhyServiceFeign {
      */
     @GetMapping("/ntocc/tmsOrder/getById")
     public AjaxResult getById(@RequestParam(name="id",required=true) Long id);
-}
+
+    @GetMapping(value = "/ntocc/outBoundSummary/getOrderListByReconciliation")
+    public Result<Page<TmsOrder>> getOrderListByReconciliation(ReconciliationDTO reconciliationDTO,
+                                                               @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
+                                                               @RequestParam(name="pageSize", defaultValue="10") Integer pageSize);
+}

mhd_finance/src/main/java/com/linke/finance/interfaces/assembler/reconciliationAccount/ReconciliationAccountAssembler.java

@@ -0,0 +1,65 @@
+package com.linke.finance.interfaces.assembler.reconciliationAccount;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import com.mhd.common.core.domain.dto.ReconciliationAccountDTO;
+import com.mhd.common.core.exception.digitalLogisticsException.DigitalLogisticsException;
+import com.mhd.common.core.exception.digitalLogisticsException.UserError;
+import com.mhd.common.core.utils.bean.BeanUtils;
+import com.mhd.common.core.utils.IgnoreNullUtil;
+import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+
+/**
+ * 【请填写功能名称】Assembler
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+@Component
+public class ReconciliationAccountAssembler {
+
+    /**
+     * 转换实体
+     */
+    public ReconciliationAccountDO toDO(ReconciliationAccountDTO reconciliationAccountDTO) {
+        ReconciliationAccountDO reconciliationAccountDO = new ReconciliationAccountDO();
+        // 拷贝
+        BeanUtils.copyProperties(reconciliationAccountDTO, reconciliationAccountDO, IgnoreNullUtil.getNullPropertyNames(reconciliationAccountDTO));
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (ObjectUtil.isNull(loginUser)) {
+            throw new DigitalLogisticsException(UserError.TIMEOUT);
+        }
+        String userName = loginUser.getUsername();
+        // 获取登录人id
+        Long userId = loginUser.getUserid();
+        if(reconciliationAccountDTO.getId() != null){
+            if(userId != null){
+                reconciliationAccountDO.setUpdateBy(userId);
+            }else {
+                reconciliationAccountDO.setUpdateBy(new Long("0"));
+            }
+            reconciliationAccountDO.setUpdateByName(userName);
+            reconciliationAccountDO.setUpdateTime(new Date());
+
+        }else {
+            if(userId != null){
+                reconciliationAccountDO.setCreateBy(userId);
+                reconciliationAccountDO.setUpdateBy(userId);
+            }else {
+                reconciliationAccountDO.setCreateBy(new Long("0"));
+                reconciliationAccountDO.setUpdateBy(new Long("0"));
+            }
+            reconciliationAccountDO.setCreateByName(userName);
+            reconciliationAccountDO.setUpdateByName(userName);
+            reconciliationAccountDO.setCreateTime(new Date());
+            reconciliationAccountDO.setUpdateTime(new Date());
+            reconciliationAccountDO.setDelFlag(1);
+        }
+        return reconciliationAccountDO;
+    }
+
+}

mhd_finance/src/main/java/com/linke/finance/interfaces/dto/TmsReceiptDTO.java

@@ -28,7 +28,7 @@ public class TmsReceiptDTO extends BaseVOEntity{
 
     @ApiModelProperty("一级组织ID")
     @Excel(name = "一级组织ID")
-    private Integer topOrganizationId;
+    private Long topOrganizationId;
 
     @ApiModelProperty("收款单号")
     @Excel(name = "收款单号")
@@ -107,22 +107,19 @@ public class TmsReceiptDTO extends BaseVOEntity{
     @Excel(name = "是否删除", readConverterExp = "删除标记：0-无状态，1-正常，2-已删除")
     private Integer delFlag;
 
+    @ApiModelProperty(name = "组织ID集合")
+    private List<Long> organizationIdList;
 
-//    @ApiModelProperty(name = "组织ID集合")
-//    @Excel(name = "组织ID集合")
-//    private List<Long> organizationIdList;
-//
-//    @ApiModelProperty(name = "权限菜单ID")
-//    @Excel(name = "权限菜单ID")
-//    private Long permissionMenuId;
-//
-//    @ApiModelProperty("组织表id")
-//    @Excel(name = "组织表id")
-//    private Long organizationId;
-//
-//    @ApiModelProperty("组织名称")
-//    @Excel(name = "组织名称")
-//    private String organizationName;
+    @ApiModelProperty(name = "权限菜单ID")
+    private Long permissionMenuId;
+
+    @ApiModelProperty("组织表id")
+    @Excel(name = "组织表id")
+    private Long organizationId;
+
+    @ApiModelProperty("组织名称")
+    @Excel(name = "组织名称")
+    private String organizationName;
 
     @ApiModelProperty("挂账原因")
     @Excel(name = "挂账原因")

mhd_finance/src/main/java/com/linke/finance/interfaces/facade/businessDocument/BusinessDocumentApi.java

@@ -15,6 +15,8 @@ import com.linke.finance.domain.reconciliation.repository.po.FinacialReconciliat
 import com.linke.finance.infrastructure.util.UniqueKeyUtil;
 import com.linke.finance.interfaces.dto.InvoiceOrderDto;
 import com.mhd.common.core.domain.dto.BusinessDocumentDetaliDTO;
+import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
 import com.mhd.common.core.domain.dto.EditPaymentMethodDTO;
 import com.mhd.common.log.annotation.Log;
 import com.mhd.common.log.enums.BusinessType;

mhd_finance/src/main/java/com/linke/finance/interfaces/facade/reconciliation/ReconciliationApi.java

@@ -2,6 +2,7 @@ package com.linke.finance.interfaces.facade.reconciliation;
 
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
 
 import com.linke.finance.application.server.businessDocument.BusinessDocumentApplicationService;
 import com.linke.finance.application.server.reconciliation.ReconciliationApplicationService;
@@ -11,6 +12,7 @@ import com.linke.finance.domain.reconciliation.entity.Reconciliation;
 import com.linke.finance.domain.reconciliation.repository.po.FinacialReconciliationListVO;
 import com.linke.finance.interfaces.assembler.businessDocument.BusinessDocumentAssembler;
 import com.mhd.common.core.domain.dto.BusinessDocumentDTO;
+import com.mhd.common.core.domain.entity.R;
 import com.mhd.common.log.annotation.Log;
 import com.mhd.common.log.enums.BusinessType;
 import io.swagger.annotations.ApiOperation;
@@ -193,6 +195,17 @@ public class ReconciliationApi extends BaseController{
         return getDataTable(list);
     }
 
+
+    /**
+     * 对账单详情
+     */
+    @GetMapping("/getFeeListByInvoiceId")
+    public R<List<Map<String,Object>>> getFeeList(@RequestParam String invoiceId)
+    {
+        List<Map<String,Object>> list = businessDocumentApplicationService.getFeeList(invoiceId);
+        return R.ok(list);
+    }
+
     /**
      * 生成对账单（调账对账）
      */
@@ -297,4 +310,4 @@ public class ReconciliationApi extends BaseController{
 
     }
 
-}
+}

mhd_finance/src/main/java/com/linke/finance/interfaces/facade/reconciliationAccount/ReconciliationAccountApi.java

@@ -0,0 +1,99 @@
+package com.linke.finance.interfaces.facade.reconciliationAccount;
+
+import java.util.List;
+
+import com.mhd.common.core.domain.dto.ReconciliationAccountDTO;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.linke.finance.domain.reconciliationAccount.repository.todo.ReconciliationAccountDO;
+import com.linke.finance.domain.reconciliationAccount.repository.po.ReconciliationAccountPO;
+import com.linke.finance.application.server.reconciliationAccount.ReconciliationAccountApplicationService;
+import com.linke.finance.interfaces.assembler.reconciliationAccount.ReconciliationAccountAssembler;
+import javax.annotation.Resource;
+import com.mhd.common.core.web.controller.BaseController;
+import com.mhd.common.core.web.domain.AjaxResult;
+import com.mhd.common.core.web.page.TableDataInfo;
+
+/**
+ * 【请填写功能名称】Api
+ *
+ * @author gen
+ * @date 2026-01-14
+ */
+@RestController
+@RequestMapping("/reconciliationAccountApi")
+public class ReconciliationAccountApi extends BaseController{
+    @Autowired
+    private ReconciliationAccountApplicationService reconciliationAccountApplicationService;
+
+    @Resource
+    private ReconciliationAccountAssembler reconciliationAccountAssembler;
+
+    /**
+     * 分页查询【请填写功能名称】列表
+     */
+    @ApiOperation("查询【请填写功能名称】列表")
+    @GetMapping("/list")
+    public TableDataInfo list(ReconciliationAccountDTO reconciliationAccountDTO)
+    {
+        //转换实体
+        ReconciliationAccountDO reconciliationAccountDO = reconciliationAccountAssembler.toDO(reconciliationAccountDTO);
+        startPage();
+        List<ReconciliationAccountPO> list = reconciliationAccountApplicationService.queryList(reconciliationAccountDO);
+        return getDataTable(list);
+    }
+
+    /**
+     * 编辑【请填写功能名称】
+     */
+    @ApiOperation("编辑【请填写功能名称】")
+    @PostMapping("/edit")
+    public AjaxResult edit(@RequestBody ReconciliationAccountDTO reconciliationAccountDTO)
+    {
+        //转换实体
+        ReconciliationAccountDO reconciliationAccountDO = reconciliationAccountAssembler.toDO(reconciliationAccountDTO);
+        if(reconciliationAccountDTO.getId() != null){
+            return toAjax(reconciliationAccountApplicationService.update(reconciliationAccountDO));
+        }else {
+            return toAjax(reconciliationAccountApplicationService.insert(reconciliationAccountDO));
+        }
+    }
+
+    /**
+     * 批量删除【请填写功能名称】
+     */
+    @ApiOperation("批量删除【请填写功能名称】")
+    @DeleteMapping("/deleteByIds/{ids}")
+    public AjaxResult delete(@PathVariable Long[] ids)
+    {
+        return toAjax(reconciliationAccountApplicationService.delete(ids));
+    }
+
+    /**
+     * 获取【请填写功能名称】详细信息
+     */
+    @ApiOperation("获取【请填写功能名称】")
+    @GetMapping(value = "/getInfo/{id}")
+    public AjaxResult getInfo(@PathVariable("id") Long id)
+    {
+        return AjaxResult.success(reconciliationAccountApplicationService.getInfo(id));
+    }
+
+
+
+
+
+
+
+
+
+
+
+}

mhd_finance/src/main/java/com/linke/finance/interfaces/facadeApp/tmsReceipt/TmsReceiptApi.java

@@ -16,6 +16,8 @@ import com.mhd.common.core.utils.IgnoreNullUtil;
 import com.mhd.common.core.utils.bean.BeanUtils;
 import com.mhd.common.log.annotation.Log;
 import com.mhd.common.log.enums.BusinessType;
+import com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
@@ -24,6 +26,7 @@ import javax.annotation.Resource;
 import com.mhd.common.core.web.controller.BaseController;
 import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.common.core.web.page.TableDataInfo;
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * 收款单Api
@@ -31,6 +34,7 @@ import com.mhd.common.core.web.page.TableDataInfo;
  * @author gen
  * @date 2025-04-28
  */
+@Slf4j
 @RestController
 @RequestMapping("/tmsReceiptApi")
 @CrossOrigin
@@ -56,6 +60,39 @@ public class TmsReceiptApi extends BaseController{
 //        TmsReceiptDO tmsReceiptDO = tmsReceiptAssembler.toDO(tmsReceiptDTO);
         TmsReceiptDO tmsReceiptDO = new TmsReceiptDO();
         BeanUtils.copyProperties(tmsReceiptDTO, tmsReceiptDO);
+        // 获取当前登录用户的组织信息，用于SQL中的数据隔离
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            Long loginOrgId = loginUser.getUserPo().getOrganizationId();
+            // 保存前端传入的组织查询条件（如果有）
+            Long frontendOrgId = tmsReceiptDO.getOrganizationId();
+            Long frontendTopOrgId = tmsReceiptDO.getTopOrganizationId();
+            
+            // 如果当前登录用户的organizationId为2827（南光组织），可查询全部组织数据；其他组织只能查询自己组织的数据
+            if (loginOrgId == null || !loginOrgId.equals(2827L)) {
+                // 其他组织：只能查询自己组织的数据，忽略前端传入的组织查询条件
+                Long topOrgId = loginUser.getUserPo().getTopOrganizationId();
+                Long orgId = loginUser.getUserPo().getOrganizationId();
+                // 强制使用当前登录用户的组织信息，确保只能查询自己组织的数据
+                if (topOrgId != null) {
+                    tmsReceiptDO.setTopOrganizationId(topOrgId);
+                }
+                if (orgId != null) {
+                    tmsReceiptDO.setOrganizationId(orgId);
+                }
+                // 注意：organizationName 条件仍然可以使用，但会被 organizationId 条件限制，只能查询自己组织的
+            } else {
+                // 南光组织（organizationId = 2827）：可以查询全部组织数据
+                // 如果前端传入了组织查询条件（organizationId、topOrganizationId或organizationName），则使用前端条件
+                // 如果前端没有传入任何组织查询条件，则不设置组织ID过滤，查询全部（但organization_name IS NOT NULL仍会生效）
+                if (frontendOrgId == null && frontendTopOrgId == null && (tmsReceiptDO.getOrganizationName() == null || tmsReceiptDO.getOrganizationName().isEmpty())) {
+                    // 前端没有传入任何组织查询条件，清空组织ID过滤，查询全部组织数据
+                    tmsReceiptDO.setTopOrganizationId(null);
+                    tmsReceiptDO.setOrganizationId(null);
+                }
+                // 如果前端传入了组织查询条件，则保留使用前端条件（organizationId、topOrganizationId或organizationName）
+            }
+        }
         startPage();
         List<TmsReceiptPO> list = tmsReceiptApplicationService.queryList(tmsReceiptDO);
         return getDataTable(list);
@@ -71,6 +108,22 @@ public class TmsReceiptApi extends BaseController{
         //转换实体
         ReceivingAccountDO receivingAccountDO = new ReceivingAccountDO();
         BeanUtils.copyProperties(receivingAccountDTO, receivingAccountDO);
+        // 获取当前登录用户的组织信息，用于数据隔离
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            Long organizationId = loginUser.getUserPo().getOrganizationId();
+            // 如果当前登录用户的organizationId为2827（南光组织），可查询全部组织数据；其他组织只能查询自己组织的数据
+            if (organizationId == null || !organizationId.equals(2827L)) {
+                Long topOrgId = loginUser.getUserPo().getTopOrganizationId();
+                Long orgId = loginUser.getUserPo().getOrganizationId();
+                if (topOrgId != null) {
+                    receivingAccountDO.setTopOrganizationId(String.valueOf(topOrgId));
+                }
+                if (orgId != null) {
+                    receivingAccountDO.setOrganizationId(String.valueOf(orgId));
+                }
+            }
+        }
         startPage();
         List<ReceivingAccountPO> list = receivingAccountApplicationService.queryList(receivingAccountDO);
         return getDataTable(list);
@@ -87,6 +140,18 @@ public class TmsReceiptApi extends BaseController{
         //转换实体
         ReceivingAccountDO receivingAccountDO = new ReceivingAccountDO();
         BeanUtils.copyProperties(receivingAccountDTO, receivingAccountDO);
+        // 获取当前登录用户的组织信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            Long organizationId = loginUser.getUserPo().getOrganizationId();
+            if (topOrganizationId != null) {
+                receivingAccountDO.setTopOrganizationId(String.valueOf(topOrganizationId));
+            }
+            if (organizationId != null) {
+                receivingAccountDO.setOrganizationId(String.valueOf(organizationId));
+            }
+        }
         return toAjax(receivingAccountApplicationService.insert(receivingAccountDO));
     }
 
@@ -98,11 +163,14 @@ public class TmsReceiptApi extends BaseController{
     @PostMapping("/batchAddAccount")
     public AjaxResult batchAddAccount(@RequestBody List<ReceivingAccountDTO> receivingAccountDTOList)
     {
-        //转换实体
         List<ReceivingAccountDO> receivingAccountDOList = new ArrayList<>();
         for (ReceivingAccountDTO dto : receivingAccountDTOList) {
             ReceivingAccountDO receivingAccountDO = new ReceivingAccountDO();
             BeanUtils.copyProperties(dto, receivingAccountDO);
+            // 完全保留DTO中的原始organizationId和topOrganizationId，不做任何修改
+            // ApplicationService层会验证organizationId是否与当前登录用户一致，不一致则跳过
+            log.debug("接口层转换：DTO中的organizationId={}, topOrganizationId={}，完全保留，不做修改",
+                dto.getOrganizationId(), dto.getTopOrganizationId());
             receivingAccountDOList.add(receivingAccountDO);
         }
         return toAjax(receivingAccountApplicationService.batchInsert(receivingAccountDOList));