refactor(slim-r3): 删除零引用死模块——keywordshare/debug/PublicWorkbenchClientVersion 三线 40 件

Project-Slimming 第三轮收尾执行(用户拍板「零引用的也都要删除」):
定谳依据=6.4 天生产访问日志零流量(970 万行单遍对撞,26 UNIQUE 前缀防撞车)
+四树代码零引用(后端类名/包名/字符串、admin、用户端、app_client 全扫)
+V163 建菜单→V165 撤菜单的历史链(功能入口 10 月底已下线,Controller 成孤儿)。

删除(40 件):
- modules/keywordshare 整模块 31 类+4 mapper XML+KeywordShareServiceTest
  (后管 V165 已撤菜单、app_client 同步链 kw_share_api 亦无调用方;
  biz_keyword_share 等表按「已应用迁移不可回改」保留在库)
- modules/debug 2 支控制器(/debug/request-info、/debug/task-recovery/*)
- workbenchclient/controller/PublicWorkbenchClientVersionController
  (/api/workbench-client/version/latest:app_client 实际走 /api/version/latest,
  admin 侧仅文案引用,无任何真实调用方)
- config/KeywordShareSyncProperties(唯一消费方 KeywordShareService 同批删)

同步编辑:
- AdminApiGuardFilter:摘 DEBUG_PREFIX 前缀(常量/javadoc/审计日志块/requiresCredential/
  guardedPrefixes 五处);ApiGuardCoverageAuditor:METHOD_GUARDED_PATHS 摘 /api/keyword-share
- PropertiesConfig 摘 KeywordShareSyncProperties.class;application.yml 与
  application-local.example.yml 摘 keyword-share-sync 段与两个 env
- 台账两处扣减:XML_SELECT_TOTAL 114→103(11 select)、XML_STATEMENT_TOTAL 164→147
  (11 select+4 insert+1 delete);MigratedSqlEquivalenceTest.NOT_MIGRATED 摘 12 条点名
  (tsv 基准账本零 KeywordShare 行,LEDGER_ROWS/LEDGER_SELECTS 不动)
- PendingPhase5ReadPathTest 摘 P1-B2(RAND 断言随 XML 删);ApiGuardCoverageAuditorTest
  前缀总数 25→24;AdminApiGuardFilterTest 摘 4 支 /debug 用例与 2 条边界 URI
- admin:workbench-client-api 死常量、页面头注释与 page-hint、operation-guides 指南文案
  摘被删端点字样;align-workbench-client.test 摘 3 条对应断言

零行为影响:全部删除件在 6.4 天窗口内零流量;守卫过滤器行为对现存前缀不变
(/api/admin、用户态、自助清单原样)。
This commit is contained in:
2026-11-16 12:18:05 +08:00
parent c9ecae6e6d
commit a5e390750b
55 changed files with 23 additions and 3070 deletions
@@ -24,19 +24,13 @@ import java.util.Set;
import java.util.stream.Collectors;
/**
* /api/admin/**、/debug/** 兜底鉴权过滤器。
* /api/admin/** 兜底鉴权过滤器。
*
* <p>SecurityConfig 全局 permitAll 且无路径级拦截,历史上有多个 /api/admin 控制器遗漏方法级
* require*(公网 18080 直连可达即匿名裸奔)。本过滤器作为第二道网:凡进入受保护前缀的请求
* 必须具备"有效身份"(Java JWT,或可信内部令牌 X-Internal-Token + operatorId,复用
* AdminAuthSupport),否则直接返回与全局异常一致的 401 响应体(HTTP 200 + {success:false,code})。
*
* <p>/debug/** 于 2026-09-11 一并纳入:两个 debug 控制器都没有方法级鉴权,而主机A 18080 公网
* 直连、主机B nginx 的 location / 全量反代 Java,实测三处均可匿名调通——
* GET /debug/request-info(泄漏实例与转发头)与
* POST /debug/task-recovery/run-stale-finalize(**写操作**,强制收尾指定 task)。
* 应急调用方改用 X-Internal-Token 或管理员 JWT 即可通过,不再裸奔。
*
* <p>只保证"已认证",管理员/菜单级校验仍由各控制器 require* 负责,避免拦截普通登录用户本可
* 访问的 /api/admin 接口(如权限菜单列表仅 requireUser)。
*
@@ -70,9 +64,6 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
private static final String ADMIN_API_PREFIX = "/api/admin";
/** 调试端点前缀:无方法级鉴权的诊断/运维入口,同样纳入兜底(2026-09-11)。 */
private static final String DEBUG_PREFIX = "/debug";
/**
* 用户态工具接口前缀:controller 无方法级鉴权(归属由请求参数 user_id 判定),
* 匿名可达即越权读写他人数据。**默认不纳入兜底**,由
@@ -290,11 +281,6 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
return;
}
}
// /debug/** 是应急/诊断入口,调用频次极低但敏感,单独留一条审计日志便于事后追溯
if (matchesPrefix(uri, DEBUG_PREFIX)) {
log.warn("[debug-guard] {} {} 通过鉴权放行,remoteAddr={}",
request.getMethod(), uri, request.getRemoteAddr());
}
chain.doFilter(request, response);
}
@@ -332,9 +318,9 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
|| Integer.valueOf(DeviceSessionPolicy.CODE_KICKED).equals(code);
}
/** 必须解析出身份才放行的前缀:/api/admin、/debug、自助接口,以及已纳入收紧清单的用户态前缀。 */
/** 必须解析出身份才放行的前缀:/api/admin、自助接口,以及已纳入收紧清单的用户态前缀。 */
private boolean requiresCredential(String uri) {
if (matchesPrefix(uri, ADMIN_API_PREFIX) || matchesPrefix(uri, DEBUG_PREFIX)) {
if (matchesPrefix(uri, ADMIN_API_PREFIX)) {
return true;
}
if (isCredentialRequiredWriteEndpoint(uri)) {
@@ -448,7 +434,6 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
public static java.util.List<String> guardedPrefixes() {
java.util.List<String> all = new java.util.ArrayList<>();
all.add(ADMIN_API_PREFIX);
all.add(DEBUG_PREFIX);
all.addAll(java.util.List.of(USER_TOOL_PREFIXES));
all.addAll(java.util.List.of(SELF_SERVICE_PREFIXES));
return all;
@@ -77,7 +77,6 @@ public class ApiGuardCoverageAuditor implements SmartInitializingSingleton {
"/logout",
"/api/version", // 客户端启动时拉最新版本号,必须先于登录
"/api/tutorial", // 后台可维护的使用教程,公开内容
"/api/workbench-client", // 数富AI工作台客户端更新检查:必须先于登录,公开只读版本元数据
"/api/kd-flow/verify", // 开店流程访问密码校验:它自己就是那道门
// 下面四条都是 AdminConsoleController 的 302 兜底(response.sendRedirect 完事,
// 不读库、不回数据),旧书签打进这些地址只会被送到 /admin-vue/。
@@ -102,12 +101,7 @@ public class ApiGuardCoverageAuditor implements SmartInitializingSingleton {
* 往里塞一条没设防的路径会红。
*/
static final Set<String> METHOD_GUARDED_PATHS = Set.of(
"/api/client/credentials",
// 五国关键词共享(2026-10-23 keywordshare 模块):9 个端点全部在 handler 体内经
// requireKeywordShareAccess → adminAuthSupport.requireUser + PermissionMenuService
// .requireConsolePageAccess(operator, …, "keyword-share") 逐请求把门,且 company_id
// 一律服务端取、不收请求参数——第二道门已到位,只欠进 USER_TOOL_PREFIXES 第一道门。
"/api/keyword-share");
"/api/client/credentials");
/**
* 待收欠账:数据按 user_id 归属、却既不进守卫名单也没有 require* 的前缀。
@@ -1,36 +0,0 @@
package com.nanri.aiimage.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.ArrayList;
import java.util.List;
/**
* 五国关键词客户端同步({@code /api/keyword-share/sync/import})的服务端参数。
*
* <p>存在的主要理由:工作台按对接文档口径使用**共享专用 API 账号**,而 {@code keyword_usage.user_name}
* 是「谁用了哪个词」的唯一出处。若一律取 token 账号名,多人使用会被记成同一个人,后台按使用者筛选
* 就失去意义;若无条件信任客户端自报姓名,又会把「阿武(扶金凡)/阿武(吴棋龙)」这类同音异写
* 直接灌进留痕表。名单校验是这两者之间的收口:命中名单才按自报姓名落库。</p>
*/
@Data
@ConfigurationProperties(prefix = "aiimage.keyword-share-sync")
public class KeywordShareSyncProperties {
/**
* 可信操作人姓名名单(真人显示名,与 {@code keyword_usage.user_name} 同形)。
* 比对时两侧都做 trim + 全角括号归一,所以名单里写「阿武(吴棋龙)」也能匹配半角写法。
*/
private List<String> usedUsers = new ArrayList<>();
/**
* 名单外姓名的处置。
* <ul>
* <li>{@code false}(默认):放行自报姓名,只在响应里计数回报——首次上线时名单还没填,
* 直接回退会把全部记录静默改写成账号名,比现状更糟;</li>
* <li>{@code true}:名单外一律回退为本次调用的账号名,并计入 {@code usedUserFallback}。</li>
* </ul>
*/
private boolean strict = false;
}
@@ -4,6 +4,6 @@ import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties({OssProperties.class, TransientStorageProperties.class, StorageProperties.class, BrandProgressProperties.class, DeleteBrandProgressProperties.class, BrandCheckProperties.class, ZiniaoProperties.class, ModuleCleanupProperties.class, TaskPressureProperties.class, TaskImageCacheCleanupProperties.class, AppearancePatentProperties.class, SimilarAsinProperties.class, ImageVideoProperties.class, InstanceRoutingProperties.class, CapacityPlanProperties.class, UserSecretProperties.class, NotificationProperties.class, DeviceLogOssProperties.class, CollectDataBrandRecheckProperties.class, ClientCredentialProperties.class, CostGuardProperties.class, KeywordShareSyncProperties.class, CollectRoutingProperties.class, EvidenceProperties.class})
@EnableConfigurationProperties({OssProperties.class, TransientStorageProperties.class, StorageProperties.class, BrandProgressProperties.class, DeleteBrandProgressProperties.class, BrandCheckProperties.class, ZiniaoProperties.class, ModuleCleanupProperties.class, TaskPressureProperties.class, TaskImageCacheCleanupProperties.class, AppearancePatentProperties.class, SimilarAsinProperties.class, ImageVideoProperties.class, InstanceRoutingProperties.class, CapacityPlanProperties.class, UserSecretProperties.class, NotificationProperties.class, DeviceLogOssProperties.class, CollectDataBrandRecheckProperties.class, ClientCredentialProperties.class, CostGuardProperties.class, CollectRoutingProperties.class, EvidenceProperties.class})
public class PropertiesConfig {
}
@@ -1,55 +0,0 @@
package com.nanri.aiimage.modules.debug.controller;
import com.nanri.aiimage.config.InstanceMetadata;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.LinkedHashMap;
import java.util.Map;
@RestController
@RequestMapping("/debug")
public class DebugRequestInfoController {
private final InstanceMetadata instanceMetadata;
public DebugRequestInfoController(InstanceMetadata instanceMetadata) {
this.instanceMetadata = instanceMetadata;
}
@GetMapping("/request-info")
public Map<String, Object> requestInfo(
HttpServletRequest request,
@RequestHeader(value = "X-Forwarded-For", required = false) String forwardedFor,
@RequestHeader(value = "X-Real-IP", required = false) String realIp,
@RequestHeader(value = "X-Forwarded-Proto", required = false) String forwardedProto,
@RequestHeader(value = "X-Forwarded-Host", required = false) String forwardedHost,
@RequestHeader(value = "X-Forwarded-Port", required = false) String forwardedPort,
@RequestHeader(value = "X-Request-Id", required = false) String requestId,
@RequestHeader(value = "X-Amzn-Trace-Id", required = false) String amazonTraceId,
@RequestHeader(value = "Traceparent", required = false) String traceparent
) {
Map<String, Object> result = new LinkedHashMap<>();
result.put("instanceId", instanceMetadata.getInstanceId());
result.put("instanceSource", instanceMetadata.getSource());
result.put("instanceStable", instanceMetadata.isStable());
result.put("hostname", instanceMetadata.getHostname());
result.put("serverName", request.getServerName());
result.put("serverPort", request.getServerPort());
result.put("method", request.getMethod());
result.put("uri", request.getRequestURI());
result.put("remoteAddr", request.getRemoteAddr());
result.put("xForwardedFor", forwardedFor);
result.put("xRealIp", realIp);
result.put("xForwardedProto", forwardedProto);
result.put("xForwardedHost", forwardedHost);
result.put("xForwardedPort", forwardedPort);
result.put("xRequestId", requestId);
result.put("xAmznTraceId", amazonTraceId);
result.put("traceparent", traceparent);
return result;
}
}
@@ -1,44 +0,0 @@
package com.nanri.aiimage.modules.debug.controller;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService;
import com.nanri.aiimage.modules.similarasin.service.SimilarAsinTaskService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
@RestController
@RequestMapping("/debug/task-recovery")
public class DebugTaskRecoveryController {
private final AppearancePatentTaskService appearancePatentTaskService;
private final SimilarAsinTaskService similarAsinTaskService;
public DebugTaskRecoveryController(AppearancePatentTaskService appearancePatentTaskService,
SimilarAsinTaskService similarAsinTaskService) {
this.appearancePatentTaskService = appearancePatentTaskService;
this.similarAsinTaskService = similarAsinTaskService;
}
@PostMapping("/run-stale-finalize")
public Map<String, Object> runStaleFinalize(@RequestParam("module") String module,
@RequestParam("taskId") Long taskId) {
String normalizedModule = module == null ? "" : module.trim().toUpperCase(Locale.ROOT);
if ("APPEARANCE_PATENT".equals(normalizedModule)) {
appearancePatentTaskService.debugFinalizeStaleTask(taskId);
} else if ("SIMILAR_ASIN".equals(normalizedModule)) {
similarAsinTaskService.debugFinalizeStaleTask(taskId);
} else {
throw new IllegalArgumentException("Unsupported module: " + module);
}
Map<String, Object> result = new LinkedHashMap<>();
result.put("module", normalizedModule);
result.put("taskId", taskId);
result.put("accepted", true);
return result;
}
}
@@ -1,188 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareAddRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareDeleteRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareSyncImportRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordUsageBatchRequest;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareAddResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareDeleteResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareFiltersVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareLogPageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareMarkResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordSharePageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareStatsGroupedVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareSyncResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareUnmarkResultVo;
import com.nanri.aiimage.modules.keywordshare.service.KeywordShareService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 五国关键词共享(桌面 Tkinter 工具的 web 化)。
*
* <p>company_id 一律服务端从当前登录人取,前端不传、也不接受传参;
* 页面权限键 {@code keyword-share}(后台菜单 column_key,经 requireConsolePageAccess 把门)。</p>
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/keyword-share")
@Tag(name = "五国关键词共享", description = "五国关键词共享词库的查询、增删、使用标记与团队共享记录。数据按公司隔离。")
public class KeywordShareController {
/** 后台菜单权限键(column_key)。 */
private static final String PERMISSION_KEY = "keyword-share";
private static final String DENIAL_MESSAGE = "无权访问五国关键词共享";
private final KeywordShareService keywordShareService;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
@GetMapping("/keywords")
@Operation(summary = "分页查询关键词", description = "按国家/类目/搜索/使用状态筛选,未使用在前、已使用按使用时间升序。")
public ApiResponse<KeywordSharePageVo> page(
HttpServletRequest request,
@Parameter(description = "国家") @RequestParam(name = "country", required = false) String country,
@Parameter(description = "一级类目") @RequestParam(name = "category", required = false) String category,
@Parameter(description = "二级类目") @RequestParam(name = "subCategory", required = false) String subCategory,
@Parameter(description = "三级类目") @RequestParam(name = "categoryL3", required = false) String categoryL3,
@Parameter(description = "四级类目") @RequestParam(name = "categoryL4", required = false) String categoryL4,
@Parameter(description = "关键词/中文模糊搜索") @RequestParam(name = "search", required = false) String search,
@Parameter(description = "使用状态:all|used|unused") @RequestParam(name = "status", required = false) String status,
@Parameter(description = "已使用时间范围(天):1=今天,7/30/90/180/360;0或不传=全部")
@RequestParam(name = "usedDays", required = false) Integer usedDays,
@Parameter(description = "仅看我使用") @RequestParam(name = "onlyMine", required = false) Boolean onlyMine,
@Parameter(description = "页码(1 起)") @RequestParam(name = "page", required = false) Long page,
@Parameter(description = "每页数量(默认 200,上限 500)") @RequestParam(name = "size", required = false) Long size) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.page(operator.companyId(), operator.userName(),
country, category, subCategory, categoryL3, categoryL4, search,
status, usedDays, Boolean.TRUE.equals(onlyMine), page, size));
}
@GetMapping("/filters")
@Operation(summary = "查询筛选名册", description = "国家列表与一级→二级→三级→四级类目树,按当前公司 DISTINCT。")
public ApiResponse<KeywordShareFiltersVo> filters(HttpServletRequest request) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.filters(operator.companyId()));
}
@GetMapping("/stats-grouped")
@Operation(summary = "词库统计", description = "国家与一级/二级/三级类目的分布计数(统计弹窗)。")
public ApiResponse<KeywordShareStatsGroupedVo> statsGrouped(HttpServletRequest request) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.statsGrouped(operator.companyId()));
}
@PostMapping("/keywords")
@Operation(summary = "批量添加关键词", description = "trim 规范化;已存在/为空跳过;成功行写词本体、添加留痕并自动标记已使用。")
public ApiResponse<KeywordShareAddResultVo> add(
HttpServletRequest request,
@Valid @RequestBody KeywordShareAddRequest body) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success("添加成功", keywordShareService.add(body, operator.companyId(), operator.userName()));
}
@DeleteMapping("/keywords")
@Operation(summary = "批量删除关键词", description = "删除本公司词行并写删除留痕。")
public ApiResponse<KeywordShareDeleteResultVo> delete(
HttpServletRequest request,
@Valid @RequestBody KeywordShareDeleteRequest body) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success("删除成功", keywordShareService.delete(body, operator.companyId(), operator.userName()));
}
@PostMapping("/usage/mark")
@Operation(summary = "批量标记已使用", description = "写 keyword_usage,唯一键冲突按 UPSERT 刷新,幂等。")
public ApiResponse<KeywordShareMarkResultVo> mark(
HttpServletRequest request,
@Valid @RequestBody KeywordUsageBatchRequest body) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.mark(body, operator.companyId(), operator.userName()));
}
@PostMapping("/usage/unmark")
@Operation(summary = "批量取消使用", description = "删除 keyword_usage 行。")
public ApiResponse<KeywordShareUnmarkResultVo> unmark(
HttpServletRequest request,
@Valid @RequestBody KeywordUsageBatchRequest body) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.unmark(body, operator.companyId()));
}
@GetMapping("/logs")
@Operation(summary = "团队共享记录", description = "使用/添加/删除三类留痕的分页只读展示。")
public ApiResponse<KeywordShareLogPageVo> logs(
HttpServletRequest request,
@Parameter(description = "记录类型:usage|add|delete", required = true)
@RequestParam(name = "type") String type,
@Parameter(description = "国家") @RequestParam(name = "country", required = false) String country,
@Parameter(description = "页码(1 起)") @RequestParam(name = "page", required = false) Long page,
@Parameter(description = "每页数量") @RequestParam(name = "size", required = false) Long size) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.logs(operator.companyId(), type, country, page, size));
}
@GetMapping("/random")
@Operation(summary = "随机抽词", description = "从当前筛选的未使用池随机抽取(默认 10 条)。")
public ApiResponse<List<KeywordShareRowVo>> random(
HttpServletRequest request,
@Parameter(description = "抽取条数(默认 10)") @RequestParam(name = "count", required = false) Long count,
@Parameter(description = "国家") @RequestParam(name = "country", required = false) String country,
@Parameter(description = "一级类目") @RequestParam(name = "category", required = false) String category,
@Parameter(description = "二级类目") @RequestParam(name = "subCategory", required = false) String subCategory,
@Parameter(description = "三级类目") @RequestParam(name = "categoryL3", required = false) String categoryL3,
@Parameter(description = "四级类目") @RequestParam(name = "categoryL4", required = false) String categoryL4,
@Parameter(description = "关键词/中文模糊搜索") @RequestParam(name = "search", required = false) String search) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success(keywordShareService.random(operator.companyId(), operator.userName(),
country, category, subCategory, categoryL3, categoryL4, search, count));
}
/**
* 客户端全量同步导入。与 {@code POST /keywords} + {@code /usage/mark} 的分工:那两条是网页侧
* 交互式单条操作(使用人/时间取服务端此刻),这条专供工作台将本地历史批量搬入,
* 必须保住客户端传来的四级类目与真实使用人/使用时间。
*/
@PostMapping("/sync/import")
@Operation(summary = "客户端批量同步导入",
description = "按 (company_id, country, keyword) UPSERT 词本体并同步使用状态,"
+ "保留客户端传入的 usedTime/usedUser;used=false 删除对应使用记录。"
+ "幂等,单请求不超过 2000 行,失败只需重传该批。")
public ApiResponse<KeywordShareSyncResultVo> syncImport(
HttpServletRequest request,
@Valid @RequestBody KeywordShareSyncImportRequest body) {
Operator operator = requireKeywordShareAccess(request);
return ApiResponse.success("同步完成",
keywordShareService.syncImport(body, operator.companyId(), operator.userName()));
}
/**
* 逐端点把门:登录态 + 后台菜单权限;公司 id 与用户名都从登录人实体取,前端传参不参与归属判定。
*/
private Operator requireKeywordShareAccess(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireUser(request);
permissionMenuService.requireConsolePageAccess(operator, DENIAL_MESSAGE, PERMISSION_KEY);
return new Operator(operator.getCompanyId(), operator.getUsername());
}
private record Operator(Long companyId, String userName) {
}
}
@@ -1,18 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordAddLogEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 五国关键词共享——添加留痕(keyword_add_log)数据访问。
*/
@Mapper
public interface KeywordAddLogMapper extends BaseMapper<KeywordAddLogEntity> {
/** 批量写添加留痕(对齐桌面版 ShareSync.log_add_batch 的单次往返)。 */
int insertBatch(@Param("rows") List<KeywordAddLogEntity> rows);
}
@@ -1,18 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordDeleteLogEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 五国关键词共享——删除留痕(keyword_delete_log)数据访问。
*/
@Mapper
public interface KeywordDeleteLogMapper extends BaseMapper<KeywordDeleteLogEntity> {
/** 批量写删除留痕。 */
int insertBatch(@Param("rows") List<KeywordDeleteLogEntity> rows);
}
@@ -1,68 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryCountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryL3CountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryTreeRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordNameCountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareFilterQuery;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordShareEntity;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 五国关键词共享——词本体(keyword_share)数据访问。
*
* <p>列表/统计/随机这类带 JOIN 与动态筛选的 SQL 全部收口在本 Mapper 的 XML 里
* ({@code mapper/keywordshare/KeywordShareMapper.xml}),筛选值一律 {@code #{}} 占位符。</p>
*/
@Mapper
public interface KeywordShareMapper extends BaseMapper<KeywordShareEntity> {
/** 筛选命中总数(含状态/时间/仅看我条件)。 */
long countHit(@Param("f") KeywordShareFilterQuery filter);
/** 当前页行:未使用在前,已使用按 used_time 升序(对齐桌面版 _filtered_rows_conn 的口径)。 */
List<KeywordShareRowVo> selectRows(@Param("f") KeywordShareFilterQuery filter);
/** 未使用池随机抽词。 */
List<KeywordShareRowVo> selectRandomUnused(@Param("f") KeywordShareFilterQuery filter);
/** 本公司跨国重复词数:同词出现在 2 个及以上国家。 */
long countDupKeywords(@Param("companyId") Long companyId);
/** 类目筛选名册:国家平铺。 */
List<String> selectFilterCountries(@Param("companyId") Long companyId);
/** 类目筛选名册:类目树的去重行(category/sub_category/category_l3/category_l4)。 */
List<KeywordCategoryTreeRow> selectFilterTreeRows(@Param("companyId") Long companyId);
/** 词库统计:按国家分布。 */
List<KeywordNameCountRow> selectCountryCounts(@Param("companyId") Long companyId);
/** 词库统计:按一级类目分布。 */
List<KeywordNameCountRow> selectCategoryCounts(@Param("companyId") Long companyId);
/** 词库统计:按二级类目分布(挂一级类目下)。 */
List<KeywordCategoryCountRow> selectSubCategoryCounts(@Param("companyId") Long companyId);
/** 词库统计:按三级类目分布(挂一级+二级下)。 */
List<KeywordCategoryL3CountRow> selectCategoryL3Counts(@Param("companyId") Long companyId);
/** 批量查 (country, keyword) 已存在的键(添加防重预检)。 */
List<KeywordShareKey> selectExistingKeywords(@Param("companyId") Long companyId,
@Param("keys") List<KeywordShareKey> keys);
/** 批量 INSERT IGNORE:命中唯一键 uk_comp_cw 的重复行静默跳过,兜底与预检双保险。 */
int insertBatchIgnore(@Param("rows") List<KeywordShareEntity> rows);
/**
* 客户端全量同步专用 UPSERT:新词整行插入,已存在的词只把非空的四级类目/chinese/ktype/source
* 覆盖进去,添加人与添加时间不动。与 {@link #insertBatchIgnore} 的区别正是这条会更新已有行。
*/
int upsertBatchFromSync(@Param("rows") List<KeywordShareEntity> rows);
}
@@ -1,24 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordUsageEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 五国关键词共享——使用状态(keyword_usage)数据访问。
* 批量标记走 UPSERT(对齐桌面版 ShareSync.mark 的 ON DUPLICATE KEY UPDATE 语义,天然幂等),
* SQL 收口在 {@code mapper/keywordshare/KeywordUsageMapper.xml}。
*/
@Mapper
public interface KeywordUsageMapper extends BaseMapper<KeywordUsageEntity> {
/** 批量 UPSERT:唯一键冲突时刷新 user_name/used_time,幂等。 */
int upsertBatch(@Param("rows") List<KeywordUsageEntity> rows);
/** 批量取消使用:按 (company_id, country, keyword) 删行,返回实际删除条数。 */
int deleteBatch(@Param("companyId") Long companyId, @Param("keys") List<KeywordShareKey> keys);
}
@@ -1,14 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
/**
* 词库统计的「一级类目 + 二级类目 + 计数」行。
*/
@Data
public class KeywordCategoryCountRow {
private String category;
private String name;
private Long count;
}
@@ -1,15 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
/**
* 词库统计的「一级 + 二级 + 三级类目 + 计数」行。
*/
@Data
public class KeywordCategoryL3CountRow {
private String category;
private String subCategory;
private String name;
private Long count;
}
@@ -1,15 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
/**
* 类目筛选名册的树行(DISTINCT category/sub_category/category_l3/category_l4),Service 内组装成树。
*/
@Data
public class KeywordCategoryTreeRow {
private String category;
private String subCategory;
private String categoryL3;
private String categoryL4;
}
@@ -1,13 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
/**
* 词库统计的「名称 + 计数」行(按国家 / 按一级类目)。
*/
@Data
public class KeywordNameCountRow {
private String name;
private Long count;
}
@@ -1,36 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import java.util.List;
/**
* 批量添加关键词请求。词的一级~四级类目由词库既有口径维护,web 端添加不携带类目字段
* (落库取列默认值 ''),与桌面版从纯文本行解析出 country/keyword/chinese 的输入面一致。
*/
@Data
@Schema(description = "五国关键词批量添加请求")
public class KeywordShareAddRequest {
@Valid
@NotEmpty(message = "items 不能为空")
@Schema(description = "待添加的词列表", requiredMode = Schema.RequiredMode.REQUIRED)
private List<Item> items;
@Data
@Schema(description = "单个待添加词")
public static class Item {
@Schema(description = "国家", requiredMode = Schema.RequiredMode.REQUIRED)
private String country;
@Schema(description = "关键词", requiredMode = Schema.RequiredMode.REQUIRED)
private String keyword;
@Schema(description = "中文翻译")
private String chinese;
}
}
@@ -1,19 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import java.util.List;
/**
* 批量删除关键词请求(按列表行的主键 id)。
*/
@Data
@Schema(description = "五国关键词批量删除请求")
public class KeywordShareDeleteRequest {
@NotEmpty(message = "ids 不能为空")
@Schema(description = "待删除的行主键列表", requiredMode = Schema.RequiredMode.REQUIRED)
private List<Long> ids;
}
@@ -1,53 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
import java.time.LocalDateTime;
/**
* keyword_share 列表/随机抽词的筛选条件与分页参数——Mapper XML 的唯一入参载体({@code @Param("f")})。
*
* <p>筛选值全部走 {@code #{}} 占位符,SQL 侧不做任何字符串拼接。</p>
*/
@Data
public class KeywordShareFilterQuery {
/** 归属公司,服务端从当前登录人取,永远不为空。 */
private Long companyId;
private String country;
private String category;
private String subCategory;
private String categoryL3;
private String categoryL4;
/** keyword/chinese 双列 LIKE 的搜索词,服务端已 trim;空串表示不筛。 */
private String search;
/** all | used | unused;空/未知按 all 处理。 */
private String status;
/** 已使用时间下限;null 表示不筛时间。 */
private LocalDateTime usedSince;
/** true = 仅看当前用户名标记的使用记录。 */
private Boolean onlyMine;
/** 仅看我的判定基准用户名。 */
private String userName;
private long offset;
private long limit;
/** 复制一份基础筛选,只换状态口径(命中总数与「命中内已使用数」要按不同 status 各数一遍)。 */
public KeywordShareFilterQuery copyWithStatus(String newStatus) {
KeywordShareFilterQuery copy = new KeywordShareFilterQuery();
copy.setCompanyId(companyId);
copy.setCountry(country);
copy.setCategory(category);
copy.setSubCategory(subCategory);
copy.setCategoryL3(categoryL3);
copy.setCategoryL4(categoryL4);
copy.setSearch(search);
copy.setStatus(newStatus);
copy.setUsedSince(usedSince);
copy.setOnlyMine(onlyMine);
copy.setUserName(userName);
copy.setOffset(offset);
copy.setLimit(limit);
return copy;
}
}
@@ -1,20 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import lombok.Data;
/**
* (country, keyword) 业务键——查重、标记/取消使用的批量键载体。
*/
@Data
public class KeywordShareKey {
private String country;
private String keyword;
public static KeywordShareKey of(String country, String keyword) {
KeywordShareKey key = new KeywordShareKey();
key.setCountry(country);
key.setKeyword(keyword);
return key;
}
}
@@ -1,80 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.Size;
import lombok.Data;
import java.util.List;
/**
* 客户端全量同步导入请求。与 {@link KeywordShareAddRequest} 的分工:那条只补新词、由服务端
* 定添加人与时间;这条要把客户端本地那份四级类目与真实使用历史原样搬进主库。
*/
@Data
@Schema(description = "五国关键词客户端批量同步导入请求")
public class KeywordShareSyncImportRequest {
@Schema(description = "只统计不写库,用于导入前对账", example = "false")
private Boolean dryRun;
@Schema(description = "是否为新词写 keyword_add_log 留痕;几十万级全量导入默认不写,避免刷屏",
example = "false")
private Boolean writeAddLogs;
@Valid
@NotEmpty(message = "items 不能为空")
@Size(max = KeywordShareSyncImportRequest.MAX_ITEMS, message = "items 单次不超过 2000 条")
@Schema(description = "待同步的词行列表", requiredMode = Schema.RequiredMode.REQUIRED)
private List<Item> items;
/** 单请求上限:2000 行 × 12 列约 0.6–1MB,留出网关与请求体日志的余量。 */
public static final int MAX_ITEMS = 2000;
@Data
@Schema(description = "单个待同步词行")
public static class Item {
@Schema(description = "国家", requiredMode = Schema.RequiredMode.REQUIRED)
private String country;
@Schema(description = "关键词", requiredMode = Schema.RequiredMode.REQUIRED)
private String keyword;
@Schema(description = "中文释义;传空不会清空主库已有值")
private String chinese;
@Schema(description = "关键词类型;传空不会清空主库已有值")
private String ktype;
@Schema(description = "来源;传空不会清空主库已有值")
private String source;
@Schema(description = "一级类目;传空不会清空主库已有值")
private String category;
@Schema(description = "二级类目;传空不会清空主库已有值")
private String subCategory;
@Schema(description = "三级类目;传空不会清空主库已有值")
private String categoryL3;
@Schema(description = "四级类目;传空不会清空主库已有值")
private String categoryL4;
@Schema(description = "使用状态三态:true 写/刷 keyword_usage,false 删该行,"
+ "**不传(null)=完全不改动该词的使用状态**。只同步词库时必须整批省略此字段,"
+ "否则会把后台已有使用记录删掉",
requiredMode = Schema.RequiredMode.NOT_REQUIRED)
private Boolean used;
@Schema(description = "真实使用人;命中服务端名单才落库,否则回退为本次调用的账号名",
example = "阿武(吴棋龙)")
private String usedUser;
@Schema(description = "真实使用时间,ISO-8601 本地日期时间;服务端按此保留历史时刻而非同步时刻",
example = "2026-10-25T22:59:26")
private String usedTime;
}
}
@@ -1,32 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import java.util.List;
/**
* 批量标记/取消使用请求。接口语义由路径区分(/usage/mark 与 /usage/unmark),body 同形。
*/
@Data
@Schema(description = "五国关键词批量标记/取消使用请求")
public class KeywordUsageBatchRequest {
@Valid
@NotEmpty(message = "items 不能为空")
@Schema(description = "待操作的词键列表", requiredMode = Schema.RequiredMode.REQUIRED)
private List<Item> items;
@Data
@Schema(description = "单个词键")
public static class Item {
@Schema(description = "国家", requiredMode = Schema.RequiredMode.REQUIRED)
private String country;
@Schema(description = "关键词", requiredMode = Schema.RequiredMode.REQUIRED)
private String keyword;
}
}
@@ -1,28 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 五国关键词共享——添加留痕(谁添加了哪个词,可追溯源头)。
*
* <p>列结构按桌面版 {@code ShareSync.log_add} 的 {@code CREATE TABLE IF NOT EXISTS keyword_add_log}
* 逐列核对(keyword_share_app.py L2058-2066):id 自增主键、country NOT NULL、keyword NOT NULL、
* user_name DEFAULT ''、add_time 可空、company_id NOT NULL DEFAULT 1。</p>
*/
@Data
@TableName("keyword_add_log")
public class KeywordAddLogEntity {
@TableId(type = IdType.AUTO)
private Long id;
private String country;
private String keyword;
private String userName;
private LocalDateTime addTime;
private Long companyId;
}
@@ -1,28 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 五国关键词共享——删除留痕(谁删了哪个词,可追溯源头)。
*
* <p>列结构按桌面版 {@code ShareSync.log_delete} 的 {@code CREATE TABLE IF NOT EXISTS keyword_delete_log}
* 逐列核对(keyword_share_app.py L2019-2026):id 自增主键、country NOT NULL、keyword NOT NULL、
* user_name DEFAULT ''、delete_time 可空、company_id NOT NULL DEFAULT 1。</p>
*/
@Data
@TableName("keyword_delete_log")
public class KeywordDeleteLogEntity {
@TableId(type = IdType.AUTO)
private Long id;
private String country;
private String keyword;
private String userName;
private LocalDateTime deleteTime;
private Long companyId;
}
@@ -1,35 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 五国关键词共享——词本体(含四级类目)。
*
* <p>表在主库(aiimage)早已存在且已是全量词库,桌面 Tkinter 工具与 web 版共用同一份,
* 每公司一份、按 {@code company_id} 隔离;唯一键 {@code uk_comp_cw(company_id, country, keyword)}。
* <b>不建表、不走 Flyway</b>:本模块只做实体/Mapper 映射既有表。</p>
*/
@Data
@TableName("keyword_share")
public class KeywordShareEntity {
@TableId(type = IdType.AUTO)
private Long id;
private String country;
private String keyword;
private String chinese;
private String ktype;
private String source;
private String category;
private String subCategory;
private String categoryL3;
private String categoryL4;
private String userName;
private LocalDateTime addTime;
private Long companyId;
}
@@ -1,27 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 五国关键词共享——使用状态(谁在什么时候标记了哪个词)。
*
* <p>每公司一份,唯一键 {@code uk_comp_cw(company_id, country, keyword)};
* 「仅看我使用」按 {@code user_name = 当前用户名} 过滤。词的删除不走这里(删词写 keyword_delete_log)。</p>
*/
@Data
@TableName("keyword_usage")
public class KeywordUsageEntity {
@TableId(type = IdType.AUTO)
private Long id;
private String country;
private String keyword;
private String userName;
private LocalDateTime usedTime;
private Long companyId;
}
@@ -1,18 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 批量添加结果:成功条数 + 跳过条数(已存在/为空/批内重复)。
*/
@Data
@Schema(description = "五国关键词批量添加结果")
public class KeywordShareAddResultVo {
@Schema(description = "成功添加条数")
private int added;
@Schema(description = "跳过条数(已存在、关键词为空或批内重复)")
private int skipped;
}
@@ -1,15 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 批量删除结果。
*/
@Data
@Schema(description = "五国关键词批量删除结果")
public class KeywordShareDeleteResultVo {
@Schema(description = "实际删除条数(仅计本公司存在的行)")
private int deleted;
}
@@ -1,53 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 类目筛选名册:国家平铺 + 一级→二级→三级→四级类目树(按当前公司 DISTINCT)。
*/
@Data
@Schema(description = "五国关键词筛选名册")
public class KeywordShareFiltersVo {
@Schema(description = "国家列表")
private List<String> countries;
@Schema(description = "类目树")
private List<CategoryNode> categories;
@Data
@Schema(description = "一级类目节点")
public static class CategoryNode {
@Schema(description = "一级类目名")
private String name;
@Schema(description = "二级类目列表")
private List<SubCategoryNode> subs;
}
@Data
@Schema(description = "二级类目节点")
public static class SubCategoryNode {
@Schema(description = "二级类目名")
private String name;
@Schema(description = "三级类目列表")
private List<L3Node> l3;
}
@Data
@Schema(description = "三级类目节点")
public static class L3Node {
@Schema(description = "三级类目名")
private String name;
@Schema(description = "四级类目列表")
private List<String> l4;
}
}
@@ -1,20 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 团队共享记录分页。
*/
@Data
@Schema(description = "五国关键词共享记录分页")
public class KeywordShareLogPageVo {
@Schema(description = "总条数")
private long total;
@Schema(description = "当前页行")
private List<KeywordShareLogVo> rows;
}
@@ -1,26 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 团队共享记录单行(使用 / 添加 / 删除三类留痕同形展示,只读)。
*/
@Data
@Schema(description = "五国关键词共享记录行")
public class KeywordShareLogVo {
@Schema(description = "操作人")
private String userName;
@Schema(description = "国家")
private String country;
@Schema(description = "关键词")
private String keyword;
@Schema(description = "操作时间(使用时间/添加时间/删除时间)")
private LocalDateTime time;
}
@@ -1,15 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 批量标记使用结果。
*/
@Data
@Schema(description = "五国关键词批量标记使用结果")
public class KeywordShareMarkResultVo {
@Schema(description = "成功标记条数(唯一键冲突按幂等处理,仍计入)")
private int marked;
}
@@ -1,23 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 关键词分页列表:总命中数 + 当前行 + 统计条。
*/
@Data
@Schema(description = "五国关键词分页列表")
public class KeywordSharePageVo {
@Schema(description = "筛选命中总数")
private long total;
@Schema(description = "当前页行")
private List<KeywordShareRowVo> rows;
@Schema(description = "统计条")
private KeywordShareStatsVo stats;
}
@@ -1,47 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 关键词列表/随机抽词的单行。
*/
@Data
@Schema(description = "五国关键词行")
public class KeywordShareRowVo {
@Schema(description = "行主键")
private Long id;
@Schema(description = "国家")
private String country;
@Schema(description = "关键词")
private String keyword;
@Schema(description = "中文翻译")
private String chinese;
@Schema(description = "一级类目")
private String category;
@Schema(description = "二级类目")
private String subCategory;
@Schema(description = "三级类目")
private String categoryL3;
@Schema(description = "四级类目")
private String categoryL4;
@Schema(description = "是否已使用")
private boolean used;
@Schema(description = "使用时间(未使用为 null)")
private LocalDateTime usedTime;
@Schema(description = "使用者(未使用为空串)")
private String usedUser;
}
@@ -1,29 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryCountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryL3CountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordNameCountRow;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 词库统计弹窗:国家、一级/二级/三级类目的分布计数(对齐桌面版统计窗的四段展示)。
*/
@Data
@Schema(description = "五国关键词词库统计")
public class KeywordShareStatsGroupedVo {
@Schema(description = "按国家分布")
private List<KeywordNameCountRow> byCountry;
@Schema(description = "按一级类目分布")
private List<KeywordNameCountRow> byCategory;
@Schema(description = "按二级类目分布(挂一级类目下)")
private List<KeywordCategoryCountRow> bySubCategory;
@Schema(description = "按三级类目分布(挂一级+二级下)")
private List<KeywordCategoryL3CountRow> byCategoryL3;
}
@@ -1,24 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 列表页统计条:命中数、命中内已/未使用数、本公司跨国重复词数。
*/
@Data
@Schema(description = "五国关键词列表统计")
public class KeywordShareStatsVo {
@Schema(description = "筛选命中总数")
private long hit;
@Schema(description = "命中内已使用数")
private long used;
@Schema(description = "命中内未使用数")
private long unused;
@Schema(description = "本公司跨国重复词数")
private long dup;
}
@@ -1,51 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 客户端批量同步导入结果。计数是观测值而非事务保证:预检与写入之间有并发窗口,
* 同一批被两个客户端同时推时 added/updated 会漂,但落库内容幂等。
*/
@Data
@Schema(description = "五国关键词客户端批量同步导入结果")
public class KeywordShareSyncResultVo {
@Schema(description = "新插入的词行数")
private int added;
@Schema(description = "命中唯一键、被刷了类目/释义的既有词行数")
private int updated;
@Schema(description = "整行丢弃数(国家或关键词为空、批内重复、字段超长)")
private int skipped;
@Schema(description = "本批请求写入或刷新 keyword_usage 的行数(dryRun 下为预计数)")
private int usageUpserted;
@Schema(description = "本批请求按 used=false 取消使用的行数(dryRun 下为预计数;"
+ "实际删除条数不会多于它,主库可能本就没有该 usage 行)")
private int usageDeleted;
@Schema(description = "词已入库但使用状态被丢弃的行数(usedTime 解析失败或早于下限)")
private int usageSkipped;
@Schema(description = "usedUser 未命中服务端名单、回退为调用账号名的行数(仅 strict=true 时会产生)")
private int usedUserFallback;
@Schema(description = "usedUser 自报姓名不在名单内的行数;非 strict 下照原样落库但仍计数,"
+ "供运维据此判断名单是否该补齐、能否切 strict")
private int usedUserUnknown;
@Schema(description = "usedTime 缺失、回退为服务端当前时间的行数")
private int usedTimeFallback;
@Schema(description = "usedTime 落在未来、被钳到当前时间的行数")
private int usedTimeClamped;
@Schema(description = "写入 keyword_add_log 留痕的行数(writeAddLogs=true 时才可能非 0)")
private int addLogged;
@Schema(description = "本次是否为 dryRun")
private boolean dryRun;
}
@@ -1,15 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 批量取消使用结果。
*/
@Data
@Schema(description = "五国关键词批量取消使用结果")
public class KeywordShareUnmarkResultVo {
@Schema(description = "实际删除的使用记录条数")
private int unmarked;
}
@@ -1,771 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.support.LooseLocalDateTimeParser;
import com.nanri.aiimage.config.KeywordShareSyncProperties;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordAddLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordDeleteLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordUsageMapper;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryCountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryL3CountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryTreeRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordNameCountRow;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareAddRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareDeleteRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareFilterQuery;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareSyncImportRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordUsageBatchRequest;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordAddLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordDeleteLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordShareEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordUsageEntity;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareAddResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareDeleteResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareFiltersVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareLogPageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareLogVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareMarkResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordSharePageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareStatsGroupedVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareStatsVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareSyncResultVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareUnmarkResultVo;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
/**
* 五国关键词共享(桌面 Tkinter 工具的 web 化)。
*
* <p>词本体 = 主库 keyword_share(每公司一份、company_id 隔离),web 版没有 SQLite;
* 所有查询/写入都以服务端取到的 companyId 收口,杜绝跨公司读写。
* 行为口径对齐桌面版 keyword_share_app.py:列表「未使用在前、已使用按 used_time 升序」,
* 添加即自动标记已使用(使用者=当前用户、时间=添加时刻),删词写 keyword_delete_log 留痕,
* 标记走 UPSERT 天然幂等。</p>
*/
@Service
@RequiredArgsConstructor
public class KeywordShareService {
/** 列表默认页容量(API 契约定值;不走 PageDefaults 以免挤进它的逐点台账)。 */
public static final long DEFAULT_PAGE_SIZE = 200;
/** 列表页容量上限。 */
public static final long MAX_PAGE_SIZE = 500;
/** 随机抽词默认条数。 */
public static final long DEFAULT_RANDOM_COUNT = 10;
/** 随机抽词单次上限。 */
public static final long MAX_RANDOM_COUNT = 100;
/** 共享记录单页上限(留痕查询非无限拉取)。 */
public static final long MAX_LOG_PAGE_SIZE = 500;
public static final String FILTER_ALL = "all";
public static final String FILTER_USED = "used";
public static final String FILTER_UNUSED = "unused";
/** 添加词的固定口径,与桌面版 insert_keyword 一致。 */
private static final String KTYPE_MANUAL = "主关键词";
private static final String SOURCE_MANUAL = "手动添加";
/**
* 同步写入的分片行数:与仓内批量写惯例一致,控制单条 SQL 的占位符总量
* (12 列 × 500 行 = 6000 个占位符)。
*/
private static final int SYNC_SHARD_SIZE = 500;
/**
* 客户端自报使用时间的可信下限。早于此的一律当作脏值丢掉使用状态(1970/0000 这类
* SQLite 零值日期),但词本体照收——不该为一个坏时间戳丢掉一个词。
*/
private static final LocalDateTime MIN_SYNC_USED_TIME = LocalDateTime.of(2000, 1, 1, 0, 0);
/**
* 各列字符上限,对齐 V177 建表口径(线上真表若更窄,由部署前的 SHOW CREATE TABLE 预检兜住)。
* 超限一律整行拒绝而不是截断入库:静默截断会让客户端以为同步成功,而词已经被改坏了。
*/
private static final int WIDTH_COUNTRY = 32;
private static final int WIDTH_KEYWORD = 255;
private static final int WIDTH_CHINESE = 255;
private static final int WIDTH_KTYPE = 64;
private static final int WIDTH_SOURCE = 64;
private static final int WIDTH_CATEGORY = 128;
private static final int WIDTH_USER_NAME = 128;
private final KeywordShareMapper keywordShareMapper;
private final KeywordUsageMapper keywordUsageMapper;
private final KeywordAddLogMapper keywordAddLogMapper;
private final KeywordDeleteLogMapper keywordDeleteLogMapper;
private final KeywordShareSyncProperties syncProperties;
// ---------------------------------------------------------------- 列表与统计
public KeywordSharePageVo page(Long companyId, String viewerUserName,
String country, String category, String subCategory,
String categoryL3, String categoryL4, String search,
String status, Integer usedDays, boolean onlyMine,
Long page, Long size) {
KeywordShareFilterQuery filter = buildFilter(companyId, viewerUserName, country, category, subCategory,
categoryL3, categoryL4, search, status, usedDays, onlyMine);
filter.setOffset((safePage(page) - 1) * safePageSize(size));
filter.setLimit(safePageSize(size));
long hit = keywordShareMapper.countHit(filter);
// 命中内已使用数:状态过滤生效时命中即答案;否则按同条件单独数一遍 used
long used = switch (filter.getStatus()) {
case FILTER_USED -> hit;
case FILTER_UNUSED -> 0;
default -> keywordShareMapper.countHit(filter.copyWithStatus(FILTER_USED));
};
List<KeywordShareRowVo> rows = keywordShareMapper.selectRows(filter).stream()
.map(this::normalizeRow)
.toList();
long dup = keywordShareMapper.countDupKeywords(companyId);
KeywordShareStatsVo stats = new KeywordShareStatsVo();
stats.setHit(hit);
stats.setUsed(used);
stats.setUnused(hit - used);
stats.setDup(dup);
KeywordSharePageVo vo = new KeywordSharePageVo();
vo.setTotal(hit);
vo.setRows(rows);
vo.setStats(stats);
return vo;
}
public KeywordShareFiltersVo filters(Long companyId) {
KeywordShareFiltersVo vo = new KeywordShareFiltersVo();
vo.setCountries(keywordShareMapper.selectFilterCountries(companyId));
Map<String, Map<String, Map<String, Set<String>>>> tree = new LinkedHashMap<>();
for (KeywordCategoryTreeRow row : keywordShareMapper.selectFilterTreeRows(companyId)) {
tree.computeIfAbsent(orEmpty(row.getCategory()), c -> new LinkedHashMap<>())
.computeIfAbsent(orEmpty(row.getSubCategory()), s -> new LinkedHashMap<>())
.computeIfAbsent(orEmpty(row.getCategoryL3()), l -> new LinkedHashSet<>())
.add(orEmpty(row.getCategoryL4()));
}
List<KeywordShareFiltersVo.CategoryNode> categories = new ArrayList<>();
tree.forEach((category, subs) -> {
KeywordShareFiltersVo.CategoryNode categoryNode = new KeywordShareFiltersVo.CategoryNode();
categoryNode.setName(category);
List<KeywordShareFiltersVo.SubCategoryNode> subNodes = new ArrayList<>();
subs.forEach((sub, l3s) -> {
KeywordShareFiltersVo.SubCategoryNode subNode = new KeywordShareFiltersVo.SubCategoryNode();
subNode.setName(sub);
List<KeywordShareFiltersVo.L3Node> l3Nodes = new ArrayList<>();
l3s.forEach((l3, l4s) -> {
// 三级/四级类目与桌面版同口径:空值不进名册
if (l3.isBlank()) {
return;
}
KeywordShareFiltersVo.L3Node l3Node = new KeywordShareFiltersVo.L3Node();
l3Node.setName(l3);
l3Node.setL4(l4s.stream().filter(l4 -> !l4.isBlank()).toList());
l3Nodes.add(l3Node);
});
subNode.setL3(l3Nodes);
subNodes.add(subNode);
});
categoryNode.setSubs(subNodes);
categories.add(categoryNode);
});
vo.setCategories(categories);
return vo;
}
public KeywordShareStatsGroupedVo statsGrouped(Long companyId) {
KeywordShareStatsGroupedVo vo = new KeywordShareStatsGroupedVo();
vo.setByCountry(keywordShareMapper.selectCountryCounts(companyId));
vo.setByCategory(keywordShareMapper.selectCategoryCounts(companyId));
vo.setBySubCategory(keywordShareMapper.selectSubCategoryCounts(companyId));
vo.setByCategoryL3(keywordShareMapper.selectCategoryL3Counts(companyId));
return vo;
}
/** 未使用池随机抽词;国家/类目筛选可选,数量默认 10、上限 100。 */
public List<KeywordShareRowVo> random(Long companyId, String viewerUserName,
String country, String category, String subCategory,
String categoryL3, String categoryL4, String search,
Long count) {
KeywordShareFilterQuery filter = buildFilter(companyId, viewerUserName, country, category, subCategory,
categoryL3, categoryL4, search, FILTER_UNUSED, null, false);
long safeCount = count == null ? DEFAULT_RANDOM_COUNT : Math.min(Math.max(count, 1), MAX_RANDOM_COUNT);
filter.setLimit(safeCount);
// AC-19(审计 P1-B2):窗口起点先数命中集再掷,MySQL 就不必给全表打 RAND 后 filesort。
// 掷的是起点而非每一行,所以同一批词的相邻关系仍在(一次抽到的是连续 id 的一段),
// 服务层洗牌补回"散着"的观感;命中集不足一批时起点恒 0,与旧口径同为"全给你"。
filter.setOffset(randomWindowOffset(keywordShareMapper.countHit(filter), safeCount));
List<KeywordShareRowVo> window = new ArrayList<>(keywordShareMapper.selectRandomUnused(filter).stream()
.map(this::normalizeRow)
.toList());
Collections.shuffle(window);
return window;
}
/** 随机窗口起点:落在 {@code [0, total - count]},装得下整批才有得掷。 */
static long randomWindowOffset(long total, long count) {
long span = total - count;
return span > 0 ? ThreadLocalRandom.current().nextLong(span + 1) : 0L;
}
// ---------------------------------------------------------------- 写操作
/** 批量添加:trim 规范化、防重跳过;成功行写词本体 + 添加留痕 + 自动标记已使用。 */
@Transactional
public KeywordShareAddResultVo add(KeywordShareAddRequest request, Long companyId, String operatorName) {
int skipped = 0;
List<KeywordShareAddRequest.Item> candidates = new ArrayList<>();
Set<String> seen = new LinkedHashSet<>();
for (KeywordShareAddRequest.Item item : request.getItems()) {
String country = normalize(item == null ? null : item.getCountry());
String keyword = normalize(item == null ? null : item.getKeyword());
if (country.isEmpty() || keyword.isEmpty()) {
skipped++;
continue;
}
if (!seen.add(country + "\n" + keyword)) {
skipped++;
continue;
}
KeywordShareAddRequest.Item normalized = new KeywordShareAddRequest.Item();
normalized.setCountry(country);
normalized.setKeyword(keyword);
normalized.setChinese(normalize(item.getChinese()));
candidates.add(normalized);
}
List<KeywordShareEntity> toInsert = new ArrayList<>();
if (!candidates.isEmpty()) {
Set<String> existing = new LinkedHashSet<>();
List<KeywordShareKey> keys = candidates.stream()
.map(item -> KeywordShareKey.of(item.getCountry(), item.getKeyword()))
.toList();
for (KeywordShareKey key : keywordShareMapper.selectExistingKeywords(companyId, keys)) {
existing.add(key.getCountry() + "\n" + key.getKeyword());
}
for (KeywordShareAddRequest.Item item : candidates) {
if (existing.contains(item.getCountry() + "\n" + item.getKeyword())) {
skipped++;
continue;
}
KeywordShareEntity entity = new KeywordShareEntity();
entity.setCountry(item.getCountry());
entity.setKeyword(item.getKeyword());
entity.setChinese(item.getChinese());
entity.setKtype(KTYPE_MANUAL);
entity.setSource(SOURCE_MANUAL);
entity.setUserName(operatorName);
entity.setAddTime(LocalDateTime.now());
entity.setCompanyId(companyId);
toInsert.add(entity);
}
}
if (!toInsert.isEmpty()) {
keywordShareMapper.insertBatchIgnore(toInsert);
keywordAddLogMapper.insertBatch(toInsert.stream().map(row -> {
KeywordAddLogEntity log = new KeywordAddLogEntity();
log.setCompanyId(companyId);
log.setCountry(row.getCountry());
log.setKeyword(row.getKeyword());
log.setUserName(operatorName);
log.setAddTime(row.getAddTime());
return log;
}).toList());
markInternal(companyId, operatorName, toInsert.stream()
.map(row -> KeywordShareKey.of(row.getCountry(), row.getKeyword()))
.toList());
}
KeywordShareAddResultVo vo = new KeywordShareAddResultVo();
vo.setAdded(toInsert.size());
vo.setSkipped(skipped);
return vo;
}
/** 批量删除:只删本公司行并写删除留痕(谁删了哪个词可追溯)。 */
@Transactional
public KeywordShareDeleteResultVo delete(KeywordShareDeleteRequest request, Long companyId, String operatorName) {
List<Long> ids = request.getIds().stream().filter(java.util.Objects::nonNull).distinct().toList();
// 公司隔离在应用侧过滤:selectBatchIds 拉回后只认本公司行,别家的 id 传进来也不动
List<KeywordShareEntity> rows = ids.isEmpty() ? List.of()
: keywordShareMapper.selectBatchIds(ids).stream()
.filter(row -> companyId != null && companyId.equals(row.getCompanyId()))
.toList();
if (!rows.isEmpty()) {
keywordShareMapper.deleteBatchIds(rows.stream().map(KeywordShareEntity::getId).toList());
keywordDeleteLogMapper.insertBatch(rows.stream().map(row -> {
KeywordDeleteLogEntity log = new KeywordDeleteLogEntity();
log.setCompanyId(companyId);
log.setCountry(row.getCountry());
log.setKeyword(row.getKeyword());
log.setUserName(operatorName);
log.setDeleteTime(LocalDateTime.now());
return log;
}).toList());
}
KeywordShareDeleteResultVo vo = new KeywordShareDeleteResultVo();
vo.setDeleted(rows.size());
return vo;
}
/** 批量标记已使用;唯一键冲突按 UPSERT 刷新,幂等。used_time 取服务器当前时间。 */
@Transactional
public KeywordShareMarkResultVo mark(KeywordUsageBatchRequest request, Long companyId, String operatorName) {
int marked = markInternal(companyId, operatorName, normalizeKeys(request));
KeywordShareMarkResultVo vo = new KeywordShareMarkResultVo();
vo.setMarked(marked);
return vo;
}
/** 批量取消使用:删 usage 行,返回实际删除条数。 */
@Transactional
public KeywordShareUnmarkResultVo unmark(KeywordUsageBatchRequest request, Long companyId) {
List<KeywordShareKey> keys = normalizeKeys(request);
int unmarked = keys.isEmpty() ? 0 : keywordUsageMapper.deleteBatch(companyId, keys);
KeywordShareUnmarkResultVo vo = new KeywordShareUnmarkResultVo();
vo.setUnmarked(unmarked);
return vo;
}
// ---------------------------------------------------------------- 客户端全量同步
/**
* 客户端全量同步导入:把工作台本地那份词库+使用状态搬进主库,并且**保住客户端传来的
* 真实使用人与真实使用时间**——这正是 {@link #add} 与 {@link #mark} 给不了的两件事:
* add() 从不写四级类目且会自动标记已使用,mark() 把 user_name/used_time 硬写成 token 账号与此刻。
*
* <p>幂等:词按 {@code uk_comp_cw} UPSERT、使用状态按同键 UPSERT/删除,同一批重复推送结果一致。
* 一个请求=一个事务=一批(items ≤ 2000),整批要么全落要么全不回;客户端只需重传失败的那一批,
* 不做逐行重放——事务内一次 SQLException 已把整笔标记为 rollback-only,重放不出第二结果。</p>
*
* @param companyId 一律由服务端从 token 取,与其余写侧同口径
* @param tokenUser 本次调用的账号名,用作自报姓名不可信时的落点
*/
@Transactional
public KeywordShareSyncResultVo syncImport(KeywordShareSyncImportRequest request,
Long companyId, String tokenUser) {
KeywordShareSyncResultVo vo = new KeywordShareSyncResultVo();
boolean dryRun = Boolean.TRUE.equals(request.getDryRun());
boolean writeAddLogs = Boolean.TRUE.equals(request.getWriteAddLogs());
vo.setDryRun(dryRun);
Map<String, String> roster = canonicalRoster(syncProperties.getUsedUsers());
boolean strict = syncProperties.isStrict();
LocalDateTime now = LocalDateTime.now();
List<KeywordShareEntity> words = new ArrayList<>();
List<KeywordUsageEntity> usageUpserts = new ArrayList<>();
List<KeywordShareKey> usageDeletes = new ArrayList<>();
Set<String> seen = new LinkedHashSet<>();
int usedUserFallback = 0;
int usedUserUnknown = 0;
int usedTimeFallback = 0;
int usedTimeClamped = 0;
int usageSkipped = 0;
for (KeywordShareSyncImportRequest.Item item : request.getItems()) {
String country = normalize(item == null ? null : item.getCountry());
String keyword = normalize(item == null ? null : item.getKeyword());
if (country.isEmpty() || keyword.isEmpty()
|| !seen.add(country + "\n" + keyword)
|| !withinSyncColumnWidths(country, keyword, item)) {
vo.setSkipped(vo.getSkipped() + 1);
continue;
}
words.add(syncWordRow(companyId, tokenUser, now, country, keyword, item));
// used 三态:null=客户端没表达使用状态,一律不改动 keyword_usage。
// 不能把缺省当 false——那等于「只同步词库」的一次调用会把后台已有使用记录整批删掉。
Boolean used = item.getUsed();
if (used == null) {
continue;
}
if (!used) {
usageDeletes.add(KeywordShareKey.of(country, keyword));
continue;
}
UsedUserResult usedUser = resolveUsedUser(item.getUsedUser(), tokenUser, roster, strict);
if (usedUser.fellBack()) {
usedUserFallback++;
}
if (usedUser.unknown()) {
usedUserUnknown++;
}
UsedTimeResult usedTime = resolveUsedTime(item.getUsedTime(), now);
switch (usedTime.outcome()) {
case MISSING, UNPARSEABLE -> usedTimeFallback++;
case FUTURE -> usedTimeClamped++;
case TOO_OLD -> usageSkipped++;
case EXACT -> { }
}
if (usedTime.value() == null) {
continue;
}
KeywordUsageEntity usage = new KeywordUsageEntity();
usage.setCompanyId(companyId);
usage.setCountry(country);
usage.setKeyword(keyword);
usage.setUserName(usedUser.value());
usage.setUsedTime(usedTime.value());
usageUpserts.add(usage);
}
vo.setUsedUserFallback(usedUserFallback);
vo.setUsedUserUnknown(usedUserUnknown);
vo.setUsedTimeFallback(usedTimeFallback);
vo.setUsedTimeClamped(usedTimeClamped);
vo.setUsageSkipped(usageSkipped);
// added/updated 走预检分组:UPSERT 的 affected-rows 是 1/2/0(插入/值变/值未变),
// 求和后不可逆,拿它计数会把「重复推同一批」报成 0 新增或 2 倍新增。
Set<String> existing = existingWordKeys(companyId, words);
List<KeywordShareEntity> freshWords = words.stream()
.filter(row -> !existing.contains(row.getCountry() + "\n" + row.getKeyword()))
.toList();
vo.setAdded(freshWords.size());
vo.setUpdated(words.size() - freshWords.size());
vo.setUsageUpserted(usageUpserts.size());
vo.setUsageDeleted(usageDeletes.size());
if (dryRun) {
return vo;
}
for (List<KeywordShareEntity> shard : shard(words, SYNC_SHARD_SIZE)) {
keywordShareMapper.upsertBatchFromSync(shard);
}
if (writeAddLogs && !freshWords.isEmpty()) {
List<KeywordAddLogEntity> logs = freshWords.stream().map(row -> {
KeywordAddLogEntity log = new KeywordAddLogEntity();
log.setCompanyId(companyId);
log.setCountry(row.getCountry());
log.setKeyword(row.getKeyword());
log.setUserName(tokenUser);
log.setAddTime(row.getAddTime());
return log;
}).toList();
for (List<KeywordAddLogEntity> shard : shard(logs, SYNC_SHARD_SIZE)) {
keywordAddLogMapper.insertBatch(shard);
}
vo.setAddLogged(logs.size());
}
for (List<KeywordUsageEntity> shard : shard(usageUpserts, SYNC_SHARD_SIZE)) {
keywordUsageMapper.upsertBatch(shard);
}
for (List<KeywordShareKey> shard : shard(usageDeletes, SYNC_SHARD_SIZE)) {
keywordUsageMapper.deleteBatch(companyId, shard);
}
return vo;
}
// ---------------------------------------------------------------- 共享记录(只读)
public KeywordShareLogPageVo logs(Long companyId, String type, String country, Long page, Long size) {
long safePage = safePage(page);
long safeSize = size == null ? DEFAULT_PAGE_SIZE : Math.min(Math.max(size, 1), MAX_LOG_PAGE_SIZE);
return switch (type == null ? "" : type) {
case "usage" -> usageLogs(companyId, country, safePage, safeSize);
case "add" -> addLogs(companyId, country, safePage, safeSize);
case "delete" -> deleteLogs(companyId, country, safePage, safeSize);
default -> throw new BusinessException("type 只支持 usage / add / delete");
};
}
private KeywordShareLogPageVo usageLogs(Long companyId, String country, long page, long size) {
LambdaQueryWrapper<KeywordUsageEntity> query = new LambdaQueryWrapper<KeywordUsageEntity>()
.eq(KeywordUsageEntity::getCompanyId, companyId)
.eq(country != null && !country.isBlank(), KeywordUsageEntity::getCountry, normalize(country))
.orderByDesc(KeywordUsageEntity::getUsedTime)
.orderByDesc(KeywordUsageEntity::getId);
long total = keywordUsageMapper.selectCount(query);
List<KeywordUsageEntity> rows = keywordUsageMapper.selectList(
query.last("LIMIT " + ((page - 1) * size) + ", " + size));
return toLogPage(total, rows.stream().map(row -> {
KeywordShareLogVo vo = new KeywordShareLogVo();
vo.setUserName(orEmpty(row.getUserName()));
vo.setCountry(orEmpty(row.getCountry()));
vo.setKeyword(orEmpty(row.getKeyword()));
vo.setTime(row.getUsedTime());
return vo;
}).toList());
}
private KeywordShareLogPageVo addLogs(Long companyId, String country, long page, long size) {
LambdaQueryWrapper<KeywordAddLogEntity> query = new LambdaQueryWrapper<KeywordAddLogEntity>()
.eq(KeywordAddLogEntity::getCompanyId, companyId)
.eq(country != null && !country.isBlank(), KeywordAddLogEntity::getCountry, normalize(country))
.orderByDesc(KeywordAddLogEntity::getAddTime)
.orderByDesc(KeywordAddLogEntity::getId);
long total = keywordAddLogMapper.selectCount(query);
List<KeywordAddLogEntity> rows = keywordAddLogMapper.selectList(
query.last("LIMIT " + ((page - 1) * size) + ", " + size));
return toLogPage(total, rows.stream().map(row -> {
KeywordShareLogVo vo = new KeywordShareLogVo();
vo.setUserName(orEmpty(row.getUserName()));
vo.setCountry(orEmpty(row.getCountry()));
vo.setKeyword(orEmpty(row.getKeyword()));
vo.setTime(row.getAddTime());
return vo;
}).toList());
}
private KeywordShareLogPageVo deleteLogs(Long companyId, String country, long page, long size) {
LambdaQueryWrapper<KeywordDeleteLogEntity> query = new LambdaQueryWrapper<KeywordDeleteLogEntity>()
.eq(KeywordDeleteLogEntity::getCompanyId, companyId)
.eq(country != null && !country.isBlank(), KeywordDeleteLogEntity::getCountry, normalize(country))
.orderByDesc(KeywordDeleteLogEntity::getDeleteTime)
.orderByDesc(KeywordDeleteLogEntity::getId);
long total = keywordDeleteLogMapper.selectCount(query);
List<KeywordDeleteLogEntity> rows = keywordDeleteLogMapper.selectList(
query.last("LIMIT " + ((page - 1) * size) + ", " + size));
return toLogPage(total, rows.stream().map(row -> {
KeywordShareLogVo vo = new KeywordShareLogVo();
vo.setUserName(orEmpty(row.getUserName()));
vo.setCountry(orEmpty(row.getCountry()));
vo.setKeyword(orEmpty(row.getKeyword()));
vo.setTime(row.getDeleteTime());
return vo;
}).toList());
}
private KeywordShareLogPageVo toLogPage(long total, List<KeywordShareLogVo> rows) {
KeywordShareLogPageVo vo = new KeywordShareLogPageVo();
vo.setTotal(total);
vo.setRows(rows);
return vo;
}
// ---------------------------------------------------------------- 内部工具
private int markInternal(Long companyId, String operatorName, List<KeywordShareKey> keys) {
if (keys.isEmpty()) {
return 0;
}
LocalDateTime now = LocalDateTime.now();
List<KeywordUsageEntity> rows = keys.stream().map(key -> {
KeywordUsageEntity entity = new KeywordUsageEntity();
entity.setCompanyId(companyId);
entity.setCountry(key.getCountry());
entity.setKeyword(key.getKeyword());
entity.setUserName(operatorName);
entity.setUsedTime(now);
return entity;
}).toList();
keywordUsageMapper.upsertBatch(rows);
return rows.size();
}
private List<KeywordShareKey> normalizeKeys(KeywordUsageBatchRequest request) {
Set<String> seen = new LinkedHashSet<>();
List<KeywordShareKey> keys = new ArrayList<>();
for (KeywordUsageBatchRequest.Item item : request.getItems()) {
String country = normalize(item == null ? null : item.getCountry());
String keyword = normalize(item == null ? null : item.getKeyword());
if (country.isEmpty() || keyword.isEmpty() || !seen.add(country + "\n" + keyword)) {
continue;
}
keys.add(KeywordShareKey.of(country, keyword));
}
return keys;
}
private KeywordShareFilterQuery buildFilter(Long companyId, String viewerUserName,
String country, String category, String subCategory,
String categoryL3, String categoryL4, String search,
String status, Integer usedDays, boolean onlyMine) {
KeywordShareFilterQuery filter = new KeywordShareFilterQuery();
filter.setCompanyId(companyId);
filter.setCountry(normalizeOrNull(country));
filter.setCategory(normalizeOrNull(category));
filter.setSubCategory(normalizeOrNull(subCategory));
filter.setCategoryL3(normalizeOrNull(categoryL3));
filter.setCategoryL4(normalizeOrNull(categoryL4));
filter.setSearch(normalizeOrNull(search));
filter.setStatus(normalizeStatus(status));
filter.setUsedSince(resolveUsedSince(usedDays));
filter.setOnlyMine(onlyMine);
filter.setUserName(viewerUserName);
return filter;
}
/** usedDays:1=今天(当日零点起),7/30/90/180/360=往前推 N 天;0/null=不限。 */
private LocalDateTime resolveUsedSince(Integer usedDays) {
if (usedDays == null || usedDays <= 0) {
return null;
}
if (usedDays == 1) {
return LocalDate.now().atStartOfDay();
}
return LocalDateTime.now().minusDays(usedDays);
}
private String normalizeStatus(String status) {
String normalized = normalize(status);
return switch (normalized) {
case FILTER_USED -> FILTER_USED;
case FILTER_UNUSED -> FILTER_UNUSED;
default -> FILTER_ALL;
};
}
private KeywordShareRowVo normalizeRow(KeywordShareRowVo row) {
if (!row.isUsed()) {
row.setUsedUser("");
}
return row;
}
private long safePage(Long page) {
return page == null ? 1 : Math.max(page, 1);
}
private long safePageSize(Long size) {
return size == null ? DEFAULT_PAGE_SIZE : Math.min(Math.max(size, 1), MAX_PAGE_SIZE);
}
private KeywordShareEntity syncWordRow(Long companyId, String tokenUser, LocalDateTime now,
String country, String keyword,
KeywordShareSyncImportRequest.Item item) {
KeywordShareEntity row = new KeywordShareEntity();
row.setCompanyId(companyId);
row.setCountry(country);
row.setKeyword(keyword);
row.setChinese(normalize(item.getChinese()));
row.setKtype(normalize(item.getKtype()));
row.setSource(normalize(item.getSource()));
row.setCategory(normalize(item.getCategory()));
row.setSubCategory(normalize(item.getSubCategory()));
row.setCategoryL3(normalize(item.getCategoryL3()));
row.setCategoryL4(normalize(item.getCategoryL4()));
// 词本体的 user_name 是「添加人」,与 usedUser(使用人)不是一回事:客户端没有自报添加人的通道,
// 新词的添加人就是本次同步账号。UPSERT 的更新分支不碰这两列,既有归属不会被同步改写。
row.setUserName(tokenUser);
row.setAddTime(now);
return row;
}
/**
* 逐列比宽。用 {@code String.length()} 数的是 UTF-16 码元,MySQL 数的是字符,
* 差异只在增补平面字符(emoji)上出现且这里偏大 ⇒ 只会多拒不会漏拒。
*/
private boolean withinSyncColumnWidths(String country, String keyword,
KeywordShareSyncImportRequest.Item item) {
return country.length() <= WIDTH_COUNTRY
&& keyword.length() <= WIDTH_KEYWORD
&& normalize(item.getChinese()).length() <= WIDTH_CHINESE
&& normalize(item.getKtype()).length() <= WIDTH_KTYPE
&& normalize(item.getSource()).length() <= WIDTH_SOURCE
&& normalize(item.getCategory()).length() <= WIDTH_CATEGORY
&& normalize(item.getSubCategory()).length() <= WIDTH_CATEGORY
&& normalize(item.getCategoryL3()).length() <= WIDTH_CATEGORY
&& normalize(item.getCategoryL4()).length() <= WIDTH_CATEGORY;
}
/** 预检哪些 (country, keyword) 已在主库:分片查,避免 IN 列表一次塞进整批。 */
private Set<String> existingWordKeys(Long companyId, List<KeywordShareEntity> words) {
List<KeywordShareKey> keys = words.stream()
.map(row -> KeywordShareKey.of(row.getCountry(), row.getKeyword()))
.toList();
Set<String> existing = new LinkedHashSet<>();
for (List<KeywordShareKey> shard : shard(keys, SYNC_SHARD_SIZE)) {
keywordShareMapper.selectExistingKeywords(companyId, shard)
.forEach(key -> existing.add(key.getCountry() + "\n" + key.getKeyword()));
}
return existing;
}
private static <T> List<List<T>> shard(List<T> rows, int size) {
List<List<T>> shards = new ArrayList<>();
for (int from = 0; from < rows.size(); from += size) {
shards.add(rows.subList(from, Math.min(from + size, rows.size())));
}
return shards;
}
/**
* 自报使用人的收口:命中名单才按姓名落库,且**落的是名单里那份写法**。
* 名单两侧都做全角/半角括号归一,所以「阿武(吴棋龙)」也能命中「阿武(吴棋龙)」;
* 若原样存客户端写法,同一个人会因括号全半角不同被后管的使用者筛选器拆成两个人。
*/
private UsedUserResult resolveUsedUser(String declared, String tokenUser,
Map<String, String> roster, boolean strict) {
String name = normalize(declared);
if (name.length() > WIDTH_USER_NAME || name.isEmpty()) {
return new UsedUserResult(tokenUser, !name.isEmpty(), true);
}
String listed = roster.get(canonicalName(name));
if (listed != null) {
return new UsedUserResult(listed, false, false);
}
return strict
? new UsedUserResult(tokenUser, true, true)
: new UsedUserResult(name, true, false);
}
/** 客户端 usedTime 的判定:缺失/不可解析回退此刻,未来值钳到此刻,早于下限则丢使用状态。 */
private UsedTimeResult resolveUsedTime(String raw, LocalDateTime now) {
LocalDateTime parsed = LooseLocalDateTimeParser.parseOrNull(raw);
if (parsed == null) {
return new UsedTimeResult(now, normalize(raw).isEmpty()
? UsedTimeOutcome.MISSING : UsedTimeOutcome.UNPARSEABLE);
}
if (parsed.isAfter(now)) {
return new UsedTimeResult(now, UsedTimeOutcome.FUTURE);
}
if (parsed.isBefore(MIN_SYNC_USED_TIME)) {
return new UsedTimeResult(null, UsedTimeOutcome.TOO_OLD);
}
return new UsedTimeResult(parsed, UsedTimeOutcome.EXACT);
}
private Map<String, String> canonicalRoster(List<String> configured) {
Map<String, String> roster = new LinkedHashMap<>();
if (configured == null) {
return roster;
}
for (String name : configured) {
String canonical = canonicalName(name);
if (!canonical.isEmpty()) {
roster.putIfAbsent(canonical, normalize(name));
}
}
return roster;
}
private String canonicalName(String value) {
return normalize(value).replace('(', '(').replace(')', ')');
}
private String normalize(String value) {
return value == null ? "" : value.trim();
}
private String normalizeOrNull(String value) {
String normalized = normalize(value);
return normalized.isEmpty() ? null : normalized;
}
private String orEmpty(String value) {
return value == null ? "" : value;
}
/** usedTime 判定结果分类,直接对应响应里的降级计数。 */
private enum UsedTimeOutcome { EXACT, MISSING, UNPARSEABLE, FUTURE, TOO_OLD }
/** 解析后的使用时间;{@code value} 为 null 表示这条使用状态不该落库。 */
private record UsedTimeResult(LocalDateTime value, UsedTimeOutcome outcome) { }
/** 自报使用人的收口结果:最终落库名、是否不在名单内、是否被回退成账号名。 */
private record UsedUserResult(String value, boolean unknown, boolean fellBack) { }
}
@@ -1,40 +0,0 @@
package com.nanri.aiimage.modules.workbenchclient.controller;
import com.nanri.aiimage.modules.workbenchclient.service.WorkbenchClientPackageService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* 工作台客户端公开版本接口。
*
* <p>返回裸 JSON(不套 ApiResponse),字段名固定为 {@code version/file_url/sha256}:
* 客户端更新器直接按这三个字段比较版本、下载、校验摘要。新增字段只能追加,不能改名。
*/
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/workbench-client/version")
@Tag(name = "工作台客户端公开版本接口", description = "工作台客户端自动更新检查")
public class PublicWorkbenchClientVersionController {
private final WorkbenchClientPackageService packageService;
@GetMapping("/latest")
@Operation(summary = "最新客户端包", description = "返回最新上传的版本号、公开下载直链与 sha256;空表时字段为 null")
public Map<String, Object> latestVersion() {
return packageService.latestPackage();
}
@GetMapping("/list")
@Operation(summary = "客户端包版本列表", description = "按上传时间倒序返回最近 50 条,供客户端「指定版本更新」使用")
public Map<String, Object> listVersions() {
return packageService.listPublicPackages();
}
}
@@ -186,8 +186,3 @@ AIIMAGE_ZINIAO_SESSION_TTL_HOURS=2
AIIMAGE_ZINIAO_SHOPS_CACHE_MINUTES=30
AIIMAGE_ZINIAO_CONNECT_TIMEOUT_SECONDS=5
AIIMAGE_ZINIAO_READ_TIMEOUT_SECONDS=15
# 工作台客户端关键词全量同步(POST /api/keyword-share/sync/import)。
# 客户端每行自报真实使用人,服务端只接受名单内姓名并按名单写法落库;名单为空时必须保持 strict=false。
AIIMAGE_KEYWORD_SHARE_SYNC_STRICT=false
AIIMAGE_KEYWORD_SHARE_SYNC_USED_USERS=
@@ -315,12 +315,6 @@ aiimage:
cron: ${AIIMAGE_MODULE_CLEANUP_CRON:0 0 0 * * *}
retention-days: ${AIIMAGE_MODULE_CLEANUP_RETENTION_DAYS:7}
module-types: ${AIIMAGE_MODULE_CLEANUP_MODULE_TYPES:DEDUPE,SPLIT,CONVERT,DELETE_BRAND,PRODUCT_RISK_RESOLVE,PRICE_TRACK,SHOP_MATCH,PATROL_DELETE,QUERY_ASIN,WITHDRAW,APPEARANCE_PATENT,SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT}
# 工作台客户端全量同步(POST /api/keyword-share/sync/import)。客户端每行自报真实使用人,
# 服务端只接受名单内姓名、并统一按名单里那份写法落库(避免全/半角括号把同一个人拆成两个使用者)。
# 名单为空时必须保持 strict=false:否则首次上线会把全部记录静默改写成同步账号名,比现状更糟。
keyword-share-sync:
strict: ${AIIMAGE_KEYWORD_SHARE_SYNC_STRICT:false}
used-users: ${AIIMAGE_KEYWORD_SHARE_SYNC_USED_USERS:}
# 以下为各业务表的保留期清理(2026-09-16 统一补齐):这些表此前只增不删,
# 或只有"读的时候顺手删一行"这类碰运气的清理。全部按天分批删除、带分布式锁单实例执行。
device-log:
@@ -1,11 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nanri.aiimage.modules.keywordshare.mapper.KeywordAddLogMapper">
<insert id="insertBatch">
INSERT INTO keyword_add_log (company_id, country, keyword, user_name, add_time)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.companyId}, #{row.country}, #{row.keyword}, #{row.userName}, #{row.addTime})
</foreach>
</insert>
</mapper>
@@ -1,11 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nanri.aiimage.modules.keywordshare.mapper.KeywordDeleteLogMapper">
<insert id="insertBatch">
INSERT INTO keyword_delete_log (company_id, country, keyword, user_name, delete_time)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.companyId}, #{row.country}, #{row.keyword}, #{row.userName}, #{row.deleteTime})
</foreach>
</insert>
</mapper>
@@ -1,167 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper">
<!-- 五国关键词共享(词本体 keyword_share)。动态筛选全部走 #{} 占位符,不做任何字符串拼接;
排序口径对齐桌面版 keyword_share_app.py _filtered_rows_conn(未使用在前、已使用按 used_time 升序)。 -->
<!-- 词表 × 使用状态:usage 行按 (company_id, country, keyword) 三键对上,与桌面版同一口径 -->
<sql id="usageJoin">
keyword_share k
LEFT JOIN keyword_usage u
ON u.company_id = k.company_id
AND u.country = k.country
AND u.keyword = k.keyword
</sql>
<sql id="filterConds">
k.company_id = #{f.companyId}
<if test="f.country != null and f.country != ''">AND k.country = #{f.country}</if>
<if test="f.category != null and f.category != ''">AND k.category = #{f.category}</if>
<if test="f.subCategory != null and f.subCategory != ''">AND k.sub_category = #{f.subCategory}</if>
<if test="f.categoryL3 != null and f.categoryL3 != ''">AND k.category_l3 = #{f.categoryL3}</if>
<if test="f.categoryL4 != null and f.categoryL4 != ''">AND k.category_l4 = #{f.categoryL4}</if>
<if test="f.search != null and f.search != ''">
AND (k.keyword LIKE CONCAT('%', #{f.search}, '%') OR k.chinese LIKE CONCAT('%', #{f.search}, '%'))
</if>
<if test="f.status == 'used'">AND u.country IS NOT NULL</if>
<if test="f.status == 'unused'">AND u.country IS NULL</if>
<if test="f.usedSince != null">AND u.country IS NOT NULL AND u.used_time &gt;= #{f.usedSince}</if>
<if test="f.onlyMine != null and f.onlyMine">AND u.user_name = #{f.userName}</if>
</sql>
<select id="countHit" resultType="long">
SELECT COUNT(*)
FROM <include refid="usageJoin"/>
WHERE <include refid="filterConds"/>
</select>
<select id="selectRows" resultType="com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo">
<!-- used_user 别名不可省:VO 属性叫 usedUser,驼峰映射只会把 user_name 认成不存在的 userName。 -->
SELECT k.id, k.country, k.keyword, k.chinese, k.category, k.sub_category, k.category_l3, k.category_l4,
(u.country IS NOT NULL) AS used, u.used_time, u.user_name AS used_user
FROM <include refid="usageJoin"/>
WHERE <include refid="filterConds"/>
ORDER BY (u.country IS NULL) ASC, u.used_time ASC
LIMIT #{f.offset}, #{f.limit}
</select>
<!-- AC-19(审计 P1-B2):随机抽词不再 ORDER BY RAND()——那一句给命中集每一行打一个随机数再
filesort 全表,词库越大越慢。改成「按主键升序取一段窗口」:窗口起点由服务层先 count 命中集、
再掷在 [0, total-limit] 上,LIMIT 之前不必排序。服务层拿到窗口后就地洗牌,
页面看到的仍是散着的词。 -->
<select id="selectRandomUnused" resultType="com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo">
SELECT k.id, k.country, k.keyword, k.chinese, k.category, k.sub_category, k.category_l3, k.category_l4,
(u.country IS NOT NULL) AS used, u.used_time, u.user_name AS used_user
FROM <include refid="usageJoin"/>
WHERE <include refid="filterConds"/>
ORDER BY k.id
LIMIT #{f.limit} OFFSET #{f.offset}
</select>
<select id="countDupKeywords" resultType="long">
SELECT COUNT(*)
FROM (
SELECT keyword FROM keyword_share
WHERE company_id = #{companyId}
GROUP BY keyword
HAVING COUNT(DISTINCT country) &gt; 1
) t
</select>
<select id="selectFilterCountries" resultType="string">
SELECT DISTINCT country
FROM keyword_share
WHERE company_id = #{companyId}
AND country IS NOT NULL AND country != ''
ORDER BY country
</select>
<select id="selectFilterTreeRows" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryTreeRow">
SELECT DISTINCT category, sub_category, category_l3, category_l4
FROM keyword_share
WHERE company_id = #{companyId}
AND category IS NOT NULL AND category != ''
ORDER BY category, sub_category, category_l3, category_l4
</select>
<select id="selectCountryCounts" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordNameCountRow">
SELECT country AS name, COUNT(*) AS count
FROM keyword_share
WHERE company_id = #{companyId}
AND country IS NOT NULL AND country != ''
GROUP BY country
ORDER BY count DESC
</select>
<select id="selectCategoryCounts" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordNameCountRow">
SELECT category AS name, COUNT(*) AS count
FROM keyword_share
WHERE company_id = #{companyId}
AND category IS NOT NULL AND category != ''
GROUP BY category
ORDER BY count DESC
</select>
<select id="selectSubCategoryCounts" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryCountRow">
SELECT category, sub_category AS name, COUNT(*) AS count
FROM keyword_share
WHERE company_id = #{companyId}
AND category IS NOT NULL AND category != ''
GROUP BY category, sub_category
ORDER BY category, count DESC
</select>
<select id="selectCategoryL3Counts" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordCategoryL3CountRow">
SELECT category, sub_category, category_l3 AS name, COUNT(*) AS count
FROM keyword_share
WHERE company_id = #{companyId}
AND category IS NOT NULL AND category != ''
GROUP BY category, sub_category, category_l3
ORDER BY category, count DESC
</select>
<select id="selectExistingKeywords" resultType="com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey">
SELECT country, keyword
FROM keyword_share
WHERE company_id = #{companyId}
AND (country, keyword) IN
<foreach collection="keys" item="key" open="(" separator="," close=")">
(#{key.country}, #{key.keyword})
</foreach>
</select>
<insert id="insertBatchIgnore">
INSERT IGNORE INTO keyword_share
(country, keyword, chinese, ktype, source, category, sub_category, category_l3, category_l4,
user_name, add_time, company_id)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.country}, #{row.keyword}, #{row.chinese}, #{row.ktype}, #{row.source}, #{row.category},
#{row.subCategory}, #{row.categoryL3}, #{row.categoryL4}, #{row.userName}, #{row.addTime}, #{row.companyId})
</foreach>
</insert>
<!-- 客户端全量同步专用 UPSERT。与 insertBatchIgnore 的分工:那条只补新词、重复行静默跳过;
这条要把客户端本地那份「四级类目」写进已存在的行——add() 从不设类目,主库存量行的类目是空的。
命中 uk_comp_cw 时只覆盖非空值(COALESCE(NULLIF(...))):客户端是四级类目的唯一权威源,
但一次不带类目的同步不该把已导入的类目永久打回空串,所以「主动清空」不走这条路。
user_name/add_time(添加人与添加时间)在更新分支一律不动:那是历史归属,不由同步改写。 -->
<insert id="upsertBatchFromSync">
INSERT INTO keyword_share
(country, keyword, chinese, ktype, source, category, sub_category, category_l3, category_l4,
user_name, add_time, company_id)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.country}, #{row.keyword}, #{row.chinese}, #{row.ktype}, #{row.source}, #{row.category},
#{row.subCategory}, #{row.categoryL3}, #{row.categoryL4}, #{row.userName}, #{row.addTime}, #{row.companyId})
</foreach>
ON DUPLICATE KEY UPDATE
chinese = COALESCE(NULLIF(VALUES(chinese), ''), chinese),
ktype = COALESCE(NULLIF(VALUES(ktype), ''), ktype),
source = COALESCE(NULLIF(VALUES(source), ''), source),
category = COALESCE(NULLIF(VALUES(category), ''), category),
sub_category = COALESCE(NULLIF(VALUES(sub_category), ''), sub_category),
category_l3 = COALESCE(NULLIF(VALUES(category_l3), ''), category_l3),
category_l4 = COALESCE(NULLIF(VALUES(category_l4), ''), category_l4)
</insert>
</mapper>
@@ -1,23 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nanri.aiimage.modules.keywordshare.mapper.KeywordUsageMapper">
<!-- 使用状态批量写:UPSERT 语义对齐桌面版 ShareSync.mark(ON DUPLICATE KEY UPDATE),
唯一键 uk_comp_cw(company_id, country, keyword) 冲突即刷新使用者与时间,天然幂等。 -->
<insert id="upsertBatch">
INSERT INTO keyword_usage (company_id, country, keyword, user_name, used_time)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.companyId}, #{row.country}, #{row.keyword}, #{row.userName}, #{row.usedTime})
</foreach>
ON DUPLICATE KEY UPDATE user_name = VALUES(user_name), used_time = VALUES(used_time)
</insert>
<delete id="deleteBatch">
DELETE FROM keyword_usage
WHERE company_id = #{companyId}
AND (country, keyword) IN
<foreach collection="keys" item="key" open="(" separator="," close=")">
(#{key.country}, #{key.keyword})
</foreach>
</delete>
</mapper>
@@ -94,7 +94,9 @@ class MigratedSqlEquivalenceTest {
// 113 → 114:2026-11-15 商品上架配额计数(b9b66bcb)在 JdProductMapper 新写 1 条只读 select
//(countByUserIds,按 owner uid 集计 biz_jd_product 行数),逐条点名进 NOT_MIGRATED。
// 该笔当时只点编译没跑整量、两处账本都漏记,2026-11-15 发版前整量抓到补记。
private static final int XML_SELECT_TOTAL = 114;
// 114 → 103:keywordshare 模块整体下线(Project-Slimming 第三轮:6.4 天访问日志零流量、
// 四树零引用、V165 已撤菜单),随删 11 条 select 与下方 NOT_MIGRATED 的 12 条点名。
private static final int XML_SELECT_TOTAL = 103;
/**
* 不是「从注解搬过来」的语句:注解时代没有原文可对撞,等价性这支只能跳过它们。
@@ -112,21 +114,6 @@ class MigratedSqlEquivalenceTest {
"UserSecretUsageMapper#addTokens",
// 失败任务重试:INSERT ... SELECT 复制采集明细行,非注解迁移件。
"CollectDataItemMapper#copyItemsForRetry",
// keywordshare 模块(五国关键词共享网页化,2026-10-23)新写 11 条 select。
"KeywordShareMapper#countHit",
"KeywordShareMapper#selectRows",
"KeywordShareMapper#selectRandomUnused",
"KeywordShareMapper#countDupKeywords",
"KeywordShareMapper#selectFilterCountries",
"KeywordShareMapper#selectFilterTreeRows",
"KeywordShareMapper#selectCountryCounts",
"KeywordShareMapper#selectCategoryCounts",
"KeywordShareMapper#selectSubCategoryCounts",
"KeywordShareMapper#selectCategoryL3Counts",
"KeywordShareMapper#selectExistingKeywords",
// 工作台客户端全量同步新写的词本体 UPSERT:注解时代没有原文可对撞,按新写语句点名留痕。
// 它是 insert 不是 select,故 XML_SELECT_TOTAL 不随之变。
"KeywordShareMapper#upsertBatchFromSync",
// brandgating 模块(品牌Gating库并入管理后台,2026-10-23)新写 8 条 select。
"BrandGatingMapper#countByFilter",
"BrandGatingMapper#selectRows",
@@ -128,7 +128,10 @@ class SqlLayeringConventionTest {
//(countByUserIds,按 owner uid 集计 biz_jd_product 行数,JdPublishQuotaService 配额原语),
// 全部新写,非迁移语句。该笔当时只点编译没跑整量、两处账本都漏记,2026-11-15 发版前
// 整量抓到补记(同轮 MigratedSqlEquivalenceTest.XML_SELECT_TOTAL 113 → 114)。
private static final int XML_STATEMENT_TOTAL = 164;
// 164 → 147:keywordshare 模块整体下线(Project-Slimming 第三轮:6.4 天访问日志零流量、
// 四树零引用、V165 已撤菜单),4 份 XML 17 条语句(11 select + 4 insert + 1 delete)随删;
// 同轮 MigratedSqlEquivalenceTest.XML_SELECT_TOTAL 114 → 103、NOT_MIGRATED 摘掉 12 条点名。
private static final int XML_STATEMENT_TOTAL = 147;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
@@ -22,7 +22,7 @@ import static org.mockito.Mockito.when;
* 兜底鉴权过滤器单测:非受保护路径放行、OPTIONS/豁免前缀放行、
* 匿名拒绝返回与全局一致的 401 体、紧急开关可整体关闭。
*
* <p>/debug/** 于 2026-09-11 纳入保护范围,对应用例见本类后半部分。
* <p>/debug/** 用例随 debug 控制器整体下线一并移除(Project-Slimming 第三轮,2026-11-16)。
*/
class AdminApiGuardFilterTest {
@@ -178,84 +178,13 @@ class AdminApiGuardFilterTest {
assertThat(chain.getRequest()).isNotNull();
}
// ---- /debug/** 纳入保护(2026-09-11)----
// 背景:两个 debug 控制器都没有方法级鉴权,而主机A 18080 公网直连、主机B nginx location /
// 全量反代 Java,导致匿名即可调通(其中 run-stale-finalize 是强制收尾指定 task 的写操作)。
@Test
void anonymousDebugWriteEndpointRejected() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request =
new MockHttpServletRequest("POST", "/debug/task-recovery/run-stale-finalize");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
JsonNode body = objectMapper.readTree(response.getContentAsString());
assertThat(body.path("success").asBoolean()).isFalse();
assertThat(body.path("code").asInt()).isEqualTo(401);
assertThat(chain.getRequest()).isNull();
}
@Test
void anonymousDebugRequestInfoRejected() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/debug/request-info");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNull();
assertThat(response.getContentAsString()).contains("401");
}
@Test
void debugEndpointStillReachableWithInternalToken() throws Exception {
// 应急调用方(run-stale-finalize 是文档指定的线上排障工具)带 X-Internal-Token 仍可直达
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request =
new MockHttpServletRequest("POST", "/debug/task-recovery/run-stale-finalize");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
verify(authSupport, never()).requireUserOrInternal(any());
assertThat(chain.getRequest()).isNotNull();
assertThat(response.getContentAsString()).isEmpty();
}
@Test
void debugBarePrefixItselfIsGuarded() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/debug");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNull();
}
@Test
void similarLookingPathsAreNotSweptIn() throws Exception {
// 前缀边界:只按整段匹配,/debugging、/debug-tools、/api/adminx 都不应被误纳入
// 前缀边界:只按整段匹配,/api/adminx 不应被误纳入(/debugging、/debug-tools 两条
// 随 /debug 前缀下线一并移除——它们守护的前缀已不存在)
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
for (String uri : new String[] {"/debugging", "/debug-tools/list", "/api/adminx"}) {
for (String uri : new String[] {"/api/adminx"}) {
MockHttpServletRequest request = new MockHttpServletRequest("GET", uri);
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
@@ -64,14 +64,14 @@ class ApiGuardCoverageAuditorTest {
void guardedPrefixesCarriesEveryGuardedList() {
List<String> guarded = AdminApiGuardFilter.guardedPrefixes();
assertTrue(guarded.contains("/api/admin"), "admin 前缀没进自检可见名单");
assertTrue(guarded.contains("/debug"), "debug 前缀没进自检可见名单");
// 这两组条数是实测基线(2026-10-08:用户态 15 条、自助 6 条)。
// 只钉"contains 某条"的话,从数组里删掉一整段都可能不红,所以钉总数。
// 2026-10-24 自助 6 → 7:cost-guard 的 status/resume 两个端点 uid 只从 JWT 取,
// 匿名既读不到状态也不该能解除暂停闸,所以进无条件名单而不是登记成「方法内自校验」。
// 2026-10-29 用户态 15 → 16:采集路由读取口 /api/collect-routing 新建即入名单。
assertEquals(24, count(guarded, "/api/"), () -> "以 /api/ 开头的守卫前缀数变了(基线 24 = admin 1 + 用户态 16 + 自助 7):" + guarded);
assertEquals(25, guarded.size(), "守卫前缀总数变了(24 条 /api/ + /debug):" + guarded);
// 2026-11-16 /debug 前缀随 debug 控制器整体下线(Project-Slimming 第三轮)后,总名单 = 24 条 /api/。
assertEquals(24, guarded.size(), "守卫前缀总数变了(24 条 /api/):" + guarded);
assertTrue(guarded.contains("/api/publish"), "2026-10-07 补的上架前缀不能退回名单外");
assertTrue(guarded.contains("/api/tasks"), "心跳/打断前缀不能退回名单外");
assertTrue(guarded.contains("/api/internal"), "内部端点前缀不能退回名单外");
@@ -1,690 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.service;
import com.nanri.aiimage.config.KeywordShareSyncProperties;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordAddLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordDeleteLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordUsageMapper;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareFilterQuery;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordAddLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordDeleteLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordShareEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordUsageEntity;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareAddRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareDeleteRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareSyncImportRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordUsageBatchRequest;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordSharePageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareSyncResultVo;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 五国关键词共享 Service 单测:列表筛选/状态过滤/排序契约、分页与 usedDays 归一化、
* mark 幂等、add 查重跳过 + 留痕 + 自动标记、delete 留痕、random、dup 计数。
*/
@ExtendWith(MockitoExtension.class)
class KeywordShareServiceTest {
private static final Long COMPANY_ID = 7L;
private static final String VIEWER = "阿华";
@Mock
private KeywordShareMapper keywordShareMapper;
@Mock
private KeywordUsageMapper keywordUsageMapper;
@Mock
private KeywordAddLogMapper keywordAddLogMapper;
@Mock
private KeywordDeleteLogMapper keywordDeleteLogMapper;
private KeywordShareService newService() {
return newService(new KeywordShareSyncProperties());
}
private KeywordShareService newService(KeywordShareSyncProperties syncProperties) {
return new KeywordShareService(keywordShareMapper, keywordUsageMapper,
keywordAddLogMapper, keywordDeleteLogMapper, syncProperties);
}
private static KeywordShareSyncProperties rosterOf(boolean strict, String... names) {
KeywordShareSyncProperties properties = new KeywordShareSyncProperties();
properties.setStrict(strict);
properties.setUsedUsers(List.of(names));
return properties;
}
private static KeywordShareRowVo row(long id, String keyword, boolean used, String usedUser) {
KeywordShareRowVo vo = new KeywordShareRowVo();
vo.setId(id);
vo.setCountry("英国");
vo.setKeyword(keyword);
vo.setChinese("翻译" + id);
vo.setUsed(used);
if (used) {
vo.setUsedTime(LocalDateTime.now().minusHours(id));
vo.setUsedUser(usedUser);
}
return vo;
}
// ---------------------------------------------------------------- 列表
@Test
@DisplayName("列表:命中数按用户筛选口径、命中内已使用数单独数一遍、dup 计数进统计条")
void pageComputesHitUsedUnusedAndDup() {
KeywordShareFilterQuery all = new KeywordShareFilterQuery();
all.setCompanyId(COMPANY_ID);
all.setStatus("all");
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(10L, 4L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(3L);
KeywordSharePageVo vo = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "all", 0, false, 1L, 200L);
assertThat(vo.getTotal()).isEqualTo(10L);
assertThat(vo.getStats().getHit()).isEqualTo(10L);
assertThat(vo.getStats().getUsed()).isEqualTo(4L);
assertThat(vo.getStats().getUnused()).isEqualTo(6L);
assertThat(vo.getStats().getDup()).isEqualTo(3L);
// 第二次 countHit 是「命中内已使用数」,必须把 status 换成 used、其余条件原样
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).countHit(captor.capture());
assertThat(captor.getAllValues().get(0).getStatus()).isEqualTo("all");
assertThat(captor.getAllValues().get(1).getStatus()).isEqualTo("used");
assertThat(captor.getAllValues().get(1).getCompanyId()).isEqualTo(COMPANY_ID);
}
@Test
@DisplayName("列表:状态过滤 used/unused 时命中内已/未使用数直接由命中推导,不再多查一遍")
void pageWithActiveStatusFilterDerivesStats() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(6L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
KeywordSharePageVo used = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "used", 0, false, 1L, 200L);
assertThat(used.getStats().getHit()).isEqualTo(6L);
assertThat(used.getStats().getUsed()).isEqualTo(6L);
assertThat(used.getStats().getUnused()).isZero();
KeywordSharePageVo unused = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "unused", 0, false, 1L, 200L);
assertThat(unused.getStats().getUsed()).isZero();
assertThat(unused.getStats().getUnused()).isEqualTo(6L);
// 状态过滤生效时不再为「命中内已使用数」多查一遍:两次 page 各查 1 次
verify(keywordShareMapper, org.mockito.Mockito.times(2)).countHit(any(KeywordShareFilterQuery.class));
}
@Test
@DisplayName("列表:筛选条件(类目/搜索/仅看我/usedDays)与分页进 Mapper 载体,size 上限 500")
void pageCarriesFilterAndNormalizedPaging() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(0L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
newService().page(COMPANY_ID, VIEWER, " 英国 ", "厨房用品", "锅具", "煎锅", "平底锅",
" storage ", "all", 30, true, 0L, 1000L);
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRows(captor.capture());
KeywordShareFilterQuery filter = captor.getValue();
assertThat(filter.getCountry()).isEqualTo("英国");
assertThat(filter.getCategory()).isEqualTo("厨房用品");
assertThat(filter.getSubCategory()).isEqualTo("锅具");
assertThat(filter.getCategoryL3()).isEqualTo("煎锅");
assertThat(filter.getCategoryL4()).isEqualTo("平底锅");
assertThat(filter.getSearch()).isEqualTo("storage");
assertThat(filter.getStatus()).isEqualTo("all");
assertThat(filter.getOnlyMine()).isTrue();
assertThat(filter.getUserName()).isEqualTo(VIEWER);
// usedDays=30:往前推 30 天
assertThat(filter.getUsedSince()).isNotNull();
assertThat(filter.getUsedSince()).isBefore(LocalDateTime.now());
assertThat(filter.getUsedSince()).isAfter(LocalDateTime.now().minusDays(31));
// 分页归一化:page=0→1、size=1000→500
assertThat(filter.getOffset()).isZero();
assertThat(filter.getLimit()).isEqualTo(500L);
}
@Test
@DisplayName("usedDays=1 表示「今天」:时间下限取当日零点;不传/0 表示不限")
void usedDaysOneMeansStartOfToday() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(0L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
newService().page(COMPANY_ID, VIEWER, null, null, null, null, null, null, "all", 1, false, 1L, 200L);
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRows(captor.capture());
assertThat(captor.getValue().getUsedSince()).isEqualTo(LocalDate.now().atStartOfDay());
newService().page(COMPANY_ID, VIEWER, null, null, null, null, null, null, "all", null, false, 1L, 200L);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).selectRows(captor.capture());
assertThat(captor.getValue().getUsedSince()).isNull();
}
@Test
@DisplayName("列表:行按 Mapper 返回顺序透传(SQL 侧已按未使用在前、已使用按 used_time 升序排好),未使用行不带使用者")
void pageRowsKeepMapperOrderAndNormalizeUnusedRows() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(3L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of(
row(2, "kw-old-used", true, "张三"),
row(3, "kw-new-used", true, VIEWER),
row(1, "kw-unused", false, "不该有名字")));
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
KeywordSharePageVo vo = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "all", 0, false, 1L, 200L);
assertThat(vo.getRows()).extracting(KeywordShareRowVo::getId).containsExactly(2L, 3L, 1L);
assertThat(vo.getRows().get(0).isUsed()).isTrue();
assertThat(vo.getRows().get(0).getUsedUser()).isEqualTo("张三");
assertThat(vo.getRows().get(2).isUsed()).isFalse();
assertThat(vo.getRows().get(2).getUsedTime()).isNull();
assertThat(vo.getRows().get(2).getUsedUser()).isEmpty();
}
@Test
@DisplayName("排序契约:Mapper XML 的 ORDER BY 必须是「已使用在前(对齐桌面版)、按 used_time 升序」,且禁止 ${} 拼接")
void mapperXmlKeepsSortContractAndPlaceholderOnly() throws Exception {
String xml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
assertThat(xml).contains("ORDER BY (u.country IS NULL) ASC, u.used_time ASC");
assertThat(xml).doesNotContain("${");
String usageXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordUsageMapper.xml"), StandardCharsets.UTF_8);
assertThat(usageXml).contains("ON DUPLICATE KEY UPDATE").doesNotContain("${");
}
// ---------------------------------------------------------------- 标记/取消使用
@Test
@DisplayName("mark:UPSERT 幂等——重复标记同一词两次结果一致,使用者与时间都取服务端当前值")
void markIsIdempotentWithServerTime() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item1 = new KeywordUsageBatchRequest.Item();
item1.setCountry("英国");
item1.setKeyword(" storage box ");
KeywordUsageBatchRequest.Item item2 = new KeywordUsageBatchRequest.Item();
item2.setCountry("德国");
item2.setKeyword("aufbewahrungsbox");
request.setItems(List.of(item1, item2));
KeywordShareService service = newService();
LocalDateTime before = LocalDateTime.now();
var first = service.mark(request, COMPANY_ID, VIEWER);
var second = service.mark(request, COMPANY_ID, VIEWER);
LocalDateTime after = LocalDateTime.now();
assertThat(first.getMarked()).isEqualTo(2);
assertThat(second.getMarked()).isEqualTo(2);
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper, org.mockito.Mockito.times(2)).upsertBatch(captor.capture());
List<KeywordUsageEntity> rows = captor.getAllValues().get(0);
assertThat(rows).hasSize(2);
assertThat(rows).allSatisfy(row -> {
assertThat(row.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(row.getUserName()).isEqualTo(VIEWER);
assertThat(row.getUsedTime()).isAfterOrEqualTo(before).isBeforeOrEqualTo(after);
});
assertThat(rows.get(0).getKeyword()).isEqualTo("storage box");
assertThat(rows.get(1).getCountry()).isEqualTo("德国");
}
@Test
@DisplayName("mark:批内重复键去重、空键跳过;全空时不动库")
void markSkipsBlankAndDuplicateKeys() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item blank = new KeywordUsageBatchRequest.Item();
blank.setCountry("英国");
blank.setKeyword(" ");
KeywordUsageBatchRequest.Item dup = new KeywordUsageBatchRequest.Item();
dup.setCountry("英国");
dup.setKeyword("box");
KeywordUsageBatchRequest.Item dupAgain = new KeywordUsageBatchRequest.Item();
dupAgain.setCountry(" 英国 ");
dupAgain.setKeyword("box");
request.setItems(List.of(blank, dup, dupAgain));
var result = newService().mark(request, COMPANY_ID, VIEWER);
assertThat(result.getMarked()).isEqualTo(1);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(captor.capture());
assertThat(captor.getValue()).hasSize(1);
assertThat(captor.getValue().get(0).getKeyword()).isEqualTo("box");
KeywordUsageBatchRequest allBlank = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item = new KeywordUsageBatchRequest.Item();
item.setKeyword(" ");
allBlank.setItems(List.of(item));
assertThat(newService().mark(allBlank, COMPANY_ID, VIEWER).getMarked()).isZero();
}
@Test
@DisplayName("unmark:按 (company, country, keyword) 删行,返回实际删除条数")
void unmarkDeletesRowsAndCountsAffected() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item = new KeywordUsageBatchRequest.Item();
item.setCountry("英国");
item.setKeyword("box");
request.setItems(List.of(item));
when(keywordUsageMapper.deleteBatch(eq(COMPANY_ID), anyList())).thenReturn(1);
var result = newService().unmark(request, COMPANY_ID);
assertThat(result.getUnmarked()).isEqualTo(1);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordShareKey>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).deleteBatch(eq(COMPANY_ID), captor.capture());
assertThat(captor.getValue().get(0).getKeyword()).isEqualTo("box");
}
// ---------------------------------------------------------------- 添加
@Test
@DisplayName("add:查重跳过已存在词,空词/批内重复跳过;成功行写词本体 + 添加留痕 + 自动标记已使用")
void addSkipsExistingAndBlankAndWritesLogsAndAutoMarks() {
KeywordShareAddRequest request = new KeywordShareAddRequest();
KeywordShareAddRequest.Item good = new KeywordShareAddRequest.Item();
good.setCountry("英国");
good.setKeyword(" storage box ");
good.setChinese("收纳盒");
KeywordShareAddRequest.Item existing = new KeywordShareAddRequest.Item();
existing.setCountry("德国");
existing.setKeyword("aufbewahrungsbox");
existing.setChinese("收纳箱");
KeywordShareAddRequest.Item blank = new KeywordShareAddRequest.Item();
blank.setCountry("法国");
blank.setKeyword(" ");
KeywordShareAddRequest.Item dup = new KeywordShareAddRequest.Item();
dup.setCountry("英国");
dup.setKeyword("storage box");
request.setItems(List.of(good, existing, blank, dup));
KeywordShareKey existingKey = KeywordShareKey.of("德国", "aufbewahrungsbox");
when(keywordShareMapper.selectExistingKeywords(eq(COMPANY_ID), anyList())).thenReturn(List.of(existingKey));
LocalDateTime before = LocalDateTime.now();
var result = newService().add(request, COMPANY_ID, VIEWER);
assertThat(result.getAdded()).isEqualTo(1);
assertThat(result.getSkipped()).isEqualTo(3);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordShareEntity>> insertCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).insertBatchIgnore(insertCaptor.capture());
KeywordShareEntity inserted = insertCaptor.getValue().get(0);
assertThat(inserted.getCountry()).isEqualTo("英国");
assertThat(inserted.getKeyword()).isEqualTo("storage box");
assertThat(inserted.getChinese()).isEqualTo("收纳盒");
assertThat(inserted.getKtype()).isEqualTo("主关键词");
assertThat(inserted.getSource()).isEqualTo("手动添加");
assertThat(inserted.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(inserted.getUserName()).isEqualTo(VIEWER);
assertThat(inserted.getAddTime()).isAfterOrEqualTo(before);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordAddLogEntity>> logCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordAddLogMapper).insertBatch(logCaptor.capture());
assertThat(logCaptor.getValue()).hasSize(1);
assertThat(logCaptor.getValue().get(0).getKeyword()).isEqualTo("storage box");
assertThat(logCaptor.getValue().get(0).getUserName()).isEqualTo(VIEWER);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getValue()).hasSize(1);
assertThat(usageCaptor.getValue().get(0).getKeyword()).isEqualTo("storage box");
assertThat(usageCaptor.getValue().get(0).getUserName()).isEqualTo(VIEWER);
}
@Test
@DisplayName("add:全部跳过时不动任何表(词本体/留痕/使用状态都不写)")
void addWithNothingToAddTouchesNothing() {
KeywordShareAddRequest request = new KeywordShareAddRequest();
KeywordShareAddRequest.Item blank = new KeywordShareAddRequest.Item();
blank.setCountry("英国");
blank.setKeyword("");
request.setItems(List.of(blank));
var result = newService().add(request, COMPANY_ID, VIEWER);
assertThat(result.getAdded()).isZero();
assertThat(result.getSkipped()).isEqualTo(1);
verify(keywordShareMapper, never()).insertBatchIgnore(anyList());
verify(keywordAddLogMapper, never()).insertBatch(anyList());
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordShareMapper, never()).selectExistingKeywords(any(), anyList());
}
// ---------------------------------------------------------------- 删除
@Test
@DisplayName("delete:只删本公司存在的行并逐行写删除留痕(谁删了哪个词可追溯)")
void deleteWritesDeleteLogForCompanyRows() {
KeywordShareDeleteRequest request = new KeywordShareDeleteRequest();
request.setIds(List.of(1L, 2L, 999L));
KeywordShareEntity row1 = new KeywordShareEntity();
row1.setId(1L);
row1.setCountry("英国");
row1.setKeyword("box");
row1.setCompanyId(COMPANY_ID);
KeywordShareEntity row2 = new KeywordShareEntity();
row2.setId(2L);
row2.setCountry("德国");
row2.setKeyword("kiste");
row2.setCompanyId(COMPANY_ID);
KeywordShareEntity foreign = new KeywordShareEntity();
foreign.setId(999L);
foreign.setCountry("法国");
foreign.setKeyword("mot-etranger");
foreign.setCompanyId(8L);
when(keywordShareMapper.selectBatchIds(List.of(1L, 2L, 999L))).thenReturn(List.of(row1, row2, foreign));
LocalDateTime before = LocalDateTime.now();
var result = newService().delete(request, COMPANY_ID, VIEWER);
// 公司隔离:999 号行是别家公司的,即使 id 在请求里也绝不能删
assertThat(result.getDeleted()).isEqualTo(2);
verify(keywordShareMapper).deleteBatchIds(List.of(1L, 2L));
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordDeleteLogEntity>> logCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordDeleteLogMapper).insertBatch(logCaptor.capture());
List<KeywordDeleteLogEntity> logs = logCaptor.getValue();
assertThat(logs).hasSize(2);
assertThat(logs).extracting(KeywordDeleteLogEntity::getKeyword).containsExactly("box", "kiste");
assertThat(logs).allSatisfy(log -> {
assertThat(log.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(log.getUserName()).isEqualTo(VIEWER);
assertThat(log.getDeleteTime()).isAfterOrEqualTo(before);
});
}
@Test
@DisplayName("delete:请求里的行都不属于本公司(或不存在)时,不动库也不留痕")
void deleteWithNoCompanyRowsTouchesNothing() {
KeywordShareDeleteRequest request = new KeywordShareDeleteRequest();
request.setIds(List.of(1L));
when(keywordShareMapper.selectBatchIds(anyList())).thenReturn(List.of());
var result = newService().delete(request, COMPANY_ID, VIEWER);
assertThat(result.getDeleted()).isZero();
verify(keywordShareMapper, never()).deleteBatchIds(anyList());
verify(keywordDeleteLogMapper, never()).insertBatch(anyList());
}
// ---------------------------------------------------------------- 随机抽词
@Test
@DisplayName("random:只从「未使用」池抽,条数默认 10、上限 100、下限 1")
void randomUsesUnusedPoolWithClampedCount() {
when(keywordShareMapper.selectRandomUnused(any(KeywordShareFilterQuery.class))).thenReturn(List.of(
row(5, "kw-random", false, "")));
var result = newService().random(COMPANY_ID, VIEWER, "英国", null, null, null, null, null, 5L);
assertThat(result).hasSize(1);
assertThat(result.get(0).getKeyword()).isEqualTo("kw-random");
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getStatus()).isEqualTo("unused");
assertThat(captor.getValue().getLimit()).isEqualTo(5L);
assertThat(captor.getValue().getCountry()).isEqualTo("英国");
newService().random(COMPANY_ID, VIEWER, null, null, null, null, null, null, null);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getLimit()).isEqualTo(KeywordShareService.DEFAULT_RANDOM_COUNT);
newService().random(COMPANY_ID, VIEWER, null, null, null, null, null, null, 1000L);
verify(keywordShareMapper, org.mockito.Mockito.times(3)).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getLimit()).isEqualTo(KeywordShareService.MAX_RANDOM_COUNT);
}
// ---------------------------------------------------------------- 防回流的供应商隔离自检
@Test
@DisplayName("公司隔离:全部 Mapper 写路径的第一个参数都是服务端给的 companyId(抽查写 SQL 收口)")
void writeSqlStaysInMapperLayerWithCompanyScope() throws Exception {
String shareXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
// 词本体的读路径一律带 company_id 条件(含 dup 子查询与类目名册)
long scopedSelects = shareXml.lines().filter(line -> line.contains("company_id = #{")).count();
assertThat(scopedSelects).isGreaterThanOrEqualTo(5);
String usageXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordUsageMapper.xml"), StandardCharsets.UTF_8);
assertThat(usageXml).contains("company_id = #{companyId}");
String addXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordAddLogMapper.xml"), StandardCharsets.UTF_8);
String deleteXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordDeleteLogMapper.xml"), StandardCharsets.UTF_8);
assertThat(addXml + deleteXml)
.contains("company_id", "user_name")
.doesNotContain("${");
}
// ---------------------------------------------------------------- 客户端全量同步
private static KeywordShareSyncImportRequest.Item syncItem(String country, String keyword, Boolean used,
String usedUser, String usedTime) {
KeywordShareSyncImportRequest.Item item = new KeywordShareSyncImportRequest.Item();
item.setCountry(country);
item.setKeyword(keyword);
item.setUsed(used);
item.setUsedUser(usedUser);
item.setUsedTime(usedTime);
return item;
}
private static KeywordShareSyncImportRequest syncRequest(List<KeywordShareSyncImportRequest.Item> items) {
KeywordShareSyncImportRequest request = new KeywordShareSyncImportRequest();
request.setItems(items);
return request;
}
@Test
@DisplayName("sync/import:客户端传来的 usedTime/usedUser 与四级类目原样落库,不被服务端此刻与账号覆盖")
void syncImportKeepsClientUsedTimeUserAndCategories() {
KeywordShareSyncImportRequest.Item item = syncItem("英国", "wraps", true, "阿武(吴棋龙)", "2026-10-25T22:59:26");
item.setChinese("包裹");
item.setCategory("衣物鞋类");
item.setSubCategory("包包");
item.setCategoryL3("其他包包");
item.setCategoryL4("其他包包");
item.setKtype("主关键词");
item.setSource("本地导入");
KeywordShareService service = newService(rosterOf(true, "阿武(吴棋龙)"));
LocalDateTime before = LocalDateTime.now();
KeywordShareSyncResultVo vo = service.syncImport(syncRequest(List.of(item)), COMPANY_ID, "kw_share_api");
// 这条用例存在的理由:mark() 走的是 used_time=now()、user_name=token 账号,
// 同步历史时会被改写成「谁在同步那一刻用的」,真实使用人与使用时刻双双丢失。
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
KeywordUsageEntity usage = usageCaptor.getValue().get(0);
assertThat(usage.getUserName()).isEqualTo("阿武(吴棋龙)");
assertThat(usage.getUsedTime()).isEqualTo(LocalDateTime.of(2026, 10, 25, 22, 59, 26))
.isBefore(before);
assertThat(usage.getCompanyId()).isEqualTo(COMPANY_ID);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(wordCaptor.capture());
KeywordShareEntity word = wordCaptor.getValue().get(0);
assertThat(word.getCategory()).isEqualTo("衣物鞋类");
assertThat(word.getSubCategory()).isEqualTo("包包");
assertThat(word.getCategoryL3()).isEqualTo("其他包包");
// 词本体的 user_name 是「添加人」,新词就是本次同步账号——它和使用人是两回事
assertThat(word.getUserName()).isEqualTo("kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1);
assertThat(vo.getUpdated()).isZero();
assertThat(vo.getUsedUserFallback()).isZero();
assertThat(vo.getUsedUserUnknown()).isZero();
assertThat(vo.getUsedTimeFallback()).isZero();
}
@Test
@DisplayName("sync/import:名单外姓名 strict=true 回退账号名并计数,strict=false 放行但仍计 unknown")
void syncImportResolvesOperatorAgainstRoster() {
// 半角括号写法要能命中全角名单,否则同一个人会被后管拆成两个使用者
KeywordShareSyncImportRequest.Item hit = syncItem("英国", "basket", true, "阿武(吴棋龙)", "2026-10-01 08:00:00");
KeywordShareSyncImportRequest.Item miss = syncItem("英国", "hanger", true, "陌生人", "2026-10-01 08:00:00");
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
KeywordShareSyncResultVo strict = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(hit, miss)), COMPANY_ID, "kw_share_api");
verify(keywordUsageMapper).upsertBatch(captor.capture());
// 命中名单后落的是名单里那份写法:客户端传半角也不能让它把同一个人拆成两个使用者
assertThat(captor.getValue()).extracting(KeywordUsageEntity::getUserName)
.containsExactly("阿武(吴棋龙)", "kw_share_api");
assertThat(strict.getUsedUserFallback()).isEqualTo(1);
assertThat(strict.getUsedUserUnknown()).isEqualTo(1);
KeywordShareSyncResultVo lenient = newService(rosterOf(false, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(hit, miss)), COMPANY_ID, "kw_share_api");
assertThat(lenient.getUsedUserFallback()).isZero();
assertThat(lenient.getUsedUserUnknown()).isEqualTo(1);
}
@Test
@DisplayName("sync/import:脏时间按行降级——1970 丢使用状态但词照收、未来值钳到此刻、缺失回退此刻")
void syncImportDegradesDirtyUsedTimePerRow() {
KeywordShareSyncImportRequest.Item ancient = syncItem("英国", "ancient", true, "阿武(吴棋龙)", "1970-01-01T00:00:00");
KeywordShareSyncImportRequest.Item future = syncItem("英国", "future", true, "阿武(吴棋龙)", "2099-01-01T00:00:00");
KeywordShareSyncImportRequest.Item missing = syncItem("英国", "missing", true, "阿武(吴棋龙)", " ");
KeywordShareSyncImportRequest.Item unparsable = syncItem("英国", "garbage", true, "阿武(吴棋龙)", "昨天下午");
LocalDateTime before = LocalDateTime.now();
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(ancient, future, missing, unparsable)), COMPANY_ID, "kw_share_api");
assertThat(vo.getUsageSkipped()).isEqualTo(1);
assertThat(vo.getUsedTimeClamped()).isEqualTo(1);
assertThat(vo.getUsedTimeFallback()).isEqualTo(2);
// 一颗脏时间戳不该打掉整批:四个词全部入库,只有 ancient 的使用状态被丢
assertThat(vo.getAdded()).isEqualTo(4);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(wordCaptor.capture());
assertThat(wordCaptor.getValue()).extracting(KeywordShareEntity::getKeyword)
.containsExactly("ancient", "future", "missing", "garbage");
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getValue()).hasSize(3)
.allSatisfy(row -> assertThat(row.getUsedTime()).isAfterOrEqualTo(before));
}
@Test
@DisplayName("sync/import:used=false 删使用记录;dryRun 只统计不写;空键与批内重复计入 skipped")
void syncImportDeletesUsageAndHonoursDryRun() {
List<KeywordShareSyncImportRequest.Item> items = List.of(
syncItem("英国", "keep", false, null, null),
syncItem("英国", "drop", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"),
syncItem("英国", "drop", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"),
syncItem("", "no-country", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"));
KeywordShareSyncImportRequest request = syncRequest(items);
KeywordShareService service = newService(rosterOf(true, "阿武(吴棋龙)"));
KeywordShareSyncImportRequest dryRunRequest = syncRequest(items);
dryRunRequest.setDryRun(true);
KeywordShareSyncResultVo dryRun = service.syncImport(dryRunRequest, COMPANY_ID, "kw_share_api");
assertThat(dryRun.isDryRun()).isTrue();
assertThat(dryRun.getSkipped()).isEqualTo(2);
assertThat(dryRun.getAdded()).isEqualTo(2);
verify(keywordShareMapper, never()).upsertBatchFromSync(anyList());
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordUsageMapper, never()).deleteBatch(any(), anyList());
KeywordShareSyncResultVo real = service.syncImport(request, COMPANY_ID, "kw_share_api");
assertThat(real.isDryRun()).isFalse();
ArgumentCaptor<List<KeywordShareKey>> deleteCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).deleteBatch(eq(COMPANY_ID), deleteCaptor.capture());
assertThat(deleteCaptor.getValue()).extracting(KeywordShareKey::getKeyword).containsExactly("keep");
assertThat(real.getUsageDeleted()).isEqualTo(1);
}
@Test
@DisplayName("sync/import:used 不传=不碰使用状态(只同步词库不能把后台已有使用记录删掉)")
void syncImportLeavesUsageUntouchedWhenUsedFlagOmitted() {
KeywordShareSyncImportRequest.Item wordOnly = syncItem("英国", "wraps", null, null, null);
wordOnly.setCategory("衣物鞋类");
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(wordOnly)), COMPANY_ID, "kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1);
assertThat(vo.getUsageUpserted()).isZero();
assertThat(vo.getUsageDeleted()).isZero();
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordUsageMapper, never()).deleteBatch(any(), anyList());
ArgumentCaptor<List<KeywordShareEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(captor.capture());
assertThat(captor.getValue().get(0).getCategory()).isEqualTo("衣物鞋类");
}
@Test
@DisplayName("sync/import:写侧按 500 行分片,不把整批塞进一条 SQL 的占位符里")
void syncImportShardsWrites() {
List<KeywordShareSyncImportRequest.Item> items = new java.util.ArrayList<>();
for (int i = 0; i < 1200; i++) {
items.add(syncItem("英国", "kw-" + i, true, "阿武(吴棋龙)", "2026-10-01T08:00:00"));
}
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(items), COMPANY_ID, "kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1200);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper, org.mockito.Mockito.times(3)).upsertBatchFromSync(wordCaptor.capture());
assertThat(wordCaptor.getAllValues()).extracting(List::size).containsExactly(500, 500, 200);
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper, org.mockito.Mockito.times(3)).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getAllValues()).extracting(List::size).containsExactly(500, 500, 200);
}
@Test
@DisplayName("sync/import 的 UPSERT SQL:类目非空才覆盖,且更新分支不得改写添加人与添加时间")
void syncUpsertKeepsCategoriesAndProvenance() throws Exception {
String xml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
String upsert = xml.substring(xml.indexOf("<insert id=\"upsertBatchFromSync\">"));
assertThat(upsert).contains("ON DUPLICATE KEY UPDATE")
.contains("category = COALESCE(NULLIF(VALUES(category), ''), category)")
.contains("sub_category = COALESCE(NULLIF(VALUES(sub_category), ''), sub_category)")
.doesNotContain("${");
// 更新分支只碰类目/释义/类型/来源:user_name、add_time 是历史归属,同步无权改写
String updateBranch = upsert.substring(upsert.indexOf("ON DUPLICATE KEY UPDATE"));
assertThat(updateBranch).doesNotContain("user_name =")
.doesNotContain("add_time =");
}
}
@@ -25,7 +25,7 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* AC-19(R8/审计 P1-B1、P1-B2、P1-B3、P1-B4):任务中心时间窗+keyset、关键词去 RAND、
* AC-19(R8/审计 P1-B1、P1-B3、P1-B4):任务中心时间窗+keyset、
* 心跳瘦字段、权限菜单短 TTL 缓存。
*
* <p>逐条证据:
@@ -35,8 +35,6 @@ import static org.mockito.Mockito.when;
* {@code ORDER BY m.createdAt DESC, m.id DESC LIMIT #{limit} OFFSET #{offset}},
* 而 {@code TaskCenterQueryService.tasks()}(:110-139)把 {@code startTime/endTime}
* 原样透传、服务层不填默认窗口 ⇒ 不带时间参数就是全历史 UNION + 深 OFFSET。</li>
* <li><b>P1-B2</b> {@code mapper/keywordshare/KeywordShareMapper.xml:53} 的
* {@code selectRandomUnused} 是 {@code ORDER BY RAND()}(全表 filesort)。</li>
* <li><b>P1-B3</b> {@code TaskHeartbeatService.java:111-116} 的 {@code selectFileTask}
* 没有 {@code .select(...)},捞整行 {@code FileTaskEntity}(含
* {@code requestJson}/{@code resultJson}),而心跳只用
@@ -82,16 +80,6 @@ class PendingPhase5ReadPathTest {
.containsAnyOf("DEFAULT_WINDOW", "minusDays", "startOfDefaultWindow");
}
@Test
void 关键词抽词不许再_ORDER_BY_RAND() throws Exception {
String body = MapperXmlSupport.statementBody(
com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper.class, "selectRandomUnused");
assertThat(body)
.as("P1-B2:ORDER BY RAND() 对全表 filesort;要么先 count 取随机 offset,要么物化 used 标记")
.doesNotContain("RAND()");
}
@Test
void 心跳取任务必须只读瘦字段() {
String service = SourceScan.withoutComments(SourceScan.sourceText("TaskHeartbeatService.java"));