基础数据模块数据权限隔离

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/Lease/LeaseApplicationService.java

@@ -77,20 +77,52 @@ public class LeaseApplicationService {
 
     public List<LeasePO> queryList(LeaseDO leaseDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        //前端传organizationId = 2827的时候查询所有组织的数据
+        if (loginUser != null && loginUser.getUserPo() != null) {
-        if (loginUser != null) {
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            Long frontendOrganizationId = leaseDO.getOrganizationId();
+            Long frontendOrganizationId = leaseDO.getOrganizationId(); // 前端传递的 organizationId
-            if (frontendOrganizationId != null && frontendOrganizationId == 2827L) {
+            
-                // 前端传递2827时，查询所有组织的数据，将organizationId设置为null
+            // 数据权限：根据 organizationId 来设置查询权限
-                leaseDO.setOrganizationId(null);
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    leaseDO.setOrganizationId(frontendOrganizationId);
+                    leaseDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    leaseDO.setOrganizationId(null);
+                    leaseDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (loginUser != null && loginUser.getUserPo() != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        leaseDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
                     if (userOrganizationId != null) {
                         leaseDO.setOrganizationId(userOrganizationId);
                     }
                 }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (leaseDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        leaseDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    leaseDO.setTopOrganizationId(null);
+                }
             }
         }
         return leaseDomainService.queryList(leaseDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/batch/BatchApplicationService.java

@@ -41,19 +41,50 @@ public class BatchApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null) {
             Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            // 当前登录用户组织ID为2827时，查询所有组织的数据
+            Long frontendOrganizationId = batchDO.getOrganizationId(); // 前端传递的 organizationId
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
             if (userOrganizationId != null && userOrganizationId == 2827L) {
-                // 不设置organizationId，查询所有组织的数据
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                batchDO.setOrganizationId(null);
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    batchDO.setOrganizationId(frontendOrganizationId);
+                    batchDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    batchDO.setOrganizationId(null);
+                    batchDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (userOrganizationId != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    batchDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        batchDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        batchDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (batchDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        batchDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    batchDO.setTopOrganizationId(null);
                 }
-            }
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
-                batchDO.setTopOrganizationId(topOrganizationId);
             }
         }
         List<BatchPO> batchPOS = batchDomainService.queryList(batchDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/brand/BrandApplicationService.java

@@ -39,19 +39,50 @@ public class BrandApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null) {
             Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            // 当前登录用户组织ID为2827时，查询所有组织的数据
+            Long frontendOrganizationId = brandDO.getOrganizationId(); // 前端传递的 organizationId
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
             if (userOrganizationId != null && userOrganizationId == 2827L) {
-                // 不设置organizationId，查询所有组织的数据
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                brandDO.setOrganizationId(null);
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    brandDO.setOrganizationId(frontendOrganizationId);
+                    brandDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    brandDO.setOrganizationId(null);
+                    brandDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (userOrganizationId != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    brandDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        brandDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        brandDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (brandDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        brandDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    brandDO.setTopOrganizationId(null);
                 }
-            }
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
-                brandDO.setTopOrganizationId(topOrganizationId);
             }
         }
         return brandDomainService.queryList(brandDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/materialBaseInfo/MaterialBaseInfoApplicationService.java

@@ -43,10 +43,52 @@ public class MaterialBaseInfoApplicationService {
 
     public List<MaterialBaseInfoPO> queryList(MaterialBaseInfoDO materialBaseInfoDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
+        if (loginUser != null && loginUser.getUserPo() != null) {
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1){
+            Long frontendOrganizationId = materialBaseInfoDO.getOrganizationId(); // 前端传递的 organizationId
-                materialBaseInfoDO.setTopOrganizationId(loginUser.getUserPo().getTopOrganizationId());
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    materialBaseInfoDO.setOrganizationId(frontendOrganizationId);
+                    materialBaseInfoDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    materialBaseInfoDO.setOrganizationId(null);
+                    materialBaseInfoDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        materialBaseInfoDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        materialBaseInfoDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (materialBaseInfoDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        materialBaseInfoDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    materialBaseInfoDO.setTopOrganizationId(null);
+                }
             }
         }
         return materialBaseInfoDomainService.queryList(materialBaseInfoDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/materialClassify/MaterialClassifyApplicationService.java

@@ -31,19 +31,50 @@ public class MaterialClassifyApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null) {
             Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            // 当前登录用户组织ID为2827时，查询所有组织的数据
+            Long frontendOrganizationId = materialClassifyDO.getOrganizationId(); // 前端传递的 organizationId
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
             if (userOrganizationId != null && userOrganizationId == 2827L) {
-                // 不设置organizationId，查询所有组织的数据
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                materialClassifyDO.setOrganizationId(null);
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    materialClassifyDO.setOrganizationId(frontendOrganizationId);
+                    materialClassifyDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    materialClassifyDO.setOrganizationId(null);
+                    materialClassifyDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (userOrganizationId != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    materialClassifyDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        materialClassifyDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        materialClassifyDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (materialClassifyDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        materialClassifyDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    materialClassifyDO.setTopOrganizationId(null);
                 }
-            }
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
-                materialClassifyDO.setTopOrganizationId(topOrganizationId);
             }
         }
         return materialClassifyDomainService.queryList(materialClassifyDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/pack/PackApplicationService.java

@@ -40,19 +40,50 @@ public class PackApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null) {
             Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            // 当前登录用户组织ID为2827时，查询所有组织的数据
+            Long frontendOrganizationId = packDO.getOrganizationId(); // 前端传递的 organizationId
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
             if (userOrganizationId != null && userOrganizationId == 2827L) {
-                // 不设置organizationId，查询所有组织的数据
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                packDO.setOrganizationId(null);
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    packDO.setOrganizationId(frontendOrganizationId);
+                    packDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    packDO.setOrganizationId(null);
+                    packDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (userOrganizationId != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    packDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        packDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        packDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (packDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        packDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    packDO.setTopOrganizationId(null);
                 }
-            }
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
-                packDO.setTopOrganizationId(topOrganizationId);
             }
         }
         return packDomainService.queryList(packDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/storageLocation/StorageLocationApplicationService.java

@@ -44,23 +44,56 @@ public class StorageLocationApplicationService {
 
     public List<StorageLocationPO> queryList(StorageLocationDO storageLocationDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        if (loginUser != null){
+        if (loginUser != null && loginUser.getUserPo() != null) {
-            //前端传organizationId = 2827的时候查询所有组织的数据
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            Long frontendOrganizationId = storageLocationDO.getOrganizationId();
+            Long frontendOrganizationId = storageLocationDO.getOrganizationId(); // 前端传递的 organizationId
-            if (frontendOrganizationId != null && frontendOrganizationId == 2827L) {
+            
-                // 前端传递2827时，查询所有组织的数据，将organizationId设置为null
+            // 数据权限：根据 organizationId 来设置查询权限
-                storageLocationDO.setOrganizationId(null);
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    storageLocationDO.setOrganizationId(frontendOrganizationId);
+                    storageLocationDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    storageLocationDO.setOrganizationId(null);
+                    storageLocationDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (loginUser != null && loginUser.getUserPo() != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        storageLocationDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
                     if (userOrganizationId != null) {
                         storageLocationDO.setOrganizationId(userOrganizationId);
                     }
                 }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (storageLocationDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        storageLocationDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    storageLocationDO.setTopOrganizationId(null);
+                }
             }
+            
             // 只有当前端没有明确传仓库条件时，才使用用户关联仓库缓存进行过滤；
-            // 避免出现“单据仓库=常温仓，但库位列表仍显示保税仓”的错配问题。
+            // 避免出现"单据仓库=常温仓，但库位列表仍显示保税仓"的错配问题。
             boolean hasWarehouseFilter = storageLocationDO.getWarehouseId() != null
                     || (storageLocationDO.getWarehouseCode() != null && !storageLocationDO.getWarehouseCode().trim().isEmpty())
                     || (storageLocationDO.getWarehouseName() != null && !storageLocationDO.getWarehouseName().trim().isEmpty());

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/storageLocationGroup/StorageLocationGroupApplicationService.java

@@ -28,25 +28,52 @@ public class StorageLocationGroupApplicationService {
 
     public List<StorageLocationGroupPO> queryList(StorageLocationGroupDO storageLocationGroupDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        //前端传organizationId = 2827的时候查询所有组织的数据
-        Long frontendOrganizationId = storageLocationGroupDO.getOrganizationId();
-        if (frontendOrganizationId != null && frontendOrganizationId == 2827L) {
-            // 前端传递2827时，查询所有组织的数据，将organizationId设置为null
-            storageLocationGroupDO.setOrganizationId(null);
-        } else {
-            // 其他情况，只查询当前登录用户所属组织的数据
-            if (loginUser != null && loginUser.getUserPo() != null) {
-                Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-                if (userOrganizationId != null) {
-                    storageLocationGroupDO.setOrganizationId(userOrganizationId);
-                }
-            }
-        }
-        // 处理topOrganizationId逻辑
         if (loginUser != null && loginUser.getUserPo() != null) {
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
+            Long frontendOrganizationId = storageLocationGroupDO.getOrganizationId(); // 前端传递的 organizationId
-                storageLocationGroupDO.setTopOrganizationId(topOrganizationId);
+            
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    storageLocationGroupDO.setOrganizationId(frontendOrganizationId);
+                    storageLocationGroupDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    storageLocationGroupDO.setOrganizationId(null);
+                    storageLocationGroupDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        storageLocationGroupDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        storageLocationGroupDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (storageLocationGroupDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        storageLocationGroupDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    storageLocationGroupDO.setTopOrganizationId(null);
+                }
             }
         }
         return storageLocationGroupDomainService.queryList(storageLocationGroupDO);

mhd-modules/mhd-system/src/main/java/com/mhd/basic/application/service/storageSection/StorageSectionApplicationService.java

@@ -43,17 +43,51 @@ public class StorageSectionApplicationService {
 
     public List<StorageSectionPO> queryList(StorageSectionDO storageSectionDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        //前端传organizationId = 2827的时候查询所有组织的数据
+        if (loginUser != null && loginUser.getUserPo() != null) {
-        Long frontendOrganizationId = storageSectionDO.getOrganizationId();
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-        if (frontendOrganizationId != null && frontendOrganizationId == 2827L) {
+            Long frontendOrganizationId = storageSectionDO.getOrganizationId(); // 前端传递的 organizationId
-            // 前端传递2827时，查询所有组织的数据，将organizationId设置为null
+            
-            storageSectionDO.setOrganizationId(null);
+            // 数据权限：根据 organizationId 来设置查询权限
-        } else {
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
-            // 其他情况，只查询当前登录用户所属组织的数据
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
-            if (loginUser != null && loginUser.getUserPo() != null) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
-                if (userOrganizationId != null) {
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
-                    storageSectionDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    storageSectionDO.setOrganizationId(frontendOrganizationId);
+                    storageSectionDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    storageSectionDO.setOrganizationId(null);
+                    storageSectionDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        storageSectionDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        storageSectionDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (storageSectionDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        storageSectionDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    storageSectionDO.setTopOrganizationId(null);
                 }
             }
         }

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

@@ -42,17 +42,51 @@ public class WarehouseApplicationService {
 
     public List<WarehousePO> queryList(WarehouseDO warehouseDO) {
         LoginUser loginUser = SecurityUtils.getLoginUser();
-        //前端传organizationId = 2827的时候查询所有组织的数据
+        if (loginUser != null && loginUser.getUserPo() != null) {
-        Long frontendOrganizationId = warehouseDO.getOrganizationId();
+            Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-        if (frontendOrganizationId != null && frontendOrganizationId == 2827L) {
+            Long frontendOrganizationId = warehouseDO.getOrganizationId(); // 前端传递的 organizationId
-            // 前端传递2827时，查询所有组织的数据，将organizationId设置为null
+            
-            warehouseDO.setOrganizationId(null);
+            // 数据权限：根据 organizationId 来设置查询权限
-        } else {
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
-            // 其他情况，只查询当前登录用户所属组织的数据
+            if (userOrganizationId != null && userOrganizationId == 2827L) {
-            if (loginUser != null && loginUser.getUserPo() != null) {
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
-                if (userOrganizationId != null) {
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
-                    warehouseDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    warehouseDO.setOrganizationId(frontendOrganizationId);
+                    warehouseDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    warehouseDO.setOrganizationId(null);
+                    warehouseDO.setTopOrganizationId(null);
+                }
+            } else {
+                // 其他组织：设置organizationId，只查询当前组织的数据
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        warehouseDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        warehouseDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (warehouseDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        warehouseDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    warehouseDO.setTopOrganizationId(null);
                 }
             }
         }

mhd_wms/src/main/java/com/mhd/wms/application/service/materialBaseInfo/MaterialBaseInfoApplicationService.java

@@ -61,19 +61,50 @@ public class MaterialBaseInfoApplicationService {
         LoginUser loginUser = SecurityUtils.getLoginUser();
         if (loginUser != null && loginUser.getUserPo() != null) {
             Long userOrganizationId = loginUser.getUserPo().getOrganizationId();
-            // 当前登录用户组织ID为2827时，查询所有组织的数据
+            Long frontendOrganizationId = materialBaseInfoDO.getOrganizationId(); // 前端传递的 organizationId
+
+            // 数据权限：根据 organizationId 来设置查询权限
+            // 当前登录用户的 organizationId 为 2827 时，可查全部组织数据；其他组织只能查自己
             if (userOrganizationId != null && userOrganizationId == 2827L) {
-                // 不设置organizationId，查询所有组织的数据
+                // 南光组织（organizationId=2827）：可以查询所有组织的数据
-                materialBaseInfoDO.setOrganizationId(null);
+                // 如果前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                // 如果前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                if (frontendOrganizationId != null) {
+                    // 前端传递了 organizationId（包括2827或其他组织），使用前端传递的值进行过滤
+                    materialBaseInfoDO.setOrganizationId(frontendOrganizationId);
+                    materialBaseInfoDO.setTopOrganizationId(null); // 明确设置为 null，避免使用 topOrganizationId 条件
+                } else {
+                    // 前端没有传递 organizationId，清空组织过滤条件，查询所有组织的数据
+                    materialBaseInfoDO.setOrganizationId(null);
+                    materialBaseInfoDO.setTopOrganizationId(null);
+                }
             } else {
-                // 其他情况，只查询当前登录用户所属组织的数据
+                // 其他组织：设置organizationId，只查询当前组织的数据
-                if (userOrganizationId != null) {
+                // 如果前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
-                    materialBaseInfoDO.setOrganizationId(userOrganizationId);
+                if (frontendOrganizationId != null && userOrganizationId != null) {
+                    // 前端传递了 organizationId，验证是否与当前登录用户的组织ID一致
+                    if (!frontendOrganizationId.equals(userOrganizationId)) {
+                        // 前端传递了其他组织的 organizationId，强制使用当前登录用户的组织ID，防止越权查询
+                        materialBaseInfoDO.setOrganizationId(userOrganizationId);
+                    }
+                    // 如果前端传递的 organizationId 与当前登录用户的组织ID一致，使用前端传递的值
+                } else {
+                    // 前端没有传递 organizationId，使用当前登录用户的组织ID
+                    if (userOrganizationId != null) {
+                        materialBaseInfoDO.setOrganizationId(userOrganizationId);
+                    }
+                }
+                // 只有当 organizationId 为 null 时，才使用 topOrganizationId 作为查询条件
+                // 如果 organizationId 不为 null，则优先使用 organizationId，不使用 topOrganizationId
+                if (materialBaseInfoDO.getOrganizationId() == null) {
+                    Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
+                    if (topOrganizationId != null && topOrganizationId != 1) {
+                        materialBaseInfoDO.setTopOrganizationId(topOrganizationId);
+                    }
+                } else {
+                    // 如果 organizationId 不为 null，清空 topOrganizationId，确保查询使用 organizationId
+                    materialBaseInfoDO.setTopOrganizationId(null);
                 }
-            }
-            Long topOrganizationId = loginUser.getUserPo().getTopOrganizationId();
-            if (topOrganizationId != null && topOrganizationId != 1) {
-                materialBaseInfoDO.setTopOrganizationId(topOrganizationId);
             }
         }
         List<MaterialBaseInfoPO> materialBaseInfoPOS = materialBaseInfoDomainService.queryList(materialBaseInfoDO);