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>