feat(店铺密钥): 筛选改走服务端、新增认当前 tab,操作列不再裁掉删除

三家公司的密钥挤在一页上,而"筛选"是拿当前页那 10 行在前端筛的:total 不动,
第 2 家的令牌要翻到它所在页才筛得出来。操作列给 160px 装不下三颗按钮,
最后一颗(删除)被 td 的 overflow:hidden + table-layout:fixed 整颗裁掉——
DOM 里在、事件也在,就是看不见点不到,这就是"没有删除功能"的真相。

- GET /api/admin/shop-keys 新增 keyword / token / whitelist_status,在公司读范围之内
  由服务端筛。keyword 那组 OR 必须括起来:不括就被后续 AND 短路成
  「备注名命中 OR (账号命中 AND 本公司)」,第 2 家的 tab 能读到第 1 家的令牌。
- create 的归属改为过读门(认当前 tab),不再只认操作者会话那一家。
  读认 tab、写认会话=两把尺子:admin 是 super_admin 且 company_id=1,
  他在别家 tab 点新增会"提示已新增、行却落进米椿花名下",再点一次就撞令牌唯一键。
  这一条推翻 10-06 定案,controller 的反向钉子(create 不许碰读门)同步换成
  「tab 必须过门 + 不许把请求原值直传下去」。
- 操作列 160→270px,.ops-cell 补 flex-wrap: wrap,把"超宽=静默消失"退化成"多占一行";
  同族结构隐患一次扫过 8 个页面(宽度够不够是像素账,会不会消失是结构账)。
- 护栏:ops-cell-must-wrap 钉跨页结构,shop-key-filter-params 钉参数下发与列宽;
  source-pin 棘轮补第二把尺子 reads=全文读点(体内+体外),
  pins 降而 reads 不同步降=把 readSource 挪出用例体冒充改进,当场红。

