feat(权限): admin_companies 从可见/可授予集合摘掉,提交时剥离不报错

This commit is contained in:
2026-10-04 20:55:43 +08:00
parent 898a8e2258
commit 5717efac92
2 changed files with 377 additions and 1 deletions
@@ -51,6 +51,10 @@ public class PermissionMenuService {
private static final String IMAGE_VIDEO_DATA_PERMISSION_KEY = "admin_image_video_task_data";
private static final String SHOP_DATA_CRAWL_DATA_PERMISSION_KEY = "admin_shop_data_crawl_task_data";
/** 角色内在闸门菜单:非超管看不见、谁也授不出去(设计文档 §8.1)。
* 与前端 src/config/company-scope.ts 的 SUPER_ADMIN_ONLY_MENU_KEYS 必须同值,由 Task 7 的跨端用例钉住。 */
private static final Set<String> SUPER_ADMIN_ONLY_KEYS = Set.of("admin_companies");
private final PermissionMenuMapper permissionMenuMapper;
private final UserColumnPermissionMapper userColumnPermissionMapper;
private final AdminUserMapper adminUserMapper;
@@ -68,6 +72,8 @@ public class PermissionMenuService {
/**
* @param grantableOnly 授权树语义:非超管只返回自己已持有的菜单,范围外的项不再下发
* (判据与 {@link #ensureGrantable} 同一套 {@link #resolveGrantableMenuIds})。
* 另:{@link #SUPER_ADMIN_ONLY_KEYS} 里的角色内在闸门菜单对**所有角色**(含超管)都不下发,
* 超管在树上拿不到就授不出去;为 false 时全量目录照旧,「菜单管理」页仍能管理这些行。
* 为了让树上仍保留「一级分组 + 子页面」层级,可授予项的祖先分组一并返回,
* 但标成 {@code grantable=false} 让前端置灰——分组自身不在操作者范围内,
* 一旦可勾,「勾父覆盖全部后代」就会把树上未展示的范围外菜单一起授出去。
@@ -84,6 +90,15 @@ public class PermissionMenuService {
.filter(menu -> menu.getId() != null && visibleIds.contains(menu.getId()))
.toList();
}
// 出口 1(授权树):可授予集合里连超管都不含这些项——超管自己都拿不到,才授不出去。
// 必须挂在 grantableOnly 上而不是 grantableIds != null 上:resolveGrantableMenuIds 对超管
// 返回 null(不限制),挂错了条件就等于只挡住了普通管理员,旁路照旧。
// 这里是重新赋值 visibleMenus,绝不能改 menus——它是 toItemVos 的层级/父节点查找表。
if (grantableOnly) {
visibleMenus = visibleMenus.stream()
.filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.toList();
}
List<PermissionMenuItemVo> items = toItemVos(visibleMenus, menus);
for (PermissionMenuItemVo item : items) {
item.setGrantable(grantableIds == null || grantableIds.contains(item.getId()));
@@ -333,7 +348,14 @@ public class PermissionMenuService {
List<PermissionMenuEntity> effectiveMenus = menus.stream()
.filter(menu -> menu.getId() != null && visibleIds.contains(menu.getId()))
.toList();
return toItemVos(effectiveMenus, menus);
// 出口 2(当前用户有效菜单):非超管即使历史上被授过这些项也不下发(前端拿不到 key,
// 侧边栏与守卫都无从显示)。超管分支在上面已经早返回,侧边栏照旧看得到——Task 1 只剪非超管。
// 只剪"下发列表",喂给 toItemVos 的第二个参数(层级/父节点查找表)必须仍是全量 menus:
// 换成剪过的集合会让只勾了子页面的用户解析不出父分组,等于把「用户管理」一起弄红。
List<PermissionMenuEntity> visibleMenus = effectiveMenus.stream()
.filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.toList();
return toItemVos(visibleMenus, menus);
}
/** Effective authorization check used by backend callers that need a boolean decision. */
@@ -568,6 +590,8 @@ public class PermissionMenuService {
AdminUserEntity target = getUserById(userId);
ensureTargetAccessible(operator, target);
List<Long> requestedIds = request == null ? List.of() : normalizeColumnIds(request.getColumnIds());
// 出口 3(提交授权):超管专属项在这里被剥掉,越权校验与落库都看不到它(剥而不拒)。
requestedIds = stripSuperAdminOnlyGrantIds(requestedIds, operator);
String normalizedType = menuType == null || menuType.isBlank()
? null
: normalizeMenuTypeRequired(menuType);
@@ -941,6 +965,49 @@ public class PermissionMenuService {
}
}
/**
* 出口 3 的实现:把 {@link #SUPER_ADMIN_ONLY_KEYS} 对应的菜单 id 从提交集合里摘掉。
*
* <p><b>剥离而不是报错</b>:授权树已经不再下发这些项,但目标用户身上可能挂着历史直接授权,
* 前端整树提交会把它原样带回;此时若判越权回滚,「保存权限 / 改密码 / 建号」这条链会整体失败
* (生产 2026-09-16 的形状)。摘掉后其余项照常落库,本次保存成功,只留一条 warn 日志。
*
* <p>剥离不许变成静默改数据:摘掉的 id 因此也进不了「无效菜单」校验(摘在前面),
* 而删除范围只由 {@code scopedMenuIds} ∩ {@code grantableIds} 算出、与提交集合无关
* (见下面 deleteScope 那段),所以既不会被它删掉历史授权行,也不会被新增回来。
* 唯一例外是超管且 menuType 为空的「整树替换」分支:{@code deleteByUserId} 先清空目标整个
* 分区再按提交重插,被剥的这条按既有语义就不会回来——那是该分支本来就有的行为,不是剥离引入的。
*/
private List<Long> stripSuperAdminOnlyGrantIds(List<Long> requestedIds, AdminUserEntity operator) {
if (requestedIds.isEmpty()) {
return requestedIds;
}
Set<Long> restricted = superAdminOnlyMenuIds();
if (restricted.isEmpty()) {
return requestedIds;
}
List<Long> stripped = requestedIds.stream().filter(restricted::contains).toList();
if (stripped.isEmpty()) {
return requestedIds;
}
log.warn("GRANT_SUPER_ADMIN_ONLY_STRIPPED 已剥离超管专属菜单授权 ids={} operatorId={}", stripped,
operator == null ? null : operator.getId());
return requestedIds.stream().filter(id -> !restricted.contains(id)).toList();
}
/**
* {@link #SUPER_ADMIN_ONLY_KEYS} 在库里的菜单 id。
*
* <p>一次全量目录查询折出来,绝不按 id 逐条点查:保存权限这个入口上 N 次点查会被日志放大,
* 而 {@code findDataPermission} 每次都是一个 {@code selectOne}。</p>
*/
private Set<Long> superAdminOnlyMenuIds() {
return loadMenus(null).stream()
.filter(menu -> SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.map(PermissionMenuEntity::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private boolean isAdmin(AdminUserEntity user) {
if (user == null) {
return false;
@@ -0,0 +1,309 @@
package com.nanri.aiimage.modules.permission;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.mapper.PermissionMenuMapper;
import com.nanri.aiimage.modules.permission.mapper.UserColumnPermissionMapper;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
/**
* admin_companies 只能由角色内在闸门管(设计文档 §8.1 的三处出口)。
*
* <p>菜单行本身要**留着**(历史 user_column_permission 数据无处安放,且「菜单管理」页还得能看见它),
* 所以断言的是"从可授予集合摘掉 + 提交时剥离",不是"库里删行"。</p>
*
* <p>两支源码扫描是绊线(防"三处出口里少了一处"),但源码文本判不出闸门是真在跑还是被写成
* {@code if (false)},所以同一文件里另有三支实跑用例 B1/B2/B3,逐个出口正反两面都钉:</p>
* <ul>
* <li>B1 出口 1(授权树 {@code list}):grantableOnly=true 时连超管都拿不到这一项(授不出去),
* grantableOnly=false(菜单管理页)时必须照旧看得到(这一行没被从目录里删掉)。</li>
* <li>B2 出口 2(当前用户有效菜单 {@code getUserColumnPermissions}):非超管历史上被授过也不下发,
* 但它的父分组与同组兄弟页必须原样保留——"顺手剪掉整组"是把用户管理页弄红的经典改法。</li>
* <li>B3 出口 3(提交授权 {@code updateUserColumnPermissions}):带这条 id 的整树提交必须
* 保存成功(绝不 403,09-16 的形状),只剥掉这一项,其余照常落库,且它绝不进"要删除"集合。</li>
* </ul>
*/
class PermissionCompanyMenuHiddenTest {
private static final String SERVICE = "PermissionMenuService.java";
private static final String KEY = "admin_companies";
/** 生产实查(2026-10 只读取证):这条菜单行 id=109,父分组 id=98,route_path=account/companies。 */
private static final Long GROUP_ID = 98L;
private static final Long COMPANY_MENU_ID = 109L;
private static final Long SIBLING_PAGE_ID = 110L;
/**
* MyBatis-Plus 的 lambda 列解析要实体的 TableInfo;本类不启动 Spring,而
* {@code loadRawMenus} 用 {@code LambdaQueryWrapper<PermissionMenuEntity>}、
* 授权落库前的有效性校验用 {@code .in(PermissionMenuEntity::getId, ...)},
* 级联清理与可授权用户查询用 {@code select(AdminUserEntity::getId, ...)}
* (静态缓存会被同 JVM 内先跑的其它用例顺带填上,所以必须显式初始化,否则单独跑本类就
* 「can not find lambda cache」)。同款初始化见 PermissionMenuServiceTest。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
}
// ---------------------------------------------------------------- 源码扫描绊线
private String source() throws IOException {
Path root = Path.of("src/main/java/com/nanri/aiimage/modules/permission/service");
assertThat(root).as("用例依赖以 backend-java 为工作目录运行,别让守卫静默通过").isDirectory();
String text = Files.readString(root.resolve(SERVICE), StandardCharsets.UTF_8);
assertThat(text).as("扫描取样集非空自检").contains("getUserColumnPermissions");
return text;
}
@Test
void threeExitsAllReferenceTheSuperAdminOnlySet() throws IOException {
String text = source();
assertThat(text).contains("SUPER_ADMIN_ONLY_KEYS");
// 三个出口各自都要引用它:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 / 提交能写回)。
assertThat(text.split("SUPER_ADMIN_ONLY_KEYS", -1).length - 1)
.as("SUPER_ADMIN_ONLY_KEYS 至少被引用 4 次(1 次定义 + 3 处出口)")
.isGreaterThanOrEqualTo(4);
}
@Test
void grantIsStrippedInsteadOfRejected() throws IOException {
String text = source();
// 整树提交里带一个历史 admin_companies 绝不能 403:那会让"改密码/建号"这条链整体回滚(09-16 的形状)。
// 注:本仓库 AssertJ 无 doesNotContainMatch,这里用等价的 doesNotContainPattern(同为正则不匹配)。
assertThat(text).doesNotContainPattern("(?s)ensureGrantable[\\s\\S]{0,600}admin_companies[\\s\\S]{0,200}BusinessException");
assertThat(text).contains("log.warn");
}
// ---------------------------------------------------------------- B1:出口 1(授权树)
/**
* 出口 1 双向钉:授权树(grantableOnly=true)里连**超管**都拿不到这一项——超管自己都授不出去,
* 才堵死"从授权树把它勾给员工"这条旁路;而菜单管理页(grantableOnly=false)必须照旧看得到、
* 改得动这一行(菜单行留在库里,Task 4 不删行)。父分组与兄弟页不受影响。
*/
@Test
void grantTreeDropsSuperAdminOnlyMenuEvenForSuperAdminButCatalogKeepsIt() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
AdminUserEntity superAdmin = user(31L, "super_admin", 1);
List<PermissionMenuItemVo> grantTree = service.list(superAdmin, "admin", true);
assertThat(grantTree).extracting(PermissionMenuItemVo::getId)
.as("超管的授权树里也没有这条:谁也授不出去")
.doesNotContain(COMPANY_MENU_ID);
assertThat(grantTree).extracting(PermissionMenuItemVo::getId)
.as("父分组与同组兄弟页必须留着,否则整组被剪掉")
.containsExactly(GROUP_ID, SIBLING_PAGE_ID);
assertThat(grantTree).extracting(PermissionMenuItemVo::getColumnKey)
.doesNotContain(KEY);
List<PermissionMenuItemVo> catalogWithoutFilter = service.list(superAdmin, "admin", false);
assertThat(catalogWithoutFilter).extracting(PermissionMenuItemVo::getId)
.as("菜单管理页仍能管理这一行(不删行、不藏行)")
.contains(COMPANY_MENU_ID);
assertThat(service.list("admin")).extracting(PermissionMenuItemVo::getId)
.as("无操作者的目录查询同样保留")
.contains(COMPANY_MENU_ID);
}
// ---------------------------------------------------------------- B2:出口 2(当前用户菜单)
/**
* 出口 2:非超管历史上被授过这条也不下发(前端拿不到 key,侧边栏与守卫都无从显示)。
*
* <p>同时钉住两件不能被顺手弄坏的事:它的父分组仍随 {@code includeAncestorGroups=true} 下发,
* 同组兄弟页完全不受影响;以及喂给 {@code toItemVos} 的第二个参数(层级表)必须仍是全量目录——
* 一旦换成剪过的集合,只勾了子页面的用户({@code includeAncestorGroups=false} 那条路径,
* 父分组不在下发列表里)就解析不出父分组,rootColumnKey 退化成自己、侧边栏再也挂不上组。
* 下面那段 flat 断言钉的就是这一条,变异 R5 验过它真的会红。</p>
*/
@Test
void effectiveMenusForNonSuperAdminExcludeLegacyGrantButKeepGroupAndSibling() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
when(userMapper.selectById(7L)).thenReturn(user(7L, "admin", 1));
when(permissionMapper.selectByUserId(7L)).thenReturn(List.of(
grant(7L, COMPANY_MENU_ID), // 历史上被超管授过的直接授权(生产实查为 0 条,形状要钉住)
grant(7L, SIBLING_PAGE_ID)));
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 7L, "admin", true);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("非超管即使被授过也不下发")
.doesNotContain(KEY);
assertThat(items).extracting(PermissionMenuItemVo::getId)
.doesNotContain(COMPANY_MENU_ID);
assertThat(items).extracting(PermissionMenuItemVo::getId)
.as("祖先分组与兄弟页都不能被连带剪掉")
.containsExactlyInAnyOrder(GROUP_ID, SIBLING_PAGE_ID);
assertThat(items.stream()
.filter(item -> SIBLING_PAGE_ID.equals(item.getId()))
.map(PermissionMenuItemVo::getRootColumnKey)
.toList())
.as("层级表仍是全量目录:兄弟页的根分组键要能解析出来")
.containsExactly("admin_account_group");
List<PermissionMenuItemVo> flat = service.getUserColumnPermissions(null, 7L, "admin", false);
assertThat(flat).extracting(PermissionMenuItemVo::getId).containsExactly(SIBLING_PAGE_ID);
assertThat(flat.stream().map(PermissionMenuItemVo::getRootColumnKey).toList())
.as("includeAncestorGroups=false 时父分组不在下发列表里,rootColumnKey 仍要能从全量目录解析出来"
+ "(把剪过的集合喂给 toItemVos 的第二个参数就会让它退化成自己,侧边栏再也挂不上分组)")
.containsExactly("admin_account_group");
}
// ---------------------------------------------------------------- B3:出口 3(提交授权)
/**
* 出口 3(超管操作者):整树提交里带这条历史 id 必须"剥离而不报错",且剥离不许变成静默改数据。
*
* <p>超管 + {@code menuType == null} 走的是既有的「整树替换」语义:{@code deleteByUserId} 先把
* 目标整个分区清空、再按提交集合重插。被剥掉的这条因此会从目标账号上消失——这是该分支
* 本来就有的 documented 行为(不是本任务的剥离引入的副作用),既有注释已写明"只增不删"仅适用于
* 数据权限那一类;本用例钉的是:其余项照常落库、被剥的这条绝不进 {@code deleteByUserIdAndColumnIds}
* 的按 id 删除集合、且提交不被 403 打断。
* {@code selectCount} 桩返回 1(不是 2)——钉住剥离发生在"无效菜单"校验之前,
* 被剥的 id 不会去撞菜单有效性检查。</p>
*/
@Test
void superAdminSaveStripsLegacyGrantInsteadOfFailing() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(userMapper.selectById(7L)).thenReturn(ownedNormalUser(7L, 30L));
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectCount(any())).thenReturn(1L);
when(menuMapper.selectOne(any())).thenReturn(null);
when(userMapper.selectList(any())).thenReturn(List.of());
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(COMPANY_MENU_ID, SIBLING_PAGE_ID));
assertThatCode(() -> service.updateUserColumnPermissions(
user(31L, "super_admin", 1), 7L, request, null)).doesNotThrowAnyException();
ArgumentCaptor<UserColumnPermissionEntity> inserted =
ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(1)).insert(inserted.capture());
assertThat(inserted.getAllValues()).extracting(UserColumnPermissionEntity::getColumnId)
.as("合法项照常落库,被剥项不落库(09-16「整单失败」不许回来)")
.containsExactly(SIBLING_PAGE_ID);
verify(permissionMapper, never())
.deleteByUserIdAndColumnIds(any(), argThat(ids -> ids != null && ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, times(1)).deleteByUserId(7L);
}
/**
* 出口 3(普通管理员操作者):自己范围外、且历史上挂在目标身上的这条,既不能被"新增"回来,
* 也不能因为剥离而顺手被删掉——删除范围只由操作者可授予集算出来,与提交集合无关。
*/
@Test
void nonSuperAdminSaveStripsItFromGrantAndFromDeleteScope() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(userMapper.selectById(7L)).thenReturn(ownedNormalUser(7L, 30L));
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectOne(any())).thenReturn(null);
when(userMapper.selectList(any())).thenReturn(List.of());
// 操作者(普通管理员 30)自己并没有这条
when(permissionMapper.selectByUserId(30L)).thenReturn(List.of(grant(30L, SIBLING_PAGE_ID)));
when(permissionMapper.selectByUserId(7L)).thenReturn(List.of(grant(7L, COMPANY_MENU_ID)));
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(COMPANY_MENU_ID, SIBLING_PAGE_ID));
assertThatCode(() -> service.updateUserColumnPermissions(
user(30L, "admin", 1), 7L, request, "admin")).doesNotThrowAnyException();
ArgumentCaptor<UserColumnPermissionEntity> inserted =
ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(1)).insert(inserted.capture());
assertThat(inserted.getAllValues()).extracting(UserColumnPermissionEntity::getColumnId)
.containsExactly(SIBLING_PAGE_ID);
verify(permissionMapper, never())
.deleteByUserIdAndColumnIds(any(), argThat(ids -> ids != null && ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, times(1)).deleteByUserIdAndColumnIds(eq(7L),
argThat(ids -> ids != null && ids.contains(SIBLING_PAGE_ID) && !ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, never()).deleteByUserId(any());
}
// ---------------------------------------------------------------- fixtures
/** 生产形状:一级分组 98 下挂公司管理 109 与另一个页面 110。 */
private List<PermissionMenuEntity> catalog() {
return List.of(
menu(GROUP_ID, null, "admin", 8, "admin_account_group"),
menu(COMPANY_MENU_ID, GROUP_ID, "admin", 9, KEY),
menu(SIBLING_PAGE_ID, GROUP_ID, "admin", 10, "admin_user_manage"));
}
private PermissionMenuEntity menu(Long id, Long parentId, String menuType, int sortOrder, String columnKey) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setColumnKey(columnKey);
entity.setName(columnKey);
entity.setRoutePath("route-" + id);
entity.setSortOrder(sortOrder);
return entity;
}
private UserColumnPermissionEntity grant(Long userId, Long columnId) {
UserColumnPermissionEntity entity = new UserColumnPermissionEntity();
entity.setUserId(userId);
entity.setColumnId(columnId);
return entity;
}
private AdminUserEntity user(Long id, String role, int isAdmin) {
AdminUserEntity entity = new AdminUserEntity();
entity.setId(id);
entity.setRole(role);
entity.setIsAdmin(isAdmin);
return entity;
}
private AdminUserEntity ownedNormalUser(Long id, Long createdById) {
AdminUserEntity entity = user(id, "normal", 0);
entity.setCreatedById(createdById);
return entity;
}
}