Merge branch 'release-20250121' into 'master'

Release 20250121

See merge request universal/infrastructure/backend/tyr!405

tyr-api/src/main/java/cn/axzo/tyr/client/model/req/ListRoleReq.java

@@ -44,15 +44,21 @@ public class ListRoleReq {
     private String roleCode;
 
     /**
-     * 租户id
+     * 项目id
+     * 因为原来每一个workspace都有一个superAdmin角色，现在同一个workspaceType只有一个superAdmin角色，
+     * 为了兼容历史代码，传入了workspaceId时，
+     * 需要自动补充sql，(workspaceId = #workspaceId# or (workspaceId = 0 and workspaceType = #workspaceType#))
      */
-    @CriteriaField(field = "workspaceId", operator = Operator.IN)
+    @CriteriaField(ignore = true)
     private List<Long> workspaceIds;
 
     /**
      * 单位id
+     * 因为原来每一个workspace都有一个superAdmin角色，现在同一个workspaceType只有一个superAdmin角色，
+     * 为了兼容历史代码，传入了ouId时，因为不会单独给ouIds查询
+     * 需要自动补充sql，(ouId = #ouId# or (ouId = 0 ))
      */
-    @CriteriaField(field = "ownerOuId", operator = Operator.IN)
+    @CriteriaField(ignore = true)
     private List<Long> ouIds;
 
     /**
@@ -140,15 +146,32 @@ public class ListRoleReq {
     @CriteriaField(ignore = true)
     private String terminal;
 
-    @CriteriaField(field = "workspaceId", operator = Operator.EQ)
+    /**
+     * 因为原来每一个workspace都有一个superAdmin角色，现在同一个workspaceType只有一个superAdmin角色，
+     * 为了兼容历史代码，传入了workspaceId时，
+     * 需要自动补充sql，(workspaceId = #workspaceId# or (workspaceId = 0 and workspaceType = #workspaceType#))
+     */
+    @CriteriaField(ignore = true)
     private Long workspaceId;
 
-    @CriteriaField(field = "ownerOuId", operator = Operator.EQ)
+    /**
+     * 单位id
+     * 因为原来每一个workspace都有一个superAdmin角色，现在同一个workspaceType只有一个superAdmin角色，
+     * 为了兼容历史代码，传入了ouId时，因为不会单独给ouIds查询
+     * 需要自动补充sql，(ouId = #ouId# or (ouId = 0 ))
+     */
+    @CriteriaField(ignore = true)
     private Long ouId;
 
     /**
      * workspaceId和ouId配对查询
      * 例如：((workspaceId = ## and ouId = ##) or (workspaceId = ## and ouId = ##))
+     *
+     * 因为原来每一个workspace都有一个superAdmin角色，现在同一个workspaceType只有一个superAdmin角色，
+     * 为了兼容历史代码，传入了workspaceId时，
+     * 需要自动补充sql，
+     * ((workspaceId = ## and ouId = ##) or (workspaceId = ## and ouId = ##) or (ouId = 0 and workspaceId = 0 and workspaceType = #workspaceType#))
+     *
      */
     @CriteriaField(ignore = true)
     private List<ListRoleUserRelationParam.WorkspaceOuPair> workspaceOuPairs;

tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/RoleServiceImpl.java

@@ -1404,23 +1404,6 @@ public class RoleServiceImpl extends ServiceImpl<SaasRoleMapper, SaasRole>
     public cn.axzo.foundation.page.PageResp<SaasRoleRes> page(PageRoleReq param) {
         QueryWrapper<SaasRole> wrapper = QueryWrapperHelper.fromBean(param, SaasRole.class);
         wrapper.eq("is_delete", 0);
-        List<ListRoleUserRelationParam.WorkspaceOuPair> workspaceOuPairs = Lists.newArrayList();
-        if (Boolean.TRUE.equals(param.getNeedPresetRole())) {
-            workspaceOuPairs.add(PRESET_WORKSPACE_OU_PAIR);
-        }
-        CollectionUtils.addAll(workspaceOuPairs, Optional.ofNullable(param.getWorkspaceOuPairs())
-                .map(List::listIterator)
-                .orElseGet(Collections::emptyListIterator));
-        if (CollectionUtils.isNotEmpty(workspaceOuPairs)) {
-            wrapper.and(j -> {
-                for (ListRoleUserRelationParam.WorkspaceOuPair workspaceOuPair : workspaceOuPairs) {
-                    j.or(k -> {
-                        k.eq(Objects.nonNull(workspaceOuPair.getOuId()), "owner_ou_id", workspaceOuPair.getOuId());
-                        k.eq(Objects.nonNull(workspaceOuPair.getWorkspaceId()), "workspace_id", workspaceOuPair.getWorkspaceId());
-                    });
-                }
-            });
-        }
 
         if (CollectionUtils.isNotEmpty(param.getRoleGroupCodes())) {
             Set<Long> roleIds = resolveRoleGroupCodes(param);
@@ -1430,9 +1413,13 @@ public class RoleServiceImpl extends ServiceImpl<SaasRoleMapper, SaasRole>
             wrapper.in(CollectionUtils.isNotEmpty(roleIds), "id", roleIds);
         }
 
-        // 因为历史是每一个workspaceId一个超管角色，现在是一个workspaceType一个超管角色，
+        // 因为历史是每一个workspaceId一个超管角色，现在是一个workspaceType一个超管角色
-        // 为了兼容历史情况，入参有workspaceId，且roleType为空或者roleType包含superAdmin的，需要组装superAdmin的查询条件
+        // 入参有workspaceId的时候，需要组装workspaceId = 0 and workspaceType = #workspaceType#
-        assembleSuperAdminWrapper(param, wrapper);
+        resolveWorkspaceOuPairWrapper(param, wrapper);
+        resolveWorkspaceIdWrapper(param, wrapper);
+        resolveWorkspaceIdsWrapper(param, wrapper);
+        resolveOuIdWrapper(param, wrapper);
+        resolveOuIdsWrapper(param, wrapper);
 
         IPage<SaasRole> page = this.page(PageConverter.toMybatis(param, SaasRole.class), wrapper);
 
@@ -1453,53 +1440,110 @@ public class RoleServiceImpl extends ServiceImpl<SaasRoleMapper, SaasRole>
                 permissionRelations));
     }
 
