Merge remote-tracking branch 'refs/remotes/origin/dev' into test

# Conflicts:
#	mhd-gateway/src/main/resources/bootstrap.yml
#	mhd-modules/mhd-system/src/main/resources/bootstrap.yml

mhd-api/mhd-api-system/src/main/java/com/mhd/system/api/WlhyServiceFeign.java

@@ -14,6 +14,7 @@ import com.mhd.common.core.domain.entity.RevenueExpensesRecord;
 import com.mhd.common.core.domain.entity.SysConfigSwitch;
 import com.mhd.common.core.domain.entity.TmsOrder;
 import com.mhd.common.core.domain.po.UserPo;
+import com.mhd.common.core.utils.sms.Result;
 import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.system.api.domain.*;
 import com.mhd.system.api.feign.FeignAutoConfiguration;
@@ -509,4 +510,6 @@ public interface WlhyServiceFeign {
     @PostMapping(value = "/feign/outBoundSummary/getOrderListByReconciliation")
     public R<List<TmsOrder>> getOrderListByReconciliation(@RequestBody ReconciliationDTO reconciliationDTO);
 
+    @GetMapping(value = "/ntocc/tmsSettlementExchangeRate/queryById")
+    public Result<?> queryById(@RequestParam(name="id",required=true) String id);
 }

mhd-api/mhd-api-system/src/main/java/com/mhd/system/api/factory/RemoteWlhyFallbackFactory.java

@@ -12,6 +12,7 @@ import com.mhd.common.core.domain.entity.R;
 import com.mhd.common.core.domain.entity.SysConfigSwitch;
 import com.mhd.common.core.domain.entity.TmsOrder;
 import com.mhd.common.core.domain.po.UserPo;
+import com.mhd.common.core.utils.sms.Result;
 import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.system.api.WlhyServiceFeign;
 import com.mhd.system.api.domain.*;
@@ -509,6 +510,11 @@ public class RemoteWlhyFallbackFactory implements FallbackFactory<WlhyServiceFei
                 res.setCode(R.FAIL);
                 return res;
             }
+
+            @Override
+            public Result<?> queryById(String id) {
+                return null;
+            }
         };
     }
 }

mhd-auth/src/main/resources/bootstrap.yml

@@ -14,15 +14,19 @@ spring:
       discovery:
 #        server-addr: 127.0.0.1:8848
         # 线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+#        server-addr: 10.33.0.129:6010
         #线上正式环境
-#        server-addr: 10.102.192.105:6848
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
       config:
 #        server-addr: 127.0.0.1:8848
         # 线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+#        server-addr: 10.33.0.129:6010
         #线上正式环境
-#        server-addr: 10.102.192.105:6848
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
         group: DEFAULT_GROUP  # 默认分组就是DEFAULT_GROUP，如果使用默认分组可以不配置
         file-extension: yml   #默认properties
         # 共享配置

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/entity/TmsOrder.java

@@ -475,6 +475,7 @@ public class TmsOrder implements Serializable {
 
     @ApiModelProperty(value = "已收运费")
     private BigDecimal collectedFreight;
+
     @ApiModelProperty(value = "未收运费")
     private BigDecimal uncollectedFreight;
     @ApiModelProperty(value = "少收运费")
@@ -523,8 +524,6 @@ public class TmsOrder implements Serializable {
     @ApiModelProperty(value = "付款方名称")
     private String payer;
 
-    @ApiModelProperty("客户编码nc")
-    private String customsCodeNc;
 
     @ApiModelProperty("制单人编码nc")
     private String makerCodeNc;
@@ -540,4 +539,23 @@ public class TmsOrder implements Serializable {
 
     @ApiModelProperty("合同编号")
     private String contractNo;
+
+    @ApiModelProperty("客户编码nc")
+    private String customerCodeNc;
+
+    @ApiModelProperty(value = "组织ID")
+    private String orgId;
+
+    @ApiModelProperty(value = "所属组织")
+    private String orgName;
+
+    @ApiModelProperty(value = "组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty(value = "组织名称")
+    private String organizationName;
+
+    @ApiModelProperty(value = "上级组织ID")
+    private Long topOrganizationId;
+
 }

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/entity/Verification.java

@@ -99,6 +99,8 @@ public class Verification extends BaseVOEntity implements Serializable,Cloneable
     private Long topOrganizationId;
     @ApiModelProperty("组织表ID")
     private Long organizationId;
+    @ApiModelProperty("组织名称")
+    private String organizationName;
 //    @ApiModelProperty("是否月结：1-是，2-否")
 //    private Integer receivableType;
     @ApiModelProperty("部门id")

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/po/AddressBookPo.java

@@ -56,4 +56,7 @@ public class AddressBookPo extends BaseVOEntity implements Serializable
     private String synthesize;
     @ApiModelProperty(name = "单位名称")
     private String unitName;
+
+    @ApiModelProperty(name = "组织ID（用于数据权限过滤，内部使用）", hidden = true)
+    private Long organizationId;
 }

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/po/RolePO.java

@@ -1,5 +1,6 @@
 package com.mhd.common.core.domain.po;
 
+import cn.hutool.core.util.ObjectUtil;
 import com.mhd.common.core.web.domain.BaseVOEntity;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
@@ -24,6 +25,10 @@ public class RolePO extends BaseVOEntity implements Serializable {
     private String roleTypeName = "";
     @ApiModelProperty(name = "组织表ID")
     private Long organizationId = 0L;
+    @ApiModelProperty(name = "组织名称")
+    private String organizationName = "";
+    @ApiModelProperty(name = "一级组织表ID")
+    private Long topOrganizationId = 0L;
     @ApiModelProperty(name = "职务/角色权限字符，控制器中定义的权限字符，如：@PreAuthorize(`@ss.hasRole('admin')`)")
     private String roleCode = "";
     @ApiModelProperty(name = "职务/角色名称")
@@ -42,6 +47,9 @@ public class RolePO extends BaseVOEntity implements Serializable {
 
     @Override
     public boolean equals(Object o) {
+        if (ObjectUtil.isNull(o)) {
+            return false;
+        }
         RolePO rolePO = (RolePO) o;
         return roleCode.equals(rolePO.getRoleCode());
     }

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/po/UserDriverListPo.java

@@ -28,6 +28,8 @@ public class UserDriverListPo {
     private String driverEnterpriseName="";
     @ApiModelProperty(name = "登录账号（2-20位）")
     private String userAccount = "";
+    @ApiModelProperty(name = "组织表ID")
+    private Long organizationId;
     @ApiModelProperty(name = "组织名称")
     private String organizationName = "";
     @ApiModelProperty(name = "身份证号")

mhd-common/mhd-common-core/src/main/java/com/mhd/common/core/domain/po/VerificationPo.java

@@ -99,6 +99,8 @@ public class VerificationPo extends BaseVOEntity implements Serializable
     private Long topOrganizationId;
     @ApiModelProperty("组织表ID")
     private Long organizationId;
+    @ApiModelProperty("组织名称")
+    private String organizationName;
     //    @ApiModelProperty("是否月结：1-是，2-否")
 //    private Integer receivableType;
     @ApiModelProperty("部门id")

mhd-common/mhd-common-core/src/main/java/minio/MinIoUploadService.java

@@ -25,7 +25,12 @@ public class MinIoUploadService {
     private static String host="http://10.102.192.5:6000";
     private static String accessKey="minioadmin";
     private static String secretKey="gmminioadmin";
+    /**
+     * minio 工具客户端
+     */
+    private static MinioClient minioClient1 = null;
 
+    private static String FILE_URL;
 
     /**
      * 上传到minio

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/addressBook/AddressBookApplicationService.java

@@ -69,9 +69,37 @@ public class AddressBookApplicationService
         // 获取登录人id
         Long userId = SecurityUtils.getLoginUser().getUserid();
         addressBookPo.setUserId(userId);
+        
+        // 添加组织数据权限过滤
+        applyOrganizationDataPermissionForAddressBook(addressBookPo);
+        
         return addressBookDomainService.selectAddressBookList(addressBookPo);
     }
 
+    /**
+     * 应用组织数据权限过滤（地址簿）
+     * 通过用户表关联来过滤组织数据
+     */
+    private void applyOrganizationDataPermissionForAddressBook(AddressBookPo addressBookPo) {
+        try {
+            LoginUser loginUser = SecurityUtils.getLoginUser();
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+                
+                // 如果当前登录用户的organizationId为2827（南光组织），可以查询全部组织数据
+                // 其他组织只能查询自己组织的数据
+                if (loginUserOrganizationId != null && !loginUserOrganizationId.equals(2827L)) {
+                    // 其他组织：需要通过用户表关联来过滤，只查询同一组织下用户创建的地址簿
+                    // 由于AddressBook表只有userId字段，需要在XML中通过用户表关联来过滤
+                    addressBookPo.setOrganizationId(loginUserOrganizationId);
+                }
+                // 如果是2827组织，不设置organizationId，可以查询全部
+            }
+        } catch (Exception e) {
+            // 如果获取登录用户信息失败，不添加过滤条件，避免影响正常查询
+        }
+    }
+
     /**
      * 新增地址簿
      *
@@ -156,12 +184,39 @@ public class AddressBookApplicationService
      */
     public List<CommonRoutePo> selectCommonRouteList(CommonRouteDo commonRouteDo){
         // 获取登录人id
-//        Long userId = SecurityUtils.getUserId()==0 ? 4L:SecurityUtils.getLoginUser().getUserid();
         Long userId = SecurityUtils.getLoginUser().getUserid();
         commonRouteDo.setCreateBy(userId);
+        
+        // 添加组织数据权限过滤
+        applyOrganizationDataPermissionForCommonRoute(commonRouteDo);
+        
         return commonRouteDomainService.selectCommonRouteList(commonRouteDo);
     }
 
+    /**
+     * 应用组织数据权限过滤（常用路线）
+     * 通过用户表关联来过滤组织数据
+     */
+    private void applyOrganizationDataPermissionForCommonRoute(CommonRouteDo commonRouteDo) {
+        try {
+            LoginUser loginUser = SecurityUtils.getLoginUser();
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+                
+                // 如果当前登录用户的organizationId为2827（南光组织），可以查询全部组织数据
+                // 其他组织只能查询自己组织的数据
+                if (loginUserOrganizationId != null && !loginUserOrganizationId.equals(2827L)) {
+                    // 其他组织：需要通过用户表关联来过滤，只查询同一组织下用户创建的常用路线
+                    // 由于CommonRoute表只有userId字段，需要在XML中通过用户表关联来过滤
+                    commonRouteDo.setOrganizationId(loginUserOrganizationId);
+                }
+                // 如果是2827组织，不设置organizationId，可以查询全部
+            }
+        } catch (Exception e) {
+            // 如果获取登录用户信息失败，不添加过滤条件，避免影响正常查询
+        }
+    }
+
     /**
      * 新增常用路线
      *

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/container/ContainerApplicationService.java

@@ -38,10 +38,30 @@ public class ContainerApplicationService {
 
     public List<ContainerPO> queryList(ContainerDO containerDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
+        if (loginUser != null && loginUser.getUserPo() != null){
+            Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
             Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            
+            // 数据权限：根据organizationId来设置查询权限
+            // organizationId等于2827时查询全部，其他仅查询各自组织的信息
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (containerDO.getOrganizationId() == null) {
+                    containerDO.setOrganizationId(null);
+                    containerDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
                 if (topOrganizationId != null && topOrganizationId != 1){
-                containerDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+                    containerDO.setTopOrganizationId(topOrganizationId);
+                }
+                // 如果前端传递了organizationId，验证是否与当前登录用户的组织ID一致
+                if (containerDO.getOrganizationId() != null && !containerDO.getOrganizationId().equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    containerDO.setOrganizationId(loginUserOrganizationId);
+                }
             }
         }
         return containerDomainService.queryList(containerDO);
@@ -52,6 +72,13 @@ public class ContainerApplicationService {
      * 新增容器管理
      */
     public Boolean insert(ContainerDO containerDO) {
+        // 设置当前登录用户的组织信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            containerDO.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            containerDO.setOrganizationName(loginUser.getUserPo().getOrganizationName());
+            containerDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        }
         //翻译库区类型
         setDataDict(containerDO);
         return containerDomainService.insert(containerDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/expenseAccount/ExpenseAccountApplicationService.java

@@ -22,6 +22,7 @@ import com.mhd.common.core.web.domain.AjaxResult;
 import com.mhd.common.security.utils.SecurityUtils;
 import com.mhd.system.api.SystemServiceFeign;
 import com.mhd.system.api.model.LoginUser;
+import com.mhd.common.core.domain.po.UserPo;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -50,29 +51,131 @@ public class ExpenseAccountApplicationService {
     /**
      * 分页查询费用科目列表
      */
-
     public List<ExpenseAccountPO> queryList(ExpenseAccountDO expenseAccountDO) {
-        setTopOrganizationIdLogin(expenseAccountDO);
-        return expenseAccountDomainService.queryList(expenseAccountDO);
+        try {
+            log.info("开始查询费用科目列表，参数：organizationId={}, topOrganizationId={}, expenseAccountDO={}",
+                expenseAccountDO.getOrganizationId(), expenseAccountDO.getTopOrganizationId(), expenseAccountDO);
+            setDataPermission(expenseAccountDO);
+
+            // 处理 createByName 和 updateByName 字段：
+            // 问题：ExpenseAccountAssembler 在查询场景下可能会自动设置 createByName 和 updateByName 为当前登录用户名
+            // 这会导致 SQL 中添加 create_by_name LIKE '%nanguang%' 和 update_by_name LIKE '%nanguang%' 条件
+            // 解决方案：
+            // 1. 如果查询所有组织（organizationId 和 topOrganizationId 都为 null），清空这些字段（除非前端明确传递了这些字段作为查询条件）
+            // 2. 如果查询指定组织（organizationId 不为 null），且是南光组织查询，如果 createByName 或 updateByName 等于当前登录用户名，清空它们
+            LoginUser loginUser = SecurityUtils.getLoginUser();
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+                String currentUserName = loginUser.getUsername();
+
+                // 先保存前端传递的 createByName 和 updateByName（用于判断是否是前端传递的查询条件）
+                String frontendCreateByName = expenseAccountDO.getCreateByName();
+                String frontendUpdateByName = expenseAccountDO.getUpdateByName();
+
+                if (expenseAccountDO.getOrganizationId() == null && expenseAccountDO.getTopOrganizationId() == null) {
+                    // 查询所有组织的数据时，不应该通过创建者或更新者来过滤，清空这些字段
+                    // 除非前端明确传递了这些字段作为查询条件
+                    if (frontendCreateByName == null || frontendCreateByName.isEmpty() ||
+                        (currentUserName != null && frontendCreateByName.equals(currentUserName))) {
+                        // 前端未传递，或者等于当前登录用户名（可能是 Assembler 自动设置的），清空
+                        log.info("查询所有组织数据，清空 createByName 过滤条件（前端未传递或由 Assembler 自动设置）");
+                        expenseAccountDO.setCreateByName(null);
+                    }
+                    if (frontendUpdateByName == null || frontendUpdateByName.isEmpty() ||
+                        (currentUserName != null && frontendUpdateByName.equals(currentUserName))) {
+                        // 前端未传递，或者等于当前登录用户名（可能是 Assembler 自动设置的），清空
+                        log.info("查询所有组织数据，清空 updateByName 过滤条件（前端未传递或由 Assembler 自动设置）");
+                        expenseAccountDO.setUpdateByName(null);
+                    }
+                } else if (expenseAccountDO.getOrganizationId() != null && loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                    // 南光组织查询指定组织时，如果 createByName 或 updateByName 等于当前登录用户名，说明可能是 Assembler 自动设置的
+                    // 清空这些字段，避免限制查询结果（因为其他组织的数据可能不是当前登录用户创建的）
+                    if (currentUserName != null) {
+                        if (expenseAccountDO.getCreateByName() != null && expenseAccountDO.getCreateByName().equals(currentUserName)) {
+                            log.info("南光组织查询指定组织数据（organizationId={}），清空 createByName 过滤条件（可能由 Assembler 自动设置）",
+                                expenseAccountDO.getOrganizationId());
+                            expenseAccountDO.setCreateByName(null);
+                        }
+                        if (expenseAccountDO.getUpdateByName() != null && expenseAccountDO.getUpdateByName().equals(currentUserName)) {
+                            log.info("南光组织查询指定组织数据（organizationId={}），清空 updateByName 过滤条件（可能由 Assembler 自动设置）",
+                                expenseAccountDO.getOrganizationId());
+                            expenseAccountDO.setUpdateByName(null);
+                        }
+                    }
+                }
+            }
+
+            log.info("设置组织ID后，查询参数：organizationId={}, topOrganizationId={}, createByName={}, updateByName={}",
+                expenseAccountDO.getOrganizationId(), expenseAccountDO.getTopOrganizationId(),
+                expenseAccountDO.getCreateByName(), expenseAccountDO.getUpdateByName());
+            List<ExpenseAccountPO> result = expenseAccountDomainService.queryList(expenseAccountDO);
+            log.info("查询费用科目列表成功，返回数据条数：{}", result != null ? result.size() : 0);
+            return result;
+        } catch (Exception e) {
+            log.error("查询费用科目列表异常", e);
+            throw e;
+        }
     }
 
     public List<ExpenseAccountPO> treeCostSubject(ExpenseAccountDO expenseAccountDO){
-        setTopOrganizationIdLogin(expenseAccountDO);
+        setDataPermission(expenseAccountDO);
         return expenseAccountDomainService.treeCostSubject(expenseAccountDO);
     }
 
     public List<ExpenseAccountPO> subjectTreeCost(ExpenseAccountDO expenseAccountDO){
-        setTopOrganizationIdLogin(expenseAccountDO);
+        setDataPermission(expenseAccountDO);
         return expenseAccountDomainService.treeCostSubject(expenseAccountDO);
     }
 
-
-    private void setTopOrganizationIdLogin(ExpenseAccountDO expenseAccountDO){
+    /**
+     * 根据当前登录用户的组织信息实现数据隔离
+     * 当前登录用户为组织ID字段organization_id为2827时可查全部组织数据，其他组织只能查自己
+     */
+    private void setDataPermission(ExpenseAccountDO expenseAccountDO){
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1){
-                expenseAccountDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("费用科目查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            return;
+        }
+
+        UserPo userPo = loginUser.getUserPo();
+        Long loginUserOrganizationId = userPo.getOrganizationId();
+        Long topOrganizationId = userPo.getTopOrganizationId();
+
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = expenseAccountDO.getOrganizationId();
+
+        // 数据权限：根据 organizationId 来设置查询权限
+        // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                expenseAccountDO.setOrganizationId(frontendOrganizationId);
+                expenseAccountDO.setTopOrganizationId(null);
+            } else {
+                expenseAccountDO.setOrganizationId(null);
+                expenseAccountDO.setTopOrganizationId(null);
+            }
+        } else {
+            // 其他组织：设置 organizationId，只查询当前组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    log.warn("费用科目查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤",
+                        frontendOrganizationId, loginUserOrganizationId);
+                    expenseAccountDO.setOrganizationId(loginUserOrganizationId);
+                } else {
+                    expenseAccountDO.setOrganizationId(frontendOrganizationId);
+                }
+                expenseAccountDO.setTopOrganizationId(topOrganizationId);
+            } else {
+                // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                if (loginUserOrganizationId != null) {
+                    expenseAccountDO.setOrganizationId(loginUserOrganizationId);
+                }
+                expenseAccountDO.setTopOrganizationId(topOrganizationId);
             }
         }
     }
@@ -276,6 +379,35 @@ public class ExpenseAccountApplicationService {
         expenseAccountDO.setUpdateByName(loginUser.getUsername());
         return expenseAccountDomainService.update(expenseAccountDO);
     }
+    /**
+     * 修改创建订单是否固定显示  0-否 1-是
+     * @param expenseAccountDTO
+     * @return
+     */
+    public boolean changeFixedOrderDisplay(ExpenseAccountDTO expenseAccountDTO) {
+        //获取登录用户信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (ObjectUtil.isNull(loginUser)) {
+            throw new DigitalLogisticsException(UserError.TIMEOUT);
+        }
+        //根据id修改启用状态停用状态
+        if(expenseAccountDTO.getExpenseAccountId() == null){
+            throw new ServiceException("费用科目id不能为空");
+        }
+        if(expenseAccountDTO.getFixedOrderDisplay() == null){
+            throw new ServiceException("状态不能为空");
+        }
+        if(expenseAccountDTO.getFixedOrderDisplay() != 0 && expenseAccountDTO.getFixedOrderDisplay()!=1){
+            throw new ServiceException("状态错误");
+        }
+        ExpenseAccountDO expenseAccountDO = new ExpenseAccountDO();
+        expenseAccountDO.setExpenseAccountId(expenseAccountDTO.getExpenseAccountId());
+        expenseAccountDO.setFixedOrderDisplay(expenseAccountDTO.getFixedOrderDisplay());
+        expenseAccountDO.setUpdateBy(loginUser.getUserid());
+        expenseAccountDO.setUpdateTime(new Date());
+        expenseAccountDO.setUpdateByName(loginUser.getUsername());
+        return expenseAccountDomainService.update(expenseAccountDO);
+    }
     /**
      *  根据编码查询费用科目信息
      */
@@ -287,13 +419,44 @@ public class ExpenseAccountApplicationService {
     }
 
     public List<QueryExpenseAccountPO> selectExpenseAccount(SearchExpenseAccountDO searchExpenseAccountDO){
+        setDataPermissionForSearch(searchExpenseAccountDO);
         return expenseAccountDomainService.selectExpenseAccount(searchExpenseAccountDO);
     }
 
     public List<QueryExpenseAccountPO> selectOtherExpenseAccount(SearchExpenseAccountDO searchExpenseAccountDO){
+        setDataPermissionForSearch(searchExpenseAccountDO);
         return expenseAccountDomainService.selectOtherExpenseAccount(searchExpenseAccountDO);
     }
 
