feat(phase-3): 后管无侵权只读页——私有鉴权闸+readCompanyIdOrOwn 公司隔离+分页钳制;前端自绘表格页与路由/操作提示/五护栏同轮记账

后端:AdminAppearancePatentCleanItemsController(GET /api/admin/appearance-patent-clean-items,requireCleanItemsAccess 照去重页形状)+ AppearancePatentCleanItemQueryService(page≤10000/size≤100 钳制防 (page-1)*page_size 溢出)+两 VO;PageDefaults 第五种 page_size=10 显式登记。前端:AppearancePatentCleanItemsPage(自绘 table+OldPagination,companyScoped)+api/filter/model 拆件;routes/company-scope/operation-guides 收口。护栏:company-tab-wiring 24 处发送口、date-range-order 分母 21 实例/9 对、date-guard EXEMPT、ChunkRow 无侵权白名单四件(LlmClient 仍是唯一结论值来源)、SourceScan 52 支、G2 WIRED_PAGE_KEYS 第七支。判据修正:columnKey→getColumnKey 对齐代码库命名。
This commit is contained in:
2026-11-10 02:27:50 +08:00
parent 0512359b21
commit 83f1ecf952
22 changed files with 1375 additions and 76 deletions
@@ -60,4 +60,7 @@ export const COMPANY_SCOPED_PAGES: readonly CompanyScopedPage[] = [
// 「无效的菜单权限项」。写侧(编辑/删除/重排)不带参数——归属由那一行的 id 与操作者公司共同判定,
// 跨公司写后端 403(见 docs/ops/menu-company-tree-design-2026-10-06.md §5)。
{ menuKey: 'admin_columns', apiFiles: ['src/pages/account/menu-manage-api.ts'], pageFiles: ['src/pages/account/MenusPage.vue'] },
// 外观专利无侵权数据(2026-11-10 v1.3):出表成功自动同步的只读明细,归属物化在行 company_id 列
// (V189,同店铺密钥形状)⇒ 后端正门 readCompanyIdOrOwn(超管显式传才收窄,非超管强制本公司)。
{ menuKey: 'admin_appearance_patent_clean_items', apiFiles: ['src/pages/patent/appearance-patent-clean-api.ts'], pageFiles: ['src/pages/patent/AppearancePatentCleanItemsPage.vue'] },
]
@@ -121,6 +121,10 @@ export const OPERATION_GUIDES: Record<string, OperationGuideData> = {
text: '按账号、业务、状态、店铺和创建时间筛出客户端任务,点任务查看明细与分组结果;顶部汇总卡给当前在跑与疑似卡住的总量。',
steps: ['按条件筛任务', '查看任务明细', '核对汇总卡'],
},
admin_appearance_patent_clean_items: {
text: '本页只读:出表成功后「结论=无侵权」的明细自动同步到这里,按分公司隔离分页展示;支持任务号/ASIN/国家/同步日期筛选,下载原表请到任务中心取结果文件。',
steps: ['筛选记录', '核对结论明细', '到任务中心下载原表'],
},
}
/** 全部有独立/兜底提示的后台业务菜单 key。 */
@@ -0,0 +1,334 @@
<script setup lang="ts">
import { formatDateTime, orderedPair } from '@/utils/datetime'
/** 外观专利无侵权数据 · 只读分页列表(v1.3,展示形式参照「去重数据库」页:自绘 table +
* OldPagination,不做卡片宫格)。数据由出表成功点自动同步(后端 SyncService),本页零写操作:
* 无编辑/导入/导出,下载走既有结果直链/任务中心。 */
import { computed, onMounted, reactive, ref, watch } from 'vue'
import { fetchAppearancePatentCleanList } from './appearance-patent-clean-api.ts'
import type { AppearancePatentCleanItem } from './appearance-patent-clean-model.ts'
import { cleanItemReasonTooltip } from './appearance-patent-clean-model.ts'
import { createAppearancePatentCleanFilterState } from './appearance-patent-clean-filter.ts'
import { ASIN_COUNTRY_CODES, asinCountryLabel } from '../asin/asin-country.ts'
import OldPagination from '@/components/OldPagination.vue'
import { useCompanyTabStore } from '@/stores/company-tab'
import { showAdminFeedback } from '@/components/admin-feedback-ui'
import { loadFailureMessage } from '@/components/load-failure-model'
import LoadFailureBar from '@/components/LoadFailureBar.vue'
const companyTab = useCompanyTabStore()
const loading = ref(false)
const loadFailure = ref('')
const rows = ref<AppearancePatentCleanItem[]>([])
const total = ref(0)
const page = ref(1)
const pageSize = ref(10)
/** 同步台账是累计数据,日期初值故意留空(默认当天会让首屏只剩今天同步的行);见 date-filter-default-today 护栏的 EXEMPT。 */
const filter = reactive(createAppearancePatentCleanFilterState())
/** min/max 挡不住手输,落值后把倒挂的起止交换回来。 */
function clampDatePair(): void {
const [s, e] = orderedPair(filter.startDate, filter.endDate)
filter.startDate = s
filter.endDate = e
}
const totalPages = computed(() => Math.max(1, Math.ceil(total.value / pageSize.value)))
async function load(): Promise<void> {
loading.value = true
loadFailure.value = ''
try {
const result = await fetchAppearancePatentCleanList({
page: page.value,
pageSize: pageSize.value,
taskId: filter.taskId,
asin: filter.asin,
country: filter.country,
startDate: filter.startDate,
endDate: filter.endDate,
companyId: companyTab.requestCompanyId,
})
rows.value = result.items
total.value = result.total
if (result.page >= 1) page.value = result.page
} catch (error) {
loadFailure.value = loadFailureMessage(error, '无侵权数据加载失败')
showAdminFeedback(loadFailure.value, 'error')
} finally {
loading.value = false
}
}
function apply(): void {
page.value = 1
void load()
}
function changePage(next: number): void {
if (next < 1 || next > totalPages.value) return
page.value = next
void load()
}
function changeSize(size: number) {
pageSize.value = size
page.value = 1
void load()
}
// 切公司 = 重新取数:任务号/ASIN 是上一家选中的值,在新一家的行集里筛不出东西,必须一起清。
watch(() => companyTab.activeId, () => { filter.taskId = ''; filter.asin = ''; page.value = 1; void load() })
onMounted(() => {
void load()
})
</script>
<template>
<div class="clean-items-view">
<section class="panel-box">
<div class="clean-panel-head">
<h3>外观专利无侵权数据</h3>
</div>
<div class="clean-filter-row">
<div class="form-group">
<label>任务号</label>
<input v-model="filter.taskId" type="text" placeholder="输入任务号" @keyup.enter="apply" />
</div>
<div class="form-group">
<label>ASIN</label>
<input v-model="filter.asin" type="text" placeholder="输入 ASIN" @keyup.enter="apply" />
</div>
<div class="form-group">
<label>国家</label>
<select v-model="filter.country">
<option value="">全部国家</option>
<option v-for="code in ASIN_COUNTRY_CODES" :key="code" :value="code">{{ asinCountryLabel(code) }}</option>
</select>
</div>
<div class="form-group">
<label>同步开始日期</label>
<input v-model="filter.startDate" type="date" :max="filter.endDate" @change="clampDatePair" />
</div>
<div class="form-group">
<label>同步结束日期</label>
<input v-model="filter.endDate" type="date" :min="filter.startDate" @change="clampDatePair" />
</div>
<div class="clean-filter-actions">
<button class="btn" type="button" @click="apply">查询</button>
</div>
</div>
<LoadFailureBar v-if="loadFailure" :message="loadFailure" @retry="load" />
<div class="table-scroll clean-table-scroll">
<table>
<thead>
<tr>
<th style="width: 90px">任务号</th>
<th>ASIN</th>
<th style="width: 64px">国家</th>
<th>SKU</th>
<th>品牌</th>
<th style="width: 90px">价格</th>
<th>标题</th>
<th style="width: 130px">结论</th>
<th style="width: 150px">同步时间</th>
</tr>
</thead>
<tbody>
<template v-if="rows.length">
<tr v-for="row in rows" :key="row.id">
<td>{{ row.taskId ?? '-' }}</td>
<td class="mono-cell">{{ row.asin || '-' }}</td>
<td>{{ asinCountryLabel(row.country || '') }}</td>
<td class="mono-cell">{{ row.sku || '-' }}</td>
<td>{{ row.brand || '-' }}</td>
<td>{{ row.price || '-' }}</td>
<td class="title-cell" :title="row.title">{{ row.title || '-' }}</td>
<td class="conclusion-cell" :title="cleanItemReasonTooltip(row)">{{ row.conclusion || '-' }}</td>
<td>{{ formatDateTime(row.syncedAt || '') }}</td>
</tr>
</template>
<tr v-else-if="loading">
<td colspan="9" class="empty-tip">加载中...</td>
</tr>
<tr v-else>
<td colspan="9" class="empty-tip">暂无无侵权数据</td>
</tr>
</tbody>
</table>
</div>
<OldPagination :total="total" :page="page" :page-size="pageSize" @change="changePage" @size-change="changeSize" />
</section>
</div>
</template>
<style scoped>
/* 像素复刻参照「去重数据库」页(panel-box + 自绘表格 + 旧式分页),只读无操作列。 */
.clean-items-view {
font-family: inherit;
color: var(--c-text, #24384d);
display: flex;
flex-direction: column;
gap: 18px;
}
.panel-box {
width: 100%;
min-width: 0;
padding: 20px 22px 24px;
border: 1px solid #d8e3ee;
border-radius: 14px;
background: linear-gradient(145deg, #ffffff, #f9fbfd);
box-shadow: 0 1px 2px rgba(39, 67, 94, 0.04), 0 14px 30px -24px rgba(39, 67, 94, 0.28);
}
h3 {
margin: 0 0 16px;
font-size: 15px;
font-weight: 650;
color: #24384d;
letter-spacing: 0.2px;
}
.clean-panel-head h3 {
margin: 0 0 16px;
}
.clean-filter-row {
display: grid;
grid-template-columns: repeat(5, minmax(150px, 1fr)) auto;
gap: 12px;
align-items: end;
margin-bottom: 16px;
}
.clean-filter-row .form-group {
min-width: 0;
}
.clean-filter-actions {
display: flex;
gap: 10px;
align-items: center;
white-space: nowrap;
}
.form-group {
display: flex;
flex-direction: column;
gap: 7px;
margin-bottom: 0;
}
.form-group label {
color: #5b6f83;
font-size: 12.5px;
font-weight: 600;
}
.form-group input,
.form-group select {
min-width: 0;
min-height: 42px;
padding: 8px 12px;
border: 1px solid #cbd9e6;
border-radius: 9px;
background: #f8fbfd;
color: #24384d;
font-size: 13.5px;
font-family: inherit;
color-scheme: light;
outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
}
.form-group input:hover,
.form-group select:hover {
border-color: #9fb7cd;
}
.form-group input:focus,
.form-group select:focus {
background: #ffffff;
border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
}
.form-group input[type="date"] {
color-scheme: light;
}
.btn {
display: inline-flex;
align-items: center;
justify-content: center;
gap: 8px;
min-height: 42px;
padding: 9px 18px;
border: 1px solid #4f78a5;
border-radius: 9px;
background: linear-gradient(135deg, #5f85ad, #4f78a5);
color: #ffffff;
font-family: inherit;
font-size: 13.5px;
cursor: pointer;
box-shadow: 0 8px 18px -14px rgba(79, 120, 165, 0.72);
transition: background 160ms ease, box-shadow 160ms ease, transform 120ms ease;
}
.btn:hover:not(:disabled) {
background: linear-gradient(135deg, #7094ba, #5d83ac);
box-shadow: 0 11px 22px -14px rgba(79, 120, 165, 0.8);
}
.btn:disabled {
cursor: not-allowed;
opacity: 0.6;
}
.table-scroll {
width: 100%;
min-width: 0;
overflow-x: auto;
border: 1px solid #dbe5ee;
border-radius: 10px;
background: #ffffff;
}
.table-scroll table {
width: 100%;
border-collapse: collapse;
table-layout: fixed;
}
.clean-table-scroll > table {
min-width: 1040px;
}
.table-scroll th,
.table-scroll td {
padding: 10px 12px;
text-align: left;
font-size: 13.5px;
line-height: 1.5;
border-bottom: 1px solid #e0e8ef;
vertical-align: middle;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.table-scroll th {
background: #edf4fa;
color: #4e6479;
border-bottom-color: #d5e1eb;
font-size: 12.5px;
font-weight: 600;
letter-spacing: 0.4px;
}
.table-scroll tbody tr:hover td {
background: #f1f7fb;
}
.table-scroll tbody tr:last-child td {
border-bottom: 0;
}
.mono-cell {
font-family: "Cascadia Mono", "SF Mono", Consolas, "Courier New", monospace;
font-size: 12.5px;
}
.title-cell {
max-width: 260px;
}
.conclusion-cell {
max-width: 130px;
}
.empty-tip {
padding: 44px 24px;
text-align: center;
color: #8293a5;
font-size: 13.5px;
}
</style>
@@ -0,0 +1,33 @@
/** 外观专利无侵权数据列表查询适配(v1.3 AC-5):GET /api/admin/appearance-patent-clean-items。
* 只读页,无写/删/导出入口。公司 tab 的值由本发送口从原始入参自己下传(白名单构造不认识
* company_id),取值口形状由 company-tab-wiring 护栏钉住。 */
import { http } from '@/api/http'
import {
toAppearancePatentCleanListParams,
type AppearancePatentCleanListParams,
} from './appearance-patent-clean-filter.ts'
import {
parseAppearancePatentCleanPage,
type AppearancePatentCleanPageResult,
} from './appearance-patent-clean-model.ts'
export const APPEARANCE_PATENT_CLEAN_ENDPOINT = '/api/admin/appearance-patent-clean-items'
export async function fetchAppearancePatentCleanList(
params: AppearancePatentCleanListParams,
): Promise<AppearancePatentCleanPageResult> {
const query = toAppearancePatentCleanListParams(
{
taskId: params.taskId ?? '',
asin: params.asin ?? '',
country: params.country ?? '',
startDate: params.startDate ?? '',
endDate: params.endDate ?? '',
},
params.page,
params.pageSize,
)
if (params.companyId != null) query.company_id = params.companyId
const { data } = await http.get<unknown>(APPEARANCE_PATENT_CLEAN_ENDPOINT, { params: query })
return parseAppearancePatentCleanPage(data)
}
@@ -0,0 +1,88 @@
/** 外观专利无侵权数据页筛选纯函数(v1.3 AC-5):任务号/ASIN/国家/起止时间 + snake 分页参数。
* 产出与后端 §3.2 参数归一逐字对撞:`page`/`page_size`(默认 10、上限 100)、`task_id`、
* `asin`、`country`、`start_date`/`end_date`(ISO yyyy-MM-dd;空白不下发)。
* 分页钳制(铁律 15):page < 1 归 1、上限 10_000(后端 CR-18 同值),(page-1)*page_size
* 最大 999_900,Number.MAX_SAFE_INTEGER 也不会把乘积顶出安全整数。纯逻辑,node --test 直测。
* 公司维不在这里:归一化构造器不认识 company_id(同 asin-filter 惯例),由 api 发送口从
* 原始入参自己下传——取值口由 company-tab-wiring 护栏的发送行钉看守。 */
import { validIsoDateOrUndefined } from '../asin/asin-filter.ts'
/** 每页条数默认 10(蓝图 §3.2),上限 100。 */
export const APPEARANCE_PATENT_CLEAN_PAGE_SIZE = 10
export const APPEARANCE_PATENT_CLEAN_MAX_PAGE_SIZE = 100
/** 页码上限:与后端 AppearancePatentCleanItemQueryService.MAX_PAGE(CR-18 先例)同值,两侧不漂。 */
export const APPEARANCE_PATENT_CLEAN_MAX_PAGE = 10_000
export interface AppearancePatentCleanFilterState {
/** 任务号(纯数字文本,空串不限)。 */
taskId: string
/** ASIN 前缀。 */
asin: string
/** 国家代码,空串=全部。 */
country: string
/** 同步开始日期(ISO yyyy-MM-dd;空串不限)。 */
startDate: string
/** 同步结束日期(ISO yyyy-MM-dd;空串不限)。 */
endDate: string
}
export function createAppearancePatentCleanFilterState(): AppearancePatentCleanFilterState {
return { taskId: '', asin: '', country: '', startDate: '', endDate: '' }
}
/** 是否有任一激活筛选条件。 */
export function appearancePatentCleanFilterActive(state: AppearancePatentCleanFilterState): boolean {
if ((state.taskId || '').trim()) return true
if ((state.asin || '').trim()) return true
if ((state.country || '').trim()) return true
if (validIsoDateOrUndefined(state.startDate) || validIsoDateOrUndefined(state.endDate)) return true
return false
}
/** 序列化到后端的查询参数(snake_case,仅下发非空字段)。 */
export interface AppearancePatentCleanQuery {
page: number
page_size: number
task_id?: number
asin?: string
country?: string
start_date?: string
end_date?: string
/** 公司 tab:白名单构造不点名它,字段只为 api 发送口的 `query.company_id = params.companyId` 存在。 */
company_id?: number
}
/** api 模块的入参:筛选态 + 分页 + 公司值(camel)。 */
export interface AppearancePatentCleanListParams {
page: number
pageSize: number
taskId?: string
asin?: string
country?: string
startDate?: string
endDate?: string
companyId?: number | null
}
/** 过滤态 + 分页 → 列表查询参数;空白/非法日期不下发,分页钳制在此单出口(不含公司维)。 */
export function toAppearancePatentCleanListParams(
state: AppearancePatentCleanFilterState,
page: number,
pageSize: number,
): AppearancePatentCleanQuery {
const safePage = Math.min(Math.max(Math.floor(page) || 1, 1), APPEARANCE_PATENT_CLEAN_MAX_PAGE)
const rawSize = Math.floor(pageSize) || APPEARANCE_PATENT_CLEAN_PAGE_SIZE
const safeSize = Math.min(Math.max(rawSize, 1), APPEARANCE_PATENT_CLEAN_MAX_PAGE_SIZE)
const query: AppearancePatentCleanQuery = { page: safePage, page_size: safeSize }
const taskId = Number.parseInt((state.taskId || '').trim(), 10)
if (Number.isFinite(taskId) && taskId > 0) query.task_id = taskId
const asin = (state.asin || '').trim()
if (asin) query.asin = asin
const country = (state.country || '').trim()
if (country) query.country = country
const startDate = validIsoDateOrUndefined(state.startDate)
if (startDate) query.start_date = startDate
const endDate = validIsoDateOrUndefined(state.endDate)
if (endDate) query.end_date = endDate
return query
}
@@ -0,0 +1,105 @@
/** 外观专利无侵权数据列表查询模型(v1.3 AC-5):解析 AppearancePatentCleanItemPageVo(camel),纯逻辑。
* 行值是同步服务从 chunk payload 原样落的,读侧只搬运不加工(与后端 toVo 同一口径)。 */
import { unwrap } from '../../api/envelope.ts'
export interface AppearancePatentCleanItem {
id: number
resultId: number | null
taskId: number | null
userId: number | null
companyId: number | null
rowNo: number | null
asin: string
country: string
sku: string
brand: string
price: string
title: string
imageUrl: string
itemUrl: string
conclusion: string
titleReason: string
appearanceReason: string
patentReason: string
sourceFilename: string
syncedAt?: string
}
export interface AppearancePatentCleanPageResult {
items: AppearancePatentCleanItem[]
total: number
page: number
pageSize: number
}
/** 前端首屏默认容量:与后端 PageDefaults.CLEAN_ITEMS_PAGE_SIZE(蓝图 §3.2 默认 10)同值。 */
export const APPEARANCE_PATENT_CLEAN_DEFAULT_SIZE = 10
export function emptyAppearancePatentCleanPage(): AppearancePatentCleanPageResult {
return { items: [], total: 0, page: 1, pageSize: APPEARANCE_PATENT_CLEAN_DEFAULT_SIZE }
}
function text(value: unknown): string {
return typeof value === 'string' ? value.trim() : ''
}
function numberOrNull(value: unknown): number | null {
return typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : null
}
/** 解析单行明细;缺 id 视为无效。camel 为正、snake 容错(与去重页模型同形)。 */
export function toAppearancePatentCleanItem(raw: unknown): AppearancePatentCleanItem | null {
if (!raw || typeof raw !== 'object') return null
const record = raw as Record<string, unknown>
const id = numberOrNull(record.id)
if (id === null) return null
return {
id,
resultId: numberOrNull(record.resultId ?? record.result_id),
taskId: numberOrNull(record.taskId ?? record.task_id),
userId: numberOrNull(record.userId ?? record.user_id),
companyId: numberOrNull(record.companyId ?? record.company_id),
rowNo: numberOrNull(record.rowNo ?? record.row_no),
asin: text(record.asin),
country: text(record.country),
sku: text(record.sku),
brand: text(record.brand),
price: text(record.price),
title: text(record.title),
imageUrl: text(record.imageUrl ?? record.image_url),
itemUrl: text(record.itemUrl ?? record.item_url),
conclusion: text(record.conclusion),
titleReason: text(record.titleReason ?? record.title_reason),
appearanceReason: text(record.appearanceReason ?? record.appearance_reason),
patentReason: text(record.patentReason ?? record.patent_reason),
sourceFilename: text(record.sourceFilename ?? record.source_filename),
syncedAt: text(record.syncedAt ?? record.synced_at) || undefined,
}
}
/** 归一化分页负载(信封或已解包 VO)为前端结果;缺省字段回默认。无 keyset 游标(蓝图 Out of Scope)。 */
export function parseAppearancePatentCleanPage(payload: unknown): AppearancePatentCleanPageResult {
const out = emptyAppearancePatentCleanPage()
const core = unwrap<unknown>(payload)
if (!core || typeof core !== 'object') return out
const record = core as Record<string, unknown>
if (Array.isArray(record.items)) {
out.items = record.items
.map((raw) => toAppearancePatentCleanItem(raw))
.filter((item): item is AppearancePatentCleanItem => item !== null)
}
if (typeof record.total === 'number') out.total = Math.floor(record.total)
if (typeof record.page === 'number' && record.page >= 1) out.page = Math.floor(record.page)
const rawSize = record.pageSize ?? record.page_size
if (typeof rawSize === 'number' && rawSize >= 1) out.pageSize = Math.floor(rawSize)
return out
}
/** 结论单元格的悬停全文:三因齐给,空因不下发(读侧不加工的展示面出口)。 */
export function cleanItemReasonTooltip(item: AppearancePatentCleanItem): string {
const parts: string[] = []
if (item.titleReason) parts.push(`标题:${item.titleReason}`)
if (item.appearanceReason) parts.push(`外观:${item.appearanceReason}`)
if (item.patentReason) parts.push(`专利:${item.patentReason}`)
return parts.join('\n')
}
+1
View File
@@ -44,6 +44,7 @@ export const adminPages: AdminPageDef[] = [
{ path: 'asin-center/query', menuKey: 'admin_query_asin', title: '查询ASIN', companyScoped: true, load: () => import('@/pages/asin/QueryAsinPage.vue') },
{ path: 'asin-center/categories', menuKey: 'admin_product_categories', title: '商品类目', companyScoped: false, load: () => import('@/pages/asin/ProductCategoryPage.vue') },
{ path: 'asin-center/skip-price', menuKey: 'admin_skip_price_asin', title: '最低价ASIN', companyScoped: true, load: () => import('@/pages/asin/SkipPricePage.vue') },
{ path: 'patent-center/clean-items', menuKey: 'admin_appearance_patent_clean_items', title: '外观专利无侵权数据', companyScoped: true, load: () => import('@/pages/patent/AppearancePatentCleanItemsPage.vue') },
]
export function routeOf(page: AdminPageDef): RouteRecordRaw {
@@ -1,9 +1,5 @@
/**
* 外观专利无侵权数据页筛选纯函数(v1.3 AC-5)—— Pending Phase 3。
*
* Phase 3 组 B 落 `src/pages/patent/appearance-patent-clean-filter.ts`(照 dedupe-total-filter.ts
* 拆分:createAppearancePatentCleanFilterState / appearancePatentCleanFilterActive /
* toAppearancePatentCleanListParams)后,把下面两条 todo 转成真用例并移除 todo 标记:
* 外观专利无侵权数据页筛选纯函数(v1.3 AC-5)—— Phase 3 激活。
*
* 1. **snake 参数形状**:toAppearancePatentCleanListParams({...}) 产出
* `page`/`page_size`(默认 10、上限 100)、`task_id`、`asin`、`country`、
@@ -15,6 +11,57 @@
* `tests/*.test.ts`,不递归;纯函数零依赖可直测)
*/
import { test } from 'node:test'
import assert from 'node:assert/strict'
test.todo('Pending Phase 3: AC-5 筛选参数——snake page/page_size/task_id/asin/country/start_date/end_date 形状')
test.todo('Pending Phase 3: AC-5 筛选参数——page 钳制防 (page-1)*page_size 溢出(铁律 15)')
import {
APPEARANCE_PATENT_CLEAN_MAX_PAGE,
createAppearancePatentCleanFilterState,
toAppearancePatentCleanListParams,
} from '../src/pages/patent/appearance-patent-clean-filter.ts'
test('AC-5 筛选参数——snake page/page_size/task_id/asin/country/start_date/end_date 形状', () => {
const full = toAppearancePatentCleanListParams(
{ taskId: '33179', asin: ' B0AB8CDEF9 ', country: 'DE', startDate: '2026-11-01', endDate: '2026-11-09' },
2,
20,
)
// snake 逐字对撞后端 §3.2;ASIN 前后空白被构造器剥掉(后端服务侧再 trim 一次是双保险)。
assert.deepEqual(full, {
page: 2,
page_size: 20,
task_id: 33179,
asin: 'B0AB8CDEF9',
country: 'DE',
start_date: '2026-11-01',
end_date: '2026-11-09',
})
// 空白/非法值不下发:全空态只有分页两项;非法日期与空串同罪。
const blank = toAppearancePatentCleanListParams(createAppearancePatentCleanFilterState(), 1, 10)
assert.deepEqual(blank, { page: 1, page_size: 10 })
const dirty = toAppearancePatentCleanListParams(
{ taskId: 'abc', asin: ' ', country: '', startDate: '2026/11/01', endDate: 'not-a-date' },
1,
10,
)
assert.deepEqual(dirty, { page: 1, page_size: 10 })
assert.equal('task_id' in dirty, false, '非数字任务号不下发')
assert.equal('start_date' in dirty, false, '非法日期不下发')
})
test('AC-5 筛选参数——page 钳制防 (page-1)*page_size 溢出(铁律 15)', () => {
// page < 1 归 1;page_size 下限 1、默认 10、上限 100。
const low = toAppearancePatentCleanListParams(createAppearancePatentCleanFilterState(), 0, 0)
assert.equal(low.page, 1, 'page<1 归 1')
assert.equal(low.page_size, 10, 'page_size 非法回默认 10')
const big = toAppearancePatentCleanListParams(createAppearancePatentCleanFilterState(), 3, 500)
assert.equal(big.page_size, 100, 'page_size 上限 100')
// 溢出边界:page 极大值钳到 10_000(与后端 MAX_PAGE 同值),乘积 999_900 必须还是安全整数——
// 不钳的话 (Number.MAX_SAFE_INTEGER-1)*100 直接顶出安全整数域,翻页偏移就不再可靠。
const extreme = toAppearancePatentCleanListParams(createAppearancePatentCleanFilterState(), Number.MAX_SAFE_INTEGER, 100)
assert.equal(extreme.page, APPEARANCE_PATENT_CLEAN_MAX_PAGE)
const offset = (extreme.page - 1) * extreme.page_size
assert.equal(Number.isSafeInteger(offset), true, `(page-1)*page_size=${offset} 必须留在安全整数域`)
assert.equal(offset, 999_900)
})
@@ -70,11 +70,12 @@ function escapeRegExp(text: string): string {
}
/**
* 全部 21 个字面发送口:批次 1 的任务看板 5 处 + 批次 2(控制方 2026-10-05 点名「切 tab 数据还一样」那五页)7 处
* 全部 24 个字面发送口:批次 1 的任务看板 5 处 + 批次 2(控制方 2026-10-05 点名「切 tab 数据还一样」那五页)7 处
* + 批次 3(控制方 2026-10-05 点名「店铺撞款监控 店铺数据也要做隔离」那两页)4 处
* + 批次 4(控制方 2026-10-05 点名「菜单权限和用户管理也要区分公司 tab 的数据」里的用户管理)1 处
* + 批次 5(控制方 2026-10-06 点名「店铺密钥管理的数据按照公司区分」)1 处
* + 批次 6(控制方 2026-10-06 点名「菜单权限也加字段来区分」)3 处:菜单目录 / 新建菜单 / 用户管理里的授权树。
* + 批次 6(控制方 2026-10-06 点名「菜单权限也加字段来区分」)3 处:菜单目录 / 新建菜单 / 用户管理里的授权树
* + 批次 7(2026-11-10 v1.3 外观专利无侵权数据)1 处:只读列表。
* 批次 2 原 12 处里的品牌库 1 处 + 商品类目 4 处,随 2026-10-06「这两页退回全平台共享」一并摘掉。
*
* <p>`window` 的取法:本轮实扫的 own(到自己那行的距离)+ ≥150 余量,且当同文件还有下一个同名发送口时必须
@@ -122,6 +123,9 @@ const SEND_POINTS: ReadonlyArray<SendPoint> = [
{ menuKey: 'admin_columns', file: 'src/pages/account/menu-manage-api.ts', fn: 'fetchMenuManageNodes', line: TASK_CENTER_SEND_LINE, window: 300, title: 'GET /permission-menus 目录(超管不带就把两家的同名行混成一排下发)' },
{ menuKey: 'admin_columns', file: 'src/pages/account/menu-manage-api.ts', fn: 'createMenu', line: TASK_CENTER_SEND_LINE, window: 300, title: 'POST /permission-menus 新建:归属由端点参数决定,前端不从树里猜' },
{ menuKey: 'admin_users', file: 'src/pages/account/user-menu-auth-api.ts', fn: 'fetchGrantableMenus', line: TASK_CENTER_SEND_LINE, window: 300, title: 'GET /permission-menus?grantableOnly 授权树:一家一套树后取错公司=已授权勾不上、提交必判无效' },
// ↓ 批次 7(2026-11-10 v1.3 外观专利无侵权数据):出表成功自动同步的只读明细,归属物化在行
// company_id 列(V189,同店铺密钥形状)⇒ 后端正门 readCompanyIdOrOwn;这一页只有一个发送口。
{ menuKey: 'admin_appearance_patent_clean_items', file: 'src/pages/patent/appearance-patent-clean-api.ts', fn: 'fetchAppearancePatentCleanList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /appearance-patent-clean-items 无侵权只读列表' },
]
/** 任务看板那 5 处(1b ④ 那条用例按文件筛它们,沿用旧名字不漂;表只有一份,不会漂出两个口径)。 */
@@ -243,6 +247,8 @@ const COMPANY_ID_SOURCE_PINS: Readonly<Record<string, readonly CompanyIdPin[]>>
// 编辑/删除/重排三支**故意不带**参数——归属由那一行的 id 与操作者公司共同判定,跨公司写后端 403
// (见 docs/ops/menu-company-tree-design-2026-10-06.md §5),给它们发 company_id 反而是第三处口径。
admin_columns: pinsFor('admin_columns'),
// 批次 7(v1.3 无侵权只读页):同样由 SEND_POINTS 现算——只有一个发送口(列表)。
admin_appearance_patent_clean_items: pinsFor('admin_appearance_patent_clean_items'),
}
/** 严格判据的分母由本轮实扫得出(修完不许恒绿也不许恒红):求值了几条 shape、其中几条通过。 */
@@ -342,7 +348,7 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
// 批次 2 原 12 条里的品牌库 1 条 + 商品类目 4 条随 2026-10-06「这两页退回全平台共享」摘掉)。
// 这条只防"整表被摘空/被改窄",逐处脱管由下面两条(对平闸门 + 窗口对平)负责。
assert.ok(SEND_POINTS.length >= 21,
`发送口表只剩 ${SEND_POINTS.length} 条(批次 1+2+3+4+5+6 实扫 21 条)⇒ 有人把钉从表里摘了,取值口看守成空`)
`发送口表只剩 ${SEND_POINTS.length} 条(批次 1+2+3+4+5+6 实扫 21 条 + 批次 7 v1.3 无侵权只读页 1 条 = 24 条)⇒ 有人把钉从表里摘了,取值口看守成空`)
for (const p of SEND_POINTS) {
const shape = pointShape(p)
const compliant = pointCompliant(p)
@@ -374,8 +380,8 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
if (hit) hit.pinned += 1
else grouped.set(key, { file: p.file, line: p.line, pinned: 1 })
}
assert.equal(grouped.size, 18,
`发送口表按 (文件, 整行) 应聚成 18 组(22 处发送口),现在却有 ${grouped.size} 组 —— 表被改形状了,对平判据失去分母`)
assert.equal(grouped.size, 19,
`发送口表按 (文件, 整行) 应聚成 19 组(24 处发送口,批次 7 再落 1 处),现在却有 ${grouped.size} 组 —— 表被改形状了,对平判据失去分母`)
for (const g of grouped.values()) {
const actual = occurrences(stripComments(read(g.file)), g.line)
assert.equal(g.pinned, actual,
@@ -717,6 +723,17 @@ const WATCH_BODY_PINS: ReadonlyArray<{
{ file: 'src/pages/account/menu-manage-api.ts', shapes: [/company_id\s*=\s*companyId\b/] },
],
},
// ↓ 批次 7(2026-11-10 v1.3 无侵权只读页):任务号/ASIN 是自由文本筛选,上一家填的值在新一家的
// 行集里筛不出东西 ⇒ 首屏「暂无无侵权数据」而输入框里还显示着那个值;页码回 1 同理。
{
file: 'src/pages/patent/AppearancePatentCleanItemsPage.vue',
token: "filter.taskId = ''; filter.asin = ''; page.value = 1; void load()",
why: '任务号/ASIN 是按行集筛的自由文本,上一家的值在新一家的行里不存在 ⇒ 切 tab 后首屏被筛成「暂无无侵权数据」,'
+ '而输入框还显示着上一家填的值;页码回 1 是因为新一家的行数更少,末尾的 void load() 才让切 tab 真的换数据',
premise: [
{ file: 'src/pages/patent/appearance-patent-clean-api.ts', shapes: [/company_id\s*=\s*params\.companyId\b/] },
],
},
]
/** 取「`watch(() => companyTab.activeId, () => { … })`」这一条语句的原文;匹配不出返回 null(由调用方判探针失效)。 */
@@ -725,9 +742,9 @@ function watchStatement(source: string): string | null {
return m ? m[0] : null
}
test('切公司的 watch 体:每对 (file, token) 都要在该页 watch 体内出现(批次 1 两页 + 批次 2 三页 + 批次 3 两页 + 批次 4 一页 + 批次 5 一页 + 批次 6 一页)', () => {
test('切公司的 watch 体:每对 (file, token) 都要在该页 watch 体内出现(批次 1 两页 + 批次 2 三页 + 批次 3 两页 + 批次 4 一页 + 批次 5 一页 + 批次 6 一页 + 批次 7 一页)', () => {
assert.ok(WATCH_BODY_PINS.length >= 10,
`watch 体看守只剩 ${WATCH_BODY_PINS.length} 对(批次 1 的店铺管理/任务看板 + 批次 2 的去重库/查询ASIN/最低价ASIN + 批次 3 的撞款监控/店铺数据记录 + 批次 4 的用户管理 + 批次 5 的店铺密钥 + 批次 6 的菜单管理共 10 对)`
`watch 体看守只剩 ${WATCH_BODY_PINS.length} 对(批次 1 的店铺管理/任务看板 + 批次 2 的去重库/查询ASIN/最低价ASIN + 批次 3 的撞款监控/店铺数据记录 + 批次 4 的用户管理 + 批次 5 的店铺密钥 + 批次 6 的菜单管理 + 批次 7 v1.3 无侵权只读页共 11 对)`
+ '⇒ 这一族又退回"只钉少数几页",被摘掉那一页的"切公司不清筛选项"再次没人看守')
const pinnedFiles = new Set(WATCH_BODY_PINS.map((pin) => pin.file))
for (const pin of WATCH_BODY_PINS) {
@@ -34,6 +34,9 @@ const EXEMPT = new Set([
'src/pages/tasks/ShopDataTasksPage.vue',
'src/pages/tasks/ImageVideoTasksPage.vue',
'src/pages/records/RecordsHistoryPage.vue',
// 2026-11-10(v1.3):外观专利无侵权数据页与去重库同形状——出表成功自动同步的累计台账,
// 默认当天会让首屏只剩今天同步的行,历史同步行整批"消失"。
'src/pages/patent/AppearancePatentCleanItemsPage.vue',
// 2026-10-05(V146):两处是「到期时间」表单字段而非列表筛选——留空 = 永不过期,
// 是有业务语义的默认值,绝不能默认当天(默认当天等于建号即过期)。
'src/pages/account/CreateUserDialog.vue',
@@ -231,11 +231,11 @@ test('orderedPair 只在两端都有值且倒挂时交换', () => {
})
test('分母硬钉:四面控件实例数与成对数(扫描失明即红)', () => {
assert.equal(adminCtrls.length, 19, '后管实例数变了,先复算普查再改这里')
assert.equal(adminCtrls.length, 21, '后管实例数变了,先复算普查再改这里(v1.3 外观专利无侵权数据页再落一对起止=2 实例)')
assert.equal(userCtrls.length, 2, '用户端实例数变了')
assert.equal(finCtrls.length, 30, '财务系统实例数变了')
assert.equal(mxCtrls.length, 4, '麦象实例数变了')
assert.equal(pairCount(adminCtrls), 8, '后管成对区间应为 8')
assert.equal(pairCount(adminCtrls), 9, '后管成对区间应为 9(v1.3 外观专利无侵权数据页再落一对)')
assert.equal(pairCount(finCtrls), 11, '财务系统成对区间应为 11')
assert.equal(pairCount(mxCtrls), 2, '麦象成对区间应为 2')
assert.equal(pairCount(userCtrls), 0, '用户端出现成对区间说明新加了两个单只控件')
@@ -1,5 +1,5 @@
/**
* 外观专利无侵权数据页(v1.3 AC-5)的挂载契约 —— Pending Phase 3。
* 外观专利无侵权数据页(v1.3 AC-5)的挂载契约 —— Phase 3 激活。
*
* 用户拍板(2026-11-10):展示形式参照「去重数据库」页(DedupeRegistryPage 形态:自绘
* `<table>` 行列表 + `OldPagination.vue` 分页,**不做卡片宫格**);`companyScoped: true`
@@ -7,29 +7,78 @@
* `{items, total, page, pageSize}`。默认仅 super_admin 可见(菜单不预授权,判据在后端
* AdminAppearancePatentCleanItemsControllerTest 的菜单迁移支,这里只管前端接线)。
*
* Phase 0 预置的判据(接缝名是判据的一部分,Phase 3 微调必须同步改本文件并登记蓝图 §5):
* ① 页面组件落位 `src/pages/patent/AppearancePatentCleanItemsPage.vue`,且确实是
* 自绘 table + OldPagination 的分页列表(不是卡片宫格);
* ② routes.ts 注册 `patent-center/clean-items`(menuKey `admin_appearance_patent_clean_items`,
* companyScoped: true),COMPANY_SCOPED_PAGES 同步登记(company-tab-wiring 护栏随注册自动覆盖);
* ③ 挂载行为样本(激活时补齐):mock api 模块 → mount → 翻页/改每页条数、切公司 Tab 重取、
* 任务号/ASIN/国家/起止时间筛选生效、空态与加载失败条。
*
* 跑法:`npx vitest run tests/mount/appearance-patent-clean-page.test.ts`
*/
import { readFileSync } from 'node:fs'
import { fileURLToPath, URL } from 'node:url'
import { describe, expect, it } from 'vitest'
import { resolve } from 'node:path'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import AppearancePatentCleanItemsPage from '@/pages/patent/AppearancePatentCleanItemsPage.vue'
import { adminPages } from '@/router/routes'
import { COMPANY_SCOPED_PAGES } from '@/config/company-scope'
import { useAdminSessionStore } from '@/stores/admin-session'
import { useCompanyTabStore } from '@/stores/company-tab'
const PAGE_PATH = 'src/pages/patent/AppearancePatentCleanItemsPage.vue'
const MENU_KEY = 'admin_appearance_patent_clean_items'
describe.skip('Pending Phase 3: AC-5 外观专利无侵权数据页(分页列表,参照去重数据库页)', () => {
const cleanApi = vi.hoisted(() => ({
fetchAppearancePatentCleanList: vi.fn(),
}))
vi.mock('@/pages/patent/appearance-patent-clean-api.ts', () => cleanApi)
function row(id: number, over: Record<string, unknown> = {}) {
return {
id,
resultId: 900 + id,
taskId: 33179,
userId: 7,
companyId: 1,
rowNo: id,
asin: `B0AB8CDEF${id}`,
country: 'DE',
sku: `SKU-${id}`,
brand: 'Anker',
price: '29.99',
title: `无侵权商品 ${id}`,
imageUrl: '',
itemUrl: '',
conclusion: '无侵权',
titleReason: '',
appearanceReason: '',
patentReason: '',
sourceFilename: 'list.xlsx',
syncedAt: '2026-11-10T10:30:00',
...over,
}
}
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
pinia = createPinia()
setActivePinia(pinia)
useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' }
useCompanyTabStore().setActiveId(1)
})
async function mountWith(payload: unknown): Promise<VueWrapper<Element>> {
cleanApi.fetchAppearancePatentCleanList.mockImplementation(() => Promise.resolve(payload))
const wrapper = mount(AppearancePatentCleanItemsPage, { global: { plugins: [pinia] } })
await flushPromises()
await flushPromises()
return wrapper
}
describe('AC-5 外观专利无侵权数据页(分页列表,参照去重数据库页)', () => {
it('页面组件落位且是自绘 table + OldPagination 的分页列表', () => {
const src = readFileSync(fileURLToPath(new URL(`../../${PAGE_PATH}`, import.meta.url)), 'utf-8')
// vitest 的 cwd = admin-frontend-vue 根(Phase 0 预置用 new URL 模板串,被 vite 静态分析成
// undefined——skip 期间从未执行所以没暴露,激活时改走 cwd 解析)。
const src = readFileSync(resolve(process.cwd(), PAGE_PATH), 'utf-8')
expect(src).toContain('OldPagination')
expect(src).toContain('<table')
expect(src).not.toContain('el-card')
@@ -46,16 +95,90 @@ describe.skip('Pending Phase 3: AC-5 外观专利无侵权数据页(分页列
expect(scoped?.pageFiles).toContain(PAGE_PATH)
})
it('挂载后走 snake 分页参数且切公司 Tab 重取(激活时用真组件挂载补齐)', async () => {
// 页面组件 Phase 3 才落盘,vite 的 import-analysis 会在收集期解析动态导入 ⇒
// 这里必须用运行期字符串 + @vite-ignore 推迟解析;skip 期间永不执行。
const pageModule = '@/pages/patent/AppearancePatentCleanItemsPage.vue'
// 激活时补齐:vi.mock('@/pages/patent/appearance-patent-clean-api.ts') →
// const { default: Page } = await import(pageModule)
// mount(Page, { global: { plugins: [createPinia()] } }) →
// 断言首次请求 query 的 page/page_size(snake)与 {items,total,page,pageSize} 解包;
// 改每页条数/翻页重发;companyTab.activeId 变化触发重取(护栏 company-tab-wiring 同口径)。
const { default: Page } = await import(/* @vite-ignore */ pageModule)
expect(Page).toBeTruthy()
it('挂载后按首屏 snake 分页参数取数并解包 {items,total,page,pageSize}', async () => {
const wrapper = await mountWith({ items: [row(1), row(2)], total: 42, page: 1, pageSize: 10 })
expect(cleanApi.fetchAppearancePatentCleanList).toHaveBeenCalledTimes(1)
const firstCall = cleanApi.fetchAppearancePatentCleanList.mock.calls[0][0]
expect(firstCall.page).toBe(1)
expect(firstCall.pageSize).toBe(10)
expect(firstCall.companyId).toBe(1)
expect(wrapper.findAll('tbody tr')).toHaveLength(2)
expect(wrapper.text()).toContain('共 42 条')
expect(wrapper.text()).toContain('B0AB8CDEF1')
expect(wrapper.text()).toContain('无侵权')
})
it('翻页与改每页条数都重发请求,改条数回第一页', async () => {
const wrapper = await mountWith({ items: [row(11)], total: 42, page: 2, pageSize: 10 })
await wrapper.findAll('button').find((b) => b.text() === '下一页')!.trigger('click')
await flushPromises()
expect(cleanApi.fetchAppearancePatentCleanList).toHaveBeenCalledTimes(2)
expect(cleanApi.fetchAppearancePatentCleanList.mock.calls[1][0].page).toBe(3)
const sizeSelect = wrapper.find('.page-size-select')
await sizeSelect.setValue('50')
await flushPromises()
const last = cleanApi.fetchAppearancePatentCleanList.mock.calls.at(-1)![0]
expect(last.pageSize).toBe(50)
expect(last.page).toBe(1, '改每页条数后回第一页')
})
it('任务号/ASIN/国家/起止时间筛选生效', async () => {
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 })
const textInputs = wrapper.findAll('input[type="text"]')
await textInputs[0].setValue('33179')
await textInputs[1].setValue('B0AB8CDEF1')
await wrapper.find('select').setValue('DE')
const dateInputs = wrapper.findAll('input[type="date"]')
await dateInputs[0].setValue('2026-11-01')
await dateInputs[1].setValue('2026-11-09')
await wrapper.findAll('button').find((b) => b.text() === '查询')!.trigger('click')
await flushPromises()
const last = cleanApi.fetchAppearancePatentCleanList.mock.calls.at(-1)![0]
expect(last).toMatchObject({
taskId: '33179',
asin: 'B0AB8CDEF1',
country: 'DE',
startDate: '2026-11-01',
endDate: '2026-11-09',
page: 1,
})
})
it('空态与加载失败条(失败给重试,不把整页打死)', async () => {
const empty = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 })
const thCount = empty.findAll('thead th').length
const emptyRow = empty.find('tbody tr')
expect(emptyRow.text()).toContain('暂无无侵权数据')
expect(Number(emptyRow.find('td').attributes('colspan'))).toBe(thCount, '空态 colspan 跟着列数走')
empty.unmount()
cleanApi.fetchAppearancePatentCleanList.mockRejectedValue(new Error('上游 502'))
const failed = mount(AppearancePatentCleanItemsPage, { global: { plugins: [pinia] } })
await flushPromises()
await flushPromises()
expect(failed.find('.load-failure-bar').exists()).toBe(true)
expect(failed.find('.load-failure-bar').text()).toContain('无侵权数据加载失败')
})
it('切公司 Tab 重取并清掉上一家的筛选(company-tab-wiring 同口径)', async () => {
const wrapper = await mountWith({ items: [row(1)], total: 1, page: 1, pageSize: 10 })
const textInputs = wrapper.findAll('input[type="text"]')
await textInputs[0].setValue('33179')
const callsAfterMount = cleanApi.fetchAppearancePatentCleanList.mock.calls.length
useCompanyTabStore().setActiveId(2)
await flushPromises()
await flushPromises()
expect(cleanApi.fetchAppearancePatentCleanList.mock.calls.length).toBeGreaterThan(callsAfterMount)
const last = cleanApi.fetchAppearancePatentCleanList.mock.calls.at(-1)![0]
expect(last.companyId).toBe(2)
expect(last.taskId).toBe('', '切公司必须清掉上一家填的任务号')
expect(last.page).toBe(1)
})
})
@@ -40,6 +40,16 @@ public final class PageDefaults {
/** {@link #USER_LIST_PAGE_SIZE} 的数字镜像。 */
public static final int USER_LIST_PAGE_SIZE_INT = 15;
/**
* 外观专利无侵权数据后管只读页默认容量 = 10(v1.3,蓝图 §3.2「page_size 默认 10、上限 100」;
* 上限钳制在 {@code AppearancePatentCleanItemQueryService},不在注解上)。前端 OldPagination
* 首屏同为 10 条/页,两侧对齐。
*/
public static final String CLEAN_ITEMS_PAGE_SIZE = "10";
/** {@link #CLEAN_ITEMS_PAGE_SIZE} 的数字镜像。 */
public static final int CLEAN_ITEMS_PAGE_SIZE_INT = 10;
/** 超管台列表默认容量 = 20。现存 6 处(设备日志、图视任务、通知×2、商品分类×2)。 */
public static final String ADMIN_LIST_PAGE_SIZE = "20";
@@ -0,0 +1,136 @@
package com.nanri.aiimage.modules.appearancepatent.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.api.PageDefaults;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentCleanItemPageVo;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentCleanItemQueryService;
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.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDate;
/**
* 后管「外观专利无侵权数据」只读页(v1.3 R2/R3)。数据由出表成功点自动同步落表
* ({@code AppearancePatentCleanSyncService}),本页只读——无写/删/导出接口,
* 下载走既有结果直链/任务中心。
*
* <p>鉴权照去重页私有 {@code requireXxxAccess} 形状:JWT → 内部令牌回退 → 超管放行 →
* 非超管菜单权限(column_key/route_path 双匹配)。菜单行由 V190 只插 columns 不预授权
* ⇒ 默认仅 super_admin 可见可访问,其余角色由超管在权限页手工勾授后才放行。</p>
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin/appearance-patent-clean-items")
@Tag(name = "外观专利无侵权数据", description = "后管只读页:出表成功自动同步的「结论=无侵权」明细,按分公司隔离分页查询。")
public class AdminAppearancePatentCleanItemsController {
private static final String CLEAN_ITEMS_COLUMN_KEY = "admin_appearance_patent_clean_items";
private static final String CLEAN_ITEMS_ROUTE_PATH = "patent-center/clean-items";
private final AppearancePatentCleanItemQueryService cleanItemQueryService;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
private final DataReadScope dataReadScope;
@GetMapping
@Operation(summary = "分页查询外观专利无侵权数据", description = "按分公司隔离分页查询同步落表的无侵权明细;"
+ "company_id 只对站点超管生效(显式传才收窄,不传全量),非超管强制本公司。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功", content = @Content(schema = @Schema(implementation = AppearancePatentCleanItemPageVo.class)))
})
public ApiResponse<AppearancePatentCleanItemPageVo> page(
@Parameter(description = "页码") @RequestParam(name = "page", defaultValue = PageDefaults.FIRST_PAGE) Long page,
@Parameter(description = "每页数量") @RequestParam(name = "page_size", defaultValue = PageDefaults.CLEAN_ITEMS_PAGE_SIZE) Long pageSize,
@Parameter(description = "任务号") @RequestParam(name = "task_id", required = false) Long taskId,
@Parameter(description = "ASIN 前缀") @RequestParam(name = "asin", required = false) String asin,
@Parameter(description = "国家代码(如 DE、UK)") @RequestParam(name = "country", required = false) String country,
@Parameter(description = "同步开始日期(包含)")
@RequestParam(name = "start_date", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
@Parameter(description = "同步结束日期(包含)")
@RequestParam(name = "end_date", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireCleanItemsAccess(request);
AdminUserEntity user = operator.user();
// 公司隔离正门是 readCompanyIdOrOwn(同店铺密钥 biz_shop_key 的表形状:归属物化在行
// company_id 列、可见集不靠账号/分组)——超管显式传才收窄、不传全量;非超管强制本公司
// (忽略请求传参)。superAdminScopedCompanyId 对非超管返回 null=按行 company_id 列查询时
// 等于把整张表交给每一家(该方法 javadoc 点名的越权形状),不是本表该走的门。
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
return ApiResponse.success(cleanItemQueryService.page(page, pageSize, taskId, asin, country,
startDate, endDate, scopedCompanyId));
}
private RequestOperator requireCleanItemsAccess(HttpServletRequest request) {
AdminUserEntity operator = resolveOperator(request);
if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "无权访问外观专利无侵权数据");
}
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
if (!superAdmin && !hasCleanItemsPermission(operator)) {
throw new BusinessException(403, "无权访问外观专利无侵权数据");
}
return new RequestOperator(operator.getId(), superAdmin, operator);
}
private AdminUserEntity resolveOperator(HttpServletRequest request) {
try {
return adminAuthSupport.requireUser(request);
} catch (BusinessException authFailure) {
AdminUserEntity internalOperator = resolveInternalOperator(request);
if (internalOperator != null) {
return internalOperator;
}
throw authFailure;
}
}
private boolean hasCleanItemsPermission(AdminUserEntity operator) {
return permissionMenuService.getUserColumnPermissions(operator.getId(), "admin")
.stream()
.anyMatch(item -> CLEAN_ITEMS_COLUMN_KEY.equals(item.getColumnKey())
|| CLEAN_ITEMS_ROUTE_PATH.equals(item.getRoutePath()));
}
private AdminUserEntity resolveInternalOperator(HttpServletRequest request) {
if (!isTrustedInternalRequest(request.getHeader("X-Internal-Token"))) {
return null;
}
String rawOperatorId = request.getParameter("operatorId");
if (rawOperatorId == null || rawOperatorId.isBlank()) {
rawOperatorId = request.getParameter("operator_id");
}
if (rawOperatorId == null || rawOperatorId.isBlank()) {
return null;
}
try {
return permissionMenuService.requireUserOperator(Long.parseLong(rawOperatorId.trim()));
} catch (NumberFormatException | BusinessException ex) {
return null;
}
}
private record RequestOperator(Long id, boolean superAdmin, AdminUserEntity user) {
}
private boolean isTrustedInternalRequest(String suppliedToken) {
return adminAuthSupport.isTrustedSuppliedToken(suppliedToken);
}
}
@@ -0,0 +1,27 @@
package com.nanri.aiimage.modules.appearancepatent.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 外观专利无侵权数据分页结果(后管只读页,v1.3 R3;照 {@code DedupeTotalDataPageVo} 形状,
* 但<b>不做</b> keyset {@code nextLastId} 游标——蓝图 Out of Scope 明确本表量级先走 OFFSET 分页)。
*/
@Data
@Schema(description = "外观专利无侵权数据分页结果")
public class AppearancePatentCleanItemPageVo {
@Schema(description = "列表")
private List<AppearancePatentCleanItemVo> items;
@Schema(description = "总数")
private Long total;
@Schema(description = "页码")
private Long page;
@Schema(description = "每页数量")
private Long pageSize;
}
@@ -0,0 +1,76 @@
package com.nanri.aiimage.modules.appearancepatent.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 外观专利无侵权数据明细行(后管只读页,v1.3 R3)。字段与 {@code biz_appearance_patent_clean_item}
* 表列(V189)一一对应——行值是同步服务从 chunk payload 原样落的(不 trim、不转写,AC-1
* 「与 payload 一致」),读侧只做搬运不做二次加工。
*/
@Data
@Schema(description = "外观专利无侵权数据明细行")
public class AppearancePatentCleanItemVo {
@Schema(description = "行 id")
private Long id;
@Schema(description = "来源结果文件行 id(biz_file_result.id)")
private Long resultId;
@Schema(description = "来源任务 id")
private Long taskId;
@Schema(description = "任务 owner 用户 id")
private Long userId;
@Schema(description = "物化归属分公司 id")
private Long companyId;
@Schema(description = "结果内行号")
private Integer rowNo;
@Schema(description = "ASIN")
private String asin;
@Schema(description = "国家代码(如 DE、UK)")
private String country;
@Schema(description = "SKU")
private String sku;
@Schema(description = "品牌")
private String brand;
@Schema(description = "价格")
private String price;
@Schema(description = "商品标题")
private String title;
@Schema(description = "商品主图/检测图 URL")
private String imageUrl;
@Schema(description = "商品详情页 URL(payload 暂无该键,恒为空)")
private String itemUrl;
@Schema(description = "检测结论原值(严格口径下全为无侵权)")
private String conclusion;
@Schema(description = "标题检测原因")
private String titleReason;
@Schema(description = "外观检测原因")
private String appearanceReason;
@Schema(description = "专利检测原因")
private String patentReason;
@Schema(description = "来源文件名")
private String sourceFilename;
@Schema(description = "同步落库时刻")
private LocalDateTime syncedAt;
}
@@ -0,0 +1,101 @@
package com.nanri.aiimage.modules.appearancepatent.service;
import com.nanri.aiimage.common.api.PageDefaults;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.appearancepatent.mapper.AppearancePatentCleanItemMapper;
import com.nanri.aiimage.modules.appearancepatent.model.entity.CleanItemEntity;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentCleanItemPageVo;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentCleanItemVo;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.util.List;
/**
* 后管「外观专利无侵权数据」只读查询(v1.3 R2)。
*
* <p>分页钳制是本服务的职责(铁律 15):mapper 的 {@code offset}/{@code limit} 只收钳制后的值
* (Phase 1 定下的单一出口,mapper 不做第二次换算)。钳制形状照关键词服务 CR-18 先例:
* {@code page} 上限 {@link #MAX_PAGE}、{@code page_size} 上限 {@link #MAX_PAGE_SIZE},
* {@code (page-1)*page_size} 最大 999_900,{@code page=Long.MAX_VALUE} 不会把乘积顶成负数
* 生成 {@code LIMIT -N} 的 500 错。</p>
*
* <p>{@code scopedCompanyId} 由控制器经 {@code DataReadScope#readCompanyIdOrOwn} 算好传入
* (本表与店铺密钥同形状:归属物化在行 {@code company_id} 列、可见集不靠账号/分组):
* {@code null} = 超管没选公司、查全量;正数 = 只查该公司(非超管恒为自己的公司)。</p>
*/
@Service
@RequiredArgsConstructor
public class AppearancePatentCleanItemQueryService {
/** 页码上限(CR-18 关键词分页同值):10000 页 x 100 条 = 100 万行封顶,乘积不溢出。 */
private static final long MAX_PAGE = 10_000;
/** 每页条数上限(蓝图 §3.2)。 */
private static final long MAX_PAGE_SIZE = 100;
private final AppearancePatentCleanItemMapper cleanItemMapper;
/**
* 分页查询只读明细({@code synced_at} 倒序)。
*
* <p>过滤面:公司(物化列 eq)、任务号、ASIN 前缀(保 {@code idx_asin} 可用,同去重页口径)、
* 国家、同步起止日期(闭区间,含 end 当天)。</p>
*/
public AppearancePatentCleanItemPageVo page(Long page, Long pageSize, Long taskId, String asin,
String country, LocalDate startDate, LocalDate endDate, Long scopedCompanyId) {
if (startDate != null && endDate != null && startDate.isAfter(endDate)) {
throw new BusinessException("开始日期不能晚于结束日期");
}
long safePage = page == null || page < 1 ? 1 : Math.min(page, MAX_PAGE);
long safeSize = pageSize == null ? PageDefaults.CLEAN_ITEMS_PAGE_SIZE_INT
: Math.min(Math.max(pageSize, 1), MAX_PAGE_SIZE);
Long companyId = scopedCompanyId != null && scopedCompanyId > 0 ? scopedCompanyId : null;
String safeAsin = trimToNull(asin);
String safeCountry = trimToNull(country);
long total = cleanItemMapper.countCleanItems(companyId, taskId, safeAsin, safeCountry, startDate, endDate);
List<CleanItemEntity> rows = total <= 0 ? List.of()
: cleanItemMapper.selectCleanItemPage(companyId, taskId, safeAsin, safeCountry, startDate, endDate,
(safePage - 1) * safeSize, (int) safeSize);
AppearancePatentCleanItemPageVo vo = new AppearancePatentCleanItemPageVo();
vo.setItems(rows.stream().map(AppearancePatentCleanItemQueryService::toVo).toList());
vo.setTotal(total);
vo.setPage(safePage);
vo.setPageSize(safeSize);
return vo;
}
private static String trimToNull(String value) {
if (value == null) {
return null;
}
String trimmed = value.trim();
return trimmed.isEmpty() ? null : trimmed;
}
/** 行值原样搬运(AC-1:与 payload 一致;读侧不加工)。 */
private static AppearancePatentCleanItemVo toVo(CleanItemEntity row) {
AppearancePatentCleanItemVo vo = new AppearancePatentCleanItemVo();
vo.setId(row.getId());
vo.setResultId(row.getResultId());
vo.setTaskId(row.getTaskId());
vo.setUserId(row.getUserId());
vo.setCompanyId(row.getCompanyId());
vo.setRowNo(row.getRowNo());
vo.setAsin(row.getAsin());
vo.setCountry(row.getCountry());
vo.setSku(row.getSku());
vo.setBrand(row.getBrand());
vo.setPrice(row.getPrice());
vo.setTitle(row.getTitle());
vo.setImageUrl(row.getImageUrl());
vo.setItemUrl(row.getItemUrl());
vo.setConclusion(row.getConclusion());
vo.setTitleReason(row.getTitleReason());
vo.setAppearanceReason(row.getAppearanceReason());
vo.setPatentReason(row.getPatentReason());
vo.setSourceFilename(row.getSourceFilename());
vo.setSyncedAt(row.getSyncedAt());
return vo;
}
}
@@ -59,6 +59,8 @@ class PageDefaultsLedgerTest {
// (本批 /groups 端点:参数名与默认值和列表端点同,台账按出站点计数、不去重)
"AdminNotificationController.java#page=FIRST_PAGE",
"AdminNotificationController.java#pageSize=ADMIN_LIST_PAGE_SIZE",
"AdminAppearancePatentCleanItemsController.java#page=FIRST_PAGE",
"AdminAppearancePatentCleanItemsController.java#page_size=CLEAN_ITEMS_PAGE_SIZE",
"AppearancePatentController.java#limit=DEFAULT_RESULT_LIMIT",
"CollectDataController.java#page=FIRST_PAGE",
"CollectDataController.java#page_size=TASK_LIST_PAGE_SIZE",
@@ -109,10 +111,10 @@ class PageDefaultsLedgerTest {
List<String> constants = actual.stream().filter(s -> !s.contains("LITERAL")).sorted().toList();
assertThat(constants)
.as("54 处分页/条数出站点的具名默认值必须与台账一一对应")
.as("56 处分页/条数出站点的具名默认值必须与台账一一对应")
.isEqualTo(LEDGER.stream().sorted().toList());
// 同口径非零对照:台账不是空的,扫描器也确实数得出 54 处
assertThat(constants).hasSize(54);
// 同口径非零对照:台账不是空的,扫描器也确实数得出 56 处
assertThat(constants).hasSize(56);
}
@Test
@@ -128,11 +130,12 @@ class PageDefaultsLedgerTest {
List<String> actual = sites();
assertThat(kindsUsing(actual, "page", "FIRST_PAGE"))
.as("页码口径只有一套:全部从 1 起")
.isEqualTo(24);
.isEqualTo(25);
assertThat(distinctConstants(actual, "page_size"))
.as("page_size 的默认容量集合:15/20/50/1000 四种各自登记,新来第五种要红")
.as("page_size 的默认容量集合:10/15/20/50/1000 五种各自登记,新来第六种要红"
+ "(10 是 v1.3 无侵权只读页,蓝图 §3.2 拍板、与前端 OldPagination 首屏同值)")
.containsExactlyInAnyOrder("USER_LIST_PAGE_SIZE", "ADMIN_LIST_PAGE_SIZE",
"TASK_LIST_PAGE_SIZE", "FULL_EXPORT_PAGE_SIZE");
"TASK_LIST_PAGE_SIZE", "FULL_EXPORT_PAGE_SIZE", "CLEAN_ITEMS_PAGE_SIZE");
// 同一个语义有两种拼写(@RequestParam(name = "page_size") 与 camelCase 的 pageSize),
// 而两种拼写实际用到的常量本来就不同。原来把同一个四项清单套在两种拼写上,
// 红的是台账写法而不是有人新增了默认值——2026-10-10 出包前对平这一条。
@@ -143,9 +146,10 @@ class PageDefaultsLedgerTest {
bothSpellings.addAll(distinctConstants(actual, "page_size"));
bothSpellings.addAll(distinctConstants(actual, "pageSize"));
assertThat(bothSpellings)
.as("两种拼写合起来仍只许那四种容量:谁长出第五种,这里就红")
.as("两种拼写合起来仍只许那五种容量:谁长出第六种,这里就红")
.containsExactlyInAnyOrderElementsOf(java.util.List.of("USER_LIST_PAGE_SIZE",
"ADMIN_LIST_PAGE_SIZE", "TASK_LIST_PAGE_SIZE", "FULL_EXPORT_PAGE_SIZE"));
"ADMIN_LIST_PAGE_SIZE", "TASK_LIST_PAGE_SIZE", "FULL_EXPORT_PAGE_SIZE",
"CLEAN_ITEMS_PAGE_SIZE"));
assertThat(distinctConstants(actual, "limit"))
.as("limit 是「本次最多返回几条」,不许和 page_size 混用同一批常量")
.containsExactlyInAnyOrder("DEFAULT_RESULT_LIMIT", "ADMIN_SCAN_LIMIT");
@@ -171,6 +175,7 @@ class PageDefaultsLedgerTest {
// 具名常量给了 String 与 int 两个面,两者一旦漂开,注解上的默认值和代码里的兜底值就不是一个数
assertPair(PageDefaults.FIRST_PAGE, PageDefaults.FIRST_PAGE_INT);
assertPair(PageDefaults.USER_LIST_PAGE_SIZE, PageDefaults.USER_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.CLEAN_ITEMS_PAGE_SIZE, PageDefaults.CLEAN_ITEMS_PAGE_SIZE_INT);
assertPair(PageDefaults.ADMIN_LIST_PAGE_SIZE, PageDefaults.ADMIN_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.TASK_LIST_PAGE_SIZE, PageDefaults.TASK_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.FULL_EXPORT_PAGE_SIZE, PageDefaults.FULL_EXPORT_PAGE_SIZE_INT);
@@ -204,11 +204,19 @@ class CompanyIdParamGoesThroughReadScopeTest {
private static final String SCOPE_CAUGHT_SHOP_KEY_KEY =
"com/nanri/aiimage/modules/shopkey/controller/ShopKeyController.java#@GetMapping";
/**
* v1.3(2026-11-10)无侵权只读页接的第九支:{@code biz_appearance_patent_clean_item} 与店铺密钥
* 同形状(V189 归属物化在行 {@code company_id} 列、可见集不靠账号/分组)⇒ 正门同为
* {@code readCompanyIdOrOwn}:超管显式传才收窄、不传全量,非超管强制本公司(忽略请求传参)。
*/
private static final String SCOPE_CAUGHT_CLEAN_ITEMS_KEY =
"com/nanri/aiimage/modules/appearancepatent/controller/AdminAppearancePatentCleanItemsController.java#@GetMapping";
/**
* 射程下限的<b>唯一一份</b>名单:C 与 D 两条射程断言共用它,不许各写一份(两处各写就会有一处先漂)。
* 这六支是"切 tab 数据还是一样"这次报障正对着的页面里<b>今天仍按公司取数</b>的那些:
* 这七支是"切 tab 数据还是一样"这次报障正对着的页面里<b>今天仍按公司取数</b>的那些:
* 批次 1 的两页(图片历史、图片视频任务)+ 批次 2 剩下三页(去重库、查询ASIN、最低价ASIN)
* + V150 的店铺密钥。
* + V150 的店铺密钥 + v1.3 的无侵权只读页。
* <p>品牌库、商品类目 2026-10-06 定案退回全平台共享({@link #SHARED_TABLES_MUST_STAY_UNSCOPED}),
* 它们的公司参数已从 controller 上摘掉,留在这里只会让 {@code contains(...)} 恒红——
* "不得回流"改由那一条反向钉看守,不靠射程名单。</p>
@@ -219,7 +227,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
SCOPE_CAUGHT_DEDUPE_KEY,
SCOPE_CAUGHT_QUERY_ASIN_KEY,
SCOPE_CAUGHT_SKIP_PRICE_ASIN_KEY,
SCOPE_CAUGHT_SHOP_KEY_KEY);
SCOPE_CAUGHT_SHOP_KEY_KEY,
SCOPE_CAUGHT_CLEAN_ITEMS_KEY);
private static final String READ_SCOPE_CALL = "readScope(";
/**
@@ -1,34 +1,61 @@
package com.nanri.aiimage.modules.appearancepatent.controller;
import org.junit.jupiter.api.Disabled;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.api.PageDefaults;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.appearancepatent.mapper.AppearancePatentCleanItemMapper;
import com.nanri.aiimage.modules.appearancepatent.model.entity.CleanItemEntity;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentCleanItemPageVo;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentCleanItemVo;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentCleanItemQueryService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* AC-4/AC-6/AC-7(v1.3 R2/R4/R5):后管「外观专利无侵权数据」只读查询接口与菜单可见性。
*
* <p>Pending Phase 3 激活。Phase 0 预置的是<b>接缝判据</b>(接缝名是判据的一部分,Phase 3 微调命名
* 必须同步改本文件并在蓝图 §5 登记);激活时除本清单外,再补真实对象的行为样本:</p>
* <p>Phase 3 已激活。前 7 支是 Phase 0 预置的<b>接缝判据</b>(接缝名是判据的一部分,改名必须
* 同步改本文件并在蓝图 §5 登记);后 5 支是激活时补的真实对象行为样本:</p>
*
* <ul>
* <li><b>AC-4</b>:公司隔离——超管显式传 company_id 收窄、不传全量;非超管强制本公司(忽略请求
* 传参);无凭据/坏凭据按业务码拒绝(200 信封形状;判据认业务码/拒绝文案,不认 HTTP 码,B80-03);</li>
* 传参);无凭据/坏凭据按业务码拒绝(200 信封形状;判据认业务码/拒绝文案,不认 HTTP 码,B80-03);
* <b>接缝随实作微调(已在蓝图 §5 登记)</b>:本表与店铺密钥同形状(归属物化在行 company_id 列、
* 可见集不靠账号/分组),正门是 {@code readCompanyIdOrOwn}——{@code superAdminScopedCompanyId}
* 对非超管返回 null,按行 company_id 列查询时等于把整张表交给每一家(该方法 javadoc 点名的
* 越权形状),非超管「强制本公司」必须走 {@code CompanyScopeSupport.requireCompanyId} 那一支;</li>
* <li><b>AC-6</b>:默认仅 super_admin 可见可访问(V21 形状:菜单注册不预授权);被授权角色放行;
* page 钳制防 {@code (page-1)*page_size} 溢出(铁律 15);</li>
* page 钳制防 {@code (page-1)*page_size} 溢出(铁律 15,行为样本见查询服务钳制支);</li>
* <li><b>AC-7</b>:删除前台任务/历史结果后,后管同步记录仍可查(独立保留)。</li>
* </ul>
*/
@Disabled("Pending Phase 3: AC-4/AC-6/AC-7 后管只读查询接口与菜单可见性(激活时移除本注解)")
class AdminAppearancePatentCleanItemsControllerTest {
private static final Path MODULE = Path.of("").toAbsolutePath();
@@ -42,6 +69,8 @@ class AdminAppearancePatentCleanItemsControllerTest {
private static final String COLUMN_KEY = "admin_appearance_patent_clean_items";
private static final String ROUTE_PATH = "patent-center/clean-items";
// ===================== Phase 0 预置接缝判据(激活) =====================
@Test
void 控制器与只读端点就位() throws IOException {
assertTrue(Files.exists(CONTROLLER),
@@ -63,16 +92,22 @@ class AdminAppearancePatentCleanItemsControllerTest {
assertTrue(source.contains(seam), "鉴权闸缺接缝 " + seam
+ "——照 DedupeTotalDataController 私有 requireXxxAccess 形状(JWT→内部令牌回退→超管放行→菜单双匹配)");
}
assertTrue(source.contains("columnKey") && (source.contains("getRoutePath")),
"菜单权限必须 column_key/route_path 双匹配(AC-6:默认不命中即拒)");
assertTrue(source.contains("getColumnKey") && (source.contains("getRoutePath")),
"菜单权限必须 column_key/route_path 双匹配(AC-6:默认不命中即拒);"
+ "判据随实作对齐代码库命名——item.getColumnKey()(激活时修正,原写法 columnKey 永不命中)");
}
@Test
void 公司隔离走superAdminScopedCompanyId() throws IOException {
void 公司隔离走readCompanyIdOrOwn() throws IOException {
String source = stripComments(Files.readString(CONTROLLER));
assertTrue(source.contains("DataReadScope"), "公司隔离唯一出口是 DataReadScope(蓝图 §2.1 Level 0)");
assertTrue(source.contains("superAdminScopedCompanyId"),
"读侧必须走 superAdminScopedCompanyId:超管显式传才收窄,非超管强制本公司(AC-4,同去重页口径)");
// 接缝随实作微调(蓝图 §5 已登记):本表与店铺密钥同形状(V189 归属物化列、无账号集兜底),
// 正门是 readCompanyIdOrOwn——超管显式传才收窄、非超管强制本公司(AC-4 后半句的行为要求)。
// superAdminScopedCompanyId 对非超管返回 null=整张表放开,不是本表该走的门。
assertTrue(source.contains("readCompanyIdOrOwn"),
"读侧必须走 readCompanyIdOrOwn:超管显式传才收窄,非超管强制本公司(AC-4,同店铺密钥 biz_shop_key 口径)");
assertFalse(source.contains("superAdminScopedCompanyId"),
"不得走 superAdminScopedCompanyId:它对非超管返回 null=按行 company_id 查询时把整张表交给每一家");
}
@Test
@@ -83,7 +118,7 @@ class AdminAppearancePatentCleanItemsControllerTest {
assertTrue(source.contains(param), "查询参数必须 snake_case:" + param + "(蓝图 §3.2,照去重页参数归一形状)");
}
assertTrue(source.contains("PageDefaults"), "page/page_size 默认值必须取 PageDefaults(page_size 默认 10);"
+ "page 钳制防 (page-1)*page_size 溢出的行为样本在激活时以真实对象补(铁律 15)");
+ "page 钳制防 (page-1)*page_size 溢出的行为样本见查询服务钳制支(铁律 15)");
}
@Test
@@ -136,6 +171,134 @@ class AdminAppearancePatentCleanItemsControllerTest {
}
}
// ===================== 激活时补的真实对象行为样本 =====================
@Test
void 控制器把公司参数交给readCompanyIdOrOwn并把结果装进200信封() {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
AppearancePatentCleanItemQueryService queryService = mock(AppearancePatentCleanItemQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminAppearancePatentCleanItemsController controller = new AdminAppearancePatentCleanItemsController(
queryService, authSupport, permissionMenuService, dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(7L);
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 超管显式传 company_id=5 ⇒ 正门把 5 交出来(不传时正门给 null=全量,同一行为样本家族)。
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
AppearancePatentCleanItemPageVo pageVo = new AppearancePatentCleanItemPageVo();
pageVo.setItems(List.of());
pageVo.setTotal(0L);
pageVo.setPage(1L);
pageVo.setPageSize((long) PageDefaults.CLEAN_ITEMS_PAGE_SIZE_INT);
when(queryService.page(1L, 10L, null, null, null, null, null, 5L)).thenReturn(pageVo);
ApiResponse<AppearancePatentCleanItemPageVo> response =
controller.page(1L, 10L, null, null, null, null, null, 5L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(queryService).page(1L, 10L, null, null, null, null, null, 5L);
assertEquals(Boolean.TRUE, response.isSuccess(), "拒绝走 403 业务码,放行必须是 success 信封(B80-03)");
assertEquals(pageVo, response.getData());
}
@Test
void 查询服务分页钳制防溢出() {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
AppearancePatentCleanItemQueryService service = new AppearancePatentCleanItemQueryService(mapper);
when(mapper.countCleanItems(any(), any(), any(), any(), any(), any())).thenReturn(1L);
// page=0 / size=null ⇒ 归一为第 1 页、默认 10 条;offset = 0。
service.page(0L, null, null, null, null, null, null, null);
ArgumentCaptor<Long> offset = ArgumentCaptor.forClass(Long.class);
ArgumentCaptor<Integer> limit = ArgumentCaptor.forClass(Integer.class);
verify(mapper).selectCleanItemPage(isNull(), isNull(), isNull(), isNull(), isNull(), isNull(),
offset.capture(), limit.capture());
assertEquals(0L, offset.getValue());
assertEquals(PageDefaults.CLEAN_ITEMS_PAGE_SIZE_INT, limit.getValue());
// page=Long.MAX_VALUE / size=500 ⇒ 钳到 10_000 页、100 条;乘积 999_900 不得变负(铁律 15,CR-18 同值)。
service.page(Long.MAX_VALUE, 500L, null, null, null, null, null, null);
ArgumentCaptor<Long> offsetMax = ArgumentCaptor.forClass(Long.class);
ArgumentCaptor<Integer> limitMax = ArgumentCaptor.forClass(Integer.class);
verify(mapper, org.mockito.Mockito.times(2)).selectCleanItemPage(any(), any(), any(), any(), any(), any(),
offsetMax.capture(), limitMax.capture());
assertEquals(999_900L, offsetMax.getValue(), "(page-1)*page_size 最大 999_900,钳制后不得溢出变负");
assertEquals(100, limitMax.getValue());
}
@Test
void 查询服务公司过滤原样直传() {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
AppearancePatentCleanItemQueryService service = new AppearancePatentCleanItemQueryService(mapper);
when(mapper.countCleanItems(any(), any(), any(), any(), any(), any())).thenReturn(0L);
// 超管显式传 5 ⇒ 按公司 5 筛(收窄);null ⇒ 全量(AC-4 前半句)。
service.page(1L, 10L, null, null, null, null, null, 5L);
verify(mapper).countCleanItems(eq(5L), isNull(), isNull(), isNull(), isNull(), isNull());
service.page(1L, 10L, null, null, null, null, null, null);
verify(mapper).countCleanItems(isNull(), isNull(), isNull(), isNull(), isNull(), isNull());
}
@Test
void 查询服务日期倒挂拒绝() {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
AppearancePatentCleanItemQueryService service = new AppearancePatentCleanItemQueryService(mapper);
BusinessException ex = assertThrows(BusinessException.class,
() -> service.page(1L, 10L, null, null, null,
LocalDate.of(2026, 11, 9), LocalDate.of(2026, 11, 1), null));
assertTrue(ex.getMessage().contains("开始日期不能晚于结束日期"),
"倒挂日期按业务异常拒绝(同去重页文案口径)");
verify(mapper, org.mockito.Mockito.never()).countCleanItems(any(), any(), any(), any(), any(), any());
}
@Test
void 行字段与VO搬运一致不加工() {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
AppearancePatentCleanItemQueryService service = new AppearancePatentCleanItemQueryService(mapper);
CleanItemEntity entity = new CleanItemEntity();
entity.setId(11L);
entity.setResultId(901L);
entity.setTaskId(33179L);
entity.setUserId(7L);
entity.setCompanyId(5L);
entity.setRowNo(3);
entity.setAsin("B0AB8CDEF1");
entity.setCountry("DE");
entity.setSku("SKU-1");
entity.setBrand("Anker");
entity.setPrice("29.99");
entity.setTitle(" 带空格的标题 ");
entity.setImageUrl("https://img.example/1.jpg");
entity.setConclusion("无侵权");
entity.setTitleReason("标题含品牌词");
entity.setSourceFilename("list.xlsx");
LocalDateTime syncedAt = LocalDateTime.of(2026, 11, 10, 10, 30);
entity.setSyncedAt(syncedAt);
when(mapper.countCleanItems(any(), any(), any(), any(), any(), any())).thenReturn(1L);
when(mapper.selectCleanItemPage(any(), any(), any(), any(), any(), any(), anyLong(),
org.mockito.ArgumentMatchers.anyInt())).thenReturn(List.of(entity));
AppearancePatentCleanItemPageVo vo = service.page(1L, 10L, 33179L, null, null, null, null, 5L);
assertEquals(1L, vo.getTotal());
AppearancePatentCleanItemVo row = vo.getItems().get(0);
// 读侧只搬运不加工:标题两侧空格原样保留(AC-1「与 payload 一致」,后端不 trim 是与行值同口径)。
assertEquals(" 带空格的标题 ", row.getTitle());
assertEquals("无侵权", row.getConclusion());
assertEquals(901L, row.getResultId());
assertEquals(33179L, row.getTaskId());
assertEquals(5L, row.getCompanyId());
assertEquals(Integer.valueOf(3), row.getRowNo());
assertEquals("https://img.example/1.jpg", row.getImageUrl());
assertEquals("标题含品牌词", row.getTitleReason());
assertEquals("list.xlsx", row.getSourceFilename());
assertEquals(syncedAt, row.getSyncedAt());
}
private static Path findCleanItemMapperXml() throws IOException {
Path resources = MODULE.resolve("src/main/resources/mapper");
if (!Files.exists(resources)) {
@@ -46,8 +46,10 @@ import static org.mockito.Mockito.when;
* <li><b>端到端黄金样本</b>——序列化 → 真读取链
* {@link AppearancePatentResultRowReader#readChunkRows} 值等闭合,且「无侵权」与
* 「外观无侵权·商标待复核」按精确相等分得开(用户拍板 ①:严格口径);</li>
* <li><b>字面量单源扫描</b>——appearancepatent 模块 main 源码里「无侵权」只许出现在
* {@code AppearancePatentLlmClient},同步服务落地(Phase 2)后再抄一份即红。</li>
* <li><b>字面量白名单扫描</b>——appearancepatent 模块 main 源码里「无侵权」只许落在白名单内:
* 唯一<b>结论值</b>来源仍是 {@code AppearancePatentLlmClient};其余命中必须全部是页面名/Swagger
* 文案/403 拒绝文案(结论值一律引用 NO_INFRINGEMENT 常量),新增命中必须在此登记,未登记即红
* (Phase 3 后管只读页以菜单名「外观专利无侵权数据」命中,已登记)。</li>
* </ol>
*/
class AppearancePatentChunkRowContractTest {
@@ -155,7 +157,7 @@ class AppearancePatentChunkRowContractTest {
}
@Test
void 无侵权字面量在模块main源码只有LlmClient一份() throws IOException {
void 无侵权字面量只许落在登记白名单() throws IOException {
Set<String> flagged = new TreeSet<>();
try (Stream<Path> files = Files.walk(MAIN_APPEARANCE_PATENT)) {
files.filter(path -> path.toString().endsWith(".java"))
@@ -167,9 +169,16 @@ class AppearancePatentChunkRowContractTest {
});
}
assertFalse(flagged.isEmpty(), "扫描空跑=判据失效:LlmClient 自身必须命中");
assertIterableEquals(List.of("client/AppearancePatentLlmClient.java"), new ArrayList<>(flagged),
"「无侵权」字面量只许存在于 AppearancePatentLlmClient(判定口径单一来源);"
+ "同步/导出/查询侧一律引用 NO_INFRINGEMENT 常量,注释里的举例不算(本判据已剥离注释)");
// 结论值唯一来源仍是 LlmClient(NO_INFRINGEMENT 常量);白名单其余条目必须是页面名/文档
// 文案,不得出现第二个"造结论"的出处。新增命中必须在此登记并说明为何不产结论值。
assertIterableEquals(List.of(
"client/AppearancePatentLlmClient.java",
"controller/AdminAppearancePatentCleanItemsController.java",
"model/vo/AppearancePatentCleanItemPageVo.java",
"model/vo/AppearancePatentCleanItemVo.java"), new ArrayList<>(flagged),
"「无侵权」字面量只许落在登记白名单(LlmClient=结论值单一来源;控制器/VO 命中全是"
+ "菜单名/Swagger/403 文案);同步/导出/查询侧产结论值一律引用 NO_INFRINGEMENT 常量,"
+ "注释里的举例不算(本判据已剥离注释)");
}
private static String readSafely(Path path) {
@@ -263,7 +263,7 @@ class SourceScanTest {
.count();
assertThat(uniqueNames)
.as("973 支文件 / 970 个唯一名 ⇒ 确有 3 组同名。相等就说明同名面被搬空了,N5 的台账要同步改")
.as("977 支文件 / 974 个唯一名 ⇒ 确有 3 组同名。相等就说明同名面被搬空了,N5 的台账要同步改")
.isLessThan((long) all.size());
}
@@ -314,16 +314,21 @@ class SourceScanTest {
// ---------------------------------------------------------------- N6 moduleSources
@Test
void moduleSources_appearancepatent返回47支含拆分后的support件() {
void moduleSources_appearancepatent登记数与真实文件同号() {
List<Path> files = SourceScan.moduleSources("modules/appearancepatent");
assertThat(files)
.as("真实集成:对真仓目录求值。47 支=1 controller+1 client+1 service 主件+4 spi/cache+"
+ "21 service/support+16 model(dto7/vo9),与 find 实测同号"
.as("真实集成:对真仓目录求值。52 支=2 controller+1 client+8 service 根件"
+ "(主件/只读查询/同步/出表作业/缓存/心跳与拉取与重试 SPI)"
+ "+21 service/support+19 model(dto7/entity1/vo11)+1 mapper,"
+ "与 find 实测同号"
+ "(3A 拆薄第十三笔再落 5 支;失败任务重试再落 1 支 RetrySpi;"
+ "v1.3 Phase 1 无侵权同步底座再落 2 支:model/entity/CleanItemEntity+"
+ "mapper/AppearancePatentCleanItemMapper)")
.hasSize(47);
+ "mapper/AppearancePatentCleanItemMapper;Phase 2 同步服务再落 1 支"
+ " AppearancePatentCleanSyncService;Phase 3 只读页再落 4 支:"
+ "controller/AdminAppearancePatentCleanItemsController+"
+ "service/AppearancePatentCleanItemQueryService+model/vo 两件)")
.hasSize(52);
assertThat(files.stream().map(p -> p.toString().replace('\\', '/')).toList())
.as("support 目录里的既有件必须在面里——聚合入口存在的理由就是拆分后的新文件要自动被看到")
.anyMatch(rel -> rel.endsWith("service/support/AppearancePatentRowNormalizer.java"));
@@ -459,7 +464,7 @@ class SourceScanTest {
.isEqualTo(7);
assertThat(rel.stream().filter(p -> p.contains("/model/vo/")).count())
.as("model/vo 一层嵌套")
.isEqualTo(9);
.isEqualTo(11);
}
@Test