-    /**
+    private void resolveWorkspaceOuPairWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
-     * 因为历史是每一个workspaceId一个超管角色，现在是一个workspaceType一个超管角色，
+
-     * 为了兼容历史情况，入参有workspaceId，且roleType为空或者roleType包含superAdmin的，需要组装superAdmin的查询条件
+        if (BooleanUtils.isNotTrue(param.getNeedPresetRole()) && CollectionUtils.isEmpty(param.getWorkspaceOuPairs())) {
-     * @param param
-     * @param wrapper
-     */
-    private void assembleSuperAdminWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
-        if (Objects.isNull(param.getWorkspaceId())
-                && CollectionUtils.isEmpty(param.getWorkspaceIds())
-                && CollectionUtils.isEmpty(param.getWorkspaceOuPairs())) {
             return;
         }
 
-        if (CollectionUtils.isEmpty(param.getRoleTypes())
+        List<ListRoleUserRelationParam.WorkspaceOuPair> workspaceOuPairs = Optional.ofNullable(param.getWorkspaceOuPairs())
-                || !param.getRoleTypes().contains(RoleTypeEnum.SUPER_ADMIN.getValue())) {
+                .orElseGet(Lists::newArrayList);
+
+        List<Long> workspaceIds = workspaceOuPairs.stream()
+                .map(ListRoleUserRelationParam.WorkspaceOuPair::getWorkspaceId)
+                .collect(Collectors.toList());
+
+        Set<Integer> workspaceTypes = listWorkspaceType(workspaceIds);
+
+        if (BooleanUtils.isTrue(param.getNeedPresetRole())) {
+            workspaceOuPairs.add(PRESET_WORKSPACE_OU_PAIR);
+        }
+
+        wrapper.and(j -> {
+            for (ListRoleUserRelationParam.WorkspaceOuPair workspaceOuPair : workspaceOuPairs) {
+                j.or(k -> {
+                    k.eq(Objects.nonNull(workspaceOuPair.getOuId()), "owner_ou_id", workspaceOuPair.getOuId());
+                    k.eq(Objects.nonNull(workspaceOuPair.getWorkspaceId()), "workspace_id", workspaceOuPair.getWorkspaceId());
+                });
+            }
+
+            j.or(CollectionUtils.isNotEmpty(workspaceTypes), k -> {
+                k.eq("workspace_id", 0L);
+                k.in("workspace_type", workspaceTypes);
+            });
+        });
+    }
+
+    private void resolveWorkspaceIdWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
+        if (Objects.isNull(param.getWorkspaceId())) {
             return;
         }
 
-        List<Long> workspaceIds = Lists.newArrayList();
+        Set<Integer> workspaceTypes = listWorkspaceType(Lists.newArrayList(param.getWorkspaceId()));
-        if (Objects.nonNull(param.getWorkspaceId())) {
+
-            workspaceIds.add(param.getWorkspaceId());
+        wrapper.and(j -> {
-        }
+            j.or(k -> k.eq("workspace_id", param.getWorkspaceId()));
-        if (CollectionUtils.isNotEmpty(param.getWorkspaceIds())) {
+
-            workspaceIds.addAll(param.getWorkspaceIds());
+            j.or(CollectionUtils.isNotEmpty(workspaceTypes), k -> {
+                k.eq("workspace_id", 0L);
+                k.in("workspace_type", workspaceTypes);
+            });
+        });
+    }
+
+    private void resolveOuIdWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
+        if (Objects.isNull(param.getOuId())) {
+            return;
         }
 