+    /**
+     * 为 SearchExpenseAccountDO 设置数据权限
+     */
+    private void setDataPermissionForSearch(SearchExpenseAccountDO searchExpenseAccountDO) {
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("费用科目查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            return;
+        }
+
+        UserPo userPo = loginUser.getUserPo();
+        Long loginUserOrganizationId = userPo.getOrganizationId();
+        Long topOrganizationId = userPo.getTopOrganizationId();
+
+        // 数据权限：根据 organizationId 来设置查询权限
+        // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据，不设置组织过滤条件
+            searchExpenseAccountDO.setOrganizationId(null);
+            searchExpenseAccountDO.setTopOrganizationId(null);
+        } else {
+            // 其他组织：只查询当前组织的数据
+            if (loginUserOrganizationId != null) {
+                searchExpenseAccountDO.setOrganizationId(loginUserOrganizationId);
+            }
+            searchExpenseAccountDO.setTopOrganizationId(topOrganizationId);
+        }
+    }
+
     public List<QueryExpenseAccountPO> selectSocialVehicleExpenseAccount(){
         return expenseAccountDomainService.selectSocialVehicleExpenseAccount();
     }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/serviceItemsManage/ServiceItemsManageApplicationService.java

@@ -35,24 +35,190 @@ public class ServiceItemsManageApplicationService {
     /**
      * 分页查询服务项管理列表
      */
-
     public List<ServiceItemsManagePO> queryList(ServiceItemsManageDO serviceItemsManageDO) {
-        setTopOrganizationIdLogin(serviceItemsManageDO);
-        return serviceItemsManageDomainService.queryList(serviceItemsManageDO);
+        try {
+            log.info("开始查询服务项管理列表，参数：organizationId={}, topOrganizationId={}, serviceItemsManageDO={}", 
+                serviceItemsManageDO.getOrganizationId(), serviceItemsManageDO.getTopOrganizationId(), serviceItemsManageDO);
+            
+            // 先保存前端传递的 organizationId 和 topOrganizationId（如果存在）
+            // 注意：这里需要在设置权限逻辑之前保存，因为 Assembler 可能已经设置了这些值
+            Long frontendOrganizationId = serviceItemsManageDO.getOrganizationId();
+            Long frontendTopOrganizationId = serviceItemsManageDO.getTopOrganizationId();
+            
+            // 获取登录用户信息
+            LoginUser loginUser = SecurityUtils.getLoginUser();
+            Long loginUserOrganizationId = null;
+            Long loginUserTopOrganizationId = null;
+            
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+                loginUserTopOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            }
+            
+            log.info("登录用户信息：loginUserOrganizationId={}, loginUserTopOrganizationId={}, 前端传递：frontendOrganizationId={}, frontendTopOrganizationId={}", 
+                loginUserOrganizationId, loginUserTopOrganizationId, frontendOrganizationId, frontendTopOrganizationId);
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    serviceItemsManageDO.setOrganizationId(frontendOrganizationId);
+                    serviceItemsManageDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                    log.info("南光组织查询指定组织：organizationId={}", frontendOrganizationId);
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    serviceItemsManageDO.setOrganizationId(null);
+                    serviceItemsManageDO.setTopOrganizationId(null);
+                    log.info("南光组织查询所有组织：不设置组织过滤条件");
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        log.warn("服务项管理查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                            frontendOrganizationId, loginUserOrganizationId);
+                        serviceItemsManageDO.setOrganizationId(loginUserOrganizationId);
+                    } else {
+                        // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                        serviceItemsManageDO.setOrganizationId(frontendOrganizationId);
+                    }
+                    if (loginUserTopOrganizationId != null) {
+                        serviceItemsManageDO.setTopOrganizationId(loginUserTopOrganizationId);
+                    }
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (loginUserOrganizationId != null) {
+                        serviceItemsManageDO.setOrganizationId(loginUserOrganizationId);
+                    }
+                    if (loginUserTopOrganizationId != null) {
+                        serviceItemsManageDO.setTopOrganizationId(loginUserTopOrganizationId);
+                    }
+                }
+            }
+            
+            // 处理 createByName 和 updateByName 字段：
+            // 问题：Assembler 在查询场景下（serviceItemsManageId == null）会自动设置 createByName 和 updateByName 为当前登录用户名
+            // 这会导致 SQL 中添加 create_by_name LIKE '%nanguang%' 和 update_by_name LIKE '%nanguang%' 条件
+            // 解决方案：
+            // 1. 如果查询所有组织（organizationId 和 topOrganizationId 都为 null），清空这些字段
+            // 2. 如果查询指定组织（organizationId 不为 null），且是南光组织查询，如果 createByName 或 updateByName 等于当前登录用户名，清空它们
+            //    因为查询其他组织的数据时，不应该通过当前登录用户的名称来过滤
+            // 注意：这种方法可能会误判（如果前端确实传递了当前登录用户名作为查询条件），但这种情况很少见，且影响较小
+            
+            String currentUserName = null;
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                currentUserName = loginUser.getUsername();
+            }
+            
+            if (serviceItemsManageDO.getOrganizationId() == null && serviceItemsManageDO.getTopOrganizationId() == null) {
+                // 查询所有组织的数据时，不应该通过创建者或更新者来过滤，清空这些字段
+                log.info("查询所有组织数据，清空 createByName 和 updateByName 过滤条件，避免限制查询结果");
+                serviceItemsManageDO.setCreateByName(null);
+                serviceItemsManageDO.setUpdateByName(null);
+            } else if (serviceItemsManageDO.getOrganizationId() != null && loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织查询指定组织时，如果 createByName 或 updateByName 等于当前登录用户名，说明可能是 Assembler 自动设置的
+                // 清空这些字段，避免限制查询结果（因为其他组织的数据可能不是当前登录用户创建的）
+                if (currentUserName != null) {
+                    if (serviceItemsManageDO.getCreateByName() != null && serviceItemsManageDO.getCreateByName().equals(currentUserName)) {
+                        log.info("南光组织查询指定组织数据（organizationId={}），清空 createByName 过滤条件（可能由 Assembler 自动设置）", 
+                            serviceItemsManageDO.getOrganizationId());
+                        serviceItemsManageDO.setCreateByName(null);
+                    }
+                    if (serviceItemsManageDO.getUpdateByName() != null && serviceItemsManageDO.getUpdateByName().equals(currentUserName)) {
+                        log.info("南光组织查询指定组织数据（organizationId={}），清空 updateByName 过滤条件（可能由 Assembler 自动设置）", 
+                            serviceItemsManageDO.getOrganizationId());
+                        serviceItemsManageDO.setUpdateByName(null);
+                    }
+                }
+            }
+            
+            log.info("设置组织ID后，查询参数：organizationId={}, topOrganizationId={}, createByName={}, updateByName={}", 
+                serviceItemsManageDO.getOrganizationId(), serviceItemsManageDO.getTopOrganizationId(),
+                serviceItemsManageDO.getCreateByName(), serviceItemsManageDO.getUpdateByName());
+            List<ServiceItemsManagePO> result = serviceItemsManageDomainService.queryList(serviceItemsManageDO);
+            log.info("查询服务项管理列表成功，返回数据条数：{}", result != null ? result.size() : 0);
+            return result;
+        } catch (Exception e) {
+            log.error("查询服务项管理列表异常", e);
+            throw e;
+        }
     }
 
     public List<ServiceItemsManagePO> getCostTypeList(ServiceItemsManageDO serviceItemsManageDO){
-        setTopOrganizationIdLogin(serviceItemsManageDO);
-        return serviceItemsManageDomainService.getCostsType(serviceItemsManageDO);
+        try {
+            log.info("开始查询费用类别列表，参数：{}", serviceItemsManageDO);
+            
+            // 先保存前端传递的 organizationId（如果存在）
+            Long frontendOrganizationId = serviceItemsManageDO.getOrganizationId();
+            
+            // 获取登录用户信息
+            LoginUser loginUser = SecurityUtils.getLoginUser();
+            Long loginUserOrganizationId = null;
+            Long topOrganizationId = null;
+            
+            if (loginUser != null && loginUser.getUserPo() != null) {
+                loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+                topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
             }
             
-    private void setTopOrganizationIdLogin(ServiceItemsManageDO serviceItemsManageDO){
-        LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1){
-                serviceItemsManageDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    serviceItemsManageDO.setOrganizationId(frontendOrganizationId);
+                    serviceItemsManageDO.setTopOrganizationId(null);
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    serviceItemsManageDO.setOrganizationId(null);
+                    serviceItemsManageDO.setTopOrganizationId(null);
                 }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        log.warn("费用类别查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                            frontendOrganizationId, loginUserOrganizationId);
+                        serviceItemsManageDO.setOrganizationId(loginUserOrganizationId);
+                    } else {
+                        // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                        serviceItemsManageDO.setOrganizationId(frontendOrganizationId);
+                    }
+                    if (topOrganizationId != null) {
+                        serviceItemsManageDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (loginUserOrganizationId != null) {
+                        serviceItemsManageDO.setOrganizationId(loginUserOrganizationId);
+                    }
+                    if (topOrganizationId != null) {
+                        serviceItemsManageDO.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            }
+            
+            log.info("设置组织ID后，费用类别查询参数：organizationId={}, topOrganizationId={}", 
+                serviceItemsManageDO.getOrganizationId(), serviceItemsManageDO.getTopOrganizationId());
+            List<ServiceItemsManagePO> result = serviceItemsManageDomainService.getCostsType(serviceItemsManageDO);
+            log.info("查询费用类别列表成功，返回数据条数：{}", result != null ? result.size() : 0);
+            return result;
+        } catch (Exception e) {
+            log.error("查询费用类别列表异常", e);
+            throw e;
         }
     }
 

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/warehouse/WarehouseApplicationService.java

@@ -56,6 +56,13 @@ public class WarehouseApplicationService {
      * 新增仓库
      */
     public Boolean insert(WarehouseDO warehouseDO) {
+        // 设置当前登录用户的组织信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            warehouseDO.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            warehouseDO.setOrganizationName(loginUser.getUserPo().getOrganizationName());
+            warehouseDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        }
         //设置数据字典键值
         setDataDict(warehouseDO);
         return warehouseDomainService.insert(warehouseDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/addressBook/todo/CommonRouteDo.java

@@ -126,4 +126,7 @@ public class CommonRouteDo extends BaseVOEntity
 
     @ApiModelProperty(name = "运费单价")
     private BigDecimal freightUnitPrice;
+
+    @ApiModelProperty(name = "组织ID（用于数据权限过滤，内部使用）", hidden = true)
+    private Long organizationId;
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/entity/ExpenseAccount.java

@@ -101,4 +101,10 @@ public class ExpenseAccount extends BaseVOEntity{
     @ApiModelProperty(name = "收支类型")
     private Integer accountExpenseType;
 
+    @ApiModelProperty(name = "创建订单是否固定显示  0-否 1-是")
+    private Integer fixedOrderDisplay;
+
+    @ApiModelProperty("费率")
+    private BigDecimal rate;
+
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/repository/persistence/ExpenseAccountImpl.java

@@ -10,6 +10,7 @@ import com.mhd.basic.domain.expenseAccount.repository.todo.ExpenseAccountDO;
 import com.mhd.basic.domain.expenseAccount.repository.todo.ExpenseAccountDoMap;
 import com.mhd.basic.domain.expenseAccount.repository.todo.SearchExpenseAccountDO;
 import com.mhd.basic.interfaces.dto.expenseAccount.SearchExpenseAccountDTO;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.ibatis.annotations.Param;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -24,6 +25,7 @@ import java.util.List;
  * @author gen
  * @date 2024-06-04
  */
+@Slf4j
 @Service
 public class ExpenseAccountImpl extends ServiceImpl<ExpenseAccountMapper, ExpenseAccount> implements IExpenseAccountService{
     @Autowired
@@ -35,7 +37,15 @@ public class ExpenseAccountImpl extends ServiceImpl<ExpenseAccountMapper, Expens
     @Override
     public List<ExpenseAccountPO> queryList(ExpenseAccountDO expenseAccountDO)
     {
-        return expenseAccountMapper.queryList(expenseAccountDO);
+        // 添加日志，记录查询参数
+        log.info("ExpenseAccountImpl.queryList 查询参数：topOrganizationId={}, subjectName={}, subjectCode={}, status={}", 
+            expenseAccountDO.getTopOrganizationId(), 
+            expenseAccountDO.getSubjectName(), 
+            expenseAccountDO.getSubjectCode(),
+            expenseAccountDO.getStatus());
+        List<ExpenseAccountPO> result = expenseAccountMapper.queryList(expenseAccountDO);
+        log.info("ExpenseAccountImpl.queryList 查询结果：{} 条", result != null ? result.size() : 0);
+        return result;
     }
 
     @Override

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/repository/po/ExpenseAccountPO.java

@@ -122,4 +122,11 @@ public class ExpenseAccountPO extends BaseVOEntity{
     @Excel(name = "服务项税率")
     private BigDecimal taxRate;
 
+
+
+    @ApiModelProperty("费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty(name = "创建订单是否固定显示  0-否 1-是")
+    private Integer fixedOrderDisplay;
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/repository/po/QueryExpenseAccountPO.java

@@ -39,5 +39,16 @@ public class QueryExpenseAccountPO {
     @Excel(name = "上级科目名称")
     private String upperSubject;
 
+    @ApiModelProperty("一级组织表ID")
+    @Excel(name = "一级组织表ID")
+    private Long topOrganizationId;
+
+    @ApiModelProperty("组织表ID")
+    @Excel(name = "组织表ID")
+    private Long organizationId;
+
+    @ApiModelProperty("组织名称")
+    @Excel(name = "组织名称")
+    private String organizationName;
 
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/repository/todo/ExpenseAccountDO.java

@@ -125,4 +125,10 @@ public class ExpenseAccountDO extends BaseVOEntity{
 
     @ApiModelProperty("服务项名称")
     private String serviceItemsName;
+
+    @ApiModelProperty("费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty(name = "创建订单是否固定显示  0-否 1-是")
+    private Integer fixedOrderDisplay;
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/expenseAccount/repository/todo/SearchExpenseAccountDO.java

@@ -25,4 +25,10 @@ public class SearchExpenseAccountDO{
 
     @ApiModelProperty("社会车辆固定显示（1-是，2-否）")
     private Integer societyStatus;
+
+    @ApiModelProperty("组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty("上级组织ID")
+    private Long topOrganizationId;
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/serviceItemsManage/repository/facade/IServiceItemsManageService.java

@@ -22,7 +22,7 @@ public interface IServiceItemsManageService extends IService<ServiceItemsManage>
     /**
      * 查询费用类别
      */
-    public List<ServiceItemsManagePO> getCostType();
+    public List<ServiceItemsManagePO> getCostType(ServiceItemsManageDO serviceItemsManageDO);
     /**
      * 新增服务项管理
      */

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/serviceItemsManage/repository/mapper/ServiceItemsManageMapper.java

@@ -21,6 +21,6 @@ public interface ServiceItemsManageMapper extends BaseMapper<ServiceItemsManage>
     /**
      *  查询费用类别
      */
-    public List<ServiceItemsManagePO> selectServiceTypes();
+    public List<ServiceItemsManagePO> selectServiceTypes(ServiceItemsManageDO serviceItemsManageDO);
 
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/serviceItemsManage/repository/persistence/ServiceItemsManageImpl.java

@@ -6,6 +6,7 @@ import com.mhd.basic.domain.serviceItemsManage.entity.ServiceItemsManage;
 import com.mhd.basic.domain.serviceItemsManage.repository.facade.IServiceItemsManageService;
 import com.mhd.basic.domain.serviceItemsManage.repository.po.ServiceItemsManagePO;
 import com.mhd.basic.domain.serviceItemsManage.repository.todo.ServiceItemsManageDO;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -19,6 +20,7 @@ import java.util.List;
  * @author gen
  * @date 2024-06-03
  */
+@Slf4j
 @Service
 public class ServiceItemsManageImpl extends ServiceImpl<ServiceItemsManageMapper, ServiceItemsManage> implements IServiceItemsManageService{
     @Autowired
@@ -30,12 +32,80 @@ public class ServiceItemsManageImpl extends ServiceImpl<ServiceItemsManageMapper
     @Override
     public List<ServiceItemsManagePO> queryList(ServiceItemsManageDO serviceItemsManageDO)
     {
-        return serviceItemsManageMapper.queryList(serviceItemsManageDO);
+        // 添加日志，记录查询参数
+        log.info("ServiceItemsManageImpl.queryList 查询参数：topOrganizationId={}, organizationId={}, serviceItemsName={}, serviceItemsCode={}", 
+            serviceItemsManageDO.getTopOrganizationId(), 
+            serviceItemsManageDO.getOrganizationId(),
+            serviceItemsManageDO.getServiceItemsName(), 
+            serviceItemsManageDO.getServiceItemsCode());
+        
+        // 构建SQL查询条件说明（用于日志，必须与 MyBatis XML 中的条件保持一致）
+        StringBuilder sqlCondition = new StringBuilder("WHERE del_flag = 1");
+        
+        // 组织过滤条件（与 XML 中的 <if test="organizationId != null"> 和 <if test="topOrganizationId != null and organizationId == null"> 对应）
+        if (serviceItemsManageDO.getOrganizationId() != null) {
+            // 如果设置了 organizationId，添加 organization_id 条件
+            sqlCondition.append(" AND organization_id = ").append(serviceItemsManageDO.getOrganizationId());
+            sqlCondition.append(" AND organization_name IS NOT NULL");
+            sqlCondition.append(" AND organization_name != ''");
+            sqlCondition.append(" AND LENGTH(TRIM(organization_name)) > 0");
+        } else if (serviceItemsManageDO.getTopOrganizationId() != null) {
+            // 如果设置了 topOrganizationId 但没有设置 organizationId，添加 top_organization_id 条件
+            sqlCondition.append(" AND top_organization_id = ").append(serviceItemsManageDO.getTopOrganizationId());
+            sqlCondition.append(" AND organization_name IS NOT NULL");
+            sqlCondition.append(" AND organization_name != ''");
+            sqlCondition.append(" AND LENGTH(TRIM(organization_name)) > 0");
+        } else {
+            // 如果 organizationId 和 topOrganizationId 都为 null，不添加组织过滤条件（查询所有组织的数据）
+            sqlCondition.append(" (无组织过滤条件，查询所有组织的数据)");
+        }
+        
+        // 其他查询条件
+        if (serviceItemsManageDO.getCreateByName() != null && !serviceItemsManageDO.getCreateByName().isEmpty()) {
+            sqlCondition.append(" AND create_by_name LIKE '%").append(serviceItemsManageDO.getCreateByName()).append("%'");
+        }
+        if (serviceItemsManageDO.getUpdateByName() != null && !serviceItemsManageDO.getUpdateByName().isEmpty()) {
+            sqlCondition.append(" AND update_by_name LIKE '%").append(serviceItemsManageDO.getUpdateByName()).append("%'");
+        }
+        if (serviceItemsManageDO.getOrganizationName() != null && !serviceItemsManageDO.getOrganizationName().isEmpty()) {
+            sqlCondition.append(" AND organization_name LIKE '%").append(serviceItemsManageDO.getOrganizationName()).append("%'");
+        }
+        if (serviceItemsManageDO.getServiceItemsName() != null && !serviceItemsManageDO.getServiceItemsName().isEmpty()) {
+            sqlCondition.append(" AND service_items_name LIKE '%").append(serviceItemsManageDO.getServiceItemsName()).append("%'");
+        }
+        if (serviceItemsManageDO.getServiceItemsCode() != null && !serviceItemsManageDO.getServiceItemsCode().isEmpty()) {
+            sqlCondition.append(" AND service_items_code = '").append(serviceItemsManageDO.getServiceItemsCode()).append("'");
+        }
+        if (serviceItemsManageDO.getTaxRate() != null) {
+            sqlCondition.append(" AND tax_rate = ").append(serviceItemsManageDO.getTaxRate());
+        }
+        if (serviceItemsManageDO.getRemark() != null && !serviceItemsManageDO.getRemark().isEmpty()) {
+            sqlCondition.append(" AND remark LIKE '%").append(serviceItemsManageDO.getRemark()).append("%'");
+        }
+        
+        log.info("ServiceItemsManageImpl.queryList 生成的SQL条件（预估）：SELECT * FROM service_items_manage {}", sqlCondition.toString());
+        log.info("ServiceItemsManageImpl.queryList 实际执行的SQL请查看 MyBatis 日志，参数：organizationId={}, topOrganizationId={}, delFlag={}", 
+            serviceItemsManageDO.getOrganizationId(), serviceItemsManageDO.getTopOrganizationId(), serviceItemsManageDO.getDelFlag());
+        
+        List<ServiceItemsManagePO> result = serviceItemsManageMapper.queryList(serviceItemsManageDO);
+        log.info("ServiceItemsManageImpl.queryList 查询结果：{} 条", result != null ? result.size() : 0);
+        // 记录查询结果中的组织ID分布
+        if (result != null && !result.isEmpty()) {
+            StringBuilder orgIds = new StringBuilder();
+            for (ServiceItemsManagePO po : result) {
+                if (orgIds.length() > 0) {
+                    orgIds.append(", ");
+                }
+                orgIds.append(po.getOrganizationId());
+            }
+            log.info("查询结果中的组织ID分布：{}", orgIds.toString());
+        }
+        return result;
     }
     
     @Override
-    public List<ServiceItemsManagePO> getCostType() {
-        return serviceItemsManageMapper.selectServiceTypes();
+    public List<ServiceItemsManagePO> getCostType(ServiceItemsManageDO serviceItemsManageDO) {
+        return serviceItemsManageMapper.selectServiceTypes(serviceItemsManageDO);
     }
     /**
      * 新增服务项管理

mhd-modules/mhd-system/src/main/java/com/mhd/basic/domain/serviceItemsManage/service/ServiceItemsManageDomainService.java

@@ -37,7 +37,7 @@ public class ServiceItemsManageDomainService {
      * 查询费用类型
      */
     public List<ServiceItemsManagePO> getCostsType(ServiceItemsManageDO serviceItemsManageDO){
-        return serviceItemsManageService.getCostType();
+        return serviceItemsManageService.getCostType(serviceItemsManageDO);
     }
 
 

mhd-modules/mhd-system/src/main/java/com/mhd/basic/interfaces/assember/expenseAccount/ExpenseAccountAssembler.java

@@ -27,8 +27,10 @@ public class ExpenseAccountAssembler {
      */
     public ExpenseAccountDO toDO(ExpenseAccountDTO expenseAccountDTO) {
         ExpenseAccountDO expenseAccountDO = new ExpenseAccountDO();
-        // 拷贝
+        // 如果 expenseAccountDTO 不为 null，才进行拷贝
+        if (expenseAccountDTO != null) {
             BeanUtils.copyProperties(expenseAccountDTO, expenseAccountDO, IgnoreNullUtil.getNullPropertyNames(expenseAccountDTO));
+        }
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (ObjectUtil.isNull(loginUser)) {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
@@ -36,16 +38,30 @@ public class ExpenseAccountAssembler {
         String userName = loginUser.getUsername();
         // 获取登录人id
         Long userId = loginUser.getUserid();
-        if(expenseAccountDTO.getExpenseAccountId() != null){
+        
+        // 只有在新增或编辑操作时才设置 createByName 和 updateByName
+        // 查询列表时不应该自动设置这些字段，否则会导致 SQL 中添加过滤条件，影响查询结果
+        if(expenseAccountDTO != null && expenseAccountDTO.getExpenseAccountId() != null){
+            // 编辑操作：只设置更新相关字段
             if(userId != null){
                 expenseAccountDO.setUpdateBy(userId);
             }else {
                 expenseAccountDO.setUpdateBy(new Long("0"));
             }
+            // 只有在 DTO 中没有传递 updateByName 时才设置（避免覆盖前端传递的值）
+            if(expenseAccountDO.getUpdateByName() == null || expenseAccountDO.getUpdateByName().isEmpty()){
                 expenseAccountDO.setUpdateByName(userName);
+            }
             expenseAccountDO.setUpdateTime(new Date());
+        } else if(expenseAccountDTO != null && expenseAccountDTO.getExpenseAccountId() == null) {
+            // expenseAccountId == null，可能是查询操作或新增操作
+            // 如果前端传递了 createByName 或 updateByName，说明是查询条件，不应该设置（已经在 BeanUtils.copyProperties 中拷贝了）
+            // 如果前端没有传递 createByName 和 updateByName，可能是新增操作，需要设置默认值
+            boolean hasQueryCondition = (expenseAccountDTO.getCreateByName() != null && !expenseAccountDTO.getCreateByName().isEmpty())
+                    || (expenseAccountDTO.getUpdateByName() != null && !expenseAccountDTO.getUpdateByName().isEmpty());
             
-        }else {
+            if(!hasQueryCondition) {
+                // 没有查询条件，可能是新增操作，设置默认值
                 if(userId != null){
                     expenseAccountDO.setCreateBy(userId);
                     expenseAccountDO.setUpdateBy(userId);
@@ -59,6 +75,9 @@ public class ExpenseAccountAssembler {
                 expenseAccountDO.setUpdateTime(new Date());
                 expenseAccountDO.setDelFlag(1);
             }
+            // 如果有查询条件（createByName 或 updateByName），说明是查询操作，不应该设置这些字段
+            // 字段值已经在 BeanUtils.copyProperties 中从 DTO 拷贝过来了
+        }
         return expenseAccountDO;
     }
 

mhd-modules/mhd-system/src/main/java/com/mhd/basic/interfaces/assember/serviceItemsManage/ServiceItemsManageAssembler.java

@@ -27,8 +27,10 @@ public class ServiceItemsManageAssembler {
      */
     public ServiceItemsManageDO toDO(ServiceItemsManageDTO serviceItemsManageDTO) {
         ServiceItemsManageDO serviceItemsManageDO = new ServiceItemsManageDO();
-        // 拷贝
+        // 如果 serviceItemsManageDTO 不为 null，才进行拷贝
+        if (serviceItemsManageDTO != null) {
             BeanUtils.copyProperties(serviceItemsManageDTO, serviceItemsManageDO, IgnoreNullUtil.getNullPropertyNames(serviceItemsManageDTO));
+        }
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (ObjectUtil.isNull(loginUser)) {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
@@ -36,16 +38,34 @@ public class ServiceItemsManageAssembler {
         String userName = loginUser.getUsername();
         // 获取登录人id
         Long userId = loginUser.getUserid();
-        if(serviceItemsManageDTO.getServiceItemsManageId() != null){
+        
+        // 只有在新增或编辑操作时才设置 createByName 和 updateByName
+        // 查询列表时不应该自动设置这些字段，否则会导致 SQL 中添加过滤条件，影响查询结果
+        // 判断规则：
+        // 1. 如果 serviceItemsManageId != null，说明是编辑操作，只设置更新相关字段
+        // 2. 如果 serviceItemsManageId == null 且前端传递了 createByName 或 updateByName，说明是查询条件，不应该覆盖
+        // 3. 如果 serviceItemsManageId == null 且前端没有传递 createByName 和 updateByName，可能是新增操作，设置默认值
+        if(serviceItemsManageDTO != null && serviceItemsManageDTO.getServiceItemsManageId() != null){
+            // 编辑操作：只设置更新相关字段
             if(userId != null){
                 serviceItemsManageDO.setUpdateBy(userId);
             }else {
                 serviceItemsManageDO.setUpdateBy(new Long("0"));
             }
+            // 只有在 DTO 中没有传递 updateByName 时才设置（避免覆盖前端传递的值）
+            if(serviceItemsManageDO.getUpdateByName() == null || serviceItemsManageDO.getUpdateByName().isEmpty()){
                 serviceItemsManageDO.setUpdateByName(userName);
+            }
             serviceItemsManageDO.setUpdateTime(new Date());
+        } else if(serviceItemsManageDTO != null && serviceItemsManageDTO.getServiceItemsManageId() == null) {
+            // serviceItemsManageId == null，可能是查询操作或新增操作
+            // 如果前端传递了 createByName 或 updateByName，说明是查询条件，不应该设置（已经在 BeanUtils.copyProperties 中拷贝了）
+            // 如果前端没有传递 createByName 和 updateByName，可能是新增操作，需要设置默认值
+            boolean hasQueryCondition = (serviceItemsManageDTO.getCreateByName() != null && !serviceItemsManageDTO.getCreateByName().isEmpty())
+                    || (serviceItemsManageDTO.getUpdateByName() != null && !serviceItemsManageDTO.getUpdateByName().isEmpty());
             
-        }else {
+            if(!hasQueryCondition) {
+                // 没有查询条件，可能是新增操作，设置默认值
                 if(userId != null){
                     serviceItemsManageDO.setCreateBy(userId);
                     serviceItemsManageDO.setUpdateBy(userId);
@@ -59,6 +79,9 @@ public class ServiceItemsManageAssembler {
                 serviceItemsManageDO.setUpdateTime(new Date());
                 serviceItemsManageDO.setDelFlag(1);
             }
+            // 如果有查询条件（createByName 或 updateByName），说明是查询操作，不应该设置这些字段
+            // 字段值已经在 BeanUtils.copyProperties 中从 DTO 拷贝过来了
+        }
         return serviceItemsManageDO;
     }
 

mhd-modules/mhd-system/src/main/java/com/mhd/basic/interfaces/dto/expenseAccount/ExpenseAccountDTO.java

@@ -126,4 +126,10 @@ public class ExpenseAccountDTO extends BaseVOEntity{
 
     @ApiModelProperty("服务项名称")
     private String serviceItemsName;
+
+    @ApiModelProperty("费率")
+    private BigDecimal rate;
+
+    @ApiModelProperty(name = "创建订单是否固定显示  0-否 1-是")
+    private Integer fixedOrderDisplay;
 }

mhd-modules/mhd-system/src/main/java/com/mhd/basic/interfaces/facade/expenseAccount/ExpenseAccountApi.java

@@ -28,6 +28,8 @@ 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 com.mhd.common.security.utils.SecurityUtils;
+import com.mhd.system.api.model.LoginUser;
 import org.springframework.web.client.RestTemplate;
 
 /**
@@ -52,11 +54,29 @@ public class ExpenseAccountApi extends BaseController{
     @GetMapping("/list")
     public TableDataInfo list(ExpenseAccountDTO expenseAccountDTO)
     {
-        //转换实体
+        logger.info("收到查询费用科目列表请求，参数：{}", expenseAccountDTO);
+        try {
+            //转换实体，如果 expenseAccountDTO 为 null，创建一个新的对象
+            if (expenseAccountDTO == null) {
+                expenseAccountDTO = new ExpenseAccountDTO();
+                logger.info("expenseAccountDTO 为 null，创建新对象");
+            }
             ExpenseAccountDO expenseAccountDO = expenseAccountAssembler.toDO(expenseAccountDTO);
+            logger.info("转换后的 ExpenseAccountDO：{}", expenseAccountDO);
             startPage();
+            logger.info("分页参数已设置");
             List<ExpenseAccountPO> list = expenseAccountApplicationService.queryList(expenseAccountDO);
+            logger.info("查询完成，返回数据条数：{}", list != null ? list.size() : 0);
+            if (list != null && list.isEmpty()) {
+                logger.warn("查询结果为空，可能的原因：1.数据库中没有符合条件的数据 2.数据权限过滤 3.SQL查询条件问题");
+                logger.warn("查询条件：topOrganizationId={}, del_flag=1", expenseAccountDO.getTopOrganizationId());
+            }
             return getDataTable(list);
+        } catch (Exception e) {
+            logger.error("查询费用科目列表失败", e);
+            e.printStackTrace();
+            return getDataTable(new ArrayList<>());
+        }
     }
 
     @ApiOperation("查询费用科目树型列表")
@@ -81,9 +101,50 @@ public class ExpenseAccountApi extends BaseController{
     public AjaxResult selectOtherExpenseAccount(SearchExpenseAccountDTO searchExpenseAccountDTO){
         SearchExpenseAccountDO searchExpenseAccountDO = new SearchExpenseAccountDO();
         BeanUtils.copyProperties(searchExpenseAccountDTO,searchExpenseAccountDO);
+
+        // 数据权限：根据组织ID实现数据隔离
+        // organizationId=2827（南光）时，查询所有组织的数据；其他组织只查询自己的数据
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getOrganizationPo() != null) {
+            Long loginUserOrganizationId = loginUser.getOrganizationPo().getOrganizationId();
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据，不设置 organizationId 过滤条件
+                searchExpenseAccountDO.setOrganizationId(null);
+            } else {
+                // 其他组织：只查询自己组织的数据
+                searchExpenseAccountDO.setOrganizationId(loginUserOrganizationId);
+            }
+        }
+
         return AjaxResult.success(expenseAccountApplicationService.selectOtherExpenseAccount(searchExpenseAccountDO));
 
     }
+    /**
+     * 测试查询 - 不设置组织ID，查看是否有数据
+     */
+    @ApiOperation("测试查询费用科目列表（不设置组织ID）")
+    @GetMapping("/testList")
+    public AjaxResult testList(ExpenseAccountDTO expenseAccountDTO)
+    {
+        logger.info("测试查询费用科目列表，不设置组织ID");
+        try {
+            if (expenseAccountDTO == null) {
+                expenseAccountDTO = new ExpenseAccountDTO();
+            }
+            ExpenseAccountDO expenseAccountDO = expenseAccountAssembler.toDO(expenseAccountDTO);
+            // 不设置组织ID，测试是否能查询到数据
+            expenseAccountDO.setTopOrganizationId(null);
+            logger.info("测试查询参数：{}", expenseAccountDO);
+            startPage();
+            List<ExpenseAccountPO> list = expenseAccountApplicationService.queryList(expenseAccountDO);
+            logger.info("测试查询结果：{} 条", list != null ? list.size() : 0);
+            return AjaxResult.success(list);
+        } catch (Exception e) {
+            logger.error("测试查询失败", e);
+            return AjaxResult.error("测试查询失败：" + e.getMessage());
+        }
+    }
+
     @ApiOperation("查询费用科目-所有现金明细")
     @GetMapping("/selectAllCashExpenseAccount")
     public AjaxResult selectAllCashExpenseAccount(){
@@ -197,7 +258,16 @@ public class ExpenseAccountApi extends BaseController{
             return AjaxResult.error(e.getMessage());
         }
     }
-
+    @ApiOperation("修改创建订单默认显示设置")
+    @PostMapping("/changeFixedOrderDisplay")
+    public AjaxResult changeFixedOrderDisplay(@RequestBody ExpenseAccountDTO expenseAccountDTO)
+    {
+        try {
+            return toAjax(expenseAccountApplicationService.changeFixedOrderDisplay(expenseAccountDTO));
+        }catch (Exception e){
+            return AjaxResult.error(e.getMessage());
+        }
+    }
 
     @ApiOperation("根据code获取费用科目")
     @GetMapping(value = "/getInfoByCode")

mhd-modules/mhd-system/src/main/java/com/mhd/system/service/impl/SysDictDataServiceImpl.java

@@ -85,12 +85,25 @@ public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDi
         if (ObjectUtil.isNull(loginUser)) {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
         }
+        // 数据权限验证：南光组织（organizationId=2827）可以删除所有组织的数据，其他组织只能删除自己组织的数据
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        Long loginUserTopOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        
         for (Long dictCode : dictCodes)
         {
             SysDictData data = selectDictDataById(dictCode);
-            if (ObjectUtil.notEqual(data.getTopOrganizationId(), loginUser.getUserPo().getTopOrganizationId())) {
-                throw new ServiceException("修改失败");
+            
+            // 南光组织（organizationId=2827）可以删除所有组织的数据
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织可以删除，不需要验证 topOrganizationId
+            } else {
+                // 其他组织：只能删除自己组织的数据
+                // 使用 Objects.equals 安全比较，处理 null 值的情况
+                if (!java.util.Objects.equals(data.getTopOrganizationId(), loginUserTopOrganizationId)) {
+                    throw new ServiceException("删除失败：无权删除其他组织的字典数据");
                 }
+            }
+            
             dictDataMapper.deleteDictDataById(dictCode);
             SysDictData dictData = new SysDictData();
             dictData.setDictType(data.getDictType());
@@ -146,11 +159,25 @@ public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDi
         if (ObjectUtil.isNull(sysDictData)) {
             throw new ServiceException("字典数据未找到");
         }
-        if ("Y".equals(sysDictData.getIsDefault())) {
-            throw new ServiceException("默认数据不允许修改");
+        
+        // 数据权限验证：南光组织（organizationId=2827）可以修改所有组织的数据（包括默认数据），其他组织只能修改自己组织的数据（包括默认数据）
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        Long loginUserTopOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        Long dictDataTopOrganizationId = sysDictData.getTopOrganizationId();
+        Long dictDataOrganizationId = sysDictData.getOrganizationId();
+        
+        // 南光组织（organizationId=2827）可以修改所有组织的数据（包括默认数据）
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织可以修改，不需要验证 topOrganizationId
+        } else {
+            // 其他组织：只能修改自己组织的数据（包括默认数据）
+            // 使用 Objects.equals 安全比较，处理 null 值的情况
+            boolean isSameTopOrg = java.util.Objects.equals(dictDataTopOrganizationId, loginUserTopOrganizationId);
+            boolean isSameOrg = java.util.Objects.equals(dictDataOrganizationId, loginUserOrganizationId);
+            
+            if (!isSameTopOrg || !isSameOrg) {
+                throw new ServiceException("修改失败：无权修改其他组织的字典数据");
             }
-        if (ObjectUtil.notEqual(sysDictData.getTopOrganizationId(), loginUser.getUserPo().getTopOrganizationId())) {
-            throw new ServiceException("修改失败");
         }
         data.setUpdateBy(loginUser.getUserPo().getUserName());
         int row = dictDataMapper.updateDictData(data);

mhd-modules/mhd-system/src/main/resources/mapper/basic/ExpenseAccountMapper.xml

@@ -102,7 +102,7 @@
         WHERE
         a.del_flag = 1
         <include refid="common_where"/>
-        order by account_type,service_items_code,upper_subject_code,show_seq
+        order by a.update_time DESC
     </select>
     <select id="selectCostSubject" parameterType="com.mhd.basic.domain.expenseAccount.repository.todo.ExpenseAccountDO"
             resultType="com.mhd.basic.domain.expenseAccount.repository.po.ExpenseAccountPO">
@@ -191,12 +191,31 @@
         <if test="expenseAccountDO.updateTimeEnd != null and expenseAccountDO.updateTimeEnd != ''">
             AND date_format(a.update_time,'%Y-%m-%d') <![CDATA[<=]]> #{expenseAccountDO.updateTimeEnd}
         </if>
-        <if test="expenseAccountDO.topOrganizationId != null ">
+        <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+        <!-- 如果 organizationId 和 topOrganizationId 都为 null，表示查询所有组织的数据（不添加组织过滤条件） -->
+        <if test="expenseAccountDO.organizationId != null">
+            <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
+            and a.organization_id = #{expenseAccountDO.organizationId}
+            and a.organization_name IS NOT NULL
+            and a.organization_name != ''
+            and LENGTH(TRIM(a.organization_name)) > 0
+        </if>
+        <if test="expenseAccountDO.topOrganizationId != null and expenseAccountDO.organizationId == null">
+            <!-- 如果设置了 topOrganizationId 但没有设置 organizationId，添加 top_organization_id 条件 -->
             and a.top_organization_id = #{expenseAccountDO.topOrganizationId}
+            and a.organization_name IS NOT NULL
+            and a.organization_name != ''
+            and LENGTH(TRIM(a.organization_name)) > 0
+        </if>
+        <if test="expenseAccountDO.organizationName != null  and expenseAccountDO.organizationName != ''">
+            and a.organization_name like concat('%', #{expenseAccountDO.organizationName}, '%')
         </if>
         <if test="expenseAccountDO.serviceItemsCode != null and expenseAccountDO.serviceItemsCode != ''">
             and b.service_items_code = #{expenseAccountDO.serviceItemsCode}
         </if>
+        <if test="expenseAccountDO.fixedOrderDisplay != null ">
+            and a.fixed_order_display = #{expenseAccountDO.fixedOrderDisplay}
+        </if>
     </sql>
     <select id="selectExpenseAccount" parameterType="com.mhd.basic.domain.expenseAccount.repository.todo.SearchExpenseAccountDO" resultType="com.mhd.basic.domain.expenseAccount.repository.po.QueryExpenseAccountPO">
         select
@@ -238,6 +257,15 @@
         <if test="searchExpenseAccountDO.societyStatus != null ">
             and a.society_status = #{searchExpenseAccountDO.societyStatus}
         </if>
+        <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+        <!-- 如果 organizationId 为 null，表示查询所有组织的数据（不添加组织过滤条件） -->
+        <if test="searchExpenseAccountDO.organizationId != null">
+            <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
+            and a.organization_id = #{searchExpenseAccountDO.organizationId}
+            and a.organization_name IS NOT NULL
+            and a.organization_name != ''
+            and LENGTH(TRIM(a.organization_name)) > 0
+        </if>
         and a.del_flag=1
         order by show_seq
     </select>

mhd-modules/mhd-system/src/main/resources/mapper/basic/ServiceItemsManageMapper.xml

@@ -8,18 +8,36 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 
     <sql id="selectServiceItemsManagePo1">
         <where>
-        del_flag = 1
+        <!-- 删除标记：0-无状态，1-正常，2-已删除，查询时只查询正常的数据 -->
+        <choose>
+            <when test="delFlag != null">
+                and del_flag = #{delFlag}
+            </when>
+            <otherwise>
+                and del_flag = 1
+            </otherwise>
+        </choose>
         <if test="createByName != null  and createByName != ''">
             and create_by_name like concat('%', #{createByName}, '%')
         </if>
         <if test="updateByName != null  and updateByName != ''">
             and update_by_name like concat('%', #{updateByName}, '%')
         </if>
-        <if test="topOrganizationId != null ">
-            and top_organization_id = #{topOrganizationId}
-        </if>
-        <if test="organizationId != null ">
+        <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+        <!-- 如果 organizationId 和 topOrganizationId 都为 null，表示查询所有组织的数据（不添加组织过滤条件） -->
+        <if test="organizationId != null">
+            <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
             and organization_id = #{organizationId}
+            and organization_name IS NOT NULL
+            and organization_name != ''
+            and LENGTH(TRIM(organization_name)) > 0
+        </if>
+        <if test="topOrganizationId != null and organizationId == null">
+            <!-- 如果设置了 topOrganizationId 但没有设置 organizationId，添加 top_organization_id 条件 -->
+            and top_organization_id = #{topOrganizationId}
+            and organization_name IS NOT NULL
+            and organization_name != ''
+            and LENGTH(TRIM(organization_name)) > 0
         </if>
         <if test="organizationName != null  and organizationName != ''">
             and organization_name like concat('%', #{organizationName}, '%')
@@ -42,12 +60,6 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         <if test="createTimeEnd != null and createTimeEnd != ''">
             AND date_format(create_time,'%Y-%m-%d') <![CDATA[<=]]> #{createTimeEnd}
         </if>
-        <if test="createByName != null  and createByName != ''">
-            and create_by_name like concat('%', #{createByName}, '%')
-        </if>
-        <if test="updateByName != null  and updateByName != ''">
-            and update_by_name like concat('%', #{updateByName}, '%')
-        </if>
         <if test="updateTimeStart != null and updateTimeStart != ''">
             AND date_format(update_time,'%Y-%m-%d') <![CDATA[>=]]> #{updateTimeStart}
         </if>
@@ -63,10 +75,10 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         <include refid="selectServiceItemsManagePo1"/>
     </select>
 
-    <select id="selectServiceTypes"
+    <select id="selectServiceTypes" parameterType="com.mhd.basic.domain.serviceItemsManage.repository.todo.ServiceItemsManageDO"
             resultType="com.mhd.basic.domain.serviceItemsManage.repository.po.ServiceItemsManagePO">
         select  organization_name,service_items_code,service_items_name,tax_rate,CONCAT(service_items_name,service_items_code) cost_type
         from service_items_manage
-        where del_flag = 1
+        <include refid="selectServiceItemsManagePo1"/>
     </select>
 </mapper>

mhd-modules/mhd-system/src/main/resources/mapper/basic/addressBook/UserConfigSwitchInterface.xml

@@ -9,6 +9,9 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                a.*
         from
              common_route a
+        <if test="commonRouteDo.organizationId != null">
+            LEFT JOIN "USER" u ON a.user_id = u.user_id AND u.del_flag = 0
+        </if>
         WHERE
             a.del_flag = 1
     </sql>
@@ -26,6 +29,10 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         and (a.mail_name like concat('%', #{commonRouteDo.synthesize}, '%') OR a.mail_phone LIKE concat('%', #{commonRouteDo.synthesize}, '%') OR a.mail_address_plot LIKE concat('%', #{commonRouteDo.synthesize}, '%')
         OR a.addressee_name like concat('%', #{commonRouteDo.synthesize}, '%') OR a.addressee_phone LIKE concat('%', #{commonRouteDo.synthesize}, '%') OR a.addressee_address_plot LIKE concat('%', #{commonRouteDo.synthesize}, '%'))
         </if>
+        <!-- 组织数据权限过滤：通过用户表关联来过滤组织数据 -->
+        <if test="commonRouteDo.organizationId != null">
+            and u.organization_id = #{commonRouteDo.organizationId}
+        </if>
     </sql>
 
     <select id="selectCommonRouteByCommonRouteId" parameterType="java.lang.Long"

mhd-modules/mhd-system/src/main/resources/mapper/basic/addressBook/UserFormConfigInterface.xml

@@ -140,27 +140,37 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     </select>
 
     <select id="selectAddressBookList" parameterType="com.mhd.common.core.domain.po.AddressBookPo" resultMap="AddressBookResult">
-        <include refid="selectAddressBookVo"/>
+        SELECT
+            ab.*
+        FROM
+            address_book ab
+        <if test="organizationId != null">
+            LEFT JOIN "USER" u ON ab.user_id = u.user_id AND u.del_flag = 0
+        </if>
         <where>
-            del_flag = 1
-            <if test="synthesize != null and synthesize != ''"> and (link_man like concat('%', #{synthesize}, '%') OR link_phone LIKE concat('%', #{synthesize}, '%') OR area_name LIKE concat('%', #{synthesize}, '%') OR address LIKE concat('%', #{synthesize}, '%') OR address_plot LIKE concat('%', #{synthesize}, '%')) </if>
-            <if test="userId != null "> and user_id = #{userId}</if>
-            <if test="linkMan != null  and linkMan != ''"> and link_man = #{linkMan}</if>
-            <if test="linkPhone != null  and linkPhone != ''"> and link_phone = #{linkPhone}</if>
-            <if test="provinceCode != null "> and province_code = #{provinceCode}</if>
-            <if test="cityCode != null "> and city_code = #{cityCode}</if>
-            <if test="countyCode != null "> and county_code = #{countyCode}</if>
-            <if test="provinceName != null  and provinceName != ''"> and province_name like concat('%', #{provinceName}, '%')</if>
-            <if test="cityName != null  and cityName != ''"> and city_name like concat('%', #{cityName}, '%')</if>
-            <if test="countyName != null  and countyName != ''"> and county_name like concat('%', #{countyName}, '%')</if>
-            <if test="address != null  and address != ''"> and address = #{address}</if>
-            <if test="doorplate != null  and doorplate != ''"> and doorplate = #{doorplate}</if>
-            <if test="defaultStatus != null "> and default_status = #{defaultStatus}</if>
-            <if test="createByName != null  and createByName != ''"> and create_by_name like concat('%', #{createByName}, '%')</if>
-            <if test="updateByName != null  and updateByName != ''"> and update_by_name like concat('%', #{updateByName}, '%')</if>
+            ab.del_flag = 1
+            <if test="synthesize != null and synthesize != ''"> and (ab.link_man like concat('%', #{synthesize}, '%') OR ab.link_phone LIKE concat('%', #{synthesize}, '%') OR ab.area_name LIKE concat('%', #{synthesize}, '%') OR ab.address LIKE concat('%', #{synthesize}, '%') OR ab.address_plot LIKE concat('%', #{synthesize}, '%')) </if>
+            <if test="userId != null "> and ab.user_id = #{userId}</if>
+            <if test="linkMan != null  and linkMan != ''"> and ab.link_man = #{linkMan}</if>
+            <if test="linkPhone != null  and linkPhone != ''"> and ab.link_phone = #{linkPhone}</if>
+            <if test="provinceCode != null "> and ab.province_code = #{provinceCode}</if>
+            <if test="cityCode != null "> and ab.city_code = #{cityCode}</if>
+            <if test="countyCode != null "> and ab.county_code = #{countyCode}</if>
+            <if test="provinceName != null  and provinceName != ''"> and ab.province_name like concat('%', #{provinceName}, '%')</if>
+            <if test="cityName != null  and cityName != ''"> and ab.city_name like concat('%', #{cityName}, '%')</if>
+            <if test="countyName != null  and countyName != ''"> and ab.county_name like concat('%', #{countyName}, '%')</if>
+            <if test="address != null  and address != ''"> and ab.address = #{address}</if>
+            <if test="doorplate != null  and doorplate != ''"> and ab.doorplate = #{doorplate}</if>
+            <if test="defaultStatus != null "> and ab.default_status = #{defaultStatus}</if>
+            <if test="createByName != null  and createByName != ''"> and ab.create_by_name like concat('%', #{createByName}, '%')</if>
+            <if test="updateByName != null  and updateByName != ''"> and ab.update_by_name like concat('%', #{updateByName}, '%')</if>
+            <!-- 组织数据权限过滤：通过用户表关联来过滤组织数据 -->
+            <if test="organizationId != null">
+                and u.organization_id = #{organizationId}
+            </if>
         </where>
         ORDER BY
-            create_time DESC
+            ab.create_time DESC
     </select>
 
     <select id="selectAddressBookListByManifestId" parameterType="java.lang.Long" resultMap="AddressBookResult">

mhd-user-center/src/main/java/com/mhd/user/application/service/DriverVehicleBindApplicationService.java

@@ -4,14 +4,17 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson2.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.mhd.user.domain.userAggregate.entity.DriverVehicleBind;
+import com.mhd.user.domain.userAggregate.repository.mapper.DriverVehicleBindMapper;
 import com.mhd.user.domain.userAggregate.repository.po.DriverVehicleBindPo;
 import com.mhd.user.domain.userAggregate.repository.todo.DriverVehicleBindDo;
 import com.mhd.user.domain.userAggregate.service.DriverVehicleBindDomainService;
 import com.mhd.user.domain.userAggregate.service.UserDriverDomainService;
 import com.mhd.system.api.TransportFeign;
 import com.mhd.user.interfaces.dto.DriverVehicleBindDto;
+import com.mhd.user.interfaces.dto.addDTO.UserDriverDTO;
 import com.mhd.user.interfaces.facadeApi.Po.VehicleDriverBindAppPo;
 import com.mhd.common.core.domain.dto.VehicleDto;
 import com.mhd.user.domain.userAggregate.repository.po.UserDriverPo;
@@ -49,6 +52,9 @@ public class DriverVehicleBindApplicationService {
     private CommonApplicationService commonApplicationService;
     @Resource
     private UserDriverDomainService userDriverDomainService;
+    @Autowired
+    private DriverVehicleBindMapper driverVehicleBindMapper;
+
     /**
      * 分页查询司机车辆绑定关系列表
      */
@@ -355,4 +361,9 @@ public class DriverVehicleBindApplicationService {
       }
      return isTrue;
   }
+
+    public int delectDriverBind(UserDriverDTO userDriverDTO) {
+       return driverVehicleBindMapper.delete(new LambdaQueryWrapper<DriverVehicleBind>().eq(DriverVehicleBind::getDriverBindId,userDriverDTO.getUserId())
+                                                                                  .eq(DriverVehicleBind::getVehicleId,userDriverDTO.getVehicleId()));
+    }
 }

mhd-user-center/src/main/java/com/mhd/user/application/service/MotorcadeApplicationService.java

@@ -40,9 +40,11 @@ import com.mhd.user.domain.roleAggregate.repository.todo.RoleDo;
 import com.mhd.user.domain.roleAggregate.service.RoleDomainService;
 import com.mhd.user.domain.userAggregate.entity.DriverVehicleBind;
 import com.mhd.user.domain.userAggregate.entity.UserRoleEntity;
+import com.mhd.common.core.domain.po.UserRoleMenuPO;
 import com.mhd.user.domain.userAggregate.repository.po.UserDriverEnterprisePo;
 import com.mhd.user.domain.userAggregate.repository.po.UserDriverPo;
 import com.mhd.user.domain.userAggregate.repository.todo.*;
+import com.mhd.user.domain.userAggregate.repository.todo.UserDO;
 import com.mhd.user.domain.motorcade.service.MotorcadeRecordDomainService;
 import com.mhd.user.domain.userAggregate.service.*;
 import com.mhd.user.infrastructure.feign.SpecialLogisticsFeign;
@@ -131,7 +133,55 @@ public class MotorcadeApplicationService {
     public List<MotorcadePo> queryList(MotorcadeDO motorcadeDo) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null){
-            motorcadeDo.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+            UserPo userPo = loginUser.getUserPo();
+            Long organizationId = userPo.getOrganizationId();
+            Long topOrganizationId = userPo.getTopOrganizationId();
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (organizationId != null && organizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                Long frontendOrganizationId = motorcadeDo.getOrganizationId();
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，使用前端传递的值进行过滤
+                    motorcadeDo.setOrganizationId(frontendOrganizationId);
+                    motorcadeDo.setTopOrganizationId(null);
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    motorcadeDo.setOrganizationId(null);
+                    motorcadeDo.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置 organizationId，只查询当前组织的数据
+                // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+                Long frontendOrganizationId = motorcadeDo.getOrganizationId();
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(organizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        log.warn("车队列表查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤",
+                            frontendOrganizationId, organizationId);
+                        motorcadeDo.setOrganizationId(organizationId);
+                    } else {
+                        // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                        motorcadeDo.setOrganizationId(frontendOrganizationId);
+                    }
+                    if (topOrganizationId != null) {
+                        motorcadeDo.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    motorcadeDo.setOrganizationId(organizationId);
+                    if (topOrganizationId != null) {
+                        motorcadeDo.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            }
+            
+            log.info("车队列表查询 - 设置组织ID后，查询参数：organizationId={}, topOrganizationId={}", 
+                motorcadeDo.getOrganizationId(), motorcadeDo.getTopOrganizationId());
         }
         return motorcadeDomainService.queryList(motorcadeDo);
     }
@@ -656,16 +706,28 @@ public class MotorcadeApplicationService {
 
         motorcadeDo.setMotorcadeHeaderName(userPo.getUserName());
         motorcadeDo.setMotorcadeHeaderAccount(userPo.getUserAccount());
-        motorcadeDo.setOrganizationId(loginUser.getUserPo().getOrganizationId());
-        motorcadeDo.setOrganizationName(loginUser.getUserPo().getOrganizationName());
-        motorcadeDo.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        
+        // 设置当前登录用户的组织信息
+        UserPo loginUserPo = loginUser.getUserPo();
+        if (loginUserPo != null) {
+            motorcadeDo.setOrganizationId(loginUserPo.getOrganizationId());
+            motorcadeDo.setOrganizationName(loginUserPo.getOrganizationName());
+            motorcadeDo.setTopOrganizationId(loginUserPo.getTopOrganizationId());
+            log.info("新增车队 - 设置当前登录用户的组织信息，组织ID: {}, 组织名称: {}, 顶级组织ID: {}", 
+                loginUserPo.getOrganizationId(), loginUserPo.getOrganizationName(), loginUserPo.getTopOrganizationId());
+        } else {
+            log.warn("新增车队 - 当前登录用户信息为空，无法设置组织信息");
+        }
+        
         motorcadeDo.setMotorcadeStatus(2L);
         //获取车队承运编码
         motorcadeDo.setDriverEnterpriseCode(userPo.getUserAccount());
 
+        // 设置当前登录用户的创建信息
         motorcadeDo.setCreateBy(loginUser.getUserid());
         motorcadeDo.setCreateByName(loginUser.getUsername());
         motorcadeDo.setCreateTime(DateUtil.date());
+        log.info("新增车队 - 设置创建人信息，创建人ID: {}, 创建人姓名: {}", loginUser.getUserid(), loginUser.getUsername());
         motorcadeDomainService.insert(motorcadeDo);
         MotorcadeDriver motorcadeDriver = new MotorcadeDriverAssembler().getEntity();
         motorcadeDriver.setMotorcadeId(motorcadeDo.getMotorcadeId());
@@ -674,9 +736,210 @@ public class MotorcadeApplicationService {
         if(!flag){
             throw new ServiceException("新增车队失败");
         }
+        
+        // 新增车队时，更新车队长的用户信息（角色、用户类型、用户身份）
+        updateCaptainUserInfo(motorcadeDo.getMotorcadeHeaderId(), loginUser);
+        
+        // 新增车队时，给车队长分配"车队长"角色
+        assignCaptainRoleToUser(motorcadeDo.getMotorcadeHeaderId(), loginUser);
+        
         return true;
     }
 
+    /**
+     * 更新车队长的用户信息（角色代码、角色名称、业务类型等）
+     * @param captainUserId 车队长用户ID
+     * @param loginUser 当前登录用户
+     */
+    private void updateCaptainUserInfo(Long captainUserId, LoginUser loginUser) {
+        if (captainUserId == null || loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("更新用户信息失败 - 车队长用户ID或登录用户信息为空");
+            return;
+        }
+        
+        log.info("新增车队 - 更新车队长的用户信息，车队长用户ID: {}", captainUserId);
+        
+        try {
+            // 获取当前登录用户的角色信息，用于设置车队长的角色
+            Long loginUserId = loginUser.getUserPo().getUserId();
+            List<UserRoleMenuPO> loginUserRoleList = userRoleDomainService.selectRolesByUserId(loginUserId);
+            
+            String roleCode = RoleEnum.CAPTAIN.getCode();
+            String roleName = RoleEnum.CAPTAIN.getName();
+            
+            // 从当前登录用户的角色中查找"车队长"角色，获取角色名称
+            if (CollUtil.isNotEmpty(loginUserRoleList)) {
+                for (UserRoleMenuPO loginUserRole : loginUserRoleList) {
+                    if (RoleEnum.CAPTAIN.getCode().equals(loginUserRole.getRoleCode())) {
+                        roleCode = loginUserRole.getRoleCode();
+                        roleName = loginUserRole.getRoleName();
+                        log.info("从当前登录用户的角色中获取车队长角色信息 - 角色代码: {}, 角色名称: {}", roleCode, roleName);
+                        break;
+                    }
+                }
+            }
+            
+            // 更新车队长的用户信息
+            UserDO userDO = new UserDO();
+            userDO.setUserId(captainUserId);
+            userDO.setRoleCode(roleCode);
+            userDO.setRoleName(roleName);
+            
+            // 设置业务类型：如果用户已经是司机，则设置为司机&车队长（3），否则设置为车队长（2）
+            UserPo captainUserPo = userApplicationService.selectByUserId(captainUserId);
+            if (captainUserPo != null) {
+                Integer businessType = captainUserPo.getBusinessType();
+                // 业务类型：1=客户，2=司机，3=司机&车队长，4=客户&司机
+                if (businessType != null && businessType == 2) {
+                    // 如果用户已经是司机，设置为司机&车队长（3）
+                    userDO.setBusinessType(3);
+                    log.info("车队长用户业务类型设置为：司机&车队长（3），原业务类型：{}", businessType);
+                } else if (businessType != null && businessType == 4) {
+                    // 如果用户是客户&司机，设置为客户&司机&车队长（保持为4，或者可以设置为5如果有的话）
+                    // 这里暂时保持为4，或者根据业务需求调整
+                    userDO.setBusinessType(4);
+                    log.info("车队长用户业务类型保持为：客户&司机（4），原业务类型：{}", businessType);
+                } else {
+                    // 如果用户不是司机，设置为车队长（2）
+                    userDO.setBusinessType(2);
+                    log.info("车队长用户业务类型设置为：车队长（2），原业务类型：{}", businessType);
+                }
+            } else {
+                // 如果查询不到用户信息，默认设置为车队长（2）
+                userDO.setBusinessType(2);
+                log.warn("查询不到车队长用户信息，默认设置业务类型为：车队长（2）");
+            }
+            
+            // 设置组织信息（从当前登录用户获取）
+            UserPo loginUserPo = loginUser.getUserPo();
+            if (loginUserPo != null) {
+                userDO.setOrganizationId(loginUserPo.getOrganizationId());
+                userDO.setOrganizationName(loginUserPo.getOrganizationName());
+                userDO.setTopOrganizationId(loginUserPo.getTopOrganizationId());
+                log.info("设置车队长的组织信息 - 组织ID: {}, 组织名称: {}, 顶级组织ID: {}", 
+                    loginUserPo.getOrganizationId(), loginUserPo.getOrganizationName(), loginUserPo.getTopOrganizationId());
+            }
+            
+            // 更新用户信息
+            UserPo updateResult = userApplicationService.updateUser(userDO);
+            if (updateResult != null && updateResult.getUserId() != null) {
+                log.info("成功更新车队长的用户信息 - 用户ID: {}, 角色代码: {}, 角色名称: {}, 业务类型: {}, 组织ID: {}, 组织名称: {}", 
+                    captainUserId, roleCode, roleName, userDO.getBusinessType(), 
+                    userDO.getOrganizationId(), userDO.getOrganizationName());
+            } else {
+                log.warn("更新车队长的用户信息失败 - 更新结果为null，用户ID: {}, 请检查用户是否存在", captainUserId);
+            }
+        } catch (Exception e) {
+            log.error("更新车队长的用户信息失败 - 用户ID: {}, 错误信息: {}", captainUserId, e.getMessage(), e);
+            // 不抛出异常，允许继续执行，但记录详细错误信息
+        }
+    }
+
+    /**
+     * 将"车队长"角色分配给车队创建时的车队长用户
+     * 优先从当前登录用户的角色中获取"车队长"角色，如果找不到，再根据组织ID查询
+     * @param captainUserId 车队长用户ID
+     * @param loginUser 当前登录用户
+     */
+    private void assignCaptainRoleToUser(Long captainUserId, LoginUser loginUser) {
+        if (captainUserId == null || loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("分配角色失败 - 车队长用户ID或登录用户信息为空");
+            return;
+        }
+        
+        log.info("新增车队 - 分配车队长角色，车队长用户ID: {}", captainUserId);
+        
+        Long loginUserId = loginUser.getUserPo().getUserId();
+        Long organizationId = loginUser.getUserPo().getOrganizationId();
+        
+        // 优先从当前登录用户的角色中查找"车队长"角色
+        List<UserRoleMenuPO> loginUserRoleList = userRoleDomainService.selectRolesByUserId(loginUserId);
+        RoleEntity roleEntity = null;
+        
+        if (CollUtil.isNotEmpty(loginUserRoleList)) {
+            log.info("当前登录用户共有 {} 个角色，查找车队长角色", loginUserRoleList.size());
+            for (UserRoleMenuPO loginUserRole : loginUserRoleList) {
+                if (RoleEnum.CAPTAIN.getCode().equals(loginUserRole.getRoleCode())) {
+                    // 找到"车队长"角色，使用当前登录用户的角色ID
+                    log.info("从当前登录用户的角色中找到车队长角色 - 角色ID: {}, 角色代码: {}", loginUserRole.getRoleId(), loginUserRole.getRoleCode());
+                    roleEntity = new RoleEntity();
+                    roleEntity.setRoleId(loginUserRole.getRoleId());
+                    roleEntity.setRoleCode(loginUserRole.getRoleCode());
+                    roleEntity.setRoleName(loginUserRole.getRoleName());
+                    break;
+                }
+            }
+        }
+        
+        // 如果当前登录用户没有"车队长"角色，根据组织ID查询
+        if (ObjectUtil.isNull(roleEntity)) {
+            if (organizationId == null) {
+                log.warn("当前登录用户的组织ID为空，无法查询车队长角色");
+                return;
+            }
+            
+            log.info("当前登录用户没有车队长角色，根据组织ID查询 - 组织ID: {}, 角色代码: {}", organizationId, RoleEnum.CAPTAIN.getCode());
+            
+            // 查询"车队长"角色
+            RoleDo roleDo = new RoleDo();
+            roleDo.setRoleCode(RoleEnum.CAPTAIN.getCode());
+            roleDo.setOrganizationId(organizationId);
+            
+            roleEntity = roleDomainService.selectByOrganizationIdAndRoleCode(roleDo);
+            
+            // 如果当前组织查询不到，尝试回退查询（不检查 organization_name IS NOT NULL）
+            if (ObjectUtil.isNull(roleEntity)) {
+                log.warn("使用 organization_name IS NOT NULL 条件查询不到角色，尝试回退查询（不检查 organization_name）- 组织ID: {}, 角色代码: {}", organizationId, RoleEnum.CAPTAIN.getCode());
+                com.mhd.common.core.domain.po.RolePO rolePO = roleDomainService.selectByRoleCodeAndOrganizationId(RoleEnum.CAPTAIN.getCode(), organizationId);
+                if (ObjectUtil.isNotNull(rolePO)) {
+                    // 将 RolePO 转换为 RoleEntity
+                    roleEntity = new RoleEntity();
+                    roleEntity.setRoleId(rolePO.getRoleId());
+                    roleEntity.setRoleCode(rolePO.getRoleCode());
+                    roleEntity.setRoleName(rolePO.getRoleName());
+                    roleEntity.setRoleRemark(rolePO.getRoleRemark());
+                    roleEntity.setRoleDataScope(rolePO.getRoleDataScope());
+                    roleEntity.setRoleStatus(rolePO.getRoleStatus());
+                    roleEntity.setRoleType(rolePO.getRoleType());
+                    roleEntity.setOrganizationId(rolePO.getOrganizationId());
+                    roleEntity.setOrganizationName(rolePO.getOrganizationName());
+                    roleEntity.setTopOrganizationId(rolePO.getTopOrganizationId());
+                    log.info("回退查询成功找到角色 - 角色ID: {}, 角色名称: {}, 组织名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName(), roleEntity.getOrganizationName());
+                }
+            }
+            
+            // 如果还是查询不到，尝试使用顶级组织ID查询
+            if (ObjectUtil.isNull(roleEntity)) {
+                Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                if (topOrganizationId != null && topOrganizationId.equals(organizationId)) {
+                    log.info("当前组织查询不到角色，尝试使用顶级组织ID查询 - 顶级组织ID: {}, 角色代码: {}", topOrganizationId, RoleEnum.CAPTAIN.getCode());
+                    roleDo.setOrganizationId(null);
+                    roleDo.setTopOrganizationId(topOrganizationId);
+                    roleEntity = roleDomainService.selectByOrganizationIdAndRoleCode(roleDo);
+                }
+            }
+        }
+        
+        if (ObjectUtil.isNotNull(roleEntity)) {
+            log.info("找到车队长角色 - 角色ID: {}, 角色名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName());
+            UserRoleDo userRoleDo = new UserRoleDo();
+            userRoleDo.setUserId(captainUserId);
+            userRoleDo.setRoleId(roleEntity.getRoleId());
+            
+            // 判断是否已存在相应角色
+            List<UserRoleEntity> userRoleEntities = userRoleDomainService.selectList(userRoleDo);
+            if (CollUtil.isEmpty(userRoleEntities)) {
+                userRoleDomainService.addUserRole(userRoleDo);
+                log.info("成功分配车队长角色给用户 - 角色ID: {}, 角色名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName());
+            } else {
+                log.info("用户已存在车队长角色，跳过 - 角色ID: {}", roleEntity.getRoleId());
+            }
+        } else {
+            log.warn("未找到车队长角色 - 组织ID: {}, 角色代码: {}, 请检查该组织下是否配置了该角色", organizationId, RoleEnum.CAPTAIN.getCode());
+            // 不抛出异常，允许继续执行，因为角色可能在其他地方分配
+        }
+    }
+
     @Transactional
     @NeedSetValueField
     public Boolean editWeb(MotorcadeDO motorcadeDo) {
@@ -1166,7 +1429,29 @@ public class MotorcadeApplicationService {
         return motorcadeDomainService.queryList(motorcadeDo);
     }
     public List<MotorcadePo> queryNonePagingList() {
-        return motorcadeDomainService.queryNonePagingList();
+        // 获取当前登录用户的组织信息，用于数据权限过滤
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser != null && loginUser.getUserPo() != null) {
+            UserPo userPo = loginUser.getUserPo();
+            Long organizationId = userPo.getOrganizationId();
+            Long topOrganizationId = userPo.getTopOrganizationId();
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (organizationId != null && organizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据，传递 null 表示不限制
+                log.info("查询车队列表（不分页） - 南光组织，查询所有组织的数据");
+                return motorcadeDomainService.queryNonePagingList(null, null);
+            } else {
+                // 其他组织：只能查询自己组织的数据
+                if (organizationId != null) {
+                    log.info("查询车队列表（不分页） - 其他组织，查询组织ID: {}", organizationId);
+                    return motorcadeDomainService.queryNonePagingList(organizationId, topOrganizationId);
+                }
+            }
+        }
+        log.warn("查询车队列表（不分页） - 未获取到登录用户信息或组织ID，返回空列表");
+        return new ArrayList<>();
     }
 
 }

mhd-user-center/src/main/java/com/mhd/user/application/service/OpenUserApplicationService.java

@@ -146,6 +146,10 @@ public class OpenUserApplicationService {
         userDriverDO.setUserId(userPo.getUserId());
         userDriverDO.setDriverEnterpriseCode(openDriverDto.getDriverEnterpriseCode());
         userDriverDO.setDataSources(openDriverDto.getDataSources());
+        // 设置组织信息
+        userDriverDO.setOrganizationId(sysTenantsPo.getOrganizationId());
+        userDriverDO.setTopOrganizationId(sysTenantsPo.getTopOrganizationId());
+        userDriverDO.setOrganizationName(sysTenantsPo.getOrganizationName());
         userDriverDomainService.saveUserDriverByOpen(userDriverDO);
 
         //处理车队数据

mhd-user-center/src/main/java/com/mhd/user/application/service/RoleApplicationService.java

@@ -83,21 +83,77 @@ public class RoleApplicationService {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
         }
         UserPo userPo = loginUser.getUserPo();
+        
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = roleDo.getOrganizationId();
+        
+        // 获取登录用户信息
+        Long loginUserOrganizationId = null;
+        Long topOrganizationId = null;
+        if (userPo != null) {
+            loginUserOrganizationId = userPo.getOrganizationId();
+            topOrganizationId = userPo.getTopOrganizationId();
+        }
+        
         if (userPo.getUserAccountType() != null && userPo.getUserAccountType() == 5){
             roleDo.setCreateBy(userPo.getCreateBy());
         }else {
             UserDataPermissionQueryDTO userDataPermissionQueryDTO = new UserDataPermissionQueryDTO();
             userDataPermissionQueryDTO.setPermissionMenuId(roleDo.getPermissionMenuId());
             userDataPermissionQueryDTO = userDataPermissionApplicationService.getUserDataPermissionQueryDTO(userDataPermissionQueryDTO);
+            
+            // 在复制属性之前，先保存前端传递的 organizationId（如果存在）
+            // 因为 BeanUtils.copyProperties 可能会覆盖掉前端传递的值
+            Long savedFrontendOrganizationId = frontendOrganizationId;
+            
             BeanUtils.copyProperties(userDataPermissionQueryDTO, roleDo, IgnoreNullUtil.getNullPropertyNames(userDataPermissionQueryDTO));
             UserPo loginUserPo = loginUser.getUserPo();
-            if (ObjectUtil.isNull(roleDo.getOrganizationId())) {
-                roleDo.setOrganizationId(loginUserPo.getOrganizationId());
+            
+            // 重新获取前端传递的 organizationId（优先使用前端传递的值）
+            // 对于南光组织，如果前端传递了 organizationId，必须使用前端传递的值
+            Long currentFrontendOrganizationId = savedFrontendOrganizationId != null ? savedFrontendOrganizationId : roleDo.getOrganizationId();
+            
+            // 数据权限：查询权限根据 organizationId 来设置，与其他模块保持一致
+            // organizationId等于2827时，为南光组织，查所有；其他组织查自己
+            if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (currentFrontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    roleDo.setOrganizationId(currentFrontendOrganizationId);
+                    roleDo.setTopOrganizationId(null);
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    roleDo.setOrganizationId(null);
+                    roleDo.setTopOrganizationId(null);
+                }
                 if (!Strings.isNullOrEmpty(loginUserPo.getRoleCode()) && RoleEnum.SUPER_ADMIN.getCode().equals(loginUserPo.getRoleCode())) {
                     //角色等级：0-无状态，1-内置角色，2-组织角色
                     roleDo.setRoleGrade(1);
+                } else {
+                    roleDo.setRoleGrade(2);
                 }
             } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+                if (currentFrontendOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!currentFrontendOrganizationId.equals(loginUserOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        log.warn("角色查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                            currentFrontendOrganizationId, loginUserOrganizationId);
+                        roleDo.setOrganizationId(loginUserOrganizationId);
+                    } else {
+                        // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                        roleDo.setOrganizationId(currentFrontendOrganizationId);
+                    }
+                    roleDo.setTopOrganizationId(topOrganizationId);
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    roleDo.setOrganizationId(loginUserOrganizationId);
+                    roleDo.setTopOrganizationId(topOrganizationId);
+                }
                 roleDo.setRoleGrade(2);
             }
         }
@@ -144,8 +200,39 @@ public class RoleApplicationService {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
         }
         UserPo loginUserPo = loginUser.getUserPo();
-        if (ObjectUtil.isNull(roleDo.getOrganizationId())) {
-            roleDo.setOrganizationId(loginUserPo.getOrganizationId());
+        
+        // 保存前端传递的 organizationId
+        Long frontendOrganizationId = roleDo.getOrganizationId();
+        Long loginUserOrganizationId = loginUserPo.getOrganizationId();
+        
+        // 数据权限：查询权限根据 organizationId 来设置，与其他模块保持一致
+        // organizationId等于2827时，为南光组织，查所有；其他组织查自己
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId 且不等于 2827，使用前端传递的值进行过滤
+            // 如果前端没有传递 organizationId 或传递的是 2827，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null && !frontendOrganizationId.equals(2827L)) {
+                // 前端传递了其他组织的 organizationId，使用前端传递的值进行过滤
+                roleDo.setOrganizationId(frontendOrganizationId);
+                roleDo.setTopOrganizationId(null);
+            } else {
+                // 前端没有传递 organizationId 或传递的是 2827，清空组织过滤条件，查询所有组织的数据
+                roleDo.setOrganizationId(null);
+                roleDo.setTopOrganizationId(null);
+            }
+        } else {
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            if (ObjectUtil.isNull(frontendOrganizationId)) {
+                roleDo.setOrganizationId(loginUserOrganizationId);
+            } else {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    log.warn("角色查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                        frontendOrganizationId, loginUserOrganizationId);
+                    roleDo.setOrganizationId(loginUserOrganizationId);
+                }
+            }
         }
         return roleDomainService.selectList(roleDo);
     }
@@ -226,10 +313,36 @@ public class RoleApplicationService {
         }
         UserPo loginUserPo = loginUser.getUserPo();
 
-        //校验组织ID是否存在
-        if(ObjectUtil.isNull(roleDo.getOrganizationId())){
-            roleDo.setOrganizationId(loginUserPo.getOrganizationId());
+        // 数据隔离：校验组织ID和权限，与其他模块保持一致
+        Long frontendOrganizationId = roleDo.getOrganizationId();
+        Long loginUserOrganizationId = loginUserPo.getOrganizationId();
+        Long topOrganizationId = loginUserPo.getTopOrganizationId();
+        
+        // 判断是否为南光组织：topOrganizationId == null 时为顶级组织（南光组织）
+        // 与其他模块保持一致（VerificationApplicationService、TmsReceiptApplicationService等）
+        boolean isNanguangOrg = (topOrganizationId == null);
+        
+        if (ObjectUtil.isNull(frontendOrganizationId)) {
+            // 如果前端没有传递 organizationId，使用当前登录用户的组织ID
+            roleDo.setOrganizationId(loginUserOrganizationId);
+        } else {
+            // 如果前端传递了 organizationId，需要进行数据权限校验
+            if (isNanguangOrg) {
+                // 南光组织：可以为任何组织创建角色，使用前端传递的 organizationId
+                roleDo.setOrganizationId(frontendOrganizationId);
+                log.info("南光组织创建角色 - 目标组织ID: {}", frontendOrganizationId);
+            } else {
+                // 其他组织：只能为自己组织创建角色，不能为其他组织创建角色
+                if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    log.warn("非南光组织尝试为其他组织创建角色 - 登录用户组织ID: {}, 尝试创建的组织ID: {}", 
+                        loginUserOrganizationId, frontendOrganizationId);
+                    throw new ServiceException("无权限为其他组织创建角色，只能为本组织创建角色");
                 }
+                // 使用当前登录用户的组织ID
+                roleDo.setOrganizationId(loginUserOrganizationId);
+            }
+        }
+        
         if (ObjectUtil.isNotNull(roleDo.getRoleId())) {
             RolePO rolePO = roleDomainService.selectByRoleId(roleDo.getRoleId());
             if (rolePO == null) {
@@ -254,7 +367,58 @@ public class RoleApplicationService {
             if (roleEntity != null){
                 throw new ServiceException("角色编码重复");
             }
-            roleDo.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            // 设置组织信息：保留传入的 organizationId，如果为 null 则使用当前登录用户的组织ID
+            // 注意：不能强制覆盖传入的 organizationId，否则会导致角色保存到错误的组织下
+            if (roleDo.getOrganizationId() == null) {
+                roleDo.setOrganizationId(loginUserPo.getOrganizationId());
+                roleDo.setOrganizationName(loginUserPo.getOrganizationName());
+                roleDo.setTopOrganizationId(loginUserPo.getTopOrganizationId());
+            } else {
+                // 如果传入了 organizationId，需要根据该 organizationId 查询对应的 organizationName
+                // 如果 organizationName 为空，尝试通过 Feign 查询组织信息
+                if (roleDo.getOrganizationName() == null || roleDo.getOrganizationName().isEmpty()) {
+                    try {
+                        AjaxResult orgInfo = organizationServiceFeign.getInfo(roleDo.getOrganizationId());
+                        if (orgInfo != null && "200".equals(String.valueOf(orgInfo.get("code")))) {
+                            JSONObject data = (JSONObject) orgInfo.get("data");
+                            if (data != null && data.containsKey("organizationName")) {
+                                roleDo.setOrganizationName(data.getString("organizationName"));
+                                log.info("通过 ProductServiceFeign 获取到组织名称: {}", roleDo.getOrganizationName());
+                            }
+                        }
+                        // 如果查询失败，使用当前登录用户的组织名称作为默认值
+                        if (roleDo.getOrganizationName() == null || roleDo.getOrganizationName().isEmpty()) {
+                            roleDo.setOrganizationName(loginUserPo.getOrganizationName());
+                            log.warn("无法通过 organizationId {} 获取组织名称，使用当前登录用户的组织名称作为默认值", roleDo.getOrganizationId());
+                        }
+                    } catch (Exception e) {
+                        log.warn("通过 ProductServiceFeign 获取组织名称失败: {}，使用当前登录用户的组织名称作为默认值", e.getMessage());
+                        roleDo.setOrganizationName(loginUserPo.getOrganizationName());
+                    }
+                }
+                // 如果 topOrganizationId 为空，尝试从组织信息中获取，否则使用当前登录用户的顶级组织ID
+                if (roleDo.getTopOrganizationId() == null) {
+                    try {
+                        AjaxResult orgInfo = organizationServiceFeign.getInfo(roleDo.getOrganizationId());
+                        if (orgInfo != null && "200".equals(String.valueOf(orgInfo.get("code")))) {
+                            JSONObject data = (JSONObject) orgInfo.get("data");
+                            if (data != null && data.containsKey("topOrganizationId")) {
+                                Object topOrgId = data.get("topOrganizationId");
+                                if (topOrgId != null) {
+                                    roleDo.setTopOrganizationId(Long.parseLong(topOrgId.toString()));
+                                }
+                            }
+                        }
+                        // 如果查询失败，使用当前登录用户的顶级组织ID作为默认值
+                        if (roleDo.getTopOrganizationId() == null) {
+                            roleDo.setTopOrganizationId(loginUserPo.getTopOrganizationId());
+                        }
+                    } catch (Exception e) {
+                        log.warn("通过 ProductServiceFeign 获取顶级组织ID失败: {}，使用当前登录用户的顶级组织ID作为默认值", e.getMessage());
+                        roleDo.setTopOrganizationId(loginUserPo.getTopOrganizationId());
+                    }
+                }
+            }
             roleDo.setCreateBy(loginUserPo.getUserId());
             roleDo.setCreateByName(loginUserPo.getUserName());
             roleDo.setCreateTime(new Date());
@@ -263,6 +427,19 @@ public class RoleApplicationService {
             roleDo.setUpdateTime(new Date());
             //删除标记：0-无状态，1-正常，2-已删除
             roleDo.setDelFlag(1);
+            
+            // 添加调试日志，确认保存的角色信息
+            log.info("新增角色 - 组织ID: {}, 组织名称: {}, 角色代码: {}, 角色名称: {}, 顶级组织ID: {}", 
+                roleDo.getOrganizationId(), roleDo.getOrganizationName(), roleDo.getRoleCode(), 
+                roleDo.getRoleName(), roleDo.getTopOrganizationId());
+            
+            // 确保 organizationName 不为空，否则查询时会查不到
+            if (roleDo.getOrganizationName() == null || roleDo.getOrganizationName().isEmpty()) {
+                log.error("新增角色失败 - organizationName 为空！组织ID: {}, 角色代码: {}", 
+                    roleDo.getOrganizationId(), roleDo.getRoleCode());
+                throw new ServiceException("组织名称不能为空，请检查组织信息是否正确");
+            }
+            
             int i = roleDomainService.addRole(roleDo);
             Long roleId = roleDo.getRoleId();
             //复制之前角色的菜单

mhd-user-center/src/main/java/com/mhd/user/application/service/UserApplicationService.java

@@ -330,17 +330,82 @@ public class UserApplicationService {
      * @Date 2023/1/12 14:58
      */
     public List<UserPo> staffList(UserDO userDo) {
+        // 首先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = userDo.getOrganizationId();
+        
         //获取当前登陆人
         LoginUser loginUser = SecurityUtils.getLoginUser();
         UserPo userPo = loginUser.getUserPo();
         if (ObjectUtil.isNull(loginUser)) {
             throw new DigitalLogisticsException(UserError.TIMEOUT);
         }
-        if (userPo.getRoleCode().contains(RoleEnum.PLAT_ADMIN.getCode()) && ObjectUtil.equal(userPo.getOrganizationId(),userPo.getTopOrganizationId())){
-            userDo.setTopOrganizationId(userPo.getTopOrganizationId());
-        }else {
-            userDo.setOrganizationId(userPo.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，使用前端传递的值进行过滤
+                userDo.setOrganizationId(frontendOrganizationId);
+                userDo.setTopOrganizationId(null);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                // 但如果用户是平台管理员且 organizationId 等于 topOrganizationId，使用 topOrganizationId
+                if (userPo.getRoleCode() != null && userPo.getRoleCode().contains(RoleEnum.PLAT_ADMIN.getCode()) 
+                    && ObjectUtil.equal(loginUserOrganizationId, topOrganizationId)) {
+                    userDo.setTopOrganizationId(topOrganizationId);
+                    userDo.setOrganizationId(null);
+                } else {
+                    userDo.setOrganizationId(null);
+                    userDo.setTopOrganizationId(null);
                 }
+            }
+        } else {
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织（包括南光）的数据
+            // 如果其他组织尝试查询南光（organizationId=2827）的数据，返回空数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId.equals(2827L)) {
+                    // 其他组织尝试查询南光的数据，设置一个不存在的 organizationId，返回空数据
+                    userDo.setOrganizationId(-1L);
+                    userDo.setTopOrganizationId(null);
+                } else if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    userDo.setOrganizationId(loginUserOrganizationId);
+                    if (topOrganizationId != null) {
+                        userDo.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    userDo.setOrganizationId(frontendOrganizationId);
+                    if (topOrganizationId != null) {
+                        userDo.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            } else {
+                // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                // 如果用户是平台管理员且 organizationId 等于 topOrganizationId，使用 topOrganizationId
+                if (userPo.getRoleCode() != null && userPo.getRoleCode().contains(RoleEnum.PLAT_ADMIN.getCode()) 
+                    && ObjectUtil.equal(loginUserOrganizationId, topOrganizationId)) {
+                    userDo.setTopOrganizationId(topOrganizationId);
+                    userDo.setOrganizationId(null);
+                } else {
+                    if (loginUserOrganizationId != null) {
+                        userDo.setOrganizationId(loginUserOrganizationId);
+                    }
+                    if (topOrganizationId != null) {
+                        userDo.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            }
+        }
+        
         return userDomainService.selectList(userDo);
     }
 
@@ -1084,6 +1149,19 @@ public class UserApplicationService {
             if (ObjectUtil.isNull(userDO.getOrganizationId())) {
                 userDO.setOrganizationId(loginUser.getUserPo().getOrganizationId());
                 userDO.setOrganizationName(loginUser.getUserPo().getOrganizationName());
+            } else {
+                // 如果前端传递了 organizationId，根据 organizationId 查询组织信息，获取正确的组织名称
+                AjaxResult orgInfoResult = productServiceFeign.getInfo(userDO.getOrganizationId());
+                String orgInfoCode = orgInfoResult.get("code").toString();
+                if ("200".equals(orgInfoCode)) {
+                    Object orgData = orgInfoResult.get("data");
+                    if (ObjectUtil.isNotNull(orgData)) {
+                        OrganizationPo organizationPo = BeanUtil.toBean(orgData, OrganizationPo.class);
+                        if (ObjectUtil.isNotNull(organizationPo)) {
+                            userDO.setOrganizationName(organizationPo.getOrganizationName());
+                        }
+                    }
+                }
             }
             UserPo userPo = new UserPo();
             //先根据组织ID获取一级组织
@@ -1151,7 +1229,15 @@ public class UserApplicationService {
             }
             BeanUtils.copyProperties(userEntity, userPo);
             //同步网货平台员工信息
+            try {
                 wlhyDomainService.addOrEditPlatformUser(userEntity);
+            } catch (Exception e) {
+                // 同步网货失败时，记录日志但不影响用户保存
+                // 避免同步失败导致整个事务回滚，用户数据无法保存
+                log.warn("同步网货平台员工信息失败，但不影响用户保存: {}", e.getMessage());
+                // 如果业务要求必须同步成功，可以取消下面的注释，让异常抛出
+                // throw e;
+            }
             return userPo;
         }
     }
@@ -1249,7 +1335,12 @@ public class UserApplicationService {
       }
       BeanUtils.copyProperties(userEntity, userPo);
       //同步网货平台员工信息
+      try {
           wlhyDomainService.addOrEditPlatformUser(userEntity);
+      } catch (Exception e) {
+          // 同步网货失败时，记录日志但不影响用户保存
+          log.warn("同步网货平台员工信息失败，但不影响用户保存: {}", e.getMessage());
+      }
       return userPo;
     }
   }
@@ -1342,7 +1433,12 @@ public class UserApplicationService {
       }
       BeanUtils.copyProperties(userEntity, userPo);
       //同步网货平台员工信息
+      try {
           wlhyDomainService.addOrEditPlatformUser(userEntity);
+      } catch (Exception e) {
+          // 同步网货失败时，记录日志但不影响用户保存
+          log.warn("同步网货平台员工信息失败，但不影响用户保存: {}", e.getMessage());
+      }
       return userPo;
     }
   }
@@ -4823,12 +4919,25 @@ public class UserApplicationService {
         if (Objects.isNull(loginUser)){
             throw new ServiceException("当前用户不存在！");
         }
-        Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        Long filterOrganizationId = null;
         Long userId = null;
+        
+        // 数据隔离：根据 organizationId 字段来实现
+        // 如果当前登录用户的organizationId为2827，可查询全部组织数据；其他组织只能查询自己组织的数据
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织：查询所有组织的数据，不设置 organizationId 和 userId 过滤条件
+            filterOrganizationId = null;
+            userId = null;
+        } else {
+            // 其他组织：只查询自己组织的数据
+            filterOrganizationId = loginUserOrganizationId;
+            // 如果当前登录用户是货主或企业用户，只查询当前登录用户的信息
             if(loginUser.getUserPo().getBusinessType()==1||loginUser.getUserPo().getBusinessType()==3||loginUser.getUserPo().getUserAccountType()==5){
                 userId = loginUser.getUserid();
             }
-        return userDomainService.findAllShipperInfo(userId,topOrganizationId);
+        }
+        return userDomainService.findAllShipperInfo(userId, filterOrganizationId);
     }
 
     private QueryAllShipperInfoVo convertToVo(UserEntity userEntity) {

mhd-user-center/src/main/java/com/mhd/user/application/service/UserDriverApplicationService.java

@@ -44,6 +44,8 @@ import com.mhd.user.domain.roleAggregate.entity.RoleEntity;
 import com.mhd.user.domain.roleAggregate.repository.todo.RoleDo;
 import com.mhd.user.domain.roleAggregate.service.RoleDomainService;
 import com.mhd.user.domain.userAggregate.entity.*;
+import com.mhd.user.domain.userAggregate.repository.mapper.DriverVehicleBindMapper;
+import com.mhd.user.domain.userAggregate.repository.mapper.UserMapper;
 import com.mhd.user.domain.userAggregate.repository.po.*;
 import com.mhd.user.domain.userAggregate.repository.po.UserDriverEnterprisePo;
 import com.mhd.user.domain.userAggregate.repository.po.UserDriverPo;
@@ -178,6 +180,10 @@ public class UserDriverApplicationService {
     private MotorcadeCollectionDomainService motorcadeCollectionDomainService;
     @Resource
     private VehicleBindingStrategyFactory vehicleBindingStrategyFactory;
+    @Autowired
+    private DriverVehicleBindMapper driverVehicleBindMapper;
+    @Autowired
+    private UserMapper userMapper;
 
     /**
      * @Description 承运人列表查询
@@ -323,6 +329,14 @@ public class UserDriverApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         Map<String, Object> result = new HashMap<>();
 
+        // 设置当前登录用户的组织信息
+        UserPo userPo = loginUser.getUserPo();
+        if (userPo != null) {
+            userDriverDO.setOrganizationId(userPo.getOrganizationId());
+            userDriverDO.setOrganizationName(userPo.getOrganizationName());
+            userDriverDO.setTopOrganizationId(userPo.getTopOrganizationId());
+        }
+
         if(userDriverDO.getUserDriverType()==1&&StringUtils.isBlank(userDriverDO.getDepartmentId())){
             throw new ServiceException("请维护司机部门信息");
         }
@@ -345,6 +359,9 @@ public class UserDriverApplicationService {
             throw new ServiceException("用户ID未设置，无法继续司机认证流程");
         }
         
+        // 新增承运人时，使用当前登录账号的用户角色
+        assignLoginUserRolesToDriver(userDriverDO.getUserId(), loginUser);
+
         // 新增的自有司机，默认审核通过
         if (userDriverDO.getUserDriverType().equals(UserDriverConstants.OWN_DIVER)){
             userDriverDO.setDriverFill(UserDriverConstants.AUTH_STATUS_APPROVED);
@@ -580,6 +597,111 @@ public class UserDriverApplicationService {
         }
     }
 
+    /**
+     * 将"个人司机"角色分配给新创建的承运人用户
+     * 优先从当前登录用户的角色中获取"个人司机"角色，如果找不到，再根据组织ID查询
+     * @param driverUserId 承运人用户ID
+     * @param loginUser 当前登录用户
+     */
+    private void assignLoginUserRolesToDriver(Long driverUserId, LoginUser loginUser) {
+        if (driverUserId == null || loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("分配角色失败 - 承运人用户ID或登录用户信息为空");
+            return;
+        }
+        
+        log.info("新增承运人 - 分配个人司机角色，承运人用户ID: {}", driverUserId);
+        
+        Long loginUserId = loginUser.getUserPo().getUserId();
+        Long organizationId = loginUser.getUserPo().getOrganizationId();
+        
+        // 优先从当前登录用户的角色中查找"个人司机"角色
+        List<UserRoleMenuPO> loginUserRoleList = userRoleDomainService.selectRolesByUserId(loginUserId);
+        RoleEntity roleEntity = null;
+        
+        if (CollUtil.isNotEmpty(loginUserRoleList)) {
+            log.info("当前登录用户共有 {} 个角色，查找个人司机角色", loginUserRoleList.size());
+            for (UserRoleMenuPO loginUserRole : loginUserRoleList) {
+                if (RoleEnum.DRIVER.getCode().equals(loginUserRole.getRoleCode())) {
+                    // 找到"个人司机"角色，使用当前登录用户的角色ID
+                    log.info("从当前登录用户的角色中找到个人司机角色 - 角色ID: {}, 角色代码: {}", loginUserRole.getRoleId(), loginUserRole.getRoleCode());
+                    roleEntity = new RoleEntity();
+                    roleEntity.setRoleId(loginUserRole.getRoleId());
+                    roleEntity.setRoleCode(loginUserRole.getRoleCode());
+                    roleEntity.setRoleName(loginUserRole.getRoleName());
+                    break;
+                }
+            }
+        }
+        
+        // 如果当前登录用户没有"个人司机"角色，根据组织ID查询
+        if (ObjectUtil.isNull(roleEntity)) {
+            if (organizationId == null) {
+                log.warn("当前登录用户的组织ID为空，无法查询个人司机角色");
+                return;
+            }
+            
+            log.info("当前登录用户没有个人司机角色，根据组织ID查询 - 组织ID: {}, 角色代码: {}", organizationId, RoleEnum.DRIVER.getCode());
+            
+            // 查询"个人司机"角色
+            RoleDo roleDo = new RoleDo();
+            roleDo.setRoleCode(RoleEnum.DRIVER.getCode());
+            roleDo.setOrganizationId(organizationId);
+            
+            roleEntity = roleDomainService.selectByOrganizationIdAndRoleCode(roleDo);
+            
+            // 如果当前组织查询不到，尝试回退查询（不检查 organization_name IS NOT NULL）
+            if (ObjectUtil.isNull(roleEntity)) {
+                log.warn("使用 organization_name IS NOT NULL 条件查询不到角色，尝试回退查询（不检查 organization_name）- 组织ID: {}, 角色代码: {}", organizationId, RoleEnum.DRIVER.getCode());
+                com.mhd.common.core.domain.po.RolePO rolePO = roleDomainService.selectByRoleCodeAndOrganizationId(RoleEnum.DRIVER.getCode(), organizationId);
+                if (ObjectUtil.isNotNull(rolePO)) {
+                    // 将 RolePO 转换为 RoleEntity
+                    roleEntity = new RoleEntity();
+                    roleEntity.setRoleId(rolePO.getRoleId());
+                    roleEntity.setRoleCode(rolePO.getRoleCode());
+                    roleEntity.setRoleName(rolePO.getRoleName());
+                    roleEntity.setRoleRemark(rolePO.getRoleRemark());
+                    roleEntity.setRoleDataScope(rolePO.getRoleDataScope());
+                    roleEntity.setRoleStatus(rolePO.getRoleStatus());
+                    roleEntity.setRoleType(rolePO.getRoleType());
+                    roleEntity.setOrganizationId(rolePO.getOrganizationId());
+                    roleEntity.setOrganizationName(rolePO.getOrganizationName());
+                    roleEntity.setTopOrganizationId(rolePO.getTopOrganizationId());
+                    log.info("回退查询成功找到角色 - 角色ID: {}, 角色名称: {}, 组织名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName(), roleEntity.getOrganizationName());
+                }
+            }
+            
+            // 如果还是查询不到，尝试使用顶级组织ID查询
+            if (ObjectUtil.isNull(roleEntity)) {
+                Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                if (topOrganizationId != null && topOrganizationId.equals(organizationId)) {
+                    log.info("当前组织查询不到角色，尝试使用顶级组织ID查询 - 顶级组织ID: {}, 角色代码: {}", topOrganizationId, RoleEnum.DRIVER.getCode());
+                    roleDo.setOrganizationId(null);
+                    roleDo.setTopOrganizationId(topOrganizationId);
+                    roleEntity = roleDomainService.selectByOrganizationIdAndRoleCode(roleDo);
+                }
+            }
+        }
+        
+        if (ObjectUtil.isNotNull(roleEntity)) {
+            log.info("找到个人司机角色 - 角色ID: {}, 角色名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName());
+            UserRoleDo userRoleDo = new UserRoleDo();
+            userRoleDo.setUserId(driverUserId);
+            userRoleDo.setRoleId(roleEntity.getRoleId());
+            
+            // 判断是否已存在相应角色
+            List<UserRoleEntity> userRoleEntities = userRoleDomainService.selectList(userRoleDo);
+            if (CollUtil.isEmpty(userRoleEntities)) {
+                userRoleDomainService.addUserRole(userRoleDo);
+                log.info("成功分配个人司机角色给承运人用户 - 角色ID: {}, 角色名称: {}", roleEntity.getRoleId(), roleEntity.getRoleName());
+            } else {
+                log.info("承运人用户已存在个人司机角色，跳过 - 角色ID: {}", roleEntity.getRoleId());
+            }
+        } else {
+            log.warn("未找到个人司机角色 - 组织ID: {}, 角色代码: {}, 请检查该组织下是否配置了该角色", organizationId, RoleEnum.DRIVER.getCode());
+            // 不抛出异常，允许继续执行，因为角色可能在其他地方分配
+        }
+    }
+
     /**
      * 托运人待审核推送
      */
@@ -2754,5 +2876,20 @@ public class UserDriverApplicationService {
 //        }
         return motorcade.getDriverEnterpriseCode();
     }
+
+    public int bindVehicleForHome(UserDriverDO userDriverDO) {
+        DriverVehicleBind driverVehicleBind = new DriverVehicleBind();
+        driverVehicleBind.setUserId(userDriverDO.getUserId());
+        driverVehicleBind.setVehicleId(userDriverDO.getVehicleId());
+        driverVehicleBind.setDefaultFlag(1);
+        driverVehicleBind.setDelFlag(1);
+        driverVehicleBind.setDriverBindId(userDriverDO.getUserId());
+        UserPo userPo = userMapper.selectByUserId(userDriverDO.getUserId());
+        driverVehicleBind.setBindDriverName(userPo.getUserName());
+        driverVehicleBind.setBindDriverPhone(userPo.getUserPhone());
+        //向网货同步添加绑定关系
+//        wlhyDomainService.binding(driverVehicleBind);
+        return driverVehicleBindMapper.insert(driverVehicleBind);
+    }
 }
 

mhd-user-center/src/main/java/com/mhd/user/application/service/UserShipperApplicationService.java

@@ -29,6 +29,7 @@ import com.mhd.system.api.service.webSocket.AsyncWebSocketApplicationService;
 import com.mhd.user.domain.roleAggregate.entity.RoleEntity;
 import com.mhd.user.domain.roleAggregate.repository.todo.RoleDo;
 import com.mhd.user.domain.roleAggregate.service.RoleDomainService;
+import com.mhd.common.core.domain.po.RolePO;
 import com.mhd.user.domain.userAggregate.entity.UserRoleEntity;
 import com.mhd.user.domain.userAggregate.entity.UserShipperEntity;
 import com.mhd.user.domain.userAggregate.event.ShipperEventPublisher;
@@ -118,17 +119,85 @@ public class UserShipperApplicationService {
      */
     @NeedSetValueMethod
     public List<UserShipperPo> userShipperList(UserShipperDO userShipperDO) {
-//        userShipperDO.setTopOrganizationId(SecurityUtils.getLoginUser().getUserPo().getTopOrganizationId());
-        List<UserShipperPo> userShipperList=userShipperDomainService.userShipperList(userShipperDO);
-        for(UserShipperPo userShipperPo:userShipperList){
-            R<TmsShipper> tmsShipper=wlhyServiceFeign.queryBySzwlUserId(userShipperPo.getUserId());
+        // 获取登录人信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("托运人列表查询 - 未获取到登录用户信息，跳过数据权限过滤");
+            List<UserShipperPo> userShipperList = userShipperDomainService.userShipperList(userShipperDO);
+            return processShipperList(userShipperList);
+        }
+        
+        UserPo userPo = loginUser.getUserPo();
+        
+        // 先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = userShipperDO.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，使用前端传递的值进行过滤
+                userShipperDO.setOrganizationId(frontendOrganizationId);
+                userShipperDO.setTopOrganizationId(null);
+                log.info("托运人列表查询 - 南光组织查询指定组织：organizationId={}", frontendOrganizationId);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                userShipperDO.setOrganizationId(null);
+                userShipperDO.setTopOrganizationId(null);
+                log.info("托运人列表查询 - 南光组织查询所有组织：不设置组织过滤条件");
+            }
+        } else {
+            // 其他组织：设置 organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    log.warn("托运人列表查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                        frontendOrganizationId, loginUserOrganizationId);
+                    userShipperDO.setOrganizationId(loginUserOrganizationId);
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    userShipperDO.setOrganizationId(frontendOrganizationId);
+                }
+                if (topOrganizationId != null) {
+                    userShipperDO.setTopOrganizationId(topOrganizationId);
+                }
+            } else {
+                // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                userShipperDO.setOrganizationId(loginUserOrganizationId);
+                if (topOrganizationId != null) {
+                    userShipperDO.setTopOrganizationId(topOrganizationId);
+                }
+            }
+        }
+        
+        log.info("托运人列表查询 - 设置组织ID后，查询参数：organizationId={}, topOrganizationId={}, userId={}",
+            userShipperDO.getOrganizationId(), userShipperDO.getTopOrganizationId(), userShipperDO.getUserId());
+        
+        List<UserShipperPo> userShipperList = userShipperDomainService.userShipperList(userShipperDO);
+        return processShipperList(userShipperList);
+    }
+    
+    /**
+     * 处理托运人列表，填充网货平台数据
+     */
+    private List<UserShipperPo> processShipperList(List<UserShipperPo> userShipperList) {
+        for(UserShipperPo userShipperPo : userShipperList){
+            R<TmsShipper> tmsShipper = wlhyServiceFeign.queryBySzwlUserId(userShipperPo.getUserId());
             if (tmsShipper.getCode() == R.SUCCESS) {
                 if(ObjectUtil.isNotNull(tmsShipper.getData())){
                     userShipperPo.setAuthorizedQuota(tmsShipper.getData().getCreditLine());
                     userShipperPo.setSettlementDay(tmsShipper.getData().getSettlementInterval());
                     userShipperPo.setAuthorizedUsedAmount(tmsShipper.getData().getUsedQuota());
                 }
-
             }
         }
         return userShipperList;
@@ -154,6 +223,13 @@ public class UserShipperApplicationService {
         if (ObjectUtil.isNull(loginUser)) {
             throw new DigitalLogisticsException(UserError.USER_NULL);
         }
+        // 设置当前登录用户的组织信息
+        UserPo userPo = loginUser.getUserPo();
+        if (userPo != null) {
+            userShipperDO.setOrganizationId(userPo.getOrganizationId());
+            userShipperDO.setOrganizationName(userPo.getOrganizationName());
+            userShipperDO.setTopOrganizationId(userPo.getTopOrganizationId());
+        }
 //      2023年5月22日，改动为个人认证和企业认证分开认证，所以此处需要根据前端认证的角色，给不同的字段赋值
         if (userShipperDO.getShipperType() == null) {
             throw new ServiceException("角色类型不能为空");
@@ -652,28 +728,33 @@ public class UserShipperApplicationService {
         String roleCodes = null;
         //实名认证通过此时赋值企业、个人货主角色
         if (userShipperDO.getShipperAuthStatus() == 3) {
-            RoleDo roleDo = new RoleDo();
-            if (userShipperDO.getAuthType() == 1) {
-                roleDo.setRoleCode(RoleEnum.SHIPPER.getCode());
-            } else if (userShipperDO.getAuthType() == 2) {
-                roleDo.setRoleCode(RoleEnum.COMPANY.getCode());
-            } else {
-                throw new ServiceException("角色未找到");
+            // 新增委托方时，使用当前登录账号的用户角色
+            Long loginUserId = loginUser.getUserPo().getUserId();
+            log.info("新增委托方 - 使用当前登录用户的角色，登录用户ID: {}", loginUserId);
+            
+            // 获取当前登录用户的所有角色
+            List<UserRoleMenuPO> loginUserRoleList = userRoleDomainService.selectRolesByUserId(loginUserId);
+            if (CollUtil.isEmpty(loginUserRoleList)) {
+                log.warn("当前登录用户没有角色，登录用户ID: {}", loginUserId);
+                throw new ServiceException("当前登录用户没有角色，无法分配给委托方");
             }
-            roleDo.setOrganizationId(loginUser.getUserPo().getOrganizationId());
-            RoleEntity roleEntity = roleDomainService.selectByOrganizationIdAndRoleCode(roleDo);
-            if (ObjectUtil.isNotNull(roleEntity)) {
+            
+            log.info("当前登录用户共有 {} 个角色", loginUserRoleList.size());
+            
+            // 将当前登录用户的所有角色分配给新创建的委托方用户
+            for (UserRoleMenuPO loginUserRole : loginUserRoleList) {
                 UserRoleDo userRoleDo = new UserRoleDo();
                 userRoleDo.setUserId(userShipperDO.getUserId());
-                userRoleDo.setRoleId(roleEntity.getRoleId());
-//                userApplicationService.assignUserRoles(userRoleDo);
-                //判断是否已存在相应角色
+                userRoleDo.setRoleId(loginUserRole.getRoleId());
+                
+                // 判断是否已存在相应角色
                 List<UserRoleEntity> userRoleEntities = userRoleDomainService.selectList(userRoleDo);
                 if (CollUtil.isEmpty(userRoleEntities)) {
                     userRoleDomainService.addUserRole(userRoleDo);
-                }
+                    log.info("成功分配角色给委托方用户 - 角色ID: {}, 角色代码: {}", loginUserRole.getRoleId(), loginUserRole.getRoleCode());
                 } else {
-                throw new ServiceException("当前组织无相应角色");
+                    log.info("委托方用户已存在该角色，跳过 - 角色ID: {}, 角色代码: {}", loginUserRole.getRoleId(), loginUserRole.getRoleCode());
+                }
             }
             //审核通过后，调用用户开通钱包
             AccountCashWalletDto accountCashWalletDto = new AccountCashWalletDto();
@@ -773,7 +854,59 @@ public class UserShipperApplicationService {
      */
     public Map<String, String> userShipperCount(UserShipperDO userShipperDO) {
         Map<String, String> res = new HashMap<>();
-//        userShipperDO.setTopOrganizationId(SecurityUtils.getLoginUser().getUserPo().getTopOrganizationId());
+        
+        // 获取登录人信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.warn("托运人统计查询 - 未获取到登录用户信息，跳过数据权限过滤");
+        } else {
+            UserPo userPo = loginUser.getUserPo();
+            
+            // 先保存前端传递的 organizationId（如果存在）
+            Long frontendOrganizationId = userShipperDO.getOrganizationId();
+            
+            // 获取当前登录用户的组织信息
+            Long loginUserOrganizationId = userPo.getOrganizationId();
+            Long topOrganizationId = userPo.getTopOrganizationId();
+            
+            // 数据权限：根据 topOrganizationId 来设置查询权限，与其他模块保持一致
+            // topOrganizationId 为 null 时，为顶级组织（南光组织），查所有；其他组织查自己
+            if (topOrganizationId == null) {
+                // 南光组织：可以查询所有组织的数据
+                // 如果前端传递了 organizationId，使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，使用前端传递的值进行过滤
+                    userShipperDO.setOrganizationId(frontendOrganizationId);
+                    userShipperDO.setTopOrganizationId(null);
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    userShipperDO.setOrganizationId(null);
+                    userShipperDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置 organizationId，只查询当前组织的数据
+                // 其他组织只能查询自己组织的数据，不能查询其他组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        log.warn("托运人统计查询 - 前端传递的组织ID {} 与当前登录用户的组织ID {} 不一致，使用当前登录用户的组织ID进行过滤", 
+                            frontendOrganizationId, loginUserOrganizationId);
+                        userShipperDO.setOrganizationId(loginUserOrganizationId);
+                    } else {
+                        // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                        userShipperDO.setOrganizationId(frontendOrganizationId);
+                    }
+                    userShipperDO.setTopOrganizationId(topOrganizationId);
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    userShipperDO.setOrganizationId(loginUserOrganizationId);
+                    userShipperDO.setTopOrganizationId(topOrganizationId);
+                }
+            }
+        }
+        
         //先将所有托运人查询出来，然后再进行
         List<UserShipperPo> userShipperPoList = userShipperDomainService.userShipperAndRoleList(userShipperDO);
         //托运人总数

mhd-user-center/src/main/java/com/mhd/user/domain/motorcade/repository/facade/MotorcadeRepositoryInterface.java

@@ -71,5 +71,5 @@ public interface MotorcadeRepositoryInterface extends IService<Motorcade>
 
     List<MotorcadePo> getAllOtherMotorcade(Long userId);
 
-    List<MotorcadePo> queryNonePagingList(Long organizationId);
+    List<MotorcadePo> queryNonePagingList(Long organizationId, Long topOrganizationId);
 }

mhd-user-center/src/main/java/com/mhd/user/domain/motorcade/repository/mapper/MotorcadeMapper.java

@@ -26,7 +26,7 @@ public interface MotorcadeMapper extends BaseMapper<Motorcade>
      */
     public List<MotorcadePo> queryList(MotorcadeDO motorcadeDo);
 
-    List<MotorcadePo> queryNonePagingList(@Param("organizationId") Long organizationId);
+    List<MotorcadePo> queryNonePagingList(@Param("organizationId") Long organizationId, @Param("topOrganizationId") Long topOrganizationId);
 
     /**
      * 查询我加入的所以车队id

mhd-user-center/src/main/java/com/mhd/user/domain/motorcade/repository/persistence/MotorcadeRepositoryImpl.java

@@ -130,7 +130,7 @@ public class MotorcadeRepositoryImpl extends ServiceImpl<MotorcadeMapper, Motorc
     }
 
     @Override
-    public List<MotorcadePo> queryNonePagingList(Long organizationId) {
-        return motorcadeMapper.queryNonePagingList(organizationId);
+    public List<MotorcadePo> queryNonePagingList(Long organizationId, Long topOrganizationId) {
+        return motorcadeMapper.queryNonePagingList(organizationId, topOrganizationId);
     }
 }

mhd-user-center/src/main/java/com/mhd/user/domain/motorcade/service/MotorcadeDomainService.java

@@ -182,11 +182,7 @@ public class MotorcadeDomainService {
     }
 
 
-    public List<MotorcadePo> queryNonePagingList() {
-        LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null && loginUser.getUserPo() != null &&loginUser.getUserPo().getTopOrganizationId()!= null){
-           return motorcadeInterface.queryNonePagingList(loginUser.getUserPo().getTopOrganizationId());
-        }
-        return Collections.emptyList();
+    public List<MotorcadePo> queryNonePagingList(Long organizationId, Long topOrganizationId) {
+        return motorcadeInterface.queryNonePagingList(organizationId, topOrganizationId);
     }
 }

mhd-user-center/src/main/java/com/mhd/user/domain/roleAggregate/entity/RoleEntity.java

@@ -25,6 +25,10 @@ public class RoleEntity extends BaseVOEntity {
     private Integer roleType;
     @ApiModelProperty(name = "组织表ID")
     private Long organizationId;
+    @ApiModelProperty(name = "组织名称")
+    private String organizationName;
+    @ApiModelProperty(name = "一级组织表ID")
+    private Long topOrganizationId;
     @ApiModelProperty(name = "职务/角色权限字符，控制器中定义的权限字符，如：@PreAuthorize(`@ss.hasRole('admin')`)")
     private String roleCode;
     @ApiModelProperty(name = "职务/角色名称")

mhd-user-center/src/main/java/com/mhd/user/domain/roleAggregate/repository/todo/RoleDo.java

@@ -17,6 +17,10 @@ public class RoleDo extends BaseVOEntity implements Serializable {
     private Long parentRoleId;
     @ApiModelProperty(name = "组织表ID")
     private Long organizationId;
+    @ApiModelProperty(name = "组织名称")
+    private String organizationName;
+    @ApiModelProperty(name = "一级组织表ID")
+    private Long topOrganizationId;
     @ApiModelProperty(name = "角色业务场景数据字典ID")
     private Long roleBusinessExampleId;
     @ApiModelProperty(name = "角色业务场景名称")

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/entity/UserDriverEntity.java

@@ -1,6 +1,7 @@
 package com.mhd.user.domain.userAggregate.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -130,4 +131,22 @@ public class UserDriverEntity extends BaseVOEntity {
 
     @ApiModelProperty(name = "用户身份")
     private Integer userIdentity;
+
+    /**
+     * 一级组织表ID
+     */
+    @ApiModelProperty(name = "一级组织表ID")
+    private Long topOrganizationId;
+
+    /**
+     * 组织表ID
+     */
+    @ApiModelProperty(name = "组织表ID")
+    private Long organizationId;
+
+    /**
+     * 组织名称
+     */
+    @ApiModelProperty(name = "组织名称")
+    private String organizationName;
 }

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/entity/UserShipperEntity.java

@@ -197,4 +197,13 @@ public class UserShipperEntity extends BaseVOEntity {
 
     @ApiModelProperty("结算币种")
     private String settlementCurrency;
+
+    @ApiModelProperty(name = "一级组织表ID")
+    private Long topOrganizationId;
+
+    @ApiModelProperty(name = "组织表ID")
+    private Long organizationId;
+
+    @ApiModelProperty(name = "组织名称")
+    private String organizationName;
 }

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/factory/UserDriverFactory.java

@@ -26,6 +26,14 @@ public class UserDriverFactory {
         String userName = loginUser.getUsername();
         // 获取登录人id
         Long userId = loginUser.getUserid();
+        
+        // 设置组织信息：如果 userDriverDO 中没有设置组织信息，则使用当前登录用户的组织信息
+        if (userDriverEntity.getOrganizationId() == null && loginUser.getUserPo() != null) {
+            userDriverEntity.setOrganizationId(loginUser.getUserPo().getOrganizationId());
+            userDriverEntity.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+            userDriverEntity.setOrganizationName(loginUser.getUserPo().getOrganizationName());
+        }
+        
         if(userDriverDO.getDriverId() != null){
             if(userId != null){
                 userDriverEntity.setUpdateBy(userId);
@@ -55,6 +63,8 @@ public class UserDriverFactory {
         UserDriverEntity userDriverEntity = new UserDriverEntity();
         BeanUtils.copyProperties(userDriverDO,userDriverEntity, IgnoreNullUtil.getNullPropertyNames(userDriverDO));
         
+        // 设置组织信息：从 userDriverDO 中复制，如果为空则保持null（开放接口可能由外部系统设置）
+
         if(userDriverDO.getDriverId() != null){
             userDriverEntity.setUpdateBy(new Long("0"));
             userDriverEntity.setUpdateTime(new Date());

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/repository/facade/UserRepositoryInterface.java

@@ -69,7 +69,7 @@ public interface UserRepositoryInterface extends IService<UserEntity> {
 
     UserEntity selectByTopOrganizationId(Long organizationId);
 
-    List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long topOrganizationId);
+    List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long organizationId);
 
 
     String finShipperEnterpriseNamedByUserId(Long userId);

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/repository/mapper/UserMapper.java

@@ -68,7 +68,7 @@ public interface UserMapper extends BaseMapper<UserEntity> {
     UserEntity selectByTopOrganizationId(@Param("organizationId") Long organizationId);
 
 
-    List<QueryAllShipperInfoVo> findAllShipperInfo(@Param("userId") Long userId, @Param("topOrganizationId") Long topOrganizationId);
+    List<QueryAllShipperInfoVo> findAllShipperInfo(@Param("userId") Long userId, @Param("organizationId") Long organizationId);
 
 
     String finShipperEnterpriseNamedByUserId(@Param("userId") Long userId);

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/repository/persistence/UserRepositoryImpl.java

@@ -160,8 +160,8 @@ public class UserRepositoryImpl extends ServiceImpl<UserMapper,UserEntity> imple
     }
 
     @Override
-    public List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long topOrganizationId) {
-        return userMapper.findAllShipperInfo(userId,topOrganizationId);
+    public List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long organizationId) {
+        return userMapper.findAllShipperInfo(userId, organizationId);
     }
 
     @Override

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/repository/po/UserShipperPo.java

@@ -100,8 +100,12 @@ public class UserShipperPo implements Serializable {
     @ApiModelProperty(name = "营业执照照片")
     private String shipperEnterpriseLicenseFrontUrl = "";
 
+    @ApiModelProperty(name = "组织表ID")
+    private Long organizationId;
     @ApiModelProperty(name = "组织名称")
-    private String organizationName = "";
+    private String organizationName;
+//    @ApiModelProperty(name = '一级组织表ID')
+    private Long topOrganizationId;
     @ApiModelProperty(name = "创建者姓名")
     private String createByName = "";
 

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/service/UserDomainService.java

@@ -246,8 +246,8 @@ public class UserDomainService {
         return userRepositoryInterface.selectByTopOrganizationId(organizationId);
     }
 
-    public List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long topOrganizationId) {
-        return userRepositoryInterface.findAllShipperInfo(userId,topOrganizationId);
+    public List<QueryAllShipperInfoVo> findAllShipperInfo(Long userId, Long organizationId) {
+        return userRepositoryInterface.findAllShipperInfo(userId, organizationId);
     }
 
     public String findUserNameByUserId(Long userId){

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/service/UserDriverDomainService.java

@@ -92,13 +92,71 @@ public class UserDriverDomainService {
      */
 //    @DataPermissions(cacheName = "master")
     public List<UserDriverListPo> userDriverList(UserDriverDO userDriverDO) {
+        // 首先保存前端传递的 organizationId（如果存在）
+        Long frontendOrganizationId = userDriverDO.getOrganizationId();
+        
         //获取当前登陆人
         LoginUser loginUser = SecurityUtils.getLoginUser();
+        Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+        Long loginUserOrganizationId = loginUser.getUserPo().getOrganizationId();
+        
         if (loginUser.getUserPo().getBusinessType() == 2){
             userDriverDO.setCreateBy(loginUser.getUserPo().getUserId());
+            // 当 businessType == 2 时，如果前端没有传递 organizationId，清空组织过滤条件
+            if (frontendOrganizationId == null) {
                 userDriverDO.setOrganizationId(null);
             }
-        userDriverDO.setTopOrganizationId(loginUser.getUserPo().getOrganizationId());
+        }
+        
+        // 数据权限：查询权限根据 organizationId 来设置
+        // 当 organizationId 是 2827 时查询全部，其他仅查询各自组织的信息
+        if (loginUserOrganizationId != null && loginUserOrganizationId.equals(2827L)) {
+            // 南光组织（organizationId=2827）：可以查询所有组织的数据
+            // 如果前端传递了 organizationId，使用前端传递的值进行过滤（包括2827）
+            // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，使用前端传递的值进行过滤
+                userDriverDO.setOrganizationId(frontendOrganizationId);
+                userDriverDO.setTopOrganizationId(null);
+            } else {
+                // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                userDriverDO.setOrganizationId(null);
+                userDriverDO.setTopOrganizationId(null);
+            }
+        } else {
+            // 其他组织：设置organizationId，只查询当前组织的数据
+            // 其他组织只能查询自己组织的数据，不能查询其他组织（包括南光）的数据
+            // 如果其他组织尝试查询南光（organizationId=2827）的数据，返回空数据
+            if (frontendOrganizationId != null) {
+                // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId.equals(2827L)) {
+                    // 其他组织尝试查询南光的数据，设置一个不存在的 organizationId，返回空数据
+                    userDriverDO.setOrganizationId(-1L);
+                    userDriverDO.setTopOrganizationId(null);
+                } else if (!frontendOrganizationId.equals(loginUserOrganizationId)) {
+                    // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                    userDriverDO.setOrganizationId(loginUserOrganizationId);
+                    if (topOrganizationId != null) {
+                        userDriverDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                    userDriverDO.setOrganizationId(frontendOrganizationId);
+                    if (topOrganizationId != null) {
+                        userDriverDO.setTopOrganizationId(topOrganizationId);
+                    }
+                }
+            } else {
+                // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                if (loginUserOrganizationId != null) {
+                    userDriverDO.setOrganizationId(loginUserOrganizationId);
+                }
+                if (topOrganizationId != null) {
+                    userDriverDO.setTopOrganizationId(topOrganizationId);
+                }
+            }
+        }
+        
         return userDriverRepositoryInterface.userDriverList(userDriverDO);
     }
 

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/service/UserShipperDomainService.java

@@ -49,10 +49,19 @@ public class UserShipperDomainService {
 
 //    @DataPermissions(cacheName = "master")
     public List<UserShipperPo> userShipperList(UserShipperDO userShipperDO) {
+        // 数据权限逻辑已在 UserShipperApplicationService.userShipperList 中处理
+        // 这里不再重复处理数据权限，直接使用传入的参数进行查询
+        
         //获取当前登陆人
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        userShipperDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
-        if(loginUser.getUserPo().getBusinessType()==1||loginUser.getUserPo().getBusinessType()==3||loginUser.getUserPo().getUserAccountType()==5){
+        // 如果 organizationId 和 topOrganizationId 都为 null，表示查询所有组织的数据（南光组织查询全部）
+        // 此时不应该设置 userId 过滤条件，否则会限制查询结果
+        boolean isQueryAllOrganizations = (userShipperDO.getOrganizationId() == null && userShipperDO.getTopOrganizationId() == null);
+        
+        if(loginUser != null && loginUser.getUserPo() != null && 
+           (loginUser.getUserPo().getBusinessType()==1||loginUser.getUserPo().getBusinessType()==3||loginUser.getUserPo().getUserAccountType()==5) &&
+           !isQueryAllOrganizations) {
+            // 只有在不是查询所有组织的情况下，才设置 userId 过滤条件
             userShipperDO.setUserId(loginUser.getUserid());
         }
         return userShipperRepositoryInterface.selectList(userShipperDO);

mhd-user-center/src/main/java/com/mhd/user/domain/userAggregate/service/UserWlhyDomainService.java

@@ -278,9 +278,17 @@ public class UserWlhyDomainService {
         tmsShipperDTO.setIdCardEndDate(idCardEndDate);
         Date idCardStartDate = DateUtil.parse(userPo.getUserIdcardDateFrom());
         tmsShipperDTO.setIdCardStartDate(idCardStartDate);
+        // 优先使用 userShipperEntity 对象中保存的组织信息，确保与数据库中的组织ID一致
+        // 如果 userShipperEntity 中没有组织信息，则使用当前登录用户的组织信息作为后备
+        if (userShipperEntity.getOrganizationId() != null) {
+            tmsShipperDTO.setOrganizationId(userShipperEntity.getOrganizationId());
+            tmsShipperDTO.setOrganizationName(userShipperEntity.getOrganizationName());
+            tmsShipperDTO.setTopOrganizationId(userShipperEntity.getTopOrganizationId());
+        } else if (loginUser.getUserPo() != null) {
             tmsShipperDTO.setOrganizationId(loginUser.getUserPo().getOrganizationId());
             tmsShipperDTO.setOrganizationName(loginUser.getUserPo().getOrganizationName());
             tmsShipperDTO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+        }
         tmsShipperDTO.setCompanyName(userShipperEntity.getShipperEnterpriseName());
         return tmsShipperDTO;
     }
@@ -640,9 +648,17 @@ public class UserWlhyDomainService {
         TmsDriverAddOrUpdateDTO tmsDriverAddOrUpdateDTO = new TmsDriverAddOrUpdateDTO();
         tmsDriverAddOrUpdateDTO.setAddress(userPo.getUserAreaAddress());
         tmsDriverAddOrUpdateDTO.setRegisteredAddress(userPo.getUserAreaAddress());
+        // 优先使用 userDriverDO 对象中保存的组织信息，确保与数据库中的组织ID一致
+        // 如果 userDriverDO 中没有组织信息，则使用 userPo 中的组织信息作为后备
+        if (userDriverDO.getOrganizationId() != null) {
+            tmsDriverAddOrUpdateDTO.setTopOrganizationId(userDriverDO.getTopOrganizationId());
+            tmsDriverAddOrUpdateDTO.setOrganizationId(userDriverDO.getOrganizationId());
+            tmsDriverAddOrUpdateDTO.setOrganizationName(userDriverDO.getOrganizationName());
+        } else if (userPo != null) {
             tmsDriverAddOrUpdateDTO.setTopOrganizationId(userPo.getTopOrganizationId());
             tmsDriverAddOrUpdateDTO.setOrganizationId(userPo.getOrganizationId());
             tmsDriverAddOrUpdateDTO.setOrganizationName(userPo.getOrganizationName());
+        }
         tmsDriverAddOrUpdateDTO.setSzwlUserId(userDriverDO.getUserId());
         Integer type = userDriverDO.getDriverType() != 1 ? 1 :  0;
         tmsDriverAddOrUpdateDTO.setType(type);

mhd-user-center/src/main/java/com/mhd/user/interfaces/facade/UserDriverAPI.java

@@ -129,7 +129,20 @@ public class UserDriverAPI extends BaseController {
         UserDriverDO userDriverDO = userDriverAssember.toUserDriverDO(userDriverDTO);
         return toAjax(userDriverApplicationService.bindVehicle(userDriverDO));
     }
+    @Log(title = "承运人管理-绑定车辆", description ="绑定车辆",businessType = BusinessType.UPDATE)
+    @ApiOperation("绑定车辆")
+    @PostMapping("/bindVehicleForHome")
+    public AjaxResult bindVehicleForHome(@RequestBody UserDriverDTO userDriverDTO){
+        UserDriverDO userDriverDO = userDriverAssember.toUserDriverDO(userDriverDTO);
+        return toAjax(userDriverApplicationService.bindVehicleForHome(userDriverDO));
+    }
 
+    @ApiOperation("删除司机绑定关系")
+    @PostMapping("/driverVehicleBindApi/delectDriverBind")
+    public AjaxResult delectDriverBind(@RequestBody UserDriverDTO userDriverDTO) {
+        return toAjax(driverVehicleBindApplicationService.delectDriverBind(userDriverDTO));
+
+    }
     @Log(title = "承运人管理-个体承运人新增绑定车辆", description ="个体承运人新增绑定车辆",businessType = BusinessType.UPDATE)
     @ApiOperation("个体承运人新增绑定车辆")
     @PostMapping("/bindVehicle1")

mhd-user-center/src/main/java/com/mhd/user/interfaces/vo/QueryAllShipperInfoVo.java

@@ -64,4 +64,12 @@ public class QueryAllShipperInfoVo {
 
     @ApiModelProperty(name = "客户nc编码")
     private String customerNcCode;
+
+    @ApiModelProperty(name = "组织ID")
+    private Long organizationId;
+
+    @ApiModelProperty(name = "一级组织ID")
+    private Long topOrganizationId;
+    @ApiModelProperty("结算币种")
+    private String settlementCurrency;
 }

mhd-user-center/src/main/resources/bootstrap.yml

@@ -20,15 +20,19 @@ spring:
       discovery:
 #        server-addr: 127.0.0.1:8848
         # 线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+#        server-addr: 10.33.0.129:6010
         #线上正式环境
-#        server-addr: 10.102.192.105:6848
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
       config:
 #        server-addr: 127.0.0.1:8848
         # 线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+#        server-addr: 10.33.0.129:6010
         #线上正式环境
-#        server-addr: 10.102.192.105:6848
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
         group: DEFAULT_GROUP  # 默认分组就是DEFAULT_GROUP，如果使用默认分组可以不配置
         file-extension: yml   #默认properties
         # 共享配置

mhd-user-center/src/main/resources/mapper/MotorcadeMapper.xml

@@ -209,8 +209,19 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="organizationName != null  and organizationName != ''">
                 and m.organization_name like concat('%', #{organizationName}, '%')
             </if>
-            <if test="topOrganizationId != null and topOrganizationId != ''">
-                and top_organization_id = #{topOrganizationId}
+            <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+            <if test="organizationId != null">
+                <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
+                and m.organization_id = #{organizationId}
+                and m.organization_name IS NOT NULL
+            </if>
+            <if test="topOrganizationId != null">
+                <!-- 如果设置了 topOrganizationId，添加 top_organization_id 条件 -->
+                and m.top_organization_id = #{topOrganizationId}
+                <if test="organizationId == null">
+                    <!-- 如果没有设置 organizationId，添加 organization_name IS NOT NULL 条件 -->
+                    and m.organization_name IS NOT NULL
+                </if>
             </if>
             <if test="organizationIdList != null ">
                 AND m.organization_id in
@@ -377,7 +388,23 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                 LEFT JOIN
             motorcade_driver d
             ON m.motorcade_id = d.motorcade_id and d.del_flag = 1
-        where top_organization_id = #{organizationId} and m.del_flag = 1
+        <where>
+            m.del_flag = 1
+            <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+            <if test="organizationId != null">
+                <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
+                and m.organization_id = #{organizationId}
+                and m.organization_name IS NOT NULL
+            </if>
+            <if test="topOrganizationId != null">
+                <!-- 如果设置了 topOrganizationId，添加 top_organization_id 条件 -->
+                and m.top_organization_id = #{topOrganizationId}
+                <if test="organizationId == null">
+                    <!-- 如果没有设置 organizationId，添加 organization_name IS NOT NULL 条件 -->
+                    and m.organization_name IS NOT NULL
+                </if>
+            </if>
+        </where>
     </select>
 
 </mapper>

mhd-user-center/src/main/resources/mapper/RoleMapper.xml

@@ -25,6 +25,8 @@
         a.role_id,
         a.parent_role_id,
         a.organization_id,
+        a.organization_name AS organizationName,
+        a.top_organization_id AS topOrganizationId,
         a.role_code,
         a.role_name,
         a.role_remark,
@@ -51,6 +53,7 @@
         a.del_flag = 1
         <include refid="common_where"></include>
         GROUP BY a.role_id
+        ORDER BY COALESCE(a.update_time, a.create_time) DESC
     </select>
     <select id="selectByOrganizationIdAndRoleCode"
             parameterType="com.mhd.user.domain.roleAggregate.repository.todo.RoleDo"
@@ -119,6 +122,16 @@
         </if>
         <if test="organizationId !=null">
             and a.organization_id = #{organizationId}
+            and a.organization_name IS NOT NULL
+        </if>
+        <if test="topOrganizationId !=null">
+            and a.top_organization_id = #{topOrganizationId}
+            <if test="organizationId == null">
+                and a.organization_name IS NOT NULL
+            </if>
+        </if>
+        <if test="organizationName != null  and organizationName != ''">
+            and a.organization_name like concat('%' , #{organizationName} , '%')
         </if>
         <if test="organizationIds !=null">
             and a.organization_id in

mhd-user-center/src/main/resources/mapper/UserDriverMapper.xml

@@ -703,7 +703,10 @@
 <!--            </foreach>-->
 <!--        </if>-->
 
-        <if test="userDriverDO.organizationId != null"> and b.organization_id = #{userDriverDO.organizationId}</if>
+        <if test="userDriverDO.organizationId != null"> 
+            and b.organization_id = #{userDriverDO.organizationId}
+            and b.organization_name IS NOT NULL
+        </if>
         <if test="userDriverDO.createBy != null">
             and (b.create_by = #{userDriverDO.createBy}
             or b.user_id = #{userDriverDO.createBy}

mhd-user-center/src/main/resources/mapper/UserMapper.xml

@@ -217,11 +217,19 @@
             and a.user_id = #{userId}
         </if>
 
-        <if test="organizationId !=null">
+        <!-- 数据权限：南光组织（organizationId=2827）查全部，其他组织查自己 -->
+        <if test="organizationId != null">
+            <!-- 如果设置了 organizationId，添加 organization_id 条件 -->
             and a.organization_id = #{organizationId}
+            and a.organization_name IS NOT NULL
         </if>
-        <if test="topOrganizationId !=null">
+        <if test="topOrganizationId != null">
+            <!-- 如果设置了 topOrganizationId，添加 top_organization_id 条件 -->
             and a.top_organization_id = #{topOrganizationId}
+            <if test="organizationId == null">
+                <!-- 如果没有设置 organizationId，添加 organization_name IS NOT NULL 条件 -->
+                and a.organization_name IS NOT NULL
+            </if>
         </if>
         /*组织名称*/
         <if test="organizationName != null  and organizationName != ''">
@@ -708,7 +716,8 @@
     </select>
 
     <select id="findAllShipperInfo" resultType="com.mhd.user.interfaces.vo.QueryAllShipperInfoVo">
-        SELECT u.user_id, u.user_name, u.user_area_address, u.user_area_county_id, u.user_area_name ,u.user_phone,u.has_default_address,b.shipper_id,b.shipper_enterprise_name,u.DOCUMENT_PREPARER_NC_CODE,b.CUSTOMER_NC_CODE
+        SELECT u.user_id, u.user_name, u.user_area_address, u.user_area_county_id, u.user_area_name ,u.user_phone,u.has_default_address,b.shipper_id,b.shipper_enterprise_name,u.DOCUMENT_PREPARER_NC_CODE,b.CUSTOMER_NC_CODE,u.organization_id AS organizationId,u.top_organization_id AS topOrganizationId,
+        b.settlement_currency AS settlementCurrency
         FROM "USER" u
                  LEFT JOIN user_shipper b ON u.user_id = b.user_id
                  left join (select user_id, LISTAGG(r.role_name, '&amp;') WITHIN GROUP(ORDER BY r.role_name) AS roleName
@@ -723,11 +732,12 @@
         <if test="userId !=null">
             AND u.user_Id = #{userId}
         </if>
-        /*一级组织ID*/
-        <if test="topOrganizationId !=null">
-            AND u.top_organization_id = #{topOrganizationId}
+        /*组织ID - 数据隔离：南光组织（organizationId=2827）查询全部，其他组织查询自己组织的数据*/
+        <if test="organizationId !=null">
+            AND u.organization_id = #{organizationId}
+            AND u.organization_name IS NOT NULL
         </if>
-        GROUP BY u.user_id
+        GROUP BY u.user_id, u.user_name, u.user_area_address, u.user_area_county_id, u.user_area_name, u.user_phone, u.has_default_address, b.shipper_id, b.shipper_enterprise_name, u.DOCUMENT_PREPARER_NC_CODE, b.CUSTOMER_NC_CODE, u.organization_id, u.top_organization_id, b.settlement_currency
     </select>
     <select id="finShipperEnterpriseNamedByUserId" resultType="string">
         SELECT

mhd-user-center/src/main/resources/mapper/UserShipperMapper.xml

@@ -114,7 +114,8 @@
                b.shipper_enterprisel_auth_id,
                a.user_phone,
                a.user_name,
-               a.organization_name,
+               a.organization_id AS organizationId,
+               a.organization_name AS organizationName,
                a.user_account,
                a.user_member_code,
                a.user_idcard_number,

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();
+        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){
-            businessDocumentDO.setTopOrganizationId(userPo.getTopOrganizationId());
-        }else {
-            businessDocumentDO.setOrganizationId(userPo.getOrganizationId());
+                // 租户管理员：使用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);
     }
@@ -1285,12 +1326,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 +1380,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 +1398,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 +1416,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 +1446,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 +1493,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 +1572,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());

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());
 
-        // 先删除所有现有数据
-        int deleteCount = receivingAccountRepository.deleteAll();
-        log.info("已删除现有收款账户数量：{}", deleteCount);
+        // 获取当前登录用户信息
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUserPo() == null) {
+            log.error("批量新增收款账户失败：未获取到登录用户信息");
+            throw new RuntimeException("未获取到登录用户信息");
+        }
+        
+        // 获取当前登录用户的组织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

@@ -1,12 +1,12 @@
 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.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 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;
@@ -15,7 +15,6 @@ import com.linke.finance.domain.reconciliation.repository.todo.ReconciliationDO;
 import com.linke.finance.domain.reconciliation.service.ReconciliationDomainService;
 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;
@@ -24,6 +23,7 @@ import com.linke.finance.infrastructure.feign.ProductServiceFeign;
 import com.linke.finance.infrastructure.feign.WlhyServiceFeign;
 import com.mhd.common.core.constant.SubjectConstants;
 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 +32,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 +40,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 +47,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;
 
 /**
@@ -85,18 +84,68 @@ public class ReconciliationApplicationService {
     public List<ReconciliationPO> queryList(ReconciliationDO reconciliationDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         UserPo userPo = loginUser.getUserPo();
+
+        // 先保存前端传递的 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 {
+            // 其他组织：设置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(userPo.getTopOrganizationId());
+                    reconciliationDO.setTopOrganizationId(topOrganizationId);
                 } else if (userPo.getUserAccountType() == 2){
-            reconciliationDO.setOrganizationId(userPo.getOrganizationId());
+                    reconciliationDO.setOrganizationId(loginUserOrganizationId);
                 } else {
                     if (loginUser.getRoleList().contains(RoleEnum.SHIPPER.getCode()) || loginUser.getRoleList().contains(RoleEnum.COMPANY.getCode())){
                         reconciliationDO.setUserId(userPo.getUserId());
                     }else {
-                reconciliationDO.setOrganizationId(userPo.getOrganizationId());
+                        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 +159,25 @@ 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());
+                    }
+                }
+            }
+        }
+
         return reconciliationPOS;
     }
 

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,15 +56,92 @@ 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);
+                }
+            }
+        }
+        
+        // 调试日志：打印设置的查询条件
+        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;
+    }
+
 
     /**
      * 新增收款单

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/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

@@ -49,11 +49,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,7 +96,11 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
     private ApprovalDocumentMapper approvalDocumentMapper;
     @Autowired
     private ApprovalDocumentDomainService approvalDocumentDomainService;
+    //nc测试环境地址
     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";
     /**
      * 查询对账单列表
      */
@@ -389,21 +400,6 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
         LoginUser loginUser= SecurityUtils.getLoginUser();
         UserPo userPo=loginUser.getUserPo();
         ObjectMapper mapper = new ObjectMapper();
-        AjaxResult ajaxResult5=userServiceFeign.getInfo(loginUser.getUserid());
-        if(ajaxResult5.get("code").toString().equals("200")){
-            Object userShipperPo= ajaxResult5.get("data");
-            JSONObject jsonObject = new JSONObject((Map) userShipperPo);
-
-            try {
-                String jsonString = mapper.writeValueAsString(jsonObject);
-                userPo = mapper.readValue(jsonString, UserPo.class);
-            } catch (JsonProcessingException e) {
-                e.printStackTrace();
-            }
-
-        }else{
-            throw new ServiceException("查询当前登录人用户信息失败");
-        }
         for (String businessDocumentDetaliId:businessDocumentDetaliIdArray){
             Reconciliation reconciliation=reconciliationMapper.selectById(businessDocumentDetaliId);
             if(reconciliation.getSynchronousStatus()==1){
@@ -426,6 +422,7 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                 reconciliationDTO.setInnerNumber(reconciliation.getInnerNumber());
                 R<List<TmsOrder>> result=wlhyServiceFeign.getOrderListByReconciliation(reconciliationDTO);
                 String makerCodeNc="";
+                if(reconciliation.getOrganizationName().contains("南歧")){
                     if(result.getCode()==200){
                         List<TmsOrder> list=result.getData();
                         if(ObjectUtil.isNotNull(list)){
@@ -435,15 +432,18 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                                     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("运单还没签收， 先签收");
                                     }
                                 }
-                            if(null==reconciliation.getSettlementPartyId()){
+                         /*   if(null==reconciliation.getSettlementPartyId()){
                                 throw new ServiceException("没有结算方，请核对");
-                            }
-                            if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getSalesmanCodeNc())) {
+                            }*/
+                       /*     if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getSalesmanCodeNc())) {
                                 throw new ServiceException("请先维护业务员编码");
                             }
                             if (org.apache.commons.lang.StringUtils.isBlank(tmsOrder.getMakerCodeNc())) {
@@ -451,13 +451,13 @@ 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.getCustomsCodeNc());
+                                item.setCustomer(tmsOrder.getCustomerCodeNc());
                                 item.setObjtype("0");
                                 item.setDirection("1");
                                 item.setScomment(tmsOrder.getAppointShipper());
@@ -468,7 +468,7 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                                 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()).setScale(2,BigDecimal.ROUND_HALF_UP);
+                                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));
@@ -542,7 +542,7 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                             reconciliation.setSynchronousStatus(1);
                             reconciliation.setSynchronousTime(new Date());
                             reconciliation.setNcId("ys"+String.valueOf(reconciliation.getReconciliationId()));
-                        reconciliationMapper.updateById(reconciliation);
+                            //reconciliationMapper.updateById(reconciliation);
                             CloseableHttpClient httpClient = HttpClients.createDefault();
                             HttpPost httpPost = new HttpPost(url);
                             StringEntity postingString = new StringEntity(xmlString, "UTF-8");
@@ -552,6 +552,42 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                                 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();
@@ -564,8 +600,190 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                             }
                         }
                     }
+                }else 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)){
+                                        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("未查询到关联运单， 请核对");
+                                    }
 
+                                }
+                         /*   if(null==reconciliation.getSettlementPartyId()){
+                                throw new ServiceException("没有结算方，请核对");
+                            }*/
+                       /*     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.getCustomsCodeNc())) {
+                                throw new ServiceException("请先维护制单员编码");
+                            }*/
+                                makerCodeNc=tmsOrder.getMakerCodeNc();
+                                Ysitem item=new Ysitem();
+                                item.setSo_deptid("NG0408");
+                                item.setPk_deptid("NG0408");
+                                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("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("");
+                            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();
+                                }
+                            }
+                        }
+                    }
+                }
             } catch (JAXBException e) {
                 e.printStackTrace();
             }
@@ -578,28 +796,6 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
         String [] businessDocumentDetaliIdArray=businessDocumentDetaliIds.split(",");
         LoginUser loginUser= SecurityUtils.getLoginUser();
         UserPo userPo=loginUser.getUserPo();
-        ObjectMapper mapper = new ObjectMapper();
-        AjaxResult ajaxResult5=userServiceFeign.getInfo(loginUser.getUserid());
-        if(ajaxResult5.get("code").toString().equals("200")){
-            Object userShipperPo= ajaxResult5.get("data");
-            JSONObject jsonObject = new JSONObject((Map) userShipperPo);
-
-            try {
-                String jsonString = mapper.writeValueAsString(jsonObject);
-                userPo = mapper.readValue(jsonString, UserPo.class);
-            } catch (JsonProcessingException e) {
-                e.printStackTrace();
-            }
-
-        }else{
-            throw new ServiceException("查询当前登录人用户信息失败");
-        }
-        if (org.apache.commons.lang.StringUtils.isBlank(userPo.getSalespersonNcCode())) {
-            throw new ServiceException("请先维护业务员编码");
-        }
-        if (org.apache.commons.lang.StringUtils.isBlank(userPo.getDocumentPreparerNcCode())) {
-            throw new ServiceException("请先维护制单员编码");
-        }
         for (String businessDocumentDetaliId:businessDocumentDetaliIdArray){
             Reconciliation reconciliation=reconciliationMapper.selectById(businessDocumentDetaliId);
             if(reconciliation.getSkSynchronousStatus()==1){
@@ -621,32 +817,25 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                 List<SKitem> ysitemList=new ArrayList<SKitem>();
                 ReconciliationDTO  reconciliationDTO=new ReconciliationDTO();
                 reconciliationDTO.setInnerNumber(reconciliation.getInnerNumber());
-                if(null==reconciliation.getSettlementPartyId()){
+              /*  if(null==reconciliation.getSettlementPartyId()){
                     throw new ServiceException("没有结算方，请核对");
-                }
+                }*/
                 String makerCodeNc="";
+                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){
-                            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.getCustomsCodeNc())) {
-                                throw new ServiceException("请先维护制单员编码");
-                            }
-
 
+                                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.getCustomsCodeNc());
+                                item.setCustomer(tmsOrder.getCustomerCodeNc());
                                 item.setPurchaseorder(tmsOrder.getGoodsNumber());
                                 item.setObjtype("0");
                                 item.setDirection("1");
@@ -731,7 +920,7 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                     reconciliation.setSkSynchronousStatus(1);
                     reconciliation.setSkSynchronousTime(new Date());
                     reconciliation.setSkNcId("sk"+String.valueOf(reconciliation.getReconciliationId()));
-                reconciliationMapper.updateById(reconciliation);
+                    //reconciliationMapper.updateById(reconciliation);
                     CloseableHttpClient httpClient = HttpClients.createDefault();
                     HttpPost httpPost = new HttpPost(url);
                     StringEntity postingString = new StringEntity(xmlString, "UTF-8");
@@ -741,6 +930,42 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                         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();
@@ -751,6 +976,163 @@ public class ReconciliationImpl extends ServiceImpl<ReconciliationMapper, Reconc
                             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) {
                 e.printStackTrace();
             }

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 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/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 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;
+
+    @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;

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.linke.finance.interfaces.dto.reconciliationAccount.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/dto/reconciliationAccount/ReconciliationAccountDTO.java

@@ -0,0 +1,77 @@
+package com.linke.finance.interfaces.dto.reconciliationAccount;
+
+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 ReconciliationAccountDTO 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;
+
+
+    @ApiModelProperty(name = "组织ID集合")
+    private List<Long> organizationIdList;
+
+    @ApiModelProperty(name = "权限菜单ID")
+    private Long permissionMenuId;
+}

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

@@ -272,7 +272,12 @@ public class ReconciliationApi extends BaseController{
     @GetMapping(value = "/synchronousNc")
     public AjaxResult synchronousNc(@RequestParam(name="reconciliationId") String reconciliationId)
     {
-        return AjaxResult.success(reconciliationApplicationService.synchronousNc(reconciliationId));
+        try{
+            return AjaxResult.success(reconciliationApplicationService.synchronousNc(reconciliationId));}
+        catch (Exception e){
+            e.printStackTrace();
+            return AjaxResult.error(e.getMessage());
+        }
     }
 
     /**
@@ -283,7 +288,13 @@ public class ReconciliationApi extends BaseController{
     @GetMapping(value = "/synchronousNcSK")
     public AjaxResult synchronousNcSK(@RequestParam(name="reconciliationId") String reconciliationId)
     {
+        try{
             return AjaxResult.success(reconciliationApplicationService.synchronousNcSK(reconciliationId));
+        } catch (Exception e){
+            e.printStackTrace();
+            return AjaxResult.error(e.getMessage());
+        }
+
     }
 
 }

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 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.interfaces.dto.reconciliationAccount.ReconciliationAccountDTO;
+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));

mhd_finance/src/main/resources/bootstrap.yml

@@ -20,14 +20,18 @@ spring:
       discovery:
 #        server-addr: 127.0.0.1:8848
         # 线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
         #线上正式环境
 #        server-addr: 10.102.192.105:6848
       config:
 #        server-addr: 127.0.0.1:8848
 #        server-addr: 116.204.23.92:8848
 #         线上测试环境配置 容器名+端口号
-        server-addr: 10.33.0.129:6010
+        server-addr: 10.102.192.5:6848
+        username: nacos
+        password: manhuoda@2023
         #线上正式环境
 #        server-addr: 10.102.192.105:6848
         group: DEFAULT_GROUP  # 默认分组就是DEFAULT_GROUP，如果使用默认分组可以不配置

mhd_finance/src/main/resources/mapper/receivingAccount/ReceivingAccountMapper.xml

@@ -11,10 +11,12 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         <result property="delFlag"    column="del_flag"    />
         <result property="createTime"    column="create_time"    />
         <result property="updateTime"    column="update_time"    />
+        <result property="topOrganizationId"    column="top_organization_id"    />
+        <result property="organizationId"    column="organization_id"    />
     </resultMap>
 
     <sql id="selectReceivingAccountPo">
-        select id, account_name, account_information, del_flag, create_time, update_time 
+        select id, account_name, account_information, del_flag, create_time, update_time, top_organization_id, organization_id 
         from receiving_account
     </sql>
 
@@ -30,6 +32,12 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="accountInformation != null and accountInformation != ''">
                 and account_information like concat('%', #{accountInformation}, '%')
             </if>
+            <if test="topOrganizationId != null and topOrganizationId != ''">
+                and top_organization_id = #{topOrganizationId}
+            </if>
+            <if test="organizationId != null and organizationId != ''">
+                and organization_id = #{organizationId}
+            </if>
             order by create_time desc
         </where>
     </sql>
@@ -47,6 +55,8 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="delFlag != null">del_flag,</if>
             <if test="createTime != null">create_time,</if>
             <if test="updateTime != null">update_time,</if>
+            <if test="topOrganizationId != null and topOrganizationId != ''">top_organization_id,</if>
+            <if test="organizationId != null and organizationId != ''">organization_id,</if>
         </trim>
         <trim prefix="values (" suffix=")" suffixOverrides=",">
             <if test="accountName != null and accountName != ''">#{accountName},</if>
@@ -54,6 +64,8 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="delFlag != null">#{delFlag},</if>
             <if test="createTime != null">#{createTime},</if>
             <if test="updateTime != null">#{updateTime},</if>
+            <if test="topOrganizationId != null and topOrganizationId != ''">#{topOrganizationId},</if>
+            <if test="organizationId != null and organizationId != ''">#{organizationId},</if>
         </trim>
     </insert>
 
@@ -84,4 +96,20 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             update_time = now()
         where del_flag = 1
     </update>
+
+    <update id="deleteByOrganization">
+        update receiving_account
+        set del_flag = 2,
+            update_time = now()
+        where del_flag = 1
+        <!-- 必须匹配 organizationId，确保只删除当前登录用户组织的数据 -->
+        <!-- 只根据 organizationId 来删除，不使用 topOrganizationId -->
+        <if test="organizationId != null and organizationId != ''">
+            and organization_id = #{organizationId}
+        </if>
+        <!-- 如果 organizationId 为空，则不执行删除操作，防止误删所有数据 -->
+        <if test="organizationId == null or organizationId == ''">
+            and 1 = 0
+        </if>
+    </update>
 </mapper>