验证:将要提交的树(HEAD + 本批白名单)在独立 worktree 实跑——前端 1762 例 0 红、
vue-tsc rc=0、Java 41 例 0 红且 959 主源 + 498 测试源全量编译过(证明不依赖并行会话
未提交的符号);主树全量 1766 例 0 红。变异自证三支全杀:摘掉一页的 flex-wrap ⇒ 恰好
1 红点名该页;把体内读盘挪进 helper ⇒ 棘轮 1 红且文案点名"不算改进";
归属退回按会话、controller 绕门直传原值 ⇒ 各自红。
This commit is contained in:
2026-10-08 18:39:19 +08:00
parent f142744ed4
commit 6d835e947e
22 changed files with 1139 additions and 324 deletions
@@ -20,7 +20,6 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
@@ -59,10 +58,10 @@ class ShopKeyControllerCompanyScopeTest {
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID, null, null, null);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
verify(shopKeyService).page(1L, 15L, COMPANY_ID, null, null, null);
}
/**
@@ -77,9 +76,9 @@ class ShopKeyControllerCompanyScopeTest {
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().page(request, 1L, 15L, COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID, null, null, null);
verify(shopKeyService).page(1L, 15L, null);
verify(shopKeyService).page(1L, 15L, null, null, null, null);
}
/**
@@ -93,9 +92,25 @@ class ShopKeyControllerCompanyScopeTest {
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, 99L);
controller().page(request, 1L, 15L, 99L, null, null, null);
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
verify(shopKeyService).page(1L, 15L, COMPANY_ID, null, null, null);
}
/**
* 三个筛选词是"只收窄不放大"的读条件:controller 不加工、不补默认值,原样交给 service。
* 这里一旦被"顺手 trim/兜底成第 1 家",前端下拉与后端谓词就会各说一套。
*/
@Test
@DisplayName("列表:keyword/token/whitelist_status 原样透传给 service")
void pageForwardsTheThreeFiltersVerbatim() {
HttpServletRequest request = login();
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID, "先锋1", "zn-15-549", "BLOCKED");
verify(shopKeyService).page(1L, 15L, COMPANY_ID, "先锋1", "zn-15-549", "BLOCKED");
}
@Test
@@ -135,25 +150,55 @@ class ShopKeyControllerCompanyScopeTest {
}
/**
* 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,
* 所以 create 这一支<b>不许</b>碰任何读门——碰了就是"建号归谁由前端说了算"。
* 写侧口径(2026-10-08 改,控制方点名"先修那个新增不看 tab 的 bug"):
* 归属走<b>与列表同一把门</b> {@code readCompanyIdOrOwn}。
*
* <p>被推翻的旧定案原文是"create 这一支不许碰任何读门——碰了就是建号归谁由前端说了算"。
* 它不成立的两点:① 列表已经认 tab,写侧认会话=两把尺子,超管在别家 tab 新增会"提示成功但看不见、
* 再点一次撞紫鸟令牌已存在";② "前端说了算"由<b>门</b>兜着,不是由"不读参数"兜着——
* 非超管那支门恒返回本公司,请求里带什么都不算(与本文件 page 那三支同一口径)。</p>
*
* <p>仍然成立的那一半:归属<b>不进请求体</b>,走查询参数,所以 service 侧
* {@code requestDtoCarriesNoCompanyField} 那支钉原样保留。</p>
*/
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
@DisplayName("新增:tab 的公司值过门,service 收到的是门的判定值")
void createSendsTheTabThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
body.setRemarkName("备注");
controller().create(request, body);
controller().create(request, COMPANY_ID, body);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(shopKeyService).create(eq(body), operatorId.capture());
ArgumentCaptor<Long> attributed = ArgumentCaptor.forClass(Long.class);
verify(shopKeyService).create(eq(body), operatorId.capture(), attributed.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
assertEquals(COMPANY_ID, attributed.getValue(), "门的判定值必须原样交给 service,不许在 controller 再加工");
}
/**
* 反向钉:非超管带别家 tab 时,门返回的是<b>会话那一家</b>,controller 不许拿请求原值往下传——
* 那才是"建号归谁由前端说了算"的真正形状。
*/
@Test
@DisplayName("新增:门按会话收窄后,交给 service 的是收窄值而不是请求里的别家 id")
void createNeverForwardsTheRawRequestedCompany() {
HttpServletRequest request = login();
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
controller().create(request, 99L, body);
verify(shopKeyService).create(eq(body), eq(OPERATOR_ID), eq(COMPANY_ID));
}
private MockHttpServletRequest login() {
@@ -107,7 +107,7 @@ class ShopKeyServiceCompanyScopeTest {
void readScopeAddsTheCompanyCondition() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY);
service.page(1L, 15L, OWN_COMPANY, null, null, null);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
// 钉成等值而不是 contains("company"):把条件写成 company_id IS NOT NULL 也含 "company",
@@ -120,7 +120,7 @@ class ShopKeyServiceCompanyScopeTest {
void readScopeNullMeansUnfilteredAndNothingIsSubstituted() {
stubPageQueries();
service.page(1L, 15L, null);
service.page(1L, 15L, null, null, null, null);
// 与上一条对照才有意义:null 是超管「不筛」的判定,这里补一个默认公司就把超管锁死在本公司,
// 而"切 tab 数字不动"的报障会重新出现。
@@ -131,12 +131,18 @@ class ShopKeyServiceCompanyScopeTest {
// -------------------------------------------------------------- 写归属
/**
* 门给 null(超管没带 tab)时才退回操作者自己那一家。这一支与下面 {@code createAttributesToTheTab}
* 是一对:只钉这一支会放行"永远落自己公司"(=2026-10-08 那个 bug),只钉那一支会放行
* "没带 tab 就落空/落 null 被 DEFAULT 1 兜住"。
*/
@Test
void createAttributesTheRowToTheOperatorCompanyNotToTheRequestBody() {
@DisplayName("门给 null 时落操作者自己那一家(与改前逐字一致)")
void createFallsBackToTheOperatorCompanyWhenTheDoorGivesNull() {
stubInsertAndReload(ROW_ID, OWN_COMPANY);
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(OWN_COMPANY));
service.create(createRequest(), OPERATOR_ID);
service.create(createRequest(), OPERATOR_ID, null);
ArgumentCaptor<ShopKeyEntity> inserted = ArgumentCaptor.forClass(ShopKeyEntity.class);
verify(shopKeyMapper).insert(inserted.capture());
@@ -144,9 +150,29 @@ class ShopKeyServiceCompanyScopeTest {
}
/**
* 请求体里根本没有 company_id 这个字段(一期定案:归属由后端从会话推导)。
* 这一支钉的是"别给 DTO 加一个 company_id 就完事"——加了之后前端传什么算什么,
* 而 {@code ShopKeyController.create} 不读任何门,归属就成了可写字段。
* 本轮修的就是这一支:超管切到第 2 家的 tab 点新增,行必须落第 2 家。
*
* <p>桩<b>故意不给</b> {@code adminUserMapper.selectById}:代码一旦退回"按操作者会话推导",
* 那次未桩的查询返回 null,{@code requireCompanyId} 就抛"归属账号不存在"——
* 红得比断言 companyId 更早,报的还是错原因,所以这里靠"门给什么就用什么"这条正断言钉。</p>
*/
@Test
@DisplayName("归属认 tab:门给第 2 家就落第 2 家,不再按操作者会话推导")
void createAttributesToTheDoorVerdictNotToTheOperatorSession() {
stubInsertAndReload(ROW_ID, OTHER_COMPANY);
service.create(createRequest(), OPERATOR_ID, OTHER_COMPANY);
ArgumentCaptor<ShopKeyEntity> inserted = ArgumentCaptor.forClass(ShopKeyEntity.class);
verify(shopKeyMapper).insert(inserted.capture());
assertThat(inserted.getValue().getCompanyId()).isEqualTo(OTHER_COMPANY);
}
/**
* 归属<b>不进请求体</b>(走查询参数并过 {@code readCompanyIdOrOwn}),这一支钉的是
* "别给 DTO 加一个 company_id 就完事":字段一旦进 body,它就跟着 {@code @Valid} 一起被当成
* 业务输入,而门在 controller 上——绕过门的那条路(直接调 service、或将来有人把
* {@code request.getCompanyId()} 传下去)就从"要改两处"变成"顺手就写了"。
*/
@Test
@DisplayName("请求体不许带归属字段:create/update 两个 DTO 都不该有 companyId")
@@ -167,7 +193,7 @@ class ShopKeyServiceCompanyScopeTest {
void createRefusesWhenTheOperatorHasNoCompany() {
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(null));
assertThatThrownBy(() -> service.create(createRequest(), OPERATOR_ID))
assertThatThrownBy(() -> service.create(createRequest(), OPERATOR_ID, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有所属公司");
@@ -266,7 +292,7 @@ class ShopKeyServiceCompanyScopeTest {
when(shopKeyMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null);
stubInsertAndReload(ROW_ID, OWN_COMPANY);
service.create(createRequest(), OPERATOR_ID);
service.create(createRequest(), OPERATOR_ID, null);
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(shopKeyMapper).selectOne(captor.capture());
@@ -275,6 +301,92 @@ class ShopKeyServiceCompanyScopeTest {
assertThat(query.getSqlSegment()).doesNotContain("company_id");
}
// ---------------------------------------------------------------- 筛选
/*
* 下面这些断言里的字面量不是猜的,是把本类同一套桩跑起来、打印 wrapper.getSqlSegment()
* 抄回来的真实形状(MP 会把整段 WHERE 外括一对括号,所以"含 (" 这种判据恒真,一律不用)。
* 实测样本:
* 公司+关键词 → (company_id = #{...MPGENVAL1} AND (remark_name LIKE #{...2} OR ziniao_account_name LIKE #{...3}))
* 令牌 → (ziniao_token LIKE #{...}),参数值 %zn-15%
* 状态 → (ip_whitelist_status = #{...}),参数值 BLOCKED
*/
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void keywordFiltersBothNameColumnsAsOneOrGroup() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY, " abc ", null, null);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment())
.as("两个词任命中其一,且必须整体 AND 进公司条件里")
.contains("remark_name LIKE")
.contains("OR ziniao_account_name LIKE")
// 这一串是跨租户的那一刀:去掉 and(...) 包装后 MP 会渲染成
// "company_id = ? AND remark_name LIKE ? OR ziniao_account_name LIKE ?",
// OR 把公司条件短路掉,第 2 家的 tab 就能读到第 1 家的令牌原文。
.contains("AND (remark_name LIKE");
// 参数值带 % 两侧:写成 eq 就不是"模糊搜索"了,而前端 placeholder 承诺的是模糊。
assertThat(query.getParamNameValuePairs().values())
.containsExactlyInAnyOrder(OWN_COMPANY, "%abc%", "%abc%");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void tokenFilterIsALikeOnTheTokenColumn() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY, null, "zn-15", null);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment()).contains("ziniao_token LIKE");
assertThat(query.getParamNameValuePairs().values()).containsExactlyInAnyOrder(OWN_COMPANY, "%zn-15%");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void whitelistStatusIsEqualityAndToleratesCase() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY, null, null, "blocked");
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment()).contains("ip_whitelist_status =");
assertThat(query.getParamNameValuePairs().values()).containsExactlyInAnyOrder(OWN_COMPANY, "BLOCKED");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void blankFiltersAddNoConditionAtAll() {
stubPageQueries();
// 空白串与只给空格都必须等于"没这一维":传成 LIKE '%%' 会把全表放出来,
// 而前端 placeholder 说的是"留空=不筛"。
service.page(1L, 15L, OWN_COMPANY, " ", "", null);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment())
.doesNotContain("remark_name")
.doesNotContain("ziniao_account_name")
.doesNotContain("ziniao_token")
.doesNotContain("ip_whitelist_status");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void illegalWhitelistStatusThrowsBeforeAnyQueryRuns() {
// 反向钉"非法值退化成不筛":那等于把一个打错的状态读成"这一家全部密钥",
// 比报错更糟——它看起来像结果。
assertThatThrownBy(() -> service.page(1L, 15L, OWN_COMPANY, null, null, "NOT_A_STATUS"))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("白名单状态只支持");
verify(shopKeyMapper, never()).selectCount(any(LambdaQueryWrapper.class));
verify(shopKeyMapper, never()).selectList(any(LambdaQueryWrapper.class));
}
// ---------------------------------------------------------------- 桩
@SuppressWarnings({"unchecked", "rawtypes"})