-        if (CollectionUtils.isNotEmpty(param.getWorkspaceOuPairs())) {
+        wrapper.and(j -> {
-            workspaceIds.addAll(param.getWorkspaceOuPairs().stream()
+            j.or(k -> k.eq("owner_ou_id", param.getOuId()));
-                    .map(ListRoleUserRelationParam.WorkspaceOuPair::getWorkspaceId)
+            j.or(k -> k.eq("owner_ou_id", 0L));
-                    .collect(Collectors.toList()));
+        });
+    }
+
+    private void resolveOuIdsWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
+        if (CollectionUtils.isEmpty(param.getOuIds())) {
+            return;
+        }
+
+        wrapper.and(j -> {
+            j.or(k -> k.in("owner_ou_id", param.getOuIds()));
+            j.or(k -> k.eq("owner_ou_id", 0L));
+        });
+    }
+
+    private void resolveWorkspaceIdsWrapper(PageRoleReq param, QueryWrapper<SaasRole> wrapper) {
+        if (CollectionUtils.isEmpty(param.getWorkspaceIds())) {
+            return;
+        }
+
+        Set<Integer> workspaceTypes = listWorkspaceType(param.getWorkspaceIds());
+
+        wrapper.and(j -> {
+            j.or(k -> k.in("workspace_id", param.getWorkspaceIds()));
+
+            j.or(CollectionUtils.isNotEmpty(workspaceTypes), k -> {
+                k.eq("workspace_id", 0L);
+                k.in("workspace_type", workspaceTypes);
+            });
+        });
+    }
+
+
+    private Set<Integer> listWorkspaceType(List<Long> workspaceIds) {
+        if (CollectionUtils.isEmpty(workspaceIds)) {
+            return Collections.emptySet();
         }
 
         GetSimpleWorkspaceReqV2 build = GetSimpleWorkspaceReqV2.builder()
                 .ids(workspaceIds)
                 .build();
-        List<SimpleWorkspaceRes> workspaces = RpcExternalUtil.rpcApolloProcessor(() -> workspaceApi.getListV2(build),
+        return RpcExternalUtil.rpcApolloProcessor(() -> workspaceApi.getListV2(build),
-                "查询项目信息", build);
+                        "查询项目信息", build)
-        if (CollectionUtils.isEmpty(workspaces)) {
+                .stream()
-            return;
+                .map(SimpleWorkspaceRes::getType)
-        }
+                .collect(Collectors.toSet());
-
-        wrapper.or(j -> {
-            j.in("workspace_type", Lists.transform(workspaces, SimpleWorkspaceRes::getType));
-            j.eq("owner_ou_id", 0L);
-            j.eq("workspace_id", 0L);
-            j.eq("role_type", RoleTypeEnum.SUPER_ADMIN.getValue());
-        });
     }
 
     private Set<Long> resolveRoleGroupCodes(PageRoleReq param) {

tyr-server/src/test/java/cn/axzo/tyr/server/service/RoleServiceTest.java

@@ -311,5 +311,42 @@ class RoleServiceTest extends BaseTest {
                 .build());
         Assertions.assertEquals(roles.size(), 1);
         // 直接查询超管角色
+
+        roles = roleService.list(ListRoleReq.builder()
+                .roleIds(Lists.newArrayList(101101L))
+                .workspaceId(3L)
+                .build());
+        Assertions.assertEquals(roles.size(), 1);
+
+        roles = roleService.list(ListRoleReq.builder()
+                        .workspaceOuPairs(Lists.newArrayList(
+                                ListRoleUserRelationParam.WorkspaceOuPair.builder().workspaceId(3L)
+                                        .ouId(4L).build()
+                        ))
+                .needPresetRole(true)
+                .build());
+        Assertions.assertEquals(roles.size(), 6);
+
+        roles = roleService.list(ListRoleReq.builder()
+                .roleIds(Lists.newArrayList(101101L, 3416L))
+                .workspaceId(3L)
+                .ouId(4L)
+                .build());
+        Assertions.assertEquals(roles.size(), 2);
+
+        roles = roleService.list(ListRoleReq.builder()
+                .roleIds(Lists.newArrayList(101101L, 3416L))
+                .roleTypes(Lists.newArrayList("super_admin"))
+                .workspaceId(3L)
+                .ouId(4L)
+                .build());
+        Assertions.assertEquals(roles.size(), 1);
+
+        roles = roleService.list(ListRoleReq.builder()
+                .roleIds(Lists.newArrayList(101101L, 3416L))
+                .workspaceId(3L)
+                .ouIds(Lists.newArrayList(4L))
+                .build());
+        Assertions.assertEquals(roles.size(), 2);
     }
 }