33 Commits

Author SHA1 Message Date
huangzd1997 b5578561df fix(guardrails): 京东上架五守卫格整量补记(24272a91 点名 87 例没跑整量、两处账本与四个分母漏记,2026-11-18 发版前整量 5689 例抓到)——①TaskFailureCategoryGuardrail B51-R1:JdPublishIngestService.summarizeTerminal 文案先落局部变量 message 再配对写列(原来三元里各写各的表达式被「写的列与文案不是同一个来源」判红;CollectDataService failTask 正本形状同源);②ApiGuardCoverageAuditor PENDING_CONVERGENCE 登记 /api/jd-publish(与 /api/jd-collect 逐形状同族:建单等五端点 requireOwnershipUserId fail-closed、chunk 判死口凭据化 isTrustedInternalToken 匿名拒绝判死、JdPublishChunkRequest 不带 userId 不进身份扫描);③RequestSuppliedIdentityOutletTest 写类分母 133→136(建单 DTO 形+activate+heartbeat 三支)、读类 67→69(items+progress 两支),chunk 不计入(留痕注释);④MigratedSqlEquivalenceTest XML_SELECT_TOTAL 103→105+NOT_MIGRATED 点名 JdPublishItemMapper#selectPublishableItems/countByPublishStatus;⑤SqlLayeringConventionTest XML_STATEMENT_TOTAL 147→149。判据:点名 5 类 34/34 绿+整量 5689 例(0 失败/19 skip)BUILD SUCCESS 9:51min——修复 jar 与平台隔离 jar 同窗 2026-11-18 02:56:14 +08:00
huangzd1997 1105320354 fix(admin-shell): 壳层锁视口高——侧边栏固定、菜单区独立滚动条(2026-11-18 用户口径「菜单加个滚动条吧 不然滚动下来 又侧看不见了」)——根因=.admin-shell 用 min-height:100vh 让整条 flex 高度链失去确定性:.admin-menu-scroll(flex:1) 内的 el-scrollbar(内部 height:100% 需父级定高)与 .admin-content(现成 overflow:auto)双双失效、滚动回落整页滚,侧边栏顶部品牌区/平台 tab 被滚出视口;改 height:100vh+overflow:hidden 后侧边栏定视口高、菜单区自出滚动条、内容区独立滚动、顶栏固定(html/body/#app L33 已 height:100% 无需动;不删任何现有声明,task-243 钉的 sidebar 252px/topbar 76px/渐变全兼容)。判据:task-243 首用例新增三条绊线断言(.admin-shell 必须 height:100vh+overflow:hidden、不得回退 min-height:100vh,改回即红;在既有用例内加断言行不新增 test 块/read 点,source-pin 棘轮钉子=460/读点=658 与基线逐字同零台账变化);vue-tsc rc=0;node --test task-243/4/242/棘轮 30/30;快检 overall=pass 四面绿(后端 9.5/后管 8.8/客户端 10.0/用户端 9.6)。纯 CSS 改动随下一窗口后管发版生效,真机目检登录后滚动菜单即见 2026-11-18 02:17:18 +08:00
huangzd1997 8ac9fafb7b feat(jd-database): 分类状态快筛加「全部」档(2026-11-18 用户口径「加个全部选项」,默认仍卡未分类)——三档下拉(全部/已分类/未分类),「全部」value='' 选中即查当前分组全部商品:序列化层对 '' 天然不下发 classified 参数(jd-product-filter toJdProductFilterQuery 单一出口,''/缺省/脏值同走该兜底)=后端 required=false 收 null=JdProductMapper.xml <if test="classified != null"> 跳过谓词,后端零改动;出厂默认与「重置」仍卡「未分类」(11-17 用户口径不动,jdProductFilterActive 对 '' 仍按未激活处理);「全部」选项与「全部分类」下拉的 value='' 全量出口同形。判据:mount jd-database-page 三档断言(['全部','已分类','未分类'] 精确数组,改回两档即红)+新增「选全部→请求不带 classified 键」行为用例+重置仍回未分类;jd-product-group 纯测试形状不变仍绿;vue-tsc rc=0;node --test 14/14;vitest mount 43/43;快检 overall=pass 四面绿(后端 9.5/后管 8.8/客户端 9.8/用户端 9.6)。纯前端改动随下一窗口后管发版生效 2026-11-18 01:56:08 +08:00
huangzd1997 2a8bdd7d29 feat(platform): 后管与桌面端菜单按用户平台隔离(2026-11-18 用户口径「隔离下除 admin 外,京东用户只看京东菜单、亚马逊看不了」)——AdminMenuPlatformScope 成为菜单 key→平台归属唯一出处(京东独占 admin_jd_database+app 三件;双侧六件=账号域基础三页+本笔补侧的菜单权限配置/密钥管理/密钥用量统计;未知 key 默认 amazon 与前端 platform-scope 同形;platform null/空白归一 amazon=列 DEFAULT 同口径,不把「没带」读成京东侧全拦),filterMenuVosByPlatform 扁平过滤保留祖先链保组树完整、分组节点按存活子项去留(与前端 filterMenuTreeNodesByPlatform 同形);裁剪只挂三个下发出口(current-user/menus 非站点超管按 users.platform 收窄+登录 VO adminColumns/appColumns 双树=后管+桌面端一起)与逐页门(requireConsolePageAccess 平台门置于 isAdmin 直通之前,越侧 key 一律 403),红线=不动 getUserColumnPermissions 本体(授权编辑读接口与整树替换保存语义不变、授权行保留);current-user 增 platform 键;前端 allowedPlatformsForUser(超管随菜单树分布、其余锁 users.platform 侧、未知/缺省兜底 amazon、交集空仍锁死本人平台)+AdminLayout watch clamp(localStorage 残留另一侧自动归位、当前页在被禁侧跳回本人平台第一可见页、单侧时 tab 条整个隐藏)+platform-tab.syncToAllowed;app 树 37 key 全集核对无平台无关 key(withdraw=取款挂品牌运营工具、erp/purchase 挂后勤工具)。判据:AdminMenuPlatformScopeTest 11+ConsolePageTest +5 平台门+AdminConsoleCurrentUserMenusPlatformTest 3+AuthServicePlatformMenuTest 3+CompanyTest +1 platform 键=43 例绿;前端 platform-menu-filter 9/9(+2)、mount admin-layout-platform-lock 4/4、授权树过滤对齐扩双侧;vue-tsc rc=0;node --test 1937/1938(唯一红=在册 B116-03 ENOENT);vitest mount 184/184;mvn -o test-compile rc=0;快检后端 2 红格=环境假红(缺 Git 工具链 PATH,前置后 30/30 绿)、四面可读棘轮红=PermissionMenuService 1661→1676 行随本笔点名记账(ops 仓同窗);桌面端界面随 appColumns 下发生效,客户端出包另窗 2026-11-18 01:28:49 +08:00
huangzd1997 24272a910c feat(phase-2): 京东商品上架后端地基(v1.5 蓝图 docs/ITERATION_PLAN.md §4 Phase 2)——V210 发布明细表 biz_jd_publish_item(号段实核:V207~V209 已按序占用)+JdPublishTaskService 建单/配额/归属/生命周期(建单即落快照行,AC-8 配额闸前置、AC-9 他人商品 403、铁律 27a 改价同源、铁律 19 LOCAL 显式写)+items 分批下发(SQL 侧下推只出 PENDING 行=AC-4 断点服务端半边,图片 jd-products 预签名 GET 新开 presignObjectDownload 出口)+JdPublishIngestService chunk 行级回传(isEnd 按行级真源汇总终态,铁律 31 分档判死口凭据化)+JdPublishStaleTaskService 判死(JdStaleTaskService 同形,60 分钟 aiimage.jd.publish.stale-minutes)+派发三件套(SPI jd-product-publish-run+白名单 JD_PUBLISH+建单响应 queuePayload,铁律 32)+JdPublishTaskHeartbeatSpi override ensureOwnership(B98-07 同形债预防:SPI 轻校验+服务层用户域归属闸,LOCAL 客户端心跳实例域不适用)+registry/EXPECTED_MODULES/清理清单/CollectChannel.LOCAL_DEFAULT_MODULES 四清单同步;激活 JdPublishContractPendingTest 7 支 Pending 契约全绿。判据:点名 12 类 87 例 BUILD SUCCESS(契约 8+建单 14+回传 11+判死 3+schema V210 格+coverage/golden/channel/pull-spi/migration 各格);mvn -o test-compile rc=0;可读棘轮 OssStorageService 1161→1176 行随本笔点名更新(presignObjectDownload +15);LockSkipWitness 分母 30→32、覆盖文件 12→13(JdPublishStaleTaskService 两处留痕,ops 仓同窗更新);快检后端 9.5/用户端 9.6 绿、唯一 fail 红格=后管 readSource 属他窗在飞 align-group-editor 用例 10→13(本笔零后管文件);真机带库整链(V210 实跑)随 Phase 5 发版窗口 2026-11-18 00:31:53 +08:00
huangzd1997 f4bde32f83 feat(admin): 新建分组组长可下拉选(2026-11-18 用户口径「组长不能下拉选吗」)——组长原为只读回显当前登录用户(2026-10-07 对齐 admin.js 的有意设计);后端 validateLeaderOperator 对站点超管本就放行任意 createdById(只要求组长与操作者同公司 ensureLeaderSharesOperatorCompany),故纯前端落地:新建+站点超管出 filterable 下拉(候选=本公司账号,公司超管永不领衔、站点超管仅保留操作者本人,管理员/普通账号均可领衔);组长改选联动两件事——组员候选按新组长重算(eligibleGroupMembers 已吃 leaderUserId)+ 把新组长从已选组员里摘掉(后端「组长不能作为组员重复加入分组」);创建提交 createdById=所选组长;编辑与非超管新建保持只读(后端更新载荷不收组长/强制组长=操作者本人);编辑历史行缺 leaderUserId 保持 null 口径不回落当前登录人(组员候选过滤不悄悄变)。判据:align_group_leader_candidates_* 3 支新模型用例+ui_wiring 改钉新形状(v-if=canPickLeader/v-else 只读回显/createdById=leaderId/companyTab 绊线保留)+platform-account-pages 调用形状同步;vue-tsc rc=0;node --test 39/39(align-group-editor 13+task-253 8+platform-account-pages 10+task-268 8) 2026-11-18 00:27:04 +08:00
huangzd1997 885fa813db feat(admin): 侧边栏父菜单默认全展开+mount 断言对齐标题去后缀(2026-11-17 用户口径「父菜单不要默认折叠」)——menu-mapper 的 groupKeysForActive(按激活路由命中展开)换 allGroupKeys(全部分组);AdminLayout 对 entries 变更命令式补开(el-menu 的 default-openeds 只在挂载读一次,平台 tab 切换/菜单树刷新后新分组不会自动展开;watch 里读当下 computed 而非触发快照,快速连切 tab 不补开已离开渲染树的旧分组——el-menu 的 open 对未注册 index 会抛);用户手动收起的组在 entries 不变期间保持收起。判据:task-6 8 例(allGroupKeys 全展开/顶级叶不产键/空菜单空键+壳层绊线:groupKeysForActive 回流即红、watch(openedKeys)+nextTick 缺一即红);mount 京东页「分类管理」断言对齐 ea9dca3f 标题去后缀(那笔漏改的存量红);vue-tsc rc=0;node --test 1932/1933(唯一红=在册 B116-03 ENOENT);vitest mount 180/180;ops fast 闸门后管格绿(overall=fail 甄别=后端巡检格/用户端棘轮格红属 crawler-plugin 34 个在飞件,本笔不触碰后端与用户端) 2026-11-18 00:00:33 +08:00
huangzd1997 ea9dca3faf style(admin): 分类管理弹窗标题去掉「· 分组名」后缀(2026-11-17 用户口径「不要显示周丽娥」)
modal-sub span 与 .modal-sub 样式整段删除;挂载用例改反向钉(.modal-sub 不存在、分组名不进标题),翻组/直建等其余 20 例不受影响。vitest 21 例全绿+vue-tsc rc=0。
2026-11-17 23:02:22 +08:00
huangzd1997 7f76a96264 style(admin): 分类管理弹窗搜索/新建/按钮合回一排(2026-11-17 用户口径「弄成一排呗」)
340px 弹窗里垂直两行显空,三件改回一行。宽度分配先试 flex 1:1.75 实测偏移(搜索 122、新建输入只剩 105,7 字占位 115px 被截),改成搜索定宽 108px+新建行吃剩余(输入 119px),两个占位都完整。挂载用例同步为一排结构,并钉新建行只有输入框+按钮两个子元素(用户旧构建截图里多出的空框=11-15 已下线的排序输入,重新构建即消)。判据:vitest 挂载 21 例全绿+vue-tsc rc=0。
2026-11-17 22:57:23 +08:00
huangzd1997 0c4354fc1e feat(jd): 京东数据库写权限放宽到管理员级+分组筛选收超管档(2026-11-17 用户口径「超管+管理员都可以,只有普通员工不能操作」「超管可以有分组筛选,管理员及以下则没有」)——后端 requirePlatformSuperAdminWrite 改 requireJdProductWrite:平台超管/公司超管/admin 三档放行、普通账号(resolveRole=null)403「仅超级管理员或管理员可以编辑或删除京东数据库数据」(四条商品行写路由同闸;批量归类 V203 requireWritableGroup 不动);前端 canWriteProducts(isAdminRole)管操作列/批量删除/勾选列/只读提示,canFilterGroup(平台+公司超管)管筛选行「分组」控件整块显隐(管理员及以下连单组锁定芯片都不渲染,分类面静默落默认组)。判据:后端 29 例(普通账号四写 403 不触服务+admin 四写放行+公司超管放行+结构钉三档谓词与 403 文案);前端挂载 42 例(普通员工 5 列只读+无分组控件、admin 7 列全写+多组也无下拉、公司超管齐写+多组可切组、超管照旧);vue-tsc rc=0;ops fast 闸门 overall=pass 2026-11-17 22:42:15 +08:00
huangzd1997 8b0cde4a51 feat(admin): 京东数据库动作条上移+文案三刀(2026-11-17 用户截图口径)——「共X条京东商品」汇总删除;原工具栏(批量编辑分类/分类筛选/状态快筛/分类管理/批量删除)整体上移并入筛选行与查询/重置同排(.jd-toolbar 容器摘除,放不下靠 flex-wrap 折行;下拉位宽钉定改 .jd-filter-row 直接子级选择器防误伤「分组」表单下拉);「删除勾选(N)」改「批量删除(N)」、确认弹窗改「确定批量删除选中的 N 个商品吗」。行为零改动(勾选累计/权限分档/筛选语义全不动)。判据:vitest 挂载 jd-database-page 39 例全绿(文案断言同步、汇总条加反向钉)+ jd-category-manage-dialog 21 例+静态扫描 node --test 24 例+vue-tsc rc=0 2026-11-17 22:23:35 +08:00
huangzd1997 c15f0ce229 fix(jd): 采集分类默认口径改「全店采集」——占位符去「不选=」改「全店采集(点击选择分类)」、未选中提示改「默认全店采集。」(2026-11-17 用户口径「默认全店采集,不要写不选=全店采集」;选择行为零改动,空数组=全店采集的三处同键契约不动)。判据:vitest 挂载 jd-collect-progress 10 例全绿(含新占位符 prop 钉与清空恢复断言)+vue-tsc rc=0 2026-11-17 21:17:18 +08:00
huangzd1997 6ccf7f2bb3 feat(admin): 账号域四弹窗撤「所属平台」手选,平台跟随当前 tab(2026-11-17 用户截图「有京东就不需要亚马逊了阿,亚马逊那边也是」)——公司/分组/用户新建编辑弹窗不再出平台单选:新建取当前平台 tab(props.platform),编辑回填行值原样下发(后端契约与 payload 形状零改动);form.platform 仍驱动授权树按平台收窄(UserMenuAuthTree)与京东上架额度可见性(includeQuota),判定出口不动。护栏翻转:platform-account-pages「单选恒在」两处改 doesNotMatch 反向钉(写回单选即红)+ task-48 编辑弹窗按钮钉回只剩角色两枚。判据:node --test 1932/1933(唯一红=B116-03 在册环境红,参考仓 shop-finance-source 已移除)+ vitest mount 177/177 + vue-tsc rc=0 + ops fast 闸门 overall=pass。⚠ 后果登记:记录跨平台挪档的弹窗入口随之消失(B116-01 的「待用户翻档归侧」前置失效),需要时另窗补列表级动作或直改 DB。 2026-11-17 21:16:23 +08:00
huangzd1997 ae250ea182 feat(admin): 分类管理弹窗删三处说明小字(2026-11-17 用户口径「小字不需要」)——弹窗顶部「分类按数据权限分组隔离…」提示、平台超管空态引导语「京东侧还没有数据权限分组…」、组长说明「组长=你…」整段删除,空态只留直建表单本体;对应 CSS(.modal-tip/.bootstrap-lead/.bootstrap-hint)与挂载断言同步(指路句改反向钉、空态改钉表单形状、有组格改钉 .group-bootstrap 不渲染)。判据:vitest 挂载 21 例全绿+vue-tsc rc=0 2026-11-17 21:09:10 +08:00
huangzd1997 d850c46f46 fix(jd): 京东分组作用域两条取组 SQL 补 platform 投影——平台闸读不到平台档把全部组(含 jd 档)判非 jd 清空,平台超管建组建成功京东侧永不显示(2026-11-17 用户截图「咋没显示」实录)。selectAllGroups/selectLedGroups 各补 g.platform AS platform(selectAllGroups 上次 47fc0e08 补 company_id 同一条查询同款病);selectLedGroups 按先例整行摘迁移等价账本点名 NOT_MIGRATED(LEDGER_ROWS 82→81/SELECTS 58→57);ShopManageGroupScopeSqlTest 升级双事故绊线:超管投影钉 company_id+platform 两列、新增组长档投影格。判据:投影缺任一列即红(mock 掉 mapper 的服务用例照旧绿——这正是两连漏的成因);mvn -o test 三类 22 例全绿 2026-11-17 21:08:59 +08:00
huangzd1997 2a0cc86572 fix(jd/account): 用户弹窗选京东桌面端分区整组消失——V209 前台京东菜单(jd_tools/jd-collect/jd-publish)补进平台判定(2026-11-17 用户截图「前台的京东少了」)。新增 JD_APP_MENU_KEYS 与 JD_MENU_KEYS 分列:app 菜单没有 admin 路由,不得混进「与 routes.ts 对撞」的后台清单;platformsOfMenuKey 两份同认,过滤算法与授权树/侧边栏两消费方零改动。判据:user-menu-tree-platform-filter 新增桌面端分区正反两例(jd 留京东工具台整组/amazon 留亚马逊 app)+三 key 判定钉;platform-menu-filter 清单钉死用例同步 JD_APP_MENU_KEYS 形状。node --test 29 例全绿+vue-tsc rc=0 2026-11-17 20:58:54 +08:00
huangzd1997 164b9b83fa feat(jd/account): 授权树按平台过滤+平台超管空态直建京东档分组——用户弹窗选京东只发京东侧菜单(京东数据库+双侧账号域三件,platform-scope 唯一算法出口、侧边栏委托同源),翻档时另一侧勾选自动收敛(pruneCheckedIdsToTree),京东档账号不再整树混发亚马逊授权;分类管理弹窗京东侧零分组时给平台超管开直建口子(POST shop-manages/groups platform 恒 jd、组长=当前登录人),建完 group-created 让父页整条作用域重取翻到新组接着建分类,不再死在「你还不属于任何数据权限分组」(2026-11-17 用户口径「admin 权限最大」)。判据:tests/user-menu-tree-platform-filter.test.ts 钉过滤/收敛/两消费方同形(B79-12 钉法);分类管理弹窗挂载 6 例(直建表单/无登录人/失败不发事件/翻组重取/非超管维持文案/有组不出口子)+京东页挂载 2 例页面级链路;vue-tsc rc=0 2026-11-17 18:59:35 +08:00
huangzd1997 0f375dcd04 feat(jd): 采集分类换 el-select 下拉多选(2026-11-17 客户口径「不要全展示出来,弄个下拉式多选」)——9 行复选列表收进 collapse-tags 下拉(+N 徽标),选择模型改 id 数组、双键按快照原序同源反查(点选先后不进请求体);暗色主题套壳。判据:纯测试钉 el-select multiple 在册+shop-cat-list 旧形状反向钉;挂载两格改用真实 ElementPlus 经 update:modelValue 模拟点选(轮询格保持轻量桩——真件在 fake timers 下会打断任务面板轮询链,实测教训写进注释)。node --test 9 例+vitest 挂载 10 例+vue-tsc rc=0 2026-11-17 18:30:09 +08:00
huangzd1997 b59663ebdb test(admin): readSource 钉子基线回写——补登记 6dc33ea7 给 jd-product-group.test.ts 新增的第 7 支用例(cases 6→7),官方通道 UPDATE_SOURCE_PIN_BASELINE=1 整档重生成,totals 与实扫对平(用例 1834→1832、钉子 463→460、读点 663→658,余为并行窗口用例删减的收紧);source-pin-ratchet 6 例复跑全绿 2026-11-17 18:30:02 +08:00
huangzd1997 6dc33ea725 feat(jd): 分类状态快筛按用户口径收敛为两档默认卡未分类——去掉「全部状态」选项(界面不再提供全量档),出厂态/重置都回 ungrouped(JD_PRODUCT_DEFAULT_CLASSIFIED 单一出处);筛选激活判定改为「偏离默认档才算激活」免得首屏永远处于有筛选状态;判据:纯测试默认档 classified:false 下发+默认激活 false、挂载两档下拉在册+首屏即 ungrouped+重置回未分类不放开 2026-11-17 18:06:14 +08:00
huangzd1997 b4e97823f4 style(admin): 分类管理弹窗按用户红框收窄到 340px(2026-11-17 用户口径「红框大小就够了」)
420 仍偏宽;按红框量到约 340px。全局 main.css 的 border-box 使 width 即总宽;复刻页此前不带该重置,把 width 读成内容宽+42px(402≠360 的成因),已在复刻件补齐同形重置。340−42=298px 可用宽度实测行内容(名称+徽标+改名/删除)与页码条(298.4px)都放得下、不挤换行。挂载测试 15 例绿、vue-tsc rc=0。
2026-11-17 17:07:54 +08:00
huangzd1997 d25c91f6da feat(jd): 京东数据库页分类状态快筛(已分类/未分类)——classified 参数按当前分组在 SQL 侧 EXISTS/NOT EXISTS 下推(铁律20同形,判据与读侧填分类列同形);后管工具栏「全部分类」旁三档下拉选中即查;与 11-16 撤掉的旧 grouped/ungrouped 无关(那两档读已停用列,控制器仍拒收)。判据:XML 两分支谓词/成对直传/classified 参数在册绊线+纯测试三档+挂载 2 例 2026-11-17 16:58:28 +08:00
huangzd1997 20ee73349e feat(jd): 京东工具台纳入后台菜单权限——V209 app菜单组jd_tools+两子行, 预授权沿V163全授组行; 用户端工具台卡片/首页入口按权限显隐(接口失败兜底全显, 同亚马逊形状); 首页computePermissionState抽薄home-permission.ts并修只授京东误亮亚马逊的兜底缺陷 2026-11-17 16:05:00 +08:00
huangzd1997 d28461d3d3 style(admin): 分类管理弹窗收窄到 420px(2026-11-17 用户口径「宽度不需要那么宽」)
垂直排列后每行拉满,480px 显空荡;收到 420px,两行输入可用宽度约 380px,紧凑且无横向留白。弹窗挂载测试 15 例仍全绿。
2026-11-17 15:41:50 +08:00
huangzd1997 56fe32e8e9 style(admin): 分类管理弹窗搜索/新建改垂直排列+分类列表加分页(2026-11-17 用户口径「垂直排阿,这样好看」「不然留白太多了」「分类这也要加分页」)
垂直排列:manage-bar 由 flex-wrap 并排改 column,搜索与新建各占整行,弹窗内容变高、列表下空白收窄;

分页:每页 6 行+上一页/下一页+「第 x / y 页·共 N 个分类」,只在超过一页时渲染。分类与父页「分类」下拉共用同一条全量接口(下拉必须全量),故做本地切片;搜索同为本地过滤 ⇒ 同源不漏项;改关键字回第一页、命中集变少把越界页码钳回。实测 8 行在 700px 高视口会顶出列表内滚动条(与页码条并存难看),故定 6 行。

闸门:--fast 唯一红格=可读棘轮,红因是 7299166e 换 el-select 顶长 5 个已登记超长页面(各 +3~30 行),非本笔;vue-tsc rc=0,本弹窗 15 例与京东数据库页 35 例挂载测试全绿。
2026-11-17 15:18:31 +08:00
huangzd1997 283921df0c style(admin): 分类管理弹窗数量徽标贴住名称,按钮仍靠右
2026-11-17 用户反馈「这个 0 和名称离的有点远」:行内 .option-name 是 flex:1,
把整行剩余空白全吃满,商品数徽标与「改名/删除」一起被顶到行尾,名称和号码
之间隔着一大片空白。

改法:名称改 flex:0 1 auto(只包自己的文字,过长仍按 min-width:0 省略号截断),
剩余空间只由 .row-actions 的 margin-left:auto 吸收 ⇒ 徽标紧贴名称、按钮照旧靠右;
只读档没有按钮时整行自然左对齐。

验证:jd-category-manage-dialog 挂载 12/12、test:mount 164/164、npm test
1923/1924(唯一红=date-range-order 在册环境红)、vue-tsc 0 错。
2026-11-17 14:55:19 +08:00
huangzd1997 2078e9efde fix(admin): 公司保存后重拉 tab 目录改走 store 具名出口,摘掉 company-config 棘轮红
ee613db0 给公司管理页加了「保存后刷共享公司目录」,却让这页自己持了一份
useCompanyTabStore(),形状与「给这页上了公司 tab」分不开 ⇒
tests/company-config-entry-super-only.test.ts 的 pageFiles 分母当场红
(公司管理按 2026-10-06 控制方口径本就该永远在名单之外)。

改法:把动作收进 src/stores/company-tab.ts 的具名导出 refreshCompanyDirectory()
(内部仍走 refresh() 的 force 档),页面只调函数、不留 store 实例。语义不变:
本页列表照常重拉,全站 18 个带 tab 页面下一跳拿到新名单;失败仍 error 落 store
+ console.warn 不弹新提示(§12 第 5 条口径)。

验证:company-config-entry-super-only 4/4、相关护栏 26/26、vue-tsc 0 错。
2026-11-17 14:55:15 +08:00
huangzd1997 7299166e96 style(admin): 全站原生下拉统一换 el-select——弹层圆角与亚马逊面一致(2026-11-17 用户口径「样式咋不是圆角 和亚马逊不统一 其他地方也要看看」)
范围:src 里原生 <select> 由 36 处清零(含全站共享分页条),15 个页面 + 1 个组件。
换法统一:class="admin-filter"(main.css 皮肤 42px/9px/#f8fbfd/focus ring)+
aria-label 定位 + el-option 显式 label;「全部 XX」空值行与 value 形状逐字保留
('' / null / String(id) / '1'/'0' / `${source}|${deviceId}` 等,下游查询参数与后端枚举不动)。

- OldPagination:每页条数下拉换 el-select(局部 import,挂载测试单 mount 也能渲染),壳压回分页条 30px/8px 档
- account 三页(菜单类型/密钥状态/分组)+ GroupsPage/UsersPage 清死 select 规则
- asin 三页(国家/弹窗分组):弹窗分组用 placeholder+clearable+:value-on-clear 钉回 null,守 number|null 契约
- patent 页(国家/分组)
- records 两页(来源/用户/终端覆盖):终端覆盖 value 仍 source|deviceId
- tasks 四页 + 任务看板(业务/状态/类型/来源/店铺/分组/场景):BrandGating/DuplicateCheck/KeywordUsage 三页本地是 34px 紧凑档,
  故把 el-select 壳压回本地 34px/7px 与同行输入框齐高(否则高 8px 错位)

测试:mount 全量 21 文件 164 passed;node --test 1924 例 1922 passed(2 红为在册:
date-range-order 环境红、company-config-entry-super-only 由 ee613db0 引入与本次无关);
vue-tsc rc=0。新增 account-select-el / records-select-el 两支换壳契约(值形状 + 空值行 + 点开→点选项)。
2026-11-17 13:49:39 +08:00
huangzd1997 80060912ca style(admin): 京东数据库页两颗下拉换 el-select——弹层圆角与亚马逊面统一(2026-11-17 用户口径「和亚马逊不统一」):分组下拉带搜索(admin-filter 同壳 42px/9px),分类筛选保留「全部分类」行同语义;删原生 select 死样式,工具栏位宽 200px 由页内钉;挂载测试换「点开→点选项」真实交互+组件树读选项(35 例全绿,vue-tsc 0 错,node --test 1922/1924 唯一红=date-range-order 在册环境红与本次无关) 2026-11-17 12:57:16 +08:00
huangzd1997 ee613db05b feat(admin): 公司tab条按平台分侧+京东分组作用域只认jd档(2026-11-17 用户口径「亚马逊侧别挂京东-团队,同理京东那边也是」)
- company-tab store:目录按当前平台 tab 拉(loadedPlatform 对撞早退),切台重拉;旧选中仍在新清单则保住,不在回落 id 最小启用公司;新增 refresh() 强制档(公司翻档/启停后 18 页 tab 条同步)
2026-11-17 11:50:13 +08:00
huangzd1997 dc3e7f3b37 test(company): CompanyVoTest 夹具补 platform 列——5c7a310e(V206 平台分侧)给 CompanyVo 加字段时漏更期望列集,本窗发版整量 mvn -o test 抓到(5630 例 1 红),补齐后复跑绿 2026-11-17 09:46:06 +08:00
huangzd1997 db71803430 feat(admin): 京东分类管理并入京东数据库页「分类管理」对话框+删「清除勾选」按钮(V208) 2026-11-17 09:32:24 +08:00
huangzd1997 848fef3b03 test(phase-0): v1.5 京东发布契约预置(后端+用户端)——AC-9 分类口唯一绊线立即绿(后端全仓扫+前端全src扫);Pending Phase 2 后端7支@Disabled(AC-1建单/明细表V208+、AC-2派发三件套、AC-8配额闸)+Pending Phase 4 用户端5支skip(Tab形状/建单体/endpoints/占位卡转正式) 2026-11-17 09:30:44 +08:00
138 changed files with 9020 additions and 2888 deletions
@@ -2,6 +2,11 @@
/** 旧版风格分页(像素复刻 admin.html .pagination)+ 每页条数下拉(10/20/50/100)。 /** 旧版风格分页(像素复刻 admin.html .pagination)+ 每页条数下拉(10/20/50/100)。
* props: total / page / pageSize / sizes(默认 10/20/50/100) / showTotal(默认 true) / jump(默认 true)。 */ * props: total / page / pageSize / sizes(默认 10/20/50/100) / showTotal(默认 true) / jump(默认 true)。 */
import { computed, ref } from 'vue' import { computed, ref } from 'vue'
// 每页条数下拉 2026-11-17 用户口径「和亚马逊不统一」:原生 <select> 的弹层是浏览器直角
// 原生物,全站分页条都有这一处 ⇒ 换 el-select(EP 圆角面板)。组件内局部导入,不与全局
// 注册表耦合:任何挂载测试单独 mount 本组件都能正确渲染(不依赖外部 app.use)。
// 样式已在 plugins/element.ts 里按组件全局引过,这里不重复引。
import { ElOption, ElSelect } from 'element-plus'
const props = withDefaults( const props = withDefaults(
defineProps<{ defineProps<{
@@ -34,8 +39,7 @@ function goJump() {
go(Math.min(Math.max(n, 1), totalPages.value)) go(Math.min(Math.max(n, 1), totalPages.value))
} }
function onSizeChange(event: Event) { function onSizeChange(value: number) {
const value = Number((event.target as HTMLSelectElement).value)
if (Number.isFinite(value) && value > 0) emit('size-change', value) if (Number.isFinite(value) && value > 0) emit('size-change', value)
} }
</script> </script>
@@ -43,9 +47,16 @@ function onSizeChange(event: Event) {
<template> <template>
<div class="old-pagination"> <div class="old-pagination">
<span v-if="showTotal" class="page-total">共 {{ total }} 条</span> <span v-if="showTotal" class="page-total">共 {{ total }} 条</span>
<select class="page-size-select" :value="pageSize" @change="onSizeChange"> <!-- el-select 出厂宽度 100%(--el-select-width),进 flex 行会横涨 ⇒ 类里钉位宽。 -->
<option v-for="size in sizes" :key="size" :value="size">{{ size }}条/页</option> <el-select
</select> class="page-size-select"
:model-value="pageSize"
size="small"
aria-label="每页条数"
@change="onSizeChange"
>
<el-option v-for="size in sizes" :key="size" :value="size" :label="`${size}条/页`" />
</el-select>
<button type="button" :disabled="page <= 1" @click="go(page - 1)">上一页</button> <button type="button" :disabled="page <= 1" @click="go(page - 1)">上一页</button>
<span class="page-cur">第 {{ page }} / {{ totalPages }} 页</span> <span class="page-cur">第 {{ page }} / {{ totalPages }} 页</span>
<button type="button" :disabled="page >= totalPages" @click="go(page + 1)">下一页</button> <button type="button" :disabled="page >= totalPages" @click="go(page + 1)">下一页</button>
@@ -92,15 +103,22 @@ function onSizeChange(event: Event) {
.page-total { .page-total {
margin-right: 4px; margin-right: 4px;
} }
/* 每页条数下拉:与原分页条同尺寸(30px 高、8px 圆角、#cbd9e6 描边、#f8fbfd 浅底)。
外形走 .el-select__wrapper(EP 的结构类,scoped 需 :deep 穿透)。 */
.page-size-select { .page-size-select {
width: 104px;
}
.page-size-select :deep(.el-select__wrapper) {
min-height: 30px; min-height: 30px;
padding: 3px 8px; padding: 3px 8px;
border: 1px solid #cbd9e6;
border-radius: 8px; border-radius: 8px;
background: #f8fbfd; background: #f8fbfd;
color: #24384d; box-shadow: 0 0 0 1px #cbd9e6 inset;
font-size: 13px; font-size: 13px;
font-family: inherit; line-height: 22px;
}
.page-size-select :deep(.el-select__wrapper:hover) {
box-shadow: 0 0 0 1px #9fb7cd inset;
} }
.page-jump { .page-jump {
display: inline-flex; display: inline-flex;
+51 -10
View File
@@ -16,28 +16,69 @@ export const PLATFORM_TABS: readonly PlatformTabDef[] = [
] ]
/** 京东侧独占菜单的 menuKey 唯一清单(与 routes.ts 的 menuKey 逐字一致,用例钉住)。 /** 京东侧独占菜单的 menuKey 唯一清单(与 routes.ts 的 menuKey 逐字一致,用例钉住)。
* 2026-11-17 加京东分类管理(用户口径「这边分组是京东的分组管理的而不是亚马逊的」—— * 2026-11-17 晚:分类管理子菜单(admin_jd_category_manage,V204)随「京东分类管理并到
* 分类管理子菜单归京东侧,不与亚马逊侧混排)。 * 京东数据库分类编辑里」用户口径整体下线(页/路由/菜单行 V208 删),key 从清单摘除。
* 后续京东新页面上线把 key 加进这里即可,清单外的 key(含店铺管理/生成记录等 * 后续京东新页面上线把 key 加进这里即可,清单外的 key(含店铺管理/生成记录等
* 存量页)一律归亚马逊或双侧清单。 */ * 存量页)一律归亚马逊或双侧清单。
* ⚠ 本清单只收后台(admin)侧 key——护栏用例要求每条都在 routes.ts 登记 menuKey;
* 桌面端(app)京东菜单走 {@link JD_APP_MENU_KEYS}(无 admin 路由,不进侧边栏)。 */
export const JD_MENU_KEYS: readonly string[] = [ export const JD_MENU_KEYS: readonly string[] = [
'admin_jd_database', 'admin_jd_database',
'admin_jd_category_manage',
] ]
/** 双侧共用菜单(2026-11-17 用户口径「这些亚马逊这边也要有」):三个账号域页面在两个 /** 桌面端(app)京东菜单的 column_key 清单(V209,2026-11-17 用户口径「前台的京东少了」):
* 平台 tab 下都显示——同一套组件、按当前 tab 给接口传 platform,各自只看/管各自平台的 * 组行 jd_tools(京东工具台)+两工具子行 jd-collect(京东店铺数据采集)/jd-publish(京东商品上架),
* 账号、分组、公司(后端 V206 三表加列,存量默认亚马逊,京东侧数据在编辑弹窗里翻档)。 */ * 与用户端 permissionKeys 逐字一致。app 菜单不进后管侧边栏与 routes.ts 路由表,故与
* {@link JD_MENU_KEYS} 分列——判定出口 {@link platformsOfMenuKey} 两份同认。
* 后续用户端京东新工具上线把 column_key 加进这里即可。 */
export const JD_APP_MENU_KEYS: readonly string[] = [
'jd_tools',
'jd-collect',
'jd-publish',
]
/** 双侧共用菜单(2026-11-17 用户口径「这些亚马逊这边也要有」;2026-11-18 扩双侧):账号域
* 页面在两个平台 tab 下都显示——同一套组件、按当前 tab 给接口传 platform,各自只看/管各自
* 平台的账号、分组、公司(后端 V206 三表加列,存量默认亚马逊,京东侧数据在编辑弹窗里翻档)。
* 2026-11-18 平台隔离落地(「非站点超管只看自己平台侧」)把三个账号域管理页也标双侧:
* 它们是账号域功能而非亚马逊业务,京东侧公司超管被锁单侧后仍要能配菜单权限、管密钥。 */
export const BOTH_PLATFORM_MENU_KEYS: readonly string[] = [ export const BOTH_PLATFORM_MENU_KEYS: readonly string[] = [
'admin_users', 'admin_users',
'admin_group_manage', 'admin_group_manage',
'admin_companies', 'admin_companies',
'admin_columns',
'admin_user_secrets',
'admin_user_secret_usage',
] ]
/** menuKey → 平台归属清单(唯一判定出口):京东独占 → ['jd'];双侧清单 → ['amazon','jd']; /** menuKey → 平台归属清单(唯一判定出口):京东独占(后台或桌面端清单)→ ['jd'];
* 其余(未知 key 在内)默认亚马逊。 */ * 双侧清单 → ['amazon','jd'];其余(未知 key 在内)默认亚马逊。 */
export function platformsOfMenuKey(key: string): PlatformTabId[] { export function platformsOfMenuKey(key: string): PlatformTabId[] {
if (JD_MENU_KEYS.includes(key)) return ['jd'] if (JD_MENU_KEYS.includes(key) || JD_APP_MENU_KEYS.includes(key)) return ['jd']
if (BOTH_PLATFORM_MENU_KEYS.includes(key)) return ['amazon', 'jd'] if (BOTH_PLATFORM_MENU_KEYS.includes(key)) return ['amazon', 'jd']
return ['amazon'] return ['amazon']
} }
/**
* 通用「按平台过滤菜单树」(唯一算法出口,2026-11-17 用户口径「授权树也按平台收」):
* 叶子按 {@link platformsOfMenuKey} 是否包含当前平台留下;分组节点自身的 key 不参与
* 平台判定,按「有存活的子项」决定去留——否则京东侧「账号与权限」这类混合分组会被整组误剪。
* 两个消费方必须同形:侧边栏(platform-menu-filter.ts)与账号弹窗的授权树
* (UserMenuAuthTree.vue),改判定规则只改这一处。
*/
export function filterMenuTreeNodesByPlatform<T extends { key?: string; children?: T[] }>(
nodes: readonly T[] | null | undefined,
platform: PlatformTabId,
): T[] {
const filtered: T[] = []
for (const node of nodes || []) {
const children = filterMenuTreeNodesByPlatform(node.children, platform)
if (children.length > 0) {
filtered.push({ ...node, children })
continue
}
if ((node.children || []).length > 0) continue
if (platformsOfMenuKey(node.key || '').includes(platform)) filtered.push({ ...node })
}
return filtered
}
+44 -9
View File
@@ -1,12 +1,12 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, watch } from 'vue' import { computed, nextTick, ref, watch } from 'vue'
import { useRoute, useRouter } from 'vue-router' import { useRoute, useRouter } from 'vue-router'
import { ElMessageBox } from 'element-plus' import { ElMessageBox } from 'element-plus'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { joinAdminPath } from '@/config/app' import { joinAdminPath } from '@/config/app'
import { pageTitleOf, topbarUserOf } from '@/layout/topbar-model' import { pageTitleOf, topbarUserOf } from '@/layout/topbar-model'
import { groupKeysForActive, toSidebarEntries } from '@/layout/menu-mapper' import { allGroupKeys, toSidebarEntries } from '@/layout/menu-mapper'
import { filterMenuTreeByPlatform, visiblePlatformsFor } from '@/layout/platform-menu-filter' import { filterMenuTreeByPlatform, allowedPlatformsForUser } from '@/layout/platform-menu-filter'
import { PLATFORM_TABS, platformsOfMenuKey } from '@/config/platform-scope' import { PLATFORM_TABS, platformsOfMenuKey } from '@/config/platform-scope'
import { usePlatformTabStore } from '@/stores/platform-tab' import { usePlatformTabStore } from '@/stores/platform-tab'
import { firstVisiblePath } from '@/router/helpers' import { firstVisiblePath } from '@/router/helpers'
@@ -41,10 +41,27 @@ const platformTab = usePlatformTabStore()
const menuEntries = computed(() => const menuEntries = computed(() =>
toSidebarEntries(filterMenuTreeByPlatform(session.menuTree, platformTab.active)), toSidebarEntries(filterMenuTreeByPlatform(session.menuTree, platformTab.active)),
) )
const visibleTabIds = computed(() => visiblePlatformsFor(session.menuTree)) // 平台锁定(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、亚马逊看不了」):
const visibleTabDefs = computed(() => PLATFORM_TABS.filter((tab) => visibleTabIds.value.includes(tab.id))) // tab 可见性 = 站点超管随菜单树分布;其余用户锁 users.platform 那一侧(后端下发树已按平台
const showPlatformTabs = computed(() => visibleTabIds.value.length > 1) // 裁剪,这里再把 tab 收敛到本人平台,单侧时 tab 条整个隐藏)。
const openedKeys = computed(() => groupKeysForActive(menuEntries.value, route.path)) const allowedTabIds = computed(() => allowedPlatformsForUser(session.menuTree, session.user))
const visibleTabDefs = computed(() => PLATFORM_TABS.filter((tab) => allowedTabIds.value.includes(tab.id)))
const showPlatformTabs = computed(() => allowedTabIds.value.length > 1)
// 父菜单默认全展开(2026-11-17 用户口径「父菜单不要默认折叠」)。el-menu 的 default-openeds
// 只在挂载时读一次,平台 tab 切换/菜单树刷新导致 entries 变化后新分组不会自动展开,
// 这里在 entries 变更渲染完成后按当下值命令式补开;用户手动收起的组在 entries 不变期间
// 保持收起(watch 不重触发)。读当下 computed 而非触发时快照:快速连切 tab 时不补开已
// 离开渲染树的旧分组(el-menu 的 open 对未注册 index 会抛)。
const menuRef = ref<{ open: (index: string) => void } | null>(null)
const openedKeys = computed(() => allGroupKeys(menuEntries.value))
watch(openedKeys, async () => {
await nextTick()
const menu = menuRef.value
if (!menu) return
for (const key of openedKeys.value) {
menu.open(key)
}
}, { immediate: true })
const emptyMenu = computed(() => shouldShowEmptyMenu(menuEntries.value.length > 0, session.loading, session.initialized)) const emptyMenu = computed(() => shouldShowEmptyMenu(menuEntries.value.length > 0, session.loading, session.initialized))
const pageTitle = computed(() => pageTitleOf(route.meta.title)) const pageTitle = computed(() => pageTitleOf(route.meta.title))
const userVm = computed(() => topbarUserOf(session.user)) const userVm = computed(() => topbarUserOf(session.user))
@@ -59,13 +76,14 @@ watch(
// 直达 URL/面包屑跳到另一平台的页面时,tab 指示自动跟过去(与侧边栏保持一致)。 // 直达 URL/面包屑跳到另一平台的页面时,tab 指示自动跟过去(与侧边栏保持一致)。
// 双侧清单里的页面(账号域三页)两个 tab 都算归属:当前 tab 已含它就不动。 // 双侧清单里的页面(账号域三页)两个 tab 都算归属:当前 tab 已含它就不动。
// 跟随目标只在允许集(allowedTabIds)里找:被平台锁定的侧不会成为落点。
watch( watch(
() => route.meta.menuKey as string | undefined, () => route.meta.menuKey as string | undefined,
(menuKey) => { (menuKey) => {
if (!menuKey) return if (!menuKey) return
const owners = platformsOfMenuKey(menuKey) const owners = platformsOfMenuKey(menuKey)
if (owners.includes(platformTab.active)) return if (owners.includes(platformTab.active)) return
const target = owners.find((platform) => visibleTabIds.value.includes(platform)) const target = owners.find((platform) => allowedTabIds.value.includes(platform))
if (target && target !== platformTab.active) { if (target && target !== platformTab.active) {
platformTab.setActive(target) platformTab.setActive(target)
} }
@@ -73,6 +91,23 @@ watch(
{ immediate: true }, { immediate: true },
) )
// 平台锁定的归位(2026-11-18):会话就位/菜单树刷新后允许集收敛时,把残留的另一侧 tab
// (超管在同一浏览器切过,localStorage 落的值)归位本人平台;当前页若在被禁侧一并跳回
// 该侧第一可见页。切 tab 的跳转复用下面 platformTab.active 的 watch(active 被 syncToAllowed
// 改写后同链路生效)。
watch(
allowedTabIds,
(allowed) => {
if (!session.user) return
platformTab.syncToAllowed(allowed)
const menuKey = route.meta.menuKey as string | undefined
if (!menuKey || platformsOfMenuKey(menuKey).includes(platformTab.active)) return
const first = firstVisiblePath(filterMenuTreeByPlatform(session.menuTree, platformTab.active))
if (first) void router.replace(first)
},
{ immediate: true },
)
// 切到另一侧 tab 时当前页多半不在那边:跳到该侧第一个可见页;该侧为空(tab 不可见)则不动。 // 切到另一侧 tab 时当前页多半不在那边:跳到该侧第一个可见页;该侧为空(tab 不可见)则不动。
// 双侧清单里的页面(账号域三页)切 tab 不跳转——页面自己按当前平台过滤数据。 // 双侧清单里的页面(账号域三页)切 tab 不跳转——页面自己按当前平台过滤数据。
watch( watch(
@@ -131,7 +166,7 @@ async function signOut() {
</nav> </nav>
<el-scrollbar class="admin-menu-scroll"> <el-scrollbar class="admin-menu-scroll">
<el-menu :default-active="activePath" :default-openeds="openedKeys" router class="admin-menu"> <el-menu ref="menuRef" :default-active="activePath" :default-openeds="openedKeys" router class="admin-menu">
<template v-for="entry in menuEntries" :key="entry.key"> <template v-for="entry in menuEntries" :key="entry.key">
<el-sub-menu v-if="entry.kind === 'group'" :index="entry.key"> <el-sub-menu v-if="entry.kind === 'group'" :index="entry.key">
<template #title> <template #title>
+16 -2
View File
@@ -7,17 +7,18 @@ import { useRoute } from 'vue-router'
import { COMPANY_STATUS_ACTIVE } from '@/api/companies-dto' import { COMPANY_STATUS_ACTIVE } from '@/api/companies-dto'
import { useCompanyTabStore } from '@/stores/company-tab' import { useCompanyTabStore } from '@/stores/company-tab'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { usePlatformTabStore } from '@/stores/platform-tab'
import { companyTabAppliesTo, companyTabInitFailureMessage } from '@/layout/company-tab-model' import { companyTabAppliesTo, companyTabInitFailureMessage } from '@/layout/company-tab-model'
import { showAdminFeedback } from '@/components/admin-feedback-ui' import { showAdminFeedback } from '@/components/admin-feedback-ui'
const route = useRoute() const route = useRoute()
const tab = useCompanyTabStore() const tab = useCompanyTabStore()
const session = useAdminSessionStore() const session = useAdminSessionStore()
const platformTab = usePlatformTabStore()
const tabs = computed(() => tab.companies.filter((c) => c.status === COMPANY_STATUS_ACTIVE)) const tabs = computed(() => tab.companies.filter((c) => c.status === COMPANY_STATUS_ACTIVE))
const show = computed(() => tab.visibleForOperator && companyTabAppliesTo(route.meta.menuKey)) const show = computed(() => tab.visibleForOperator && companyTabAppliesTo(route.meta.menuKey))
watch(() => session.isSuperAdmin, (v) => { function ensureLoaded() {
if (!v) return
// 2026-10-05 修复轮 1:改前这里是 `void tab.initialize()`,store 里也只有 try/finally ⇒ // 2026-10-05 修复轮 1:改前这里是 `void tab.initialize()`,store 里也只有 try/finally ⇒
// GET /companies 抛错时异常变成 unhandled rejection(全仓 src 无 errorHandler/unhandledrejection 兜底), // GET /companies 抛错时异常变成 unhandled rejection(全仓 src 无 errorHandler/unhandledrejection 兜底),
// 现场只剩"tab 条没画出来",Task 13 人工清单第一项无从判断是权限问题还是接口挂了。 // 现场只剩"tab 条没画出来",Task 13 人工清单第一项无从判断是权限问题还是接口挂了。
@@ -29,7 +30,20 @@ watch(() => session.isSuperAdmin, (v) => {
console.warn('[company-tab] 公司目录没取到,tab 条不渲染', error) console.warn('[company-tab] 公司目录没取到,tab 条不渲染', error)
showAdminFeedback(companyTabInitFailureMessage(error), 'warning') showAdminFeedback(companyTabInitFailureMessage(error), 'warning')
}) })
}
watch(() => session.isSuperAdmin, (v) => {
if (!v) return
ensureLoaded()
}, { immediate: true }) }, { immediate: true })
// 平台 tab 切换=公司目录换一份(V206 平台分侧;2026-11-17 用户口径「亚马逊侧别再挂京东-团队,
// 京东侧同理」):store 按 loadedPlatform 对撞早退,切了台必然重拉。非超管目录恒空不发请求,
// 这里同样按超管闸早退。
watch(() => platformTab.active, () => {
if (!session.isSuperAdmin) return
ensureLoaded()
})
</script> </script>
<template> <template>
+3 -3
View File
@@ -34,11 +34,11 @@ export function toSidebarEntries(nodes: AdminMenuNode[] | null | undefined): Sid
return entries return entries
} }
/** 计算需默认展开的分组 key:分组下含当前激活路由子项时返回该分组 key。 */ /** 计算需默认展开的分组 key:父菜单默认全展开(2026-11-17 用户口径「父菜单不要默认折叠」)。 */
export function groupKeysForActive(entries: SidebarEntry[], activeRoute: string): string[] { export function allGroupKeys(entries: SidebarEntry[]): string[] {
const keys: string[] = [] const keys: string[] = []
for (const entry of entries) { for (const entry of entries) {
if (entry.kind === 'group' && entry.children.some((child) => child.route === activeRoute)) { if (entry.kind === 'group') {
keys.push(entry.key) keys.push(entry.key)
} }
} }
@@ -122,12 +122,10 @@ export const OPERATION_GUIDES: Record<string, OperationGuideData> = {
steps: ['筛选记录', '核对结论明细', '到任务中心下载原表'], steps: ['筛选记录', '核对结论明细', '到任务中心下载原表'],
}, },
admin_jd_database: { admin_jd_database: {
text: '本页只读:客户端采集的京东店铺商品自动同步到这里(同店铺同商品只保留最新一次),按分公司隔离分页展示;点行查看全部属性与图片,可用自定义分组归档商品。', // 2026-11-17 分类管理子菜单并入本页(用户口径「京东分类管理并到京东数据库分类编辑里」,
steps: ['筛选商品记录', '查看属性与图片明细', '按分组归档管理'], // 原 admin_jd_category_manage 条目随之摘除):分类建/改名/删在工具栏「分类管理」。
}, text: '本页只读:客户端采集的京东店铺商品自动同步到这里(同店铺同商品只保留最新一次),按分公司隔离分页展示;点行查看全部属性与图片;分类的新建/改名/删除在工具栏「分类管理」,给商品归类先勾选再「批量编辑分类」。',
admin_jd_category_manage: { steps: ['筛选商品记录', '查看属性与图片明细', '用「分类管理」维护分类并批量归类'],
text: '本页维护京东自定义分类:分类按数据权限分组隔离,当前组只组长/超管可新建、改名、删除(删除不删商品,只解挂归属);给商品归类请到「京东数据库」页勾选后「批量编辑分类」。',
steps: ['切换分组', '新建或改名分类', '到京东数据库页归类商品'],
}, },
} }
@@ -1,5 +1,6 @@
import type { AdminMenuNode } from '../types/admin' import type { AdminMenuNode, AdminUser } from '../types/admin'
import { PLATFORM_TABS, platformsOfMenuKey } from '../config/platform-scope.ts' import { isSuperAdminRole } from '../types/admin.ts'
import { PLATFORM_TABS, filterMenuTreeNodesByPlatform } from '../config/platform-scope.ts'
import type { PlatformTabId } from '../config/platform-scope.ts' import type { PlatformTabId } from '../config/platform-scope.ts'
import { firstVisiblePath } from '../router/helpers.ts' import { firstVisiblePath } from '../router/helpers.ts'
@@ -7,27 +8,15 @@ import { firstVisiblePath } from '../router/helpers.ts'
* 按平台 tab 过滤后端菜单树(2026-11-16「亚马逊/京东不混」):**只做显示分组,不做鉴权**—— * 按平台 tab 过滤后端菜单树(2026-11-16「亚马逊/京东不混」):**只做显示分组,不做鉴权**——
* 准入仍由 session.menuTree(后端按权限裁剪)与路由守卫负责,这里只是把当前用户已被授权的 * 准入仍由 session.menuTree(后端按权限裁剪)与路由守卫负责,这里只是把当前用户已被授权的
* 菜单按平台分到两个 tab 下展示。 * 菜单按平台分到两个 tab 下展示。
* 规则:叶子按 platformsOfMenuKey(key) 是否包含当前平台留下(双侧清单里的账号域三页两个 * 规则与算法在 {@link filterMenuTreeNodesByPlatform}(2026-11-17 起唯一出口,账号弹窗授权树
* tab 都显示);分组节点(admin_group_*)自身的 key 不参与平台判定,按「留住的子项数 > 0」 * 同用一份);本壳只钉侧边栏专属的两条:节点的 key/name/route/children 形状原样透传(浅拷贝
* 决定去留——否则京东 tab 下「账号与权限」这类混合分组会被整组误剪。节点的 key/name/ * 不改写),toSidebarEntries、groupKeysForActive 与面包屑都不受影响。
* route/children 形状原样透传(浅拷贝不改写),toSidebarEntries、groupKeysForActive 与
* 面包屑都不受影响。
*/ */
export function filterMenuTreeByPlatform( export function filterMenuTreeByPlatform(
nodes: AdminMenuNode[] | null | undefined, nodes: AdminMenuNode[] | null | undefined,
platform: PlatformTabId, platform: PlatformTabId,
): AdminMenuNode[] { ): AdminMenuNode[] {
const filtered: AdminMenuNode[] = [] return filterMenuTreeNodesByPlatform(nodes, platform)
for (const node of nodes || []) {
const children = filterMenuTreeByPlatform(node.children, platform)
if (children.length > 0) {
filtered.push({ ...node, children })
continue
}
if ((node.children || []).length > 0) continue
if (platformsOfMenuKey(node.key || '').includes(platform)) filtered.push({ ...node })
}
return filtered
} }
/** 当前用户在哪些平台下至少有一个可点页面(tab 显示依据);顺序固定随 PLATFORM_TABS。 /** 当前用户在哪些平台下至少有一个可点页面(tab 显示依据);顺序固定随 PLATFORM_TABS。
@@ -37,3 +26,20 @@ export function visiblePlatformsFor(nodes: AdminMenuNode[] | null | undefined):
.filter((tab) => firstVisiblePath(filterMenuTreeByPlatform(nodes, tab.id)) !== '') .filter((tab) => firstVisiblePath(filterMenuTreeByPlatform(nodes, tab.id)) !== '')
.map((tab) => tab.id) .map((tab) => tab.id)
} }
/** 登录用户可用的平台 tab(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、
* 亚马逊看不了」):站点超管不限侧、沿用菜单树分布;其余用户锁 users.platform 那一侧
* (未知/缺省按亚马逊存量口径,与后端 AdminMenuPlatformScope.normalize 同形),与「菜单树
* 该侧有可点页面」求交——交集空则仍回落单侧(管理角色必有双侧账号域页,交集实际非空;
* 宁可锁死自己平台也不放开被禁侧)。会话未就位(user 为空)时按可见分布,锁定的收窄
* 由 AdminLayout 的 watch 在 user 就位后再做。 */
export function allowedPlatformsForUser(
nodes: AdminMenuNode[] | null | undefined,
user: Pick<AdminUser, 'role' | 'platform'> | null | undefined,
): PlatformTabId[] {
const visible = visiblePlatformsFor(nodes)
if (!user || isSuperAdminRole(user.role)) return visible
const own: PlatformTabId = user.platform === 'jd' ? 'jd' : 'amazon'
const allowed = visible.filter((id) => id === own)
return allowed.length > 0 ? allowed : [own]
}
@@ -8,6 +8,7 @@ import { formatDateTime } from '@/utils/datetime'
import { fetchCompanies } from '@/api/companies' import { fetchCompanies } from '@/api/companies'
import { COMPANY_STATUS_ACTIVE, type CompanyItem } from '@/api/companies-dto' import { COMPANY_STATUS_ACTIVE, type CompanyItem } from '@/api/companies-dto'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { refreshCompanyDirectory } from '@/stores/company-tab'
import { usePlatformTabStore } from '@/stores/platform-tab' import { usePlatformTabStore } from '@/stores/platform-tab'
import OldPagination from '@/components/OldPagination.vue' import OldPagination from '@/components/OldPagination.vue'
import CompanyEditorDialog from './CompanyEditorDialog.vue' import CompanyEditorDialog from './CompanyEditorDialog.vue'
@@ -60,6 +61,18 @@ function openEdit(company: CompanyItem) {
editorVisible.value = true editorVisible.value = true
} }
// 保存成功后:本页列表照常重拉,共享公司目录(tab 条)强制重拉一份。
// 本页不参与公司隔离(控制方 2026-10-06「公司管理不要有 tab」)⇒ 走 store 的具名出口
// refreshCompanyDirectory,而不是自己持一份 company-tab store(后者形状与「给这页上了 tab」
// 分不开,company-config-entry-super-only 的 pageFiles 分母会当场红)。
// 重拉失败不弹新提示(§12 第 5 条未批的界面暴露):tab 条保留旧名单,下一次切平台 tab / 重进页面会再试。
async function onCompaniesSaved() {
await loadCompanies()
refreshCompanyDirectory().catch((error: unknown) => {
console.warn('[company-tab] 公司保存后目录重拉失败', error)
})
}
// 切平台 tab(V206)= 重新取数:公司归属按平台分列,两 tab 各看各的公司。 // 切平台 tab(V206)= 重新取数:公司归属按平台分列,两 tab 各看各的公司。
watch(() => platformTab.active, () => { watch(() => platformTab.active, () => {
page.value = 1 page.value = 1
@@ -136,7 +149,7 @@ onMounted(loadCompanies)
/> />
</section> </section>
<CompanyEditorDialog v-model="editorVisible" :company="editingCompany" :platform="platformTab.active" @saved="loadCompanies" /> <CompanyEditorDialog v-model="editorVisible" :company="editingCompany" :platform="platformTab.active" @saved="onCompaniesSaved" />
</div> </div>
</template> </template>
@@ -13,7 +13,9 @@ import {
import { showAdminFeedback } from '@/components/admin-feedback-ui' import { showAdminFeedback } from '@/components/admin-feedback-ui'
import { actionableErrorText } from '@/components/admin-feedback' import { actionableErrorText } from '@/components/admin-feedback'
/** 新建/编辑公司(改名 + 启停 + 备注 + 所属平台 V206);写操作仅超管可用,权限由后端把关。 */ /** 新建/编辑公司(改名 + 启停 + 备注);写操作仅超管可用,权限由后端把关。
* 所属平台不设手选(2026-11-17 用户口径「有京东就不需要亚马逊了,亚马逊那边也是」):
* 平台跟随当前平台 tab——新建取当前 tab(props.platform),编辑保持行值原样下发。 */
const props = defineProps<{ modelValue: boolean; company: CompanyItem | null; platform?: PlatformTabId }>() const props = defineProps<{ modelValue: boolean; company: CompanyItem | null; platform?: PlatformTabId }>()
const emit = defineEmits<{ (e: 'update:modelValue', v: boolean): void; (e: 'saved'): void }>() const emit = defineEmits<{ (e: 'update:modelValue', v: boolean): void; (e: 'saved'): void }>()
@@ -77,12 +79,6 @@ async function save() {
placeholder="请输入公司名称(全平台唯一)" placeholder="请输入公司名称(全平台唯一)"
/> />
</el-form-item> </el-form-item>
<el-form-item label="所属平台">
<el-radio-group v-model="form.platform">
<el-radio-button value="amazon">亚马逊</el-radio-button>
<el-radio-button value="jd">京东</el-radio-button>
</el-radio-group>
</el-form-item>
<el-form-item label="状态"> <el-form-item label="状态">
<el-select v-model="form.status" style="width: 100%"> <el-select v-model="form.status" style="width: 100%">
<el-option :value="COMPANY_STATUS_ACTIVE" label="启用" /> <el-option :value="COMPANY_STATUS_ACTIVE" label="启用" />
@@ -29,7 +29,7 @@ const props = defineProps<{
operatorCompanyId?: number | null operatorCompanyId?: number | null
/** 当前公司 tab:这次建号落在哪家,就决定能建哪些角色。 */ /** 当前公司 tab:这次建号落在哪家,就决定能建哪些角色。 */
activeCompanyId?: number | null activeCompanyId?: number | null
/** 当前平台 tab(V206):新号默认落当前平台,单选可改。 */ /** 当前平台 tab(V206):新号落当前平台(跟随所在 tab,弹窗不再手选——2026-11-17 用户口径)。 */
platform?: PlatformTabId platform?: PlatformTabId
}>() }>()
const emit = defineEmits<{ (e: 'update:modelValue', v: boolean): void; (e: 'created'): void }>() const emit = defineEmits<{ (e: 'update:modelValue', v: boolean): void; (e: 'created'): void }>()
@@ -136,12 +136,6 @@ async function create(): Promise<void> {
<el-option v-for="opt in roleChoices" :key="opt.value" :label="opt.label" :value="opt.value" /> <el-option v-for="opt in roleChoices" :key="opt.value" :label="opt.label" :value="opt.value" />
</el-select> </el-select>
</el-form-item> </el-form-item>
<el-form-item label="所属平台">
<el-radio-group v-model="form.platform">
<el-radio-button value="amazon">亚马逊</el-radio-button>
<el-radio-button value="jd">京东</el-radio-button>
</el-radio-group>
</el-form-item>
<el-form-item <el-form-item
v-if="operatorSuper && form.role === 'company_super_admin'" v-if="operatorSuper && form.role === 'company_super_admin'"
label="所属公司" label="所属公司"
@@ -184,7 +178,9 @@ async function create(): Promise<void> {
</el-form-item> </el-form-item>
<el-form-item label="菜单权限(勾选上级菜单会继承全部子菜单)"> <el-form-item label="菜单权限(勾选上级菜单会继承全部子菜单)">
<div class="auth-tree-box"> <div class="auth-tree-box">
<UserMenuAuthTree v-model:checked="form.columnIds" :company-id="form.companyId" /> <!-- 授权树按账号平台收(2026-11-17 用户口径):京东 tab 只给京东侧菜单。
平台不再手选(跟随当前 tab),树收窄的判定出口不变。 -->
<UserMenuAuthTree v-model:checked="form.columnIds" :company-id="form.companyId" :platform="form.platform" />
</div> </div>
</el-form-item> </el-form-item>
</el-form> </el-form>
@@ -128,12 +128,6 @@ async function save(): Promise<void> {
<el-form-item v-if="targetIsCompanySuperAdmin" label="角色"> <el-form-item v-if="targetIsCompanySuperAdmin" label="角色">
<el-input model-value="公司超级管理员" readonly /> <el-input model-value="公司超级管理员" readonly />
</el-form-item> </el-form-item>
<el-form-item label="所属平台">
<el-radio-group v-model="form.platform">
<el-radio-button value="amazon">亚马逊</el-radio-button>
<el-radio-button value="jd">京东</el-radio-button>
</el-radio-group>
</el-form-item>
<el-form-item v-if="expiryEditable" label="到期时间(清空 = 永不过期;到期后该账号及其名下账号将停用)"> <el-form-item v-if="expiryEditable" label="到期时间(清空 = 永不过期;到期后该账号及其名下账号将停用)">
<el-date-picker <el-date-picker
v-model="form.expiresAt" v-model="form.expiresAt"
@@ -152,7 +146,9 @@ async function save(): Promise<void> {
</el-form-item> </el-form-item>
<el-form-item label="菜单权限(勾选上级菜单会继承全部子菜单)"> <el-form-item label="菜单权限(勾选上级菜单会继承全部子菜单)">
<div class="auth-tree-box"> <div class="auth-tree-box">
<UserMenuAuthTree v-model:checked="form.columnIds" :company-id="props.companyId" /> <!-- 授权树按账号平台收(2026-11-17 用户口径):京东档账号不再整树混发亚马逊菜单。
平台不再手选(跟随当前平台 tab,编辑取行值),树收窄的判定出口不变。 -->
<UserMenuAuthTree v-model:checked="form.columnIds" :company-id="props.companyId" :platform="form.platform" />
<div v-if="loadingAuth" class="auth-loading">菜单权限加载中…</div> <div v-if="loadingAuth" class="auth-loading">菜单权限加载中…</div>
<div v-else-if="!authReady" class="auth-loading auth-loading-error"> <div v-else-if="!authReady" class="auth-loading auth-loading-error">
菜单权限加载失败,保存已禁用;请关闭后重试 菜单权限加载失败,保存已禁用;请关闭后重试
@@ -3,6 +3,7 @@ import { computed, onMounted, ref, watch } from 'vue'
import type { AdminUser } from '@/types/admin' import type { AdminUser } from '@/types/admin'
import type { PlatformTabId } from '@/config/platform-scope' import type { PlatformTabId } from '@/config/platform-scope'
import { import {
eligibleGroupLeaders,
eligibleGroupMembers, eligibleGroupMembers,
groupMemberCandidateHint, groupMemberCandidateHint,
validateShopGroupForm, validateShopGroupForm,
@@ -19,22 +20,38 @@ const emit = defineEmits<{ (e: 'update:modelValue', v: boolean): void; (e: 'save
const session = useAdminSessionStore() const session = useAdminSessionStore()
const groupName = ref('') const groupName = ref('')
/** 所属平台(V206):新建默认当前平台 tab,编辑回填分组原值,单选可翻档。 */ /** 所属平台(V206):不设手选(2026-11-17 用户口径「有京东就不需要亚马逊了,亚马逊那边也是」)——
* 新建取当前平台 tab(props.platform),编辑保持分组原值,值仍随保存下发。 */
const groupPlatform = ref<PlatformTabId>('amazon') const groupPlatform = ref<PlatformTabId>('amazon')
const memberIds = ref<number[]>([]) const memberIds = ref<number[]>([])
const errorText = ref('') const errorText = ref('')
const busy = ref(false) const busy = ref(false)
const users = ref<AdminUser[]>([]) const users = ref<AdminUser[]>([])
/** 组长:新建=当前登录用户;编辑=分组原组长(不可改,只读展示)。 */ /**
const leaderUserId = computed<number | null>(() => * 组长:新建默认当前登录用户,站点超管可下拉改选(2026-11-18 用户口径,后端 validateLeaderOperator
props.group ? (props.group.leaderUserId ?? null) : (session.user?.id ?? null), * 对站点超管放行任意 createdById、只要求组长与操作者同公司);编辑=分组原组长(后端更新载荷不收
) * 组长,不可改);非站点超管新建时后端强制组长=操作者本人,同样只读展示。
const leaderUsername = computed<string>(() => */
props.group ? (props.group.leaderUsername || '') : (session.user?.username || '当前登录用户'), const leaderUserId = ref<number | null>(null)
) /** 只有「新建 + 站点超管」出组长下拉;其余场景只读回显。 */
const canPickLeader = computed(() => !props.group && !!props.operatorSuper)
const operatorRole = computed<string>(() => session.user?.role || '') const operatorRole = computed<string>(() => session.user?.role || '')
const leaderUsername = computed<string>(() => {
const picked = leaderUserId.value != null
? users.value.find((u) => u.id === leaderUserId.value)
: null
if (picked) return picked.username
if (props.group) return props.group.leaderUsername || ''
return session.user?.username || '当前登录用户'
})
/** 组长候选:与组员同池(本公司账号),排除公司超管;站点超管仅保留操作者本人。 */
const leaderCandidates = computed(() =>
eligibleGroupLeaders(users.value, operatorRole.value, session.user?.id ?? null),
)
/** 组员候选:按组长归属过滤(超管全量、非超管仅本组长创建的普通账号)。 */ /** 组员候选:按组长归属过滤(超管全量、非超管仅本组长创建的普通账号)。 */
const memberCandidates = computed(() => const memberCandidates = computed(() =>
eligibleGroupMembers(users.value, leaderUserId.value, operatorRole.value), eligibleGroupMembers(users.value, leaderUserId.value, operatorRole.value),
@@ -52,18 +69,29 @@ watch(
groupName.value = props.group.name groupName.value = props.group.name
memberIds.value = props.group.memberUserIds ?? [] memberIds.value = props.group.memberUserIds ?? []
groupPlatform.value = props.group.platform === 'jd' ? 'jd' : 'amazon' groupPlatform.value = props.group.platform === 'jd' ? 'jd' : 'amazon'
// 编辑保持原值口径:历史行可能没有 leaderUserId(旧负载),回落 null 而不是当前登录人,
// 否则组员候选过滤会跟着悄悄变。
leaderUserId.value = props.group.leaderUserId ?? null
} else { } else {
groupPlatform.value = props.platform ?? 'amazon' groupPlatform.value = props.platform ?? 'amazon'
leaderUserId.value = session.user?.id ?? null
} }
}, },
) )
// 组长改选后,若该人已被选为组员要立刻摘掉——后端「组长不能作为组员重复加入分组」会打回。
watch(leaderUserId, (id) => {
if (id == null) return
memberIds.value = memberIds.value.filter((v) => v !== id)
})
async function loadCandidates(): Promise<void> { async function loadCandidates(): Promise<void> {
try { try {
// 对齐 admin.js loadUserOptions:page=1&page_size=999 全量拉取,避免归属过滤漏人。 // 对齐 admin.js loadUserOptions:page=1&page_size=999 全量拉取,避免归属过滤漏人。
// company_id 必带:不带时后端对站点超管返回全平台账号,别家公司的人就会出现在本公司分组的候选里。 // company_id 必带:不带时后端对站点超管返回全平台账号,别家公司的人就会出现在本公司分组的候选里。
// 取的是**组长自己那家**(当前登录用户),不是公司 tab——新建时组长就是操作者本人, // 取操作者自己那家,不是公司 tab——组长候选与组员候选同池,后端要求组长与操作者同公司
// 按 tab 取人会在超管停在别家 tab 时列出那家的人,保存时被后端"只能添加组长本公司的账号"打回。 // (ensureLeaderSharesOperatorCompany),按 tab 取人会在超管停在别家 tab 时列出保存必被
// 打回的人("只能添加组长本公司的账号")。
const page = await fetchUserList({ page: 1, pageSize: 999, companyId: session.user?.companyId ?? null }) const page = await fetchUserList({ page: 1, pageSize: 999, companyId: session.user?.companyId ?? null })
users.value = page.items users.value = page.items
} catch (error) { } catch (error) {
@@ -85,13 +113,13 @@ async function save(): Promise<void> {
await updateShopGroup(props.group.id, groupName.value, memberIds.value, groupPlatform.value) await updateShopGroup(props.group.id, groupName.value, memberIds.value, groupPlatform.value)
showAdminFeedback('更新成功', 'success') showAdminFeedback('更新成功', 'success')
} else { } else {
// 对齐 admin:组长恒为当前登录用户,提交 createdBy=当前用户 id。 // 组长默认当前登录用户;站点超管可改选本公司其他账号(createdById=所选组长)。
const operatorId = session.user?.id ?? 0 const leaderId = leaderUserId.value ?? 0
if (!operatorId) { if (!leaderId) {
showAdminFeedback('无法获取当前登录用户,请重新登录', 'error') showAdminFeedback('无法获取组长账号,请重新登录', 'error')
return return
} }
await createShopGroup(groupName.value, memberIds.value, operatorId, groupPlatform.value) await createShopGroup(groupName.value, memberIds.value, leaderId, groupPlatform.value)
showAdminFeedback('创建成功', 'success') showAdminFeedback('创建成功', 'success')
} }
emit('saved') emit('saved')
@@ -119,14 +147,17 @@ onMounted(loadCandidates)
<el-form-item label="分组名称" :error="errorText || undefined"> <el-form-item label="分组名称" :error="errorText || undefined">
<el-input v-model="groupName" placeholder="请输入分组名称" /> <el-input v-model="groupName" placeholder="请输入分组名称" />
</el-form-item> </el-form-item>
<el-form-item label="所属平台">
<el-radio-group v-model="groupPlatform">
<el-radio-button value="amazon">亚马逊</el-radio-button>
<el-radio-button value="jd">京东</el-radio-button>
</el-radio-group>
</el-form-item>
<el-form-item label="组长"> <el-form-item label="组长">
<el-input :model-value="leaderUsername" readonly placeholder="当前登录用户" /> <el-select
v-if="canPickLeader"
v-model="leaderUserId"
filterable
placeholder="选择组长(默认当前登录用户)"
style="width: 100%"
>
<el-option v-for="u in leaderCandidates" :key="u.id" :label="u.username" :value="u.id" />
</el-select>
<el-input v-else :model-value="leaderUsername" readonly placeholder="当前登录用户" />
</el-form-item> </el-form-item>
<el-form-item label="组员"> <el-form-item label="组员">
<el-select <el-select
@@ -228,8 +228,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -243,12 +242,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -236,11 +236,15 @@ onMounted(loadMenus)
</div> </div>
<div class="form-group" style="min-width: 160px"> <div class="form-group" style="min-width: 160px">
<label>菜单类型</label> <label>菜单类型</label>
<select v-model="filterType"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option value="">全部</option> ⇒ 换 el-select(admin-filter 同壳 42px/9px 圆角,弹层是 EP 圆角面板)。
<option value="admin">后台</option> 「全部」保留为空值首行=空串不按类型筛(与旧原生下拉同语义);model 是空串时
<option value="app">软件</option> EP 不显示 label 而走 placeholder,所以 placeholder 同文案,观感与改前一致。 -->
</select> <el-select v-model="filterType" class="admin-filter" placeholder="全部" aria-label="筛选菜单类型">
<el-option label="全部" value="" />
<el-option label="后台" value="admin" />
<el-option label="软件" value="app" />
</el-select>
</div> </div>
</div> </div>
@@ -398,8 +402,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -413,12 +416,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -1,10 +1,12 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, nextTick, onMounted, ref, watch } from 'vue' import { computed, nextTick, onMounted, ref, watch } from 'vue'
import { filterMenuTreeNodesByPlatform } from '../../config/platform-scope.ts'
import type { PlatformTabId } from '../../config/platform-scope.ts'
import type { MenuOptionNode } from './user-menu-auth' import type { MenuOptionNode } from './user-menu-auth'
import { compactDirectGrantIds } from './user-menu-auth' import { compactDirectGrantIds, pruneCheckedIdsToTree } from './user-menu-auth'
import { fetchGrantableMenus } from './user-menu-auth-api' import { fetchGrantableMenus } from './user-menu-auth-api'
const props = defineProps<{ checked?: number[]; companyId?: number | null }>() const props = defineProps<{ checked?: number[]; companyId?: number | null; platform?: PlatformTabId }>()
const emit = defineEmits<{ const emit = defineEmits<{
(e: 'update:checked', ids: number[]): void (e: 'update:checked', ids: number[]): void
(e: 'load', ok: boolean): void (e: 'load', ok: boolean): void
@@ -17,9 +19,16 @@ const appTree = ref<{ setCheckedKeys(keys: unknown[]): void; getCheckedKeys(): u
const data = ref<MenuOptionNode[]>([]) const data = ref<MenuOptionNode[]>([])
const loaded = ref(false) const loaded = ref(false)
/**
* 按平台过滤后的可见树(2026-11-17 用户口径「授权树也按平台收,选京东就去掉亚马逊的」):
* 平台缺省按亚马逊(历史调用形状)。过滤算法与侧边栏同源(platform-scope 唯一出口),
* 叶子按 menuKey 判定——京东侧=「京东数据库+双侧账号域三件+桌面端京东工具台三件」。
*/
const visibleData = computed(() => filterMenuTreeNodesByPlatform(data.value, props.platform ?? 'amazon'))
/** 两种一级分类…(与 API menuType 分区一致):后台(admin) / 桌面端(app)。 */ /** 两种一级分类…(与 API menuType 分区一致):后台(admin) / 桌面端(app)。 */
const adminNodes = computed(() => data.value.filter((node) => node.type === 'admin')) const adminNodes = computed(() => visibleData.value.filter((node) => node.type === 'admin'))
const appNodes = computed(() => data.value.filter((node) => node.type === 'app')) const appNodes = computed(() => visibleData.value.filter((node) => node.type === 'app'))
function applyChecked(): void { function applyChecked(): void {
const ids = Array.isArray(props.checked) ? props.checked.filter((id) => typeof id === 'number' && id > 0) : [] const ids = Array.isArray(props.checked) ? props.checked.filter((id) => typeof id === 'number' && id > 0) : []
@@ -37,7 +46,8 @@ function onCheck(): void {
// 提交前压缩为最小直接授权集:父级已勾选时后代不再重复提交(后端按“父级授权 // 提交前压缩为最小直接授权集:父级已勾选时后代不再重复提交(后端按“父级授权
// 展开全部后代”判断权限,与旧 admin.html 勾父清后代语义一致), // 展开全部后代”判断权限,与旧 admin.html 勾父清后代语义一致),
// 并剔除置灰的祖先分组(派生勾选,操作者无权授予)。 // 并剔除置灰的祖先分组(派生勾选,操作者无权授予)。
emit('update:checked', compactDirectGrantIds(ids, data.value)) // 压缩按「可见树」算:另一侧菜单不在树上,其历史勾选天然进不来。
emit('update:checked', compactDirectGrantIds(ids, visibleData.value))
} }
async function load(): Promise<void> { async function load(): Promise<void> {
@@ -49,12 +59,26 @@ async function load(): Promise<void> {
// 渲染完成后再应用已勾选 id,否则作用在空 store 上导致已授权不回显。 // 渲染完成后再应用已勾选 id,否则作用在空 store 上导致已授权不回显。
await nextTick() await nextTick()
applyChecked() applyChecked()
// 首屏就把勾选集收敛进可见树:编辑一个混档账号(既有亚马逊又有京东授权)时,
// 打开弹窗那一刻就该按当前平台剪掉另一侧,而不是等用户点一下树才剪。
pruneChecked()
} catch { } catch {
loaded.value = false loaded.value = false
emit('load', false) emit('load', false)
} }
} }
/** 平台切换/首屏后把勾选集收敛进可见树:被过滤掉的另一侧勾选不再随表单提交,
* 否则「京东档账号保存后仍带亚马逊授权」会把平台分侧静默架空。集合没变就不发
* update 事件(避免与父级 v-model 循环互刷)。 */
function pruneChecked(): void {
const pruned = pruneCheckedIdsToTree(props.checked, visibleData.value)
const current = Array.isArray(props.checked) ? props.checked : []
if (pruned.length !== current.length || pruned.some((id, index) => id !== current[index])) {
emit('update:checked', pruned)
}
}
onMounted(load) onMounted(load)
watch( watch(
() => props.checked, () => props.checked,
@@ -62,6 +86,16 @@ watch(
if (loaded.value) applyChecked() if (loaded.value) applyChecked()
}, },
) )
/** 平台翻档:可见树整棵换,勾选集同步收敛到新树并回显(被剪掉的勾选以 emit 形式
* 落回表单,父级拿到的是纯当前平台的授权集)。 */
watch(
() => props.platform,
() => {
if (!loaded.value) return
pruneChecked()
void nextTick().then(applyChecked)
},
)
/** 公司换了要整棵重取:勾选集里存的是 column id,别家同名菜单是另一份 id(V149 每公司一套树), /** 公司换了要整棵重取:勾选集里存的是 column id,别家同名菜单是另一份 id(V149 每公司一套树),
* 拿别家的树勾出来的 id 提交会被后端判「无效的菜单权限项」,而已授权项也因为 id 不在这棵树上勾不上。 */ * 拿别家的树勾出来的 id 提交会被后端判「无效的菜单权限项」,而已授权项也因为 id 不在这棵树上勾不上。 */
watch( watch(
@@ -151,10 +151,14 @@ onMounted(load)
</div> </div>
<div class="form-group" v-if="isSuperAdmin && groupOptions.length" style="min-width: 170px"> <div class="form-group" v-if="isSuperAdmin && groupOptions.length" style="min-width: 170px">
<label>分组</label> <label>分组</label>
<select v-model="groupFilter"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option :value="null">全部分组</option> ⇒ 换 el-select(admin-filter 同壳 42px/9px 圆角,弹层是 EP 圆角面板),组多时可搜。
<option v-for="group in groupOptions" :key="group.id" :value="group.id">{{ group.groupName }}</option> 「全部分组」的值仍是 null(下游 groupId 照旧 `|| undefined`),空档时由
</select> placeholder 显示同一句文案。 -->
<el-select v-model="groupFilter" class="admin-filter" filterable placeholder="全部分组" aria-label="筛选分组">
<el-option label="全部分组" :value="null" />
<el-option v-for="group in groupOptions" :key="group.id" :label="group.groupName" :value="group.id" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>&nbsp;</label> <label>&nbsp;</label>
@@ -290,8 +294,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -305,12 +308,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -324,16 +324,23 @@ onMounted(load)
</div> </div>
<div class="form-group" style="min-width: 170px"> <div class="form-group" style="min-width: 170px">
<label>状态(三项都通过才算通过)</label> <label>状态(三项都通过才算通过)</label>
<select v-model="statusFilter"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option v-for="option in STATUS_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> ⇒ 换 el-select(admin-filter 同壳 42px/9px 圆角,弹层是 EP 圆角面板)。
</select> 「全部状态」仍是 STATUS_OPTIONS 里的空串档(下游 checkStatus 照旧传 ''→undefined);
model 为空串时 EP 走 placeholder 显示,故 placeholder 与首档同文案。 -->
<el-select v-model="statusFilter" class="admin-filter" placeholder="全部状态" aria-label="筛选密钥状态">
<el-option v-for="option in STATUS_OPTIONS" :key="option.value" :label="option.label" :value="option.value" />
</el-select>
</div> </div>
<div class="form-group" v-if="isSuperAdmin && groupOptions.length" style="min-width: 170px"> <div class="form-group" v-if="isSuperAdmin && groupOptions.length" style="min-width: 170px">
<label>分组</label> <label>分组</label>
<select v-model="groupFilter"> <!-- 同上(2026-11-17 换 el-select):分组可能很多 ⇒ 保留 filterable 可搜。
<option :value="null">全部分组</option> 「全部分组」的值仍是 null(下游 groupId 照旧 `|| undefined`),空档时由
<option v-for="group in groupOptions" :key="group.id" :value="group.id">{{ group.groupName }}</option> placeholder 显示同一句文案。 -->
</select> <el-select v-model="groupFilter" class="admin-filter" filterable placeholder="全部分组" aria-label="筛选分组">
<el-option label="全部分组" :value="null" />
<el-option v-for="group in groupOptions" :key="group.id" :label="group.groupName" :value="group.id" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>&nbsp;</label> <label>&nbsp;</label>
@@ -553,8 +560,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -568,12 +574,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -182,26 +182,32 @@ function goJump() {
// ② 用户名全平台唯一(V143 的唯一索引),留着上一家填的关键字去筛新一家 ⇒ 必然空页,而输入框还显示着那个值。 // ② 用户名全平台唯一(V143 的唯一索引),留着上一家填的关键字去筛新一家 ⇒ 必然空页,而输入框还显示着那个值。
watch(() => companyTab.activeId, () => { filters.createdByAdminId = null; filters.keyword = ''; filters.page = 1; void loadUsers() }) watch(() => companyTab.activeId, () => { filters.createdByAdminId = null; filters.keyword = ''; filters.page = 1; void loadUsers() })
// 切平台 tab(V206)= 同样的重取数:列表按平台过滤,候选/关键字跨平台无意义,一并清掉。 // 切平台 tab(V206)= 同样的重取数:列表按平台过滤,候选/关键字跨平台无意义,一并清掉;
// 建「公司超级管理员」的公司候选也按平台换一份(2026-11-17:京东 tab 下不能还选到亚马逊公司)。
watch(() => platformTab.active, () => { watch(() => platformTab.active, () => {
filters.createdByAdminId = null filters.createdByAdminId = null
filters.keyword = '' filters.keyword = ''
filters.page = 1 filters.page = 1
void loadUsers() void loadUsers()
loadCompanyOptions()
}) })
// 公司目录仅站点超管拉取(建「公司超级管理员」时选公司用);非超管不发这个请求,后端 403 兜底。
// 按当前平台 tab 过滤(V206)——公司本身已按平台分侧,候选下拉跟着 tab 走。
function loadCompanyOptions() {
if (!isSuperAdmin.value) return
void fetchCompanies(platformTab.active)
.then((items) => {
companyOptions.value = items.map((c) => ({ id: c.id, companyName: c.companyName }))
})
.catch(() => {
companyOptions.value = []
})
}
onMounted(() => { onMounted(() => {
void loadUsers() void loadUsers()
// 公司目录仅站点超管拉取(建「公司超级管理员」时选公司用);非超管不发这个请求,后端 403 兜底 loadCompanyOptions()
if (isSuperAdmin.value) {
void fetchCompanies()
.then((items) => {
companyOptions.value = items.map((c) => ({ id: c.id, companyName: c.companyName }))
})
.catch(() => {
companyOptions.value = []
})
}
}) })
</script> </script>
@@ -384,8 +390,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -399,12 +404,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -155,6 +155,30 @@ export function eligibleGroupMembers(
}) })
} }
/**
* 组长候选(2026-11-18 用户口径「新建分组组长要能下拉选」):
* - 公司超管永不领衔——与组员「超级管理员不属于任何分组」同源,它是本公司最高账号;
* - 站点超管只保留操作者本人(admin 保持「自己领衔建组」的既有能力,其余站点超管不进候选);
* - 管理员与普通账号均可领衔(普通账号当组长有既有文案背书:「当前账号只能作为组长使用」)。
*
* 后端契约:站点超管走 `validateLeaderOperator` 放行通道,可给任意 `createdById` 建组,
* 但组长必须与操作者同公司(`ensureLeaderSharesOperatorCompany`)——候选池天然同公司(按操作者
* companyId 拉取),不会列出后端要打回的人。非超管操作者不出下拉(后端强制组长=操作者本人)。
*/
export function eligibleGroupLeaders(
users: GroupMemberCandidateUser[],
operatorRole: string,
operatorId: number | null,
): GroupMemberCandidateUser[] {
const operatorKey = operatorId != null && operatorId > 0 ? String(operatorId) : ''
const operatorIsSiteSuper = isSuperAdminRole(operatorRole)
return users.filter((u) => {
if (!isGroupIneligibleRole(u.role)) return true
// 两档超管默认不领衔;站点超管只保留操作者本人这一个例外。
return operatorIsSiteSuper && String(u.id) === operatorKey
})
}
/** 组员候选帮助文案(对齐 admin.js:3179-3182)。 */ /** 组员候选帮助文案(对齐 admin.js:3179-3182)。 */
export function groupMemberCandidateHint(candidateCount: number, operatorRole: string): string { export function groupMemberCandidateHint(candidateCount: number, operatorRole: string): string {
if (candidateCount > 0) return '可添加当前组长创建的普通员工账号' if (candidateCount > 0) return '可添加当前组长创建的普通员工账号'
@@ -22,7 +22,7 @@ export interface CreateUserForm {
expiresAt: string expiresAt: string
/** 所属公司 id:仅 role=company_super_admin 时由站点超管必选(2026-10-05 需求)。 */ /** 所属公司 id:仅 role=company_super_admin 时由站点超管必选(2026-10-05 需求)。 */
companyId?: number | null companyId?: number | null
/** 所属平台(V206):弹窗打开时预填当前平台 tab,单选可改。 */ /** 所属平台(V206):弹窗打开时预填当前平台 tab(不设手选——2026-11-17 用户口径)。 */
platform: PlatformTabId platform: PlatformTabId
} }
@@ -46,7 +46,7 @@ export interface CreateUserPayload {
* 反向钉(company-user-create.test.ts)唯一豁免的例外:公司超管必须落指定公司, * 反向钉(company-user-create.test.ts)唯一豁免的例外:公司超管必须落指定公司,
* 否则会静默落操作者自己的公司(公司 1),用户需求就是给别家公司开超管。 */ * 否则会静默落操作者自己的公司(公司 1),用户需求就是给别家公司开超管。 */
companyId?: number companyId?: number
/** 所属平台(V206):恒下发(弹窗单选默认当前平台 tab),缺省后端落 amazon。 */ /** 所属平台(V206):恒下发(预填当前平台 tab),缺省后端落 amazon。 */
platform: PlatformTabId platform: PlatformTabId
} }
@@ -20,7 +20,7 @@ export interface EditUserForm {
originalRole: string originalRole: string
/** 到期时间(yyyy-MM-dd HH:mm:ss);空串 = 永不过期。null = 后端本来就无到期。 */ /** 到期时间(yyyy-MM-dd HH:mm:ss);空串 = 永不过期。null = 后端本来就无到期。 */
expiresAt: string expiresAt: string
/** 所属平台(V206):单选可翻档,未知/缺省归亚马逊(存量默认)。 */ /** 所属平台(V206):编辑回填行值(不设手选——2026-11-17 用户口径),未知/缺省归亚马逊(存量默认)。 */
platform: PlatformTabId platform: PlatformTabId
} }
@@ -38,7 +38,7 @@ export interface EditUserUpdateRequest {
password?: string password?: string
/** 到期时间:空串=清除(恢复永不过期),有值=改期;总是下发(与后端"传了就更新"对齐)。 */ /** 到期时间:空串=清除(恢复永不过期),有值=改期;总是下发(与后端"传了就更新"对齐)。 */
expiresAt: string expiresAt: string
/** 所属平台(V206):总是下发(弹窗单选恒渲染),翻档即把记录挪到另一平台的列表。 */ /** 所属平台(V206):总是下发(编辑保持行值原样,后端显式才落)。 */
platform: PlatformTabId platform: PlatformTabId
} }
@@ -146,3 +146,24 @@ export function compactDirectGrantIds(checkedIds: unknown, tree: MenuOptionNode[
walk(tree, false) walk(tree, false)
return ids.filter((id) => !ungrantable.has(id) && !coveredByAncestor.has(id)) return ids.filter((id) => !ungrantable.has(id) && !coveredByAncestor.has(id))
} }
/**
* 把勾选集收敛到「可见树」内(2026-11-17 用户口径「授权树按平台收」的另一半):
* 授权树按平台过滤后,另一侧的已勾 id 在树上不可见、也不再属于这棵树——它们必须
* 从表单勾选集里剔除,否则「京东档账号」保存后仍携带整批亚马逊菜单授权(侧边栏
* 亚马逊 tab 照样全亮,平台分侧被静默架空)。纯函数:入参不动,返回去重升序交集。
*/
export function pruneCheckedIdsToTree(checkedIds: unknown, visibleTree: MenuOptionNode[]): number[] {
const ids = normalizeMenuIds(checkedIds)
if (ids.length === 0) return []
if (visibleTree.length === 0) return []
const visible = new Set<number>()
const walk = (nodes: MenuOptionNode[]): void => {
for (const node of nodes) {
visible.add(node.id)
if (node.children?.length) walk(node.children)
}
}
walk(visibleTree)
return ids.filter((id) => visible.has(id))
}
@@ -290,8 +290,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -305,12 +304,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -70,6 +70,10 @@ const editSaving = ref(false)
const editTarget = ref<DedupeTotalItem | null>(null) const editTarget = ref<DedupeTotalItem | null>(null)
const editValue = ref('') const editValue = ref('')
const editGroupId = ref<number | null>(null) const editGroupId = ref<number | null>(null)
/** 弹窗分组下拉的清空回填值:EP 的 el-select 默认清空写 undefined,会破 editGroupId/importGroupId
* 的 `number | null` 契约(下游 saveEdit/importValid 按假值判「未选」、updateDedupeTotal 的入参是 number)
* ⇒ 清空一律钉回 null,与旧原生 select 空行(value=null)同语义。 */
const nullOnClear = (): null => null
type ImportMode = 'add' | 'delete' type ImportMode = 'add' | 'delete'
const importVisible = ref(false) const importVisible = ref(false)
@@ -373,10 +377,14 @@ onUnmounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>国家</label> <label>国家</label>
<select v-model="filter.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option value="">全部国家</option> ⇒ 换 el-select(admin-filter 与亚马逊面同壳 42px/9px,弹层是 EP 圆角面板)。
<option v-for="code in ASIN_COUNTRY_CODES" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> 「全部国家」保留为空值首行(value="" 与改前同语义,下发参数仍是空串=不限);
</select> EP 把 '' 当空值 ⇒ 闭壳显示 placeholder,因此同时钉 placeholder="全部国家",视觉不变。 -->
<el-select v-model="filter.country" class="admin-filter" filterable placeholder="全部国家" aria-label="筛选国家">
<el-option label="全部国家" value="" />
<el-option v-for="code in ASIN_COUNTRY_CODES" :key="code" :label="asinCountryLabel(code)" :value="code" />
</el-select>
</div> </div>
<div class="dedupe-filter-actions"> <div class="dedupe-filter-actions">
<button class="btn" type="button" @click="apply">查询</button> <button class="btn" type="button" @click="apply">查询</button>
@@ -452,10 +460,23 @@ onUnmounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>分组</label> <label>分组</label>
<select v-model="editGroupId" :disabled="lockedGroupId != null"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物 ⇒ el-select。
<option disabled :value="null">请选择分组</option> 「未选」语义:原写法是 disabled 的空行(:value="null",选中后不可回退),这里改成
<option v-for="group in groups" :key="group.id" :value="group.id">{{ group.name }}</option> placeholder="请选择分组" + clearable,并用 :value-on-clear 把清空值钉回 null
</select> (理由见上方 nullOnClear 注释:EP 默认回 undefined 会破 number | null 契约)。
值域仍是 null 或分组 id(number),下游 editGroupId 的假值判断与入参形状不变;
非超管单分组时照旧锁定展示(:disabled 与护栏测试钉住的写法一致)。 -->
<el-select
v-model="editGroupId"
class="admin-filter"
placeholder="请选择分组"
clearable
:value-on-clear="nullOnClear"
:disabled="lockedGroupId != null"
aria-label="编辑分组"
>
<el-option v-for="group in groups" :key="group.id" :label="group.name" :value="group.id" />
</el-select>
</div> </div>
<div class="modal-actions"> <div class="modal-actions">
<button class="btn" type="button" :disabled="editSaving" @click="saveEdit">保存</button> <button class="btn" type="button" :disabled="editSaving" @click="saveEdit">保存</button>
@@ -473,10 +494,20 @@ onUnmounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>分组</label> <label>分组</label>
<select v-model="importGroupId" :disabled="importRunning || lockedGroupId != null"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物 ⇒ el-select。
<option disabled :value="null">请选择分组</option> 与编辑弹窗同款「未选」处理(placeholder + clearable + 清空钉回 null),
<option v-for="group in groups" :key="group.id" :value="group.id">{{ group.name }}</option> 导入锁定条件(importRunning 或单分组)照旧挂在 :disabled 上。 -->
</select> <el-select
v-model="importGroupId"
class="admin-filter"
placeholder="请选择分组"
clearable
:value-on-clear="nullOnClear"
:disabled="importRunning || lockedGroupId != null"
aria-label="导入分组"
>
<el-option v-for="group in groups" :key="group.id" :label="group.name" :value="group.id" />
</el-select>
</div> </div>
<div v-if="importProgress" class="progress-wrap"> <div v-if="importProgress" class="progress-wrap">
<div class="progress-text">{{ importProgress }}</div> <div class="progress-text">{{ importProgress }}</div>
@@ -591,8 +622,9 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, /* 下拉壳由全局 .el-select.admin-filter(main.css:42px/9px 圆角/#f8fbfd 浅底/focus ring)出,
.form-group select { 与亚马逊面同一套;这里只留 input 的原生壳规则(2026-11-17 原生 select 全换 el-select)。 */
.form-group input {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -606,12 +638,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -387,10 +387,14 @@ onMounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>国家</label> <label>国家</label>
<select v-model="filter.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option value="">全部国家</option> ⇒ 换 el-select(与上面分组同一套 admin-filter 壳 42px/9px,弹层是 EP 圆角面板)。
<option v-for="code in QUERY_ASIN_COUNTRIES" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> 「全部国家」保留为空值首行(value="" 与改前同语义,下发仍是空串=不限);
</select> EP 把 '' 视作空值 ⇒ 闭壳走 placeholder,因此同步钉 placeholder="全部国家" 保持文案。 -->
<el-select v-model="filter.country" class="admin-filter" filterable placeholder="全部国家" aria-label="筛选国家">
<el-option label="全部国家" value="" />
<el-option v-for="code in QUERY_ASIN_COUNTRIES" :key="code" :label="asinCountryLabel(code)" :value="code" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>ASIN</label> <label>ASIN</label>
@@ -582,8 +586,9 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, /* 下拉壳由全局 .el-select.admin-filter(main.css:42px/9px 圆角/#f8fbfd 浅底/focus ring)出,
.form-group select { 与亚马逊面同一套;这里只留 input 的原生壳规则(2026-11-17 原生 select 全换 el-select)。 */
.form-group input {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -597,12 +602,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -432,10 +432,14 @@ onMounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>国家</label> <label>国家</label>
<select v-model="filter.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 的弹层是浏览器直角原生物
<option value="">全部国家</option> ⇒ 换 el-select(与上面分组同一套 admin-filter 壳 42px/9px,弹层是 EP 圆角面板)。
<option v-for="code in COUNTRIES" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> 「全部国家」保留为空值首行(value="" 与改前同语义,下发仍是空串=不限);
</select> EP 把 '' 视作空值 ⇒ 闭壳走 placeholder,因此同步钉 placeholder="全部国家" 保持文案。 -->
<el-select v-model="filter.country" class="admin-filter" filterable placeholder="全部国家" aria-label="筛选国家">
<el-option label="全部国家" value="" />
<el-option v-for="code in COUNTRIES" :key="code" :label="asinCountryLabel(code)" :value="code" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>ASIN</label> <label>ASIN</label>
@@ -646,8 +650,9 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, /* 下拉壳由全局 .el-select.admin-filter(main.css:42px/9px 圆角/#f8fbfd 浅底/focus ring)出,
.form-group select { 与亚马逊面同一套;这里只留 input 的原生壳规则(2026-11-17 原生 select 全换 el-select)。 */
.form-group input {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -661,12 +666,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -3,7 +3,7 @@
* 京东数据库页勾选商品(翻页累计,由页面持有勾选集)→ 本对话框选目标分类或移出分类 → * 京东数据库页勾选商品(翻页累计,由页面持有勾选集)→ 本对话框选目标分类或移出分类 →
* 一次批量归类。归属写「本组」的归属行(biz_jd_product_group_assign,V203 一组一商品一行), * 一次批量归类。归属写「本组」的归属行(biz_jd_product_group_assign,V203 一组一商品一行),
* 归类不置人工编辑锁(采集照常更新价格/库存)。本组无分类时只有提示不给提交 * 归类不置人工编辑锁(采集照常更新价格/库存)。本组无分类时只有提示不给提交
* (移出对未分类行是无谓操作),引导去「京东分类管理」新建。 */ * (移出对未分类行是无谓操作),引导去工具栏「分类管理」新建(2026-11-17 独立页并回本页)。 */
import { computed, ref, watch } from 'vue' import { computed, ref, watch } from 'vue'
import { batchAssignJdProductGroup, type JdProductGroup } from './jd-product-api.ts' import { batchAssignJdProductGroup, type JdProductGroup } from './jd-product-api.ts'
import { requestErrorMessage } from '../../api/envelope.ts' import { requestErrorMessage } from '../../api/envelope.ts'
@@ -78,7 +78,7 @@ async function submit(): Promise<void> {
</p> </p>
<p v-if="errorText" class="group-error">{{ errorText }}</p> <p v-if="errorText" class="group-error">{{ errorText }}</p>
<div v-if="!categories.length" class="batch-empty">本组暂无分类,先去「京东分类管理」新建一个</div> <div v-if="!categories.length" class="batch-empty">本组暂无分类,先用工具栏「分类管理」新建一个</div>
<ul v-else class="option-list"> <ul v-else class="option-list">
<li <li
v-for="group in categories" v-for="group in categories"
@@ -0,0 +1,579 @@
<script setup lang="ts">
/** 分类管理对话框(2026-11-17 用户口径「京东分类管理并到京东数据库分类编辑里,
* 做一个搜索和添加 删除 编辑 分类名称即可」):原 V204 独立子菜单页(JdCategoryManagerPage)
* 整体并入本对话框,从京东数据库页工具栏「分类管理」打开。
* 职责不变:当前数据权限分组的分类建/改名/删除+新增的名称搜索;商品归类不在这里
* (去「批量编辑分类」)。列表状态自管理(写操作后自刷新并 emit changed 让父页刷筛选下拉)。
* 权限口径(V203)不变:本组管理员/公司超管/平台超管可写(editable);同组普通号
* 只读可看(无新建行,改名/删除按钮逐行不渲染),后端同口径 403 兜底。
* 2026-11-17 晚用户口径「admin 权限最大」:京东侧还没有任何数据权限分组时(平台闸
* 上线后 jd 档组全空),平台超管在本弹窗空态直建第一个京东档分组(组长=自己),
* 建完 emit group-created 让父页重取作用域,当前分组翻到新组后接着就能建分类,
* 不再死在「你还不属于任何数据权限分组」。 */
import { computed, ref, watch } from 'vue'
import {
createJdProductGroup,
deleteJdProductGroup,
fetchJdProductGroups,
updateJdProductGroup,
type JdProductGroup,
} from './jd-product-api.ts'
import { createShopGroup } from '../account/shop-group-api.ts'
import { useAdminSessionStore } from '@/stores/admin-session'
import { openAdminConfirm } from '@/components/admin-confirm'
import { showAdminFeedback } from '@/components/admin-feedback-ui'
import { loadFailureMessage } from '@/components/load-failure-model'
import LoadFailureBar from '@/components/LoadFailureBar.vue'
import { requestErrorMessage } from '../../api/envelope.ts'
const props = defineProps<{
visible: boolean
/** 当前数据权限分组(分类的作用域;<=0=不属于任何分组,只留空态)。 */
ownerGroupId: number
ownerGroupName: string
/** 当前分组可写(scope 的 editable):建/改名/删除控件全挂它。 */
editable: boolean
/** 操作者是否平台超管(scope 原样透传):只在「还没有分组」的空态开直建口子。 */
platformSuperAdmin?: boolean
}>()
const emit = defineEmits<{ (event: 'close'): void; (event: 'changed'): void; (event: 'group-created'): void }>()
const session = useAdminSessionStore()
const loading = ref(false)
/** 首屏取数失败(可见红条+重试);写操作失败走 errorText 红条(无重试语义)。 */
const loadFailure = ref('')
const errorText = ref('')
const groups = ref<JdProductGroup[]>([])
/** 搜索:按分类名称包含过滤(本地过滤,不另发请求)。 */
const keyword = ref('')
/** 分页(2026-11-17 用户口径「分类这也要加分页」):分类与父页「分类」下拉共用同一条全量
* 接口(下拉必须全量,不能分页),所以这里做本地切片;搜索同样是本地过滤 ⇒ 分页与搜索
* 同源,不会出现「先 limit 再过滤」那种翻页永久漏项。每页 6 行:实测 8 行在 700px 高的
* 视口里会顶出列表内滚动条(滚动条与页码条并存很难看),6 行矮屏也一屏放得下。 */
const PAGE_SIZE = 6
const pageNo = ref(1)
/** 新建:只收名称(排序输入 2026-11-15 客户口径下线,sortOrder 恒 0,后端契约不变)。 */
const createName = ref('')
const creating = ref(false)
/** 改名:正在编辑的分类 id 与草稿名。 */
const editingId = ref(0)
const editingName = ref('')
const saving = ref(false)
const canCreate = computed(() => props.editable && createName.value.trim().length > 0 && !creating.value && !saving.value)
/** 搜索命中(名称包含,大小写不敏感;空关键字=全量)。 */
const filteredGroups = computed(() => {
const kw = keyword.value.trim().toLowerCase()
if (!kw) return groups.value
return groups.value.filter((group) => group.name.toLowerCase().includes(kw))
})
/** 总页数(至少 1 页:空列表时页码条不渲染,但钳制逻辑要有个有效上界)。 */
const totalPages = computed(() => Math.max(1, Math.ceil(filteredGroups.value.length / PAGE_SIZE)))
/** 当前页的行(在搜索命中集上切片)。 */
const pagedGroups = computed(() => {
const start = (pageNo.value - 1) * PAGE_SIZE
return filteredGroups.value.slice(start, start + PAGE_SIZE)
})
/** 只有超过一页才出页码条:一屏装得下时不白占一行。 */
const showPager = computed(() => filteredGroups.value.length > PAGE_SIZE)
/** 翻页:页码钳在 [1, totalPages](删除/搜索后越界不会翻到空白页)。 */
function goPage(target: number): void {
pageNo.value = Math.min(Math.max(1, target), totalPages.value)
}
/** 空表文案分四种:不属于任何组 / 本组没分类(可管理)/ 本组没分类(只读)/ 搜索无命中。
* 平台超管的「还没有分组」空态不走这里——模板换成直建分组的表单(canBootstrapGroup)。 */
const emptyListText = computed(() => {
if (props.ownerGroupId <= 0) return '你还不属于任何数据权限分组'
if (!groups.value.length) {
return props.editable ? '本组暂无分类,先新建一个' : '本组暂无分类'
}
return '没有匹配的分类'
})
/** 空态直建分组的口子(2026-11-17 用户口径「admin 权限最大」):平台超管 + 还没有任何
* 可见分组时才开。组员/翻档等完整分组管理仍归「分组管理」页,这里只解决「从 0 到 1」。 */
const canBootstrapGroup = computed(() => props.platformSuperAdmin === true && props.ownerGroupId <= 0)
/** 直建表单:只收名称;组长=当前操作者,platform 恒 'jd'(京东侧作用域只认 jd 档)。 */
const newGroupName = ref('')
const creatingGroup = ref(false)
const canCreateGroup = computed(() =>
canBootstrapGroup.value && newGroupName.value.trim().length > 0 && !creatingGroup.value)
/** 平台超管空态直建第一个京东档分组:走分组管理同一条 POST(shop-manages/groups),
* 组长=当前操作者、组员先空。成功后 emit group-created 让父页整条作用域重取——
* ownerGroupId 翻到新组后由下方 watch 接手按新组重取分类,操作者接着就能建分类。 */
async function submitCreateGroup(): Promise<void> {
const name = newGroupName.value.trim()
if (!name || creatingGroup.value || !canBootstrapGroup.value) return
const operatorId = session.user?.id ?? 0
if (!operatorId) {
errorText.value = '无法获取当前登录用户,请重新登录'
return
}
creatingGroup.value = true
errorText.value = ''
try {
await createShopGroup(name, [], operatorId, 'jd')
newGroupName.value = ''
showAdminFeedback(`已新建京东档分组「${name}」`, 'success')
emit('group-created')
} catch (error) {
errorText.value = requestErrorMessage(error) || '新建分组失败'
} finally {
creatingGroup.value = false
}
}
async function loadGroups(): Promise<void> {
if (props.ownerGroupId <= 0) {
groups.value = []
loading.value = false
loadFailure.value = ''
errorText.value = ''
return
}
loading.value = true
loadFailure.value = ''
try {
groups.value = await fetchJdProductGroups(props.ownerGroupId)
} catch (error) {
loadFailure.value = loadFailureMessage(error, '分类列表加载失败')
groups.value = []
} finally {
loading.value = false
}
}
async function submitCreate(): Promise<void> {
const name = createName.value.trim()
if (!name || creating.value || !props.editable) return
creating.value = true
errorText.value = ''
try {
await createJdProductGroup({ name, sortOrder: 0, ownerGroupId: props.ownerGroupId })
createName.value = ''
keyword.value = ''
showAdminFeedback(`已新建分类「${name}」`, 'success')
emit('changed')
await loadGroups()
} catch (error) {
errorText.value = requestErrorMessage(error) || '新建分类失败'
} finally {
creating.value = false
}
}
function startRename(group: JdProductGroup): void {
editingId.value = group.id
editingName.value = group.name
errorText.value = ''
}
function cancelRename(): void {
editingId.value = 0
editingName.value = ''
}
async function submitRename(group: JdProductGroup): Promise<void> {
const name = editingName.value.trim()
if (!name || saving.value) return
saving.value = true
errorText.value = ''
try {
await updateJdProductGroup(group.id, { name, sortOrder: group.sortOrder })
groups.value = groups.value.map((item) => (item.id === group.id ? { ...item, name } : item))
cancelRename()
showAdminFeedback(`已把分类改名为「${name}」`, 'success')
emit('changed')
} catch (error) {
errorText.value = requestErrorMessage(error) || '改名失败'
} finally {
saving.value = false
}
}
/** 删除分类不删商品:只解挂本组归属行(商品回到未分类),后端 JdProductGroupService.delete。 */
async function removeGroup(group: JdProductGroup): Promise<void> {
const ok = await openAdminConfirm({ title: '删除分类', message: `确定删除分类「${group.name}」吗?删除后该分类下 ${group.productCount} 个商品回到未分类。`, confirmText: '确认删除', danger: true })
if (!ok || saving.value) return
saving.value = true
errorText.value = ''
try {
await deleteJdProductGroup(group.id)
showAdminFeedback(`已删除分类「${group.name}」`, 'success')
emit('changed')
await loadGroups()
} catch (error) {
errorText.value = requestErrorMessage(error) || '删除分类失败'
} finally {
saving.value = false
}
}
watch(
() => props.visible,
(visible) => {
if (visible) {
keyword.value = ''
errorText.value = ''
loadFailure.value = ''
cancelRename()
createName.value = ''
newGroupName.value = ''
pageNo.value = 1
void loadGroups()
}
},
// immediate:对话框可能以 visible=true 直接挂载(测试/复用场景),这时也要首取。
{ immediate: true },
)
/** 建组成功后父页重取作用域会把 ownerGroupId 翻到新组:按新组重取分类列表,
* 操作者不用关弹窗重开就能接着建分类。 */
watch(
() => props.ownerGroupId,
(next, prev) => {
if (next > 0 && next !== prev) void loadGroups()
},
)
/** 改关键字回第一页(命中集变了,停在旧页码会落在空白处)。 */
watch(keyword, () => {
pageNo.value = 1
})
/** 命中集变少(删掉最后一条/搜索收窄)后把越界页码钳回最后一页。 */
watch(totalPages, (pages) => {
if (pageNo.value > pages) pageNo.value = pages
})
</script>
<template>
<div v-if="visible" class="modal-mask" @click.self="emit('close')">
<div class="manage-modal">
<div class="modal-head">
<h3>分类管理</h3>
<button class="modal-close" type="button" aria-label="关闭" @click="emit('close')">×</button>
</div>
<div class="manage-bar">
<input v-model="keyword" class="search-input" type="text" placeholder="搜索分类名称" aria-label="搜索分类名称" />
<div v-if="editable" class="group-create">
<input v-model="createName" type="text" placeholder="输入新分类名称" aria-label="新分类名称" @keyup.enter="submitCreate" />
<button class="btn" type="button" :disabled="!canCreate" @click="submitCreate">新建</button>
</div>
</div>
<LoadFailureBar v-if="loadFailure" :message="loadFailure" @retry="loadGroups" />
<p v-if="errorText" class="group-error">{{ errorText }}</p>
<ul class="option-list">
<template v-if="filteredGroups.length">
<li v-for="group in pagedGroups" :key="group.id" class="option-row">
<template v-if="editingId === group.id">
<input v-model="editingName" class="rename-input" type="text" aria-label="分类新名称" @keyup.enter="submitRename(group)" />
<span class="row-actions">
<button class="btn btn-sm" type="button" :disabled="saving" @click="submitRename(group)">保存</button>
<button class="btn btn-sm btn-secondary" type="button" @click="cancelRename">取消</button>
</span>
</template>
<template v-else>
<span class="option-name" :title="group.name">{{ group.name }}</span>
<span class="option-meta" title="该分类下的商品数">{{ group.productCount }}</span>
<span v-if="editable" class="row-actions">
<button class="btn btn-sm btn-secondary" type="button" :disabled="saving" @click="startRename(group)">改名</button>
<button class="btn btn-sm btn-danger" type="button" :disabled="saving" @click="removeGroup(group)">删除</button>
</span>
</template>
</li>
</template>
<li v-else-if="loading" class="manage-empty">加载中...</li>
<li v-else class="manage-empty">
<template v-if="canBootstrapGroup">
<div class="group-bootstrap">
<input
v-model="newGroupName"
class="search-input"
type="text"
placeholder="输入分组名称"
aria-label="新分组名称"
@keyup.enter="submitCreateGroup"
/>
<button class="btn" type="button" :disabled="!canCreateGroup" @click="submitCreateGroup">新建分组</button>
</div>
</template>
<template v-else>{{ emptyListText }}</template>
</li>
</ul>
<div v-if="showPager" class="manage-pager">
<button class="btn btn-sm btn-secondary" type="button" :disabled="pageNo <= 1" @click="goPage(pageNo - 1)">上一页</button>
<span class="pager-text">第 {{ pageNo }} / {{ totalPages }} 页 · 共 {{ filteredGroups.length }} 个分类</span>
<button class="btn btn-sm btn-secondary" type="button" :disabled="pageNo >= totalPages" @click="goPage(pageNo + 1)">下一页</button>
</div>
<div class="modal-foot">
<button class="btn btn-secondary" type="button" @click="emit('close')">关闭</button>
</div>
</div>
</div>
</template>
<style scoped>
.modal-mask {
position: fixed;
inset: 0;
z-index: 2800;
display: flex;
align-items: center;
justify-content: center;
padding: 40px 20px;
background: rgba(45, 66, 86, 0.36);
backdrop-filter: blur(6px);
}
.manage-modal {
display: flex;
flex-direction: column;
/* 2026-11-17 用户口径「宽度不需要那么宽」「红框大小就够了」:垂直排列后每行拉满,
480/420 都显空荡;按用户红框量到约 340px(全局 main.css 有 `* { box-sizing: border-box }`,
这个 width 就是含内边距与边框的总宽)。行内容(名称+商品数徽标+改名/删除)与页码条
在 340−42=298px 可用宽度里仍放得下,不会挤换行。 */
width: min(340px, 100%);
max-height: 80vh;
padding: 18px 20px 20px;
border: 1px solid #c7d7e5;
border-radius: 14px;
background: #ffffff;
box-shadow: 0 22px 60px rgba(39, 67, 94, 0.2);
}
.modal-head {
display: flex;
align-items: center;
justify-content: space-between;
}
.modal-head h3 {
margin: 0;
font-size: 15px;
font-weight: 650;
color: #24384d;
}
.modal-close {
width: 30px;
height: 30px;
border: 1px solid transparent;
border-radius: 9px;
background: none;
color: #5b6f83;
font-size: 20px;
line-height: 1;
cursor: pointer;
}
.modal-close:hover {
border-color: #cbd9e6;
background: #eef4fa;
color: #24384d;
}
/* 2026-11-17 用户口径演变:「垂直排阿」→ 弹窗收窄到 340px 后「弄成一排呗」:
搜索框、新分类名输入、新建按钮合回一行。340−42=298px 可用宽度:新建按钮约 56
+两处 gap 16。实测按比例分(flex 1:1.75)会偏移(搜索 122/新建输入只剩 105,
7 字占位 115px 被截),改成搜索定宽 108px(6 字占位 102px 放得下),新建行吃剩余
(298−108−16=174,输入约 118px,占位完整)。 */
.manage-bar {
display: flex;
flex-wrap: nowrap;
gap: 8px;
align-items: center;
margin-bottom: 12px;
}
.search-input,
.group-create input {
min-height: 36px;
padding: 6px 12px;
border: 1px solid #cbd9e6;
border-radius: 9px;
background: #f8fbfd;
color: #24384d;
font-size: 13px;
font-family: inherit;
outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
}
.search-input:hover,
.group-create input:hover {
border-color: #9fb7cd;
}
.search-input:focus,
.group-create input:focus {
background: #ffffff;
border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
}
.search-input {
flex: 0 0 108px;
min-width: 0;
}
.group-create {
display: flex;
flex: 1;
gap: 8px;
min-width: 0;
}
.group-create input {
flex: 1;
min-width: 0;
}
.group-error {
margin: 0 0 8px;
padding: 10px 12px;
border: 1px solid #f0c9c2;
border-radius: 10px;
background: #fdf1ef;
color: #a04432;
font-size: 13px;
}
.option-list {
flex: 1;
min-height: 0;
overflow-y: auto;
margin: 0;
padding: 0;
list-style: none;
border-top: 1px solid #e7eef5;
}
.option-row {
display: flex;
align-items: center;
gap: 10px;
padding: 9px 8px;
border-bottom: 1px solid #e7eef5;
font-size: 13.5px;
}
.option-row:hover {
background: #f1f7fb;
}
/* 名称不占剩余空间:它只包住自己的文字,数量徽标紧贴其后。
剩余空间全部让给 row-actions 的 margin-left:auto(有操作时按钮仍靠右)。
写回 flex:1 会让名称把空白吃满、把号码顶到行尾(2026-11-17 用户反馈「0 和名称离的有点远」)。 */
.option-name {
flex: 0 1 auto;
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
color: #24384d;
}
.option-meta {
flex: none;
min-width: 22px;
padding: 1px 7px;
border-radius: 9px;
background: #eef4fa;
color: #4e6479;
font-size: 12px;
text-align: center;
white-space: nowrap;
}
.row-actions {
flex: none;
margin-left: auto;
white-space: nowrap;
}
.manage-empty {
padding: 30px 12px;
text-align: center;
color: #8293a5;
font-size: 13px;
list-style: none;
}
/* 平台超管空态直建分组:只有输入行(引导语/组长说明等小字 2026-11-17 用户口径「小字不需要」删除)。 */
.group-bootstrap {
display: flex;
gap: 8px;
}
.group-bootstrap .search-input {
flex: 1;
min-width: 0;
text-align: left;
}
.manage-pager {
display: flex;
align-items: center;
justify-content: center;
gap: 10px;
margin-top: 10px;
}
.pager-text {
color: #5b6f83;
font-size: 12.5px;
white-space: nowrap;
}
.rename-input {
flex: 1;
min-width: 0;
min-height: 32px;
padding: 4px 10px;
border: 1px solid #cbd9e6;
border-radius: 8px;
font-size: 13.5px;
font-family: inherit;
outline: none;
}
.rename-input:focus {
background: #ffffff;
border-color: #5f85ad;
}
.modal-foot {
display: flex;
justify-content: flex-end;
gap: 10px;
margin-top: 14px;
}
.btn {
display: inline-flex;
align-items: center;
justify-content: center;
min-height: 36px;
padding: 6px 14px;
border: 1px solid #4f78a5;
border-radius: 9px;
background: linear-gradient(135deg, #5f85ad, #4f78a5);
color: #ffffff;
font-family: inherit;
font-size: 13px;
cursor: pointer;
}
.btn:disabled {
cursor: not-allowed;
opacity: 0.55;
}
.btn-sm {
min-height: 28px;
padding: 3px 10px;
font-size: 12.5px;
margin-right: 6px;
}
.btn-sm:last-child {
margin-right: 0;
}
.btn-secondary {
background: #ffffff;
color: #5b6f83;
border-color: #c7d7e5;
}
.btn-secondary:hover:not(:disabled) {
color: #2f5d8b;
border-color: #95b1cb;
background: #edf5fb;
}
/* 危险动作与全站 .btn-danger 同形(实心红渐变+白字)。 */
.btn-danger {
background: linear-gradient(135deg, #c06d77, #b35f6a);
border-color: #b35f6a;
color: #ffffff;
}
.btn-danger:hover:not(:disabled) {
background: linear-gradient(135deg, #cb7c84, #b96570);
}
</style>
@@ -1,486 +0,0 @@
<script setup lang="ts">
/** 京东分类管理(2026-11-17 用户口径「店铺分类弹窗删了,加个京东分类管理的子菜单维护 CRUD」):
* 当前数据权限分组的分类建/改名/删除独立成页(V204 菜单行);分组作用域与京东数据库页
* 同一套(京东的分组管理,非亚马逊——platform-scope JD_MENU_KEYS 京东侧)。
* 商品归类不在这里:去「京东数据库」页勾选商品后「批量编辑分类」。
* 权限口径(V203):本组管理员/公司超管/平台超管可写(scope 的 editable);同组普通号
* 只读(无新建行,改名/删除按钮逐行不渲染),后端同口径 403 兜底。 */
import { computed, onMounted, ref } from 'vue'
import {
createJdProductGroup,
deleteJdProductGroup,
fetchJdCategoryScope,
fetchJdProductGroups,
updateJdProductGroup,
type JdCategoryGroupOption,
type JdProductGroup,
} from './jd-product-api.ts'
import { openAdminConfirm } from '@/components/admin-confirm'
import { showAdminFeedback } from '@/components/admin-feedback-ui'
import { loadFailureMessage } from '@/components/load-failure-model'
import LoadFailureBar from '@/components/LoadFailureBar.vue'
import { requestErrorMessage } from '../../api/envelope.ts'
const loading = ref(false)
/** 首屏取数失败(可见红条+重试);写操作失败走 errorText 红条(无重试语义)。 */
const loadFailure = ref('')
const errorText = ref('')
const groups = ref<JdProductGroup[]>([])
/** 新建:只收名称(排序输入 2026-11-15 客户口径下线,sortOrder 恒 0,后端契约不变)。 */
const createName = ref('')
const creating = ref(false)
/** 改名:正在编辑的分类 id 与草稿名。 */
const editingId = ref(0)
const editingName = ref('')
const saving = ref(false)
/** 分类作用域:可见分组 + 每组可写标记。失败回空作用域(页面提示不属于任何分组)。 */
const categoryScope = ref<JdCategoryGroupOption[]>([])
const scopeDefaultGroupId = ref(0)
const ownerGroupId = ref(0)
const currentGroupOption = computed<JdCategoryGroupOption | null>(() =>
categoryScope.value.find((group) => group.id === ownerGroupId.value) || null)
const currentGroupName = computed(() => currentGroupOption.value?.name || '')
/** 分类可管理(建/改名/删除):本组管理员、公司超管、平台超管(后端 scope 判)。 */
const canManage = computed(() => currentGroupOption.value?.editable === true)
/** 分组下拉只在能看多组时才渲染;只有一组(含无可见组)时按锁定态展示。 */
const canSwitchGroup = computed(() => categoryScope.value.length > 1)
const canCreate = computed(() => canManage.value && createName.value.trim().length > 0 && !creating.value && !saving.value)
/** 空表文案分三种:不属于任何组 / 本组还没分类(可管理)/ 本组还没分类(只读)。 */
const emptyListText = computed(() => {
if (ownerGroupId.value <= 0) return '你还不属于任何数据权限分组'
return canManage.value ? '本组暂无分类,先新建一个' : '本组暂无分类'
})
async function loadScope(): Promise<void> {
try {
const scope = await fetchJdCategoryScope()
categoryScope.value = scope.groups
scopeDefaultGroupId.value = scope.defaultGroupId ?? 0
} catch {
categoryScope.value = []
scopeDefaultGroupId.value = 0
}
const keep = categoryScope.value.some((group) => group.id === ownerGroupId.value)
if (!keep) ownerGroupId.value = scopeDefaultGroupId.value
await loadGroups()
}
async function loadGroups(): Promise<void> {
if (ownerGroupId.value <= 0) {
groups.value = []
loading.value = false
loadFailure.value = ''
errorText.value = ''
return
}
loading.value = true
loadFailure.value = ''
try {
groups.value = await fetchJdProductGroups(ownerGroupId.value)
} catch (error) {
loadFailure.value = loadFailureMessage(error, '分类列表加载失败')
groups.value = []
} finally {
loading.value = false
}
}
/** 切换「分组」下拉:列表换成本组(跨组分类不可见,V203)。 */
async function changeOwnerGroup(next: number): Promise<void> {
if (next === ownerGroupId.value) return
ownerGroupId.value = next
cancelRename()
createName.value = ''
await loadGroups()
}
async function submitCreate(): Promise<void> {
const name = createName.value.trim()
if (!name || creating.value || !canManage.value) return
creating.value = true
errorText.value = ''
try {
await createJdProductGroup({ name, sortOrder: 0, ownerGroupId: ownerGroupId.value })
createName.value = ''
showAdminFeedback(`已新建分类「${name}」`, 'success')
await loadGroups()
} catch (error) {
errorText.value = requestErrorMessage(error) || '新建分类失败'
} finally {
creating.value = false
}
}
function startRename(group: JdProductGroup): void {
editingId.value = group.id
editingName.value = group.name
errorText.value = ''
}
function cancelRename(): void {
editingId.value = 0
editingName.value = ''
}
async function submitRename(group: JdProductGroup): Promise<void> {
const name = editingName.value.trim()
if (!name || saving.value) return
saving.value = true
errorText.value = ''
try {
await updateJdProductGroup(group.id, { name, sortOrder: group.sortOrder })
groups.value = groups.value.map((item) => (item.id === group.id ? { ...item, name } : item))
cancelRename()
showAdminFeedback(`已把分类改名为「${name}」`, 'success')
} catch (error) {
errorText.value = requestErrorMessage(error) || '改名失败'
} finally {
saving.value = false
}
}
/** 删除分类不删商品:只解挂本组归属行(商品回到未分类),后端 JdProductGroupService.delete。 */
async function removeGroup(group: JdProductGroup): Promise<void> {
const ok = await openAdminConfirm({ title: '删除分类', message: `确定删除分类「${group.name}」吗?删除后该分类下 ${group.productCount} 个商品回到未分类。`, confirmText: '确认删除', danger: true })
if (!ok || saving.value) return
saving.value = true
errorText.value = ''
try {
await deleteJdProductGroup(group.id)
showAdminFeedback(`已删除分类「${group.name}」`, 'success')
await loadGroups()
} catch (error) {
errorText.value = requestErrorMessage(error) || '删除分类失败'
} finally {
saving.value = false
}
}
onMounted(() => {
void loadScope()
})
</script>
<template>
<div class="jd-category-view">
<section class="panel-box">
<div class="jd-panel-head">
<h3>京东分类管理</h3>
</div>
<p class="page-tip">
分类按「数据权限分组」隔离(京东侧的分组,不同组看不到彼此的分类):当前组只组长/超管可维护;
商品归类去「京东数据库」页勾选商品后「批量编辑分类」,删除分类不删商品(只解挂归属)。
</p>
<div class="scope-row">
<div class="form-group">
<label>分组</label>
<select
v-if="canSwitchGroup"
:value="ownerGroupId"
aria-label="当前分组"
@change="changeOwnerGroup(Number(($event.target as HTMLSelectElement).value))"
>
<option v-for="group in categoryScope" :key="group.id" :value="group.id">{{ group.label }}</option>
</select>
<span v-else-if="currentGroupName" class="group-locked" title="你的数据权限内只有这一个分组">{{ currentGroupName }}</span>
<span v-else class="group-locked group-locked-empty">你还不属于任何数据权限分组</span>
</div>
<div v-if="canManage" class="group-create">
<input v-model="createName" type="text" placeholder="输入新分类名称" @keyup.enter="submitCreate" />
<button class="btn" type="button" :disabled="!canCreate" @click="submitCreate">新建</button>
</div>
</div>
<LoadFailureBar v-if="loadFailure" :message="loadFailure" @retry="loadGroups" />
<p v-if="errorText" class="group-error">{{ errorText }}</p>
<div class="table-scroll">
<table>
<thead>
<tr>
<th>分类名称</th>
<th style="width: 96px">商品数</th>
<th v-if="canManage" style="width: 150px">操作</th>
</tr>
</thead>
<tbody>
<template v-if="groups.length">
<tr v-for="group in groups" :key="group.id">
<td>
<template v-if="editingId === group.id">
<input v-model="editingName" class="rename-input" type="text" @keyup.enter="submitRename(group)" />
<span class="row-actions">
<button class="btn btn-sm" type="button" :disabled="saving" @click="submitRename(group)">保存</button>
<button class="btn btn-sm btn-secondary" type="button" @click="cancelRename">取消</button>
</span>
</template>
<template v-else>
<span class="group-name" :title="group.name">{{ group.name }}</span>
</template>
</td>
<td>{{ group.productCount }}</td>
<td v-if="canManage" class="ops-cell">
<button class="btn btn-sm" type="button" :disabled="saving" @click="startRename(group)">改名</button>
<button class="btn btn-sm btn-danger" type="button" :disabled="saving" @click="removeGroup(group)">删除</button>
</td>
</tr>
</template>
<tr v-else-if="loading">
<td :colspan="canManage ? 3 : 2" class="empty-tip">加载中...</td>
</tr>
<tr v-else>
<td :colspan="canManage ? 3 : 2" class="empty-tip">{{ emptyListText }}</td>
</tr>
</tbody>
</table>
</div>
</section>
</div>
</template>
<style scoped>
.jd-category-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);
}
.jd-panel-head {
display: flex;
align-items: center;
justify-content: space-between;
margin-bottom: 10px;
}
.jd-panel-head h3 {
margin: 0;
font-size: 15px;
font-weight: 650;
color: #24384d;
letter-spacing: 0.2px;
}
.page-tip {
margin: 0 0 14px;
color: #8293a5;
font-size: 12.5px;
line-height: 1.6;
}
.scope-row {
display: flex;
flex-wrap: wrap;
gap: 12px;
align-items: flex-end;
margin-bottom: 14px;
}
.form-group {
display: flex;
flex-direction: column;
gap: 7px;
min-width: 200px;
}
.form-group label {
color: #5b6f83;
font-size: 12.5px;
font-weight: 600;
}
.form-group select,
.group-create input {
min-height: 42px;
padding: 8px 12px;
border: 1px solid #cbd9e6;
border-radius: 9px;
background: #f8fbfd;
color: #24384d;
font-size: 13.5px;
font-family: inherit;
outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
}
.form-group select:hover,
.group-create input:hover {
border-color: #9fb7cd;
}
.form-group select:focus,
.group-create input:focus {
background: #ffffff;
border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
}
/* 与京东数据库页筛选行同款自绘箭头:appearance:none 后补 padding-right 给箭头留位。 */
.form-group select {
min-width: 220px;
padding-right: 34px;
background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8'%3E%3Cpath d='M1 1.5 6 6.5 11 1.5' fill='none' stroke='%235b6f83' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
background-repeat: no-repeat;
background-position: right 12px center;
appearance: none;
-webkit-appearance: none;
cursor: pointer;
}
.group-create {
display: flex;
gap: 8px;
}
.group-create input {
width: 220px;
}
/* 只有一个可见分组时锁定的组名:与下拉同高同壳的静态芯片(京东数据库页同款)。 */
.group-locked {
display: inline-flex;
align-items: center;
min-height: 42px;
padding: 0 12px;
border: 1px solid #dbe5ee;
border-radius: 9px;
background: #f1f6fb;
color: #4e6479;
font-size: 13.5px;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.group-locked-empty {
color: #8293a5;
}
.group-error {
margin: 0 0 10px;
padding: 10px 12px;
border: 1px solid #f0c9c2;
border-radius: 10px;
background: #fdf1ef;
color: #a04432;
font-size: 13px;
}
.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;
}
.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;
}
.group-name {
color: #24384d;
}
.rename-input {
width: 200px;
min-height: 32px;
padding: 4px 10px;
border: 1px solid #cbd9e6;
border-radius: 8px;
font-size: 13.5px;
font-family: inherit;
outline: none;
}
.rename-input:focus {
background: #ffffff;
border-color: #5f85ad;
}
.row-actions {
margin-left: 8px;
white-space: nowrap;
}
.ops-cell {
display: flex;
flex-wrap: wrap;
gap: 4px;
overflow: visible;
}
.btn {
display: inline-flex;
align-items: center;
justify-content: center;
gap: 8px;
min-height: 38px;
padding: 7px 16px;
border: 1px solid #4f78a5;
border-radius: 9px;
background: linear-gradient(135deg, #5f85ad, #4f78a5);
color: #ffffff;
font-family: inherit;
font-size: 13px;
cursor: pointer;
transition: background 160ms ease, box-shadow 160ms ease;
}
.btn:disabled {
cursor: not-allowed;
opacity: 0.55;
}
.btn-sm {
min-height: 28px;
padding: 3px 10px;
font-size: 12.5px;
margin-right: 6px;
}
.btn-sm:last-child {
margin-right: 0;
}
.btn-secondary {
background: #ffffff;
color: #5b6f83;
border-color: #c7d7e5;
}
.btn-secondary:hover:not(:disabled) {
color: #2f5d8b;
border-color: #95b1cb;
background: #edf5fb;
}
/* 危险动作与全站 .btn-danger 同形(实心红渐变+白字)。 */
.btn-danger {
background: linear-gradient(135deg, #c06d77, #b35f6a);
border-color: #b35f6a;
color: #ffffff;
}
.btn-danger:hover:not(:disabled) {
background: linear-gradient(135deg, #cb7c84, #b96570);
}
.empty-tip {
padding: 44px 24px;
text-align: center;
color: #8293a5;
font-size: 13.5px;
}
</style>
@@ -2,8 +2,10 @@
/** 京东公共商品库:支持分类和京麦类目组合筛选。 /** 京东公共商品库:支持分类和京麦类目组合筛选。
* V203(2026-11-16 用户口径):分类按「数据权限分组」隔离——不同组看不到彼此的分类, * V203(2026-11-16 用户口径):分类按「数据权限分组」隔离——不同组看不到彼此的分类,
* 能看多组的人用筛选行「分组」下拉切换当前组(只有一组时锁定显示)。 * 能看多组的人用筛选行「分组」下拉切换当前组(只有一组时锁定显示)。
* 2026-11-17 用户口径:店铺分类弹窗下线(建/改名/删分类挪「京东分类管理」子菜单页); * 2026-11-17 用户口径:店铺分类弹窗下线,本页工具栏改「批量编辑分类」——勾选商品
* 本页工具栏改「批量编辑分类」——勾选商品(翻页累计记忆)后选目标分类归入或移出。 */ * (翻页累计记忆)后选目标分类归入或移出;同日第二刀「京东分类管理并到京东数据库分类
* 编辑里」:V204 独立子菜单页(JdCategoryManagerPage)下线,建/改名/删分类收进工具栏
* 「分类管理」对话框(JdCategoryManageDialog,带名称搜索)。 */
import { computed, onMounted, reactive, ref } from 'vue' import { computed, onMounted, reactive, ref } from 'vue'
import { import {
deleteJdProducts, deleteJdProducts,
@@ -22,18 +24,26 @@ import JdProductDetailDrawer from './JdProductDetailDrawer.vue'
import JdProductEditDrawer from './JdProductEditDrawer.vue' import JdProductEditDrawer from './JdProductEditDrawer.vue'
import JdCategoryCascader from './JdCategoryCascader.vue' import JdCategoryCascader from './JdCategoryCascader.vue'
import JdBatchAssignDialog from './JdBatchAssignDialog.vue' import JdBatchAssignDialog from './JdBatchAssignDialog.vue'
import JdCategoryManageDialog from './JdCategoryManageDialog.vue'
import OldPagination from '@/components/OldPagination.vue' import OldPagination from '@/components/OldPagination.vue'
import { showAdminFeedback } from '@/components/admin-feedback-ui' import { showAdminFeedback } from '@/components/admin-feedback-ui'
import { openAdminConfirm } from '@/components/admin-confirm' import { openAdminConfirm } from '@/components/admin-confirm'
import { loadFailureMessage } from '@/components/load-failure-model' import { loadFailureMessage } from '@/components/load-failure-model'
import LoadFailureBar from '@/components/LoadFailureBar.vue' import LoadFailureBar from '@/components/LoadFailureBar.vue'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { isAdminRole, isCompanySuperAdminRole } from '@/types/admin'
import { formatDateTime, orderedPair } from '@/utils/datetime' import { formatDateTime, orderedPair } from '@/utils/datetime'
/** 写权限口径(2026-11-16 用户口径):商品行写(编辑/删除/勾选批量删)只对平台超级管理员渲染; /** 写权限口径(2026-11-17 用户口径「超管+管理员都可以,只有普通员工不能操作」):
* 分类写(建/改名/删除、归类)由 scope 的每组 editable 决定(本组管理员/公司超管/平台超管)。 */ * 商品行写(编辑/删除/批量删除/传图)对管理员级(超级管理员/公司超级管理员/admin 档)渲染,
* 普通账号只读(后端 requireJdProductWrite 同口径兜底);分类写(建/改名/删除、归类)
* 由 scope 的每组 editable 决定(本组管理员/公司超管/平台超管),与本档无关。 */
const session = useAdminSessionStore() const session = useAdminSessionStore()
const isSuperAdmin = computed(() => session.isSuperAdmin) const canWriteProducts = computed(() => isAdminRole(session.user?.role))
/** 分组筛选(同日用户口径「超管可以有分组筛选,管理员及以下则没有」):筛选行「分组」控件
* (下拉+单组锁定芯片)只对超管档(超级管理员/公司超级管理员)渲染;管理员及以下
* 不出现,其分类面固定落在作用域默认分组上。 */
const canFilterGroup = computed(() => session.isSuperAdmin || isCompanySuperAdminRole(session.user?.role))
const loading = ref(false) const loading = ref(false)
const loadFailure = ref('') const loadFailure = ref('')
@@ -45,6 +55,10 @@ const filter = reactive(createJdProductFilterState())
/** 分类作用域(V203):可见分组 + 每组可写标记。失败静默回空作用域(分类列全空但商品照常)。 */ /** 分类作用域(V203):可见分组 + 每组可写标记。失败静默回空作用域(分类列全空但商品照常)。 */
const categoryScope = ref<JdCategoryGroupOption[]>([]) const categoryScope = ref<JdCategoryGroupOption[]>([])
const scopeDefaultGroupId = ref(0) const scopeDefaultGroupId = ref(0)
/** 操作者是否平台超管(scope 原样透传):京东侧还没有任何分组时,分类管理弹窗
* 靠它给平台超管开「直接新建数据权限分组」的口子(2026-11-17 用户口径「admin 权限最大」),
* 其余角色维持空态指路,不在分类管理里建组。 */
const scopeSuperAdmin = ref(false)
/** 当前分组(数据权限分组 id):分类列/分类筛选/分类管理的共同作用域。 */ /** 当前分组(数据权限分组 id):分类列/分类筛选/分类管理的共同作用域。 */
const ownerGroupId = ref(0) const ownerGroupId = ref(0)
/** 当前分组的分类下拉选项(按 ownerGroupId 取,切组即换)。 */ /** 当前分组的分类下拉选项(按 ownerGroupId 取,切组即换)。 */
@@ -55,6 +69,8 @@ const detailItem = ref<JdProductItem | null>(null)
const detailVisible = ref(false) const detailVisible = ref(false)
/** 批量编辑分类对话框(2026-11-17 替代下线的店铺分类弹窗)。 */ /** 批量编辑分类对话框(2026-11-17 替代下线的店铺分类弹窗)。 */
const batchEditVisible = ref(false) const batchEditVisible = ref(false)
/** 分类管理对话框(2026-11-17 第二刀:独立子菜单页并进来,建/改名/删+搜索)。 */
const manageVisible = ref(false)
/** 行级编辑抽屉(2026-11-15 用户口径「每一条数据后面 需要编辑或者删除;编辑的话 /** 行级编辑抽屉(2026-11-15 用户口径「每一条数据后面 需要编辑或者删除;编辑的话
* 这里面都是可以编辑的」):删除走下面的 removeOne(同一条删除链),编辑走独立抽屉。 */ * 这里面都是可以编辑的」):删除走下面的 removeOne(同一条删除链),编辑走独立抽屉。 */
const editItem = ref<JdProductItem | null>(null) const editItem = ref<JdProductItem | null>(null)
@@ -66,12 +82,12 @@ const currentGroupOption = computed<JdCategoryGroupOption | null>(() =>
const currentGroupName = computed(() => currentGroupOption.value?.name || '') const currentGroupName = computed(() => currentGroupOption.value?.name || '')
/** 分类可管理(建/改名/删除/归类):本组管理员、公司超管、平台超管(后端 scope 判)。 */ /** 分类可管理(建/改名/删除/归类):本组管理员、公司超管、平台超管(后端 scope 判)。 */
const canManageCategories = computed(() => currentGroupOption.value?.editable === true) const canManageCategories = computed(() => currentGroupOption.value?.editable === true)
/** 勾选列服务两类写:批量删除(只超管)+批量编辑分类(本组可写分类的管理员也要勾)。 /** 勾选列服务两类写:批量删除(管理员级)+批量编辑分类(本组可写分类的管理员也要勾)。
* 2026-11-17 弹窗下线后管理员失去弹窗右栏的勾选面 ⇒ 勾选列必须对「本组可写」放开, * 2026-11-17 弹窗下线后管理员失去弹窗右栏的勾选面 ⇒ 勾选列必须对「本组可写」放开,
* 否则本组管理员没有归类入口。商品行按钮(编辑/删除/删除勾选)仍只归平台超管。 */ * 否则本组管理员没有归类入口。 */
const hasSelectionColumn = computed(() => isSuperAdmin.value || canManageCategories.value) const hasSelectionColumn = computed(() => canWriteProducts.value || canManageCategories.value)
/** 空态行 colspan:勾选列有无决定 5/6/7 列三种形状(超管含操作列)。 */ /** 空态行 colspan:勾选列有无决定 5/6/7 列三种形状(管理员级含操作列)。 */
const emptyColspan = computed(() => (isSuperAdmin.value ? 7 : hasSelectionColumn.value ? 6 : 5)) const emptyColspan = computed(() => (canWriteProducts.value ? 7 : hasSelectionColumn.value ? 6 : 5))
/** 分组下拉只在能看多组时才渲染;只有一组(含无可见组)时按锁定态展示。 */ /** 分组下拉只在能看多组时才渲染;只有一组(含无可见组)时按锁定态展示。 */
const canSwitchGroup = computed(() => categoryScope.value.length > 1) const canSwitchGroup = computed(() => categoryScope.value.length > 1)
@@ -105,9 +121,11 @@ async function loadCategoryScope(): Promise<void> {
const scope = await fetchJdCategoryScope() const scope = await fetchJdCategoryScope()
categoryScope.value = scope.groups categoryScope.value = scope.groups
scopeDefaultGroupId.value = scope.defaultGroupId ?? 0 scopeDefaultGroupId.value = scope.defaultGroupId ?? 0
scopeSuperAdmin.value = scope.platformSuperAdmin === true
} catch { } catch {
categoryScope.value = [] categoryScope.value = []
scopeDefaultGroupId.value = 0 scopeDefaultGroupId.value = 0
scopeSuperAdmin.value = false
} }
// 当前分组:保留用户已选(仍可见时),否则回默认(可见组第一项)。 // 当前分组:保留用户已选(仍可见时),否则回默认(可见组第一项)。
const keep = categoryScope.value.some((group) => group.id === ownerGroupId.value) const keep = categoryScope.value.some((group) => group.id === ownerGroupId.value)
@@ -151,6 +169,26 @@ async function openBatchEdit(): Promise<void> {
batchEditVisible.value = true batchEditVisible.value = true
} }
/** 打开分类管理(对话框自取列表);入口对所有人渲染——同组普通号只读可看(V203),
* 写控件由对话框按 editable 分档。 */
function openManage(): void {
manageVisible.value = true
}
/** 分类管理里有写操作(建/改/删):刷一遍筛选下拉与商品数徽标。 */
async function onManaged(): Promise<void> {
await loadGroupOptions()
}
/**
* 分类管理里新建了第一个数据权限分组(平台超管空态直建,2026-11-17 用户口径「admin
* 权限最大」):整条作用域重取——新组会进可见集并把「当前分组」翻过去,分类下拉、
* 弹窗内分类列表随之按新组取,操作者接着就能建分类,不用关弹窗再开一遍。
*/
async function onGroupCreated(): Promise<void> {
await loadCategoryScope()
}
/** 批量归类完成(对话框已关):清勾选+重取列表(行集 groupName 变了)。 /** 批量归类完成(对话框已关):清勾选+重取列表(行集 groupName 变了)。
* 移出分类 targetName 为 null;updated 是后端实际写入/解挂的归属行数。 */ * 移出分类 targetName 为 null;updated 是后端实际写入/解挂的归属行数。 */
async function onBatchAssigned(updated: number, targetName: string | null): Promise<void> { async function onBatchAssigned(updated: number, targetName: string | null): Promise<void> {
@@ -173,6 +211,7 @@ async function load(): Promise<void> {
titleKeyword: filter.titleKeyword, titleKeyword: filter.titleKeyword,
category: filter.category, category: filter.category,
groupId: filter.groupId, groupId: filter.groupId,
classified: filter.classified,
ownerGroupId: ownerGroupId.value, ownerGroupId: ownerGroupId.value,
syncedFrom: filter.syncedFrom, syncedFrom: filter.syncedFrom,
syncedTo: filter.syncedTo, syncedTo: filter.syncedTo,
@@ -181,8 +220,8 @@ async function load(): Promise<void> {
total.value = result.total total.value = result.total
if (result.page >= 1) page.value = result.page if (result.page >= 1) page.value = result.page
// 勾选跨页记忆(2026-11-17 用户口径「支持勾选翻页也要记住」):翻页/重取/改筛选都 // 勾选跨页记忆(2026-11-17 用户口径「支持勾选翻页也要记住」):翻页/重取/改筛选都
// 不清勾选集——批量编辑分类与批量删除都按累计 id 提交,操作前的确认弹窗点名数量, // 不清勾选集——批量编辑分类与批量删除都按累计 id 提交,操作前的确认弹窗点名数量;
// 工具栏「清除勾选」给显式的反悔出口。 // 「清除勾选」按钮同日用户口径删除,勾选只在批量操作成功后自动清。
} catch (error) { } catch (error) {
loadFailure.value = loadFailureMessage(error, '京东商品列表加载失败') loadFailure.value = loadFailureMessage(error, '京东商品列表加载失败')
showAdminFeedback(loadFailure.value, 'error') showAdminFeedback(loadFailure.value, 'error')
@@ -246,7 +285,8 @@ async function copyText(text: string): Promise<void> {
// ---------------- 删除(先删桶、全成功才删库行,语义在后端 JdProductDeleteService) ---------------- // ---------------- 删除(先删桶、全成功才删库行,语义在后端 JdProductDeleteService) ----------------
/** 勾选集(按商品 id,跨页累计记忆,2026-11-17 用户口径)。翻页/重取不清;显式出口 /** 勾选集(按商品 id,跨页累计记忆,2026-11-17 用户口径)。翻页/重取不清;显式出口
* 是工具栏「清除勾选」,批量删除/批量归类成功后自动清。 */ * 曾是工具栏「清除勾选」,同日用户口径「清除勾选这个按钮删除」后只剩批量删除/
* 批量归类成功后自动清。 */
const selectedIds = ref<Set<number>>(new Set()) const selectedIds = ref<Set<number>>(new Set())
const deleting = ref(false) const deleting = ref(false)
@@ -270,19 +310,14 @@ function toggleSelectAll(checked: boolean): void {
selectedIds.value = next selectedIds.value = next
} }
/** 显式清空勾选(跨页累计后用户需要一个看得见的反悔口)。 */
function clearSelection(): void {
selectedIds.value = new Set()
}
/** 单行删除入口(行内按钮):确认弹窗点名商品编码与「桶内图片一并删除」。 */ /** 单行删除入口(行内按钮):确认弹窗点名商品编码与「桶内图片一并删除」。 */
async function removeOne(row: JdProductItem): Promise<void> { async function removeOne(row: JdProductItem): Promise<void> {
await removeMany([row.id], `确定删除商品「${row.productCode || row.title}」吗?`) await removeMany([row.id], `确定删除商品「${row.productCode || row.title}」吗?`)
} }
/** 批量删除入口(工具栏按钮):按累计勾选 id 直删(跨页的行也在内),确认弹窗点名总数。 */ /** 批量删除入口(筛选行右侧按钮):按累计勾选 id 直删(跨页的行也在内),确认弹窗点名总数。 */
async function removeSelected(): Promise<void> { async function removeSelected(): Promise<void> {
await removeMany([...selectedIds.value], `确定删除勾选的 ${selectedIds.value.size} 个商品吗?`) await removeMany([...selectedIds.value], `确定批量删除选中的 ${selectedIds.value.size} 个商品吗?`)
} }
/** 删除主流程:二次确认 → 先删桶、全成功才删库行(后端保证)→ 刷新列表并清勾选。 */ /** 删除主流程:二次确认 → 先删桶、全成功才删库行(后端保证)→ 刷新列表并清勾选。 */
@@ -342,20 +377,26 @@ onMounted(async () => {
@change="onCategoryPicked" @change="onCategoryPicked"
/> />
</div> </div>
<div v-if="categoryScope.length" class="form-group"> <div v-if="canFilterGroup && categoryScope.length" class="form-group">
<label>分组</label> <label>分组</label>
<!-- 当前分组(V203):能看多组的人(平台超管/公司超管)下拉切换;只有一组时锁定显示组名。 <!-- 当前分组(V203):超管档(平台/公司超管)专属——2026-11-17 用户口径
「超管可以有分组筛选,管理员及以下则没有」,本控件对管理员及以下整块不渲染
(其分类面固定落在作用域默认分组)。能看多组的人下拉切换;只有一组时锁定显示组名。
2026-11-16 用户口径「做成分组」:从工具栏裸下拉上移进筛选行,做成带标签的表单控件 2026-11-16 用户口径「做成分组」:从工具栏裸下拉上移进筛选行,做成带标签的表单控件
(与其他筛选同壳同圆角)。分组是分类列/分类筛选/分类管理的作用域,不是筛选条件 (与其他筛选同壳同圆角)。2026-11-17 用户口径「和亚马逊不统一」:原生 <select> 的
⇒ 放在筛选行也只是占位,「重置」不清它(挂载测试钉住)。 --> 弹层是浏览器直角原生物,换 el-select(同亚马逊面 admin-filter 同壳),组多时可搜索。
<select 分组是分类列/分类筛选/分类管理的作用域,不是筛选条件 ⇒ 放在筛选行也只是占位,
「重置」不清它(挂载测试钉住)。 -->
<el-select
v-if="canSwitchGroup" v-if="canSwitchGroup"
:value="ownerGroupId" :model-value="ownerGroupId"
class="admin-filter"
filterable
aria-label="当前分组" aria-label="当前分组"
@change="changeOwnerGroup(Number(($event.target as HTMLSelectElement).value))" @change="changeOwnerGroup"
> >
<option v-for="group in categoryScope" :key="group.id" :value="group.id">{{ group.label }}</option> <el-option v-for="group in categoryScope" :key="group.id" :value="group.id" :label="group.label" />
</select> </el-select>
<span v-else class="jd-group-locked" title="你的数据权限内只有这一个分组">{{ currentGroupName }}</span> <span v-else class="jd-group-locked" title="你的数据权限内只有这一个分组">{{ currentGroupName }}</span>
</div> </div>
<div class="form-group"> <div class="form-group">
@@ -370,14 +411,12 @@ onMounted(async () => {
<button class="btn" type="button" @click="apply">查询</button> <button class="btn" type="button" @click="apply">查询</button>
<button class="btn btn-secondary" type="button" @click="reset">重置</button> <button class="btn btn-secondary" type="button" @click="reset">重置</button>
</div> </div>
</div> <!-- 批量动作条(2026-11-17 用户口径「共X条京东商品删掉,工具栏整体上移」):
原「汇总+工具栏」整行上移并入筛选行,与查询/重置同排;汇总数字删除。
<LoadFailureBar v-if="loadFailure" :message="loadFailure" @retry="load" /> 放不下的项随 .jd-filter-row 的 flex-wrap 自然折行。 -->
<div class="jd-toolbar">
<span class="jd-summary">共 {{ total }} 条京东商品</span>
<!-- 批量编辑分类(2026-11-17 用户口径「店铺分类弹窗删了,加个批量编辑分类」): <!-- 批量编辑分类(2026-11-17 用户口径「店铺分类弹窗删了,加个批量编辑分类」):
只对当前分组可写档(本组管理员/公司超管/平台超管)渲染;勾选 0 时置灰(与 只对当前分组可写档(本组管理员/公司超管/平台超管)渲染;勾选 0 时置灰(与
删除勾选同款常显口径),打开后按累计勾选(跨页)提交归入/移出。 --> 批量删除同款常显口径),打开后按累计勾选(跨页)提交归入/移出。 -->
<button <button
v-if="canManageCategories" v-if="canManageCategories"
class="btn btn-secondary" class="btn btn-secondary"
@@ -385,33 +424,63 @@ onMounted(async () => {
:disabled="!selectedCount" :disabled="!selectedCount"
@click="openBatchEdit" @click="openBatchEdit"
>批量编辑分类</button> >批量编辑分类</button>
<!-- 商品行写只对平台超管;分类写由当前分组 editable 决定(本组管理员/公司超管/平台超管)。 <!-- 商品行写对管理员级(超管+管理员)开放,普通账号看到只读提示;分类写由当前分组
非超管看到只读提示,分类维护入口指向「京东分类管理」子菜单页(同组普通号在那页只读查看)。 --> editable 决定(本组管理员/公司超管/平台超管),分类维护入口=「分类管理」
<span v-if="!isSuperAdmin" class="jd-readonly-tip">只读:编辑/删除仅超级管理员可用;分类由本组管理员在「京东分类管理」维护</span> (只读可看,写控件按 editable 分档)。 -->
<select v-model="filter.groupId" aria-label="筛选店铺分类" @change="apply"> <span v-if="!canWriteProducts" class="jd-readonly-tip">只读:编辑/删除需超级管理员或管理员;分类在本页「分类管理」查看与维护</span>
<option value="">全部分类</option> <!-- 分类筛选(2026-11-17 与分组同刀换 el-select,弹层圆角与亚马逊统一):保留显式
<option v-for="group in groupOptions" :key="group.id" :value="String(group.id)">{{ group.name }}</option> 「全部分类」行(value='',与旧原生下拉同语义——列表里永远有回全量的出口),
</select> 选中它/重置回 '' 时闭壳显示同文案占位。 -->
<!-- 清除勾选(2026-11-17 勾选跨页记忆的显式反悔口):只在有勾选时出现。 --> <el-select
v-model="filter.groupId"
class="admin-filter"
placeholder="全部分类"
aria-label="筛选店铺分类"
@change="apply"
>
<el-option label="全部分类" value="" />
<el-option v-for="group in groupOptions" :key="group.id" :label="group.name" :value="String(group.id)" />
</el-select>
<!-- 分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」+同日收敛
「默认卡在未分类上就行」;2026-11-18 用户口径「加个全部选项」恢复全量档):
已分类=当前分组下有分类(V203 归属表,与列表分类列同形——筛"未分类"的行
分类列必显示未分类);三档下拉、出厂默认仍卡「未分类」(11-17 口径不动),
「全部」(value='')选中即查当前分组全部商品(序列化不下发 classified 参数,
后端 required=false 跳过谓词);选中即查(回第一页);「重置」仍回未分类档。 -->
<el-select
v-model="filter.classified"
class="admin-filter"
placeholder="未分类"
aria-label="筛选分类状态"
@change="apply"
>
<el-option label="全部" value="" />
<el-option label="已分类" value="classified" />
<el-option label="未分类" value="ungrouped" />
</el-select>
<!-- 分类管理(2026-11-17 用户口径「京东分类管理并到京东数据库分类编辑里」):V204 独立
子菜单页整体并入本对话框(搜索+新建+改名+删除)。入口对所有人渲染(同组普通号
只读可看,V203),写控件由对话框按当前分组 editable 分档。 -->
<button <button
v-if="selectedCount" class="btn btn-secondary jd-manage-btn"
class="btn btn-secondary jd-clear-btn"
type="button" type="button"
@click="clearSelection" @click="openManage"
>清除勾选</button> >分类管理</button>
<!-- 批量删除 2026-11-16 客户口径「不要勾选后才显示」:常显,勾选 0 时置灰。 <!-- 批量删除 2026-11-16 客户口径「不要勾选后才显示」:常显,勾选 0 时置灰。
同日写权限收窄到超管:非超管整颗按钮不渲染(勾选列 2026-11-17 起对本组可写 写权限 2026-11-17 口径放宽到管理员级:普通账号整颗按钮不渲染(勾选列 2026-11-17
分类管理员开放,服务批量归类)。 --> 起对本组可写分类管理员开放,服务批量归类)。文案 2026-11-17 用户口径「删除勾选改成批量删除」。 -->
<button <button
v-if="isSuperAdmin" v-if="canWriteProducts"
class="btn btn-danger jd-delete-btn" class="btn btn-danger jd-delete-btn"
type="button" type="button"
:disabled="deleting || !selectedCount" :disabled="deleting || !selectedCount"
@click="removeSelected" @click="removeSelected"
> >
{{ deleting ? '删除中...' : `删除勾选(${selectedCount})` }} {{ deleting ? '删除中...' : `批量删除(${selectedCount})` }}
</button> </button>
</div> </div>
<LoadFailureBar v-if="loadFailure" :message="loadFailure" @retry="load" />
<div class="table-scroll jd-table-scroll"> <div class="table-scroll jd-table-scroll">
<table> <table>
<thead> <thead>
@@ -422,9 +491,10 @@ onMounted(async () => {
<th style="width: 76px">总库存</th> <th style="width: 76px">总库存</th>
<th style="width: 120px">价格</th> <th style="width: 120px">价格</th>
<!-- 同步时间收尾(创建/修改两列 2026-11-16 客户口径「不要」下线,仍收详情抽屉); <!-- 同步时间收尾(创建/修改两列 2026-11-16 客户口径「不要」下线,仍收详情抽屉);
操作列 2026-11-16「操作放最后一列」口径置末;同日写权限收窄到超管 ⇒ 非超管不渲染。 --> 操作列 2026-11-16「操作放最后一列」口径置末;写权限 2026-11-17 放宽到
管理员级 ⇒ 普通账号不渲染该列。 -->
<th style="width: 170px">同步时间</th> <th style="width: 170px">同步时间</th>
<th v-if="isSuperAdmin" style="width: 138px">操作</th> <th v-if="canWriteProducts" style="width: 138px">操作</th>
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
@@ -459,8 +529,8 @@ onMounted(async () => {
<td>{{ formatDateTime(row.syncedAt || '') }}</td> <td>{{ formatDateTime(row.syncedAt || '') }}</td>
<!-- 操作列(2026-11-15 用户口径):编辑/删除;@click.stop 防冒泡开详情抽屉。 <!-- 操作列(2026-11-15 用户口径):编辑/删除;@click.stop 防冒泡开详情抽屉。
2026-11-16「操作放最后一列」口径置末;「上架时间 / 商品状态」列同日整列下线; 2026-11-16「操作放最后一列」口径置末;「上架时间 / 商品状态」列同日整列下线;
同日写权限收窄到超管 ⇒ 非超管不渲染该列。 --> 写权限 2026-11-17 口径放宽到管理员级 ⇒ 普通账号不渲染该列。 -->
<td v-if="isSuperAdmin" class="jd-ops-cell" @click.stop> <td v-if="canWriteProducts" class="jd-ops-cell" @click.stop>
<button class="btn btn-sm" type="button" @click="openEdit(row)">编辑</button> <button class="btn btn-sm" type="button" @click="openEdit(row)">编辑</button>
<button class="btn btn-sm btn-danger" type="button" :disabled="deleting" @click="removeOne(row)">删除</button> <button class="btn btn-sm btn-danger" type="button" :disabled="deleting" @click="removeOne(row)">删除</button>
</td> </td>
@@ -488,6 +558,16 @@ onMounted(async () => {
@close="batchEditVisible = false" @close="batchEditVisible = false"
@done="onBatchAssigned" @done="onBatchAssigned"
/> />
<JdCategoryManageDialog
:visible="manageVisible"
:owner-group-id="ownerGroupId"
:owner-group-name="currentGroupName"
:editable="canManageCategories"
:platform-super-admin="scopeSuperAdmin"
@close="manageVisible = false"
@changed="onManaged"
@group-created="onGroupCreated"
/>
<JdProductDetailDrawer <JdProductDetailDrawer
:item="detailItem" :item="detailItem"
:visible="detailVisible" :visible="detailVisible"
@@ -62,8 +62,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -77,12 +76,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -125,54 +122,26 @@ h3 {
border-color: #95b1cb; border-color: #95b1cb;
background: #edf5fb; background: #edf5fb;
} }
.jd-toolbar { /* 批量动作条(2026-11-17 用户口径「汇总删掉、工具栏整体上移」):并入 .jd-filter-row
display: flex; 与查询/重置同排,不再有独立 .jd-toolbar 容器;放不下靠筛选行的 flex-wrap 折行。 */
align-items: center; /* 分类筛选/状态快筛下拉(2026-11-17 用户口径「和亚马逊不统一」起换 el-select):42px 外壳、
gap: 10px; 9px 圆角、#cbd9e6 描边、#f8fbfd 浅底与 focus ring 都由全局 .el-select.admin-filter
margin-bottom: 10px; 皮肤(main.css)出——与亚马逊面同一套,弹层不再是浏览器原生直角列表。
只钉动作条里的下拉位宽(admin-filter 出厂 width:100%,进 flex 行会横涨);
用直接子级选择器,别误伤「分组」表单组里嵌的同款下拉(那个跟 form-group 走宽)。 */
.jd-filter-row > .el-select.admin-filter {
width: 200px;
flex-shrink: 0;
} }
/* 工具栏里的下拉与按钮统一 42px 外壳(2026-11-16 用户口径「样式要统一」): /* 危险动作(批量删除)推到行尾:留在「批量编辑分类/分类筛选」旁边会被读成同一组动作。 */
这一行此前只有 .btn 有壳,原生 <select> 落成 28px 灰框、字号也不跟,
与旁边按钮同排时高矮不齐(分组下拉同日上移进筛选行,本行只剩分类筛选一颗)。
数值与 .form-group select / .btn 同一套(42px 高、
9px 圆角、#cbd9e6 描边、#f8fbfd 底),箭头用内联 SVG 自绘,避免各浏览器原生
箭头粗细不一(appearance:none 后必须补 padding-right 给箭头留位)。 */
.jd-toolbar select {
min-height: 42px;
max-width: 220px;
padding: 0 34px 0 12px;
border: 1px solid #cbd9e6;
border-radius: 9px;
background-color: #f8fbfd;
background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8'%3E%3Cpath d='M1 1.5 6 6.5 11 1.5' fill='none' stroke='%235b6f83' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
background-repeat: no-repeat;
background-position: right 12px center;
appearance: none;
-webkit-appearance: none;
color: #24384d;
font-family: inherit;
font-size: 13.5px;
cursor: pointer;
outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
}
.jd-toolbar select:hover {
border-color: #9fb7cd;
}
.jd-toolbar select:focus {
background-color: #ffffff;
border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
}
/* 危险动作(删除勾选)推到行尾:留在「批量编辑分类/分类筛选」旁边会被读成同一组动作。 */
.jd-delete-btn { .jd-delete-btn {
margin-left: auto; margin-left: auto;
} }
/* 清除勾选(勾选跨页记忆的显式反悔口):贴着删除勾选(同一组勾选管理动作)。 */ /* 分类管理(2026-11-17 独立分类管理页并入本页的对话框入口):贴着分类筛选下拉。 */
.jd-clear-btn { .jd-manage-btn {
margin-left: 6px; margin-left: 6px;
} }
/* 危险动作(删除勾选):与全站 .btn-danger 同形——实心红渐变+白字。 /* 危险动作(批量删除):与全站 .btn-danger 同形——实心红渐变+白字。
旧版是白底红字描边,落在工具栏里看着像「未激活的次要按钮」,与打卡/分组等页不统一。 */ 旧版是白底红字描边,落在工具栏里看着像「未激活的次要按钮」,与打卡/分组等页不统一。 */
.btn-danger { .btn-danger {
background: linear-gradient(135deg, #c06d77, #b35f6a); background: linear-gradient(135deg, #c06d77, #b35f6a);
@@ -182,19 +151,15 @@ h3 {
.btn-danger:hover:not(:disabled) { .btn-danger:hover:not(:disabled) {
background: linear-gradient(135deg, #cb7c84, #b96570); background: linear-gradient(135deg, #cb7c84, #b96570);
} }
.jd-summary { /* 非超管只读提示(2026-11-16 写权限收窄):动作条里的一句话说明,不冒充可点按钮。
color: #5b6f83; (汇总「共 X 条京东商品」2026-11-17 用户口径删除,.jd-summary 样式随之摘除。) */
font-size: 13px;
white-space: nowrap;
}
/* 非超管只读提示(2026-11-16 写权限收窄):紧跟汇总的一句话,不冒充可点按钮。 */
.jd-readonly-tip { .jd-readonly-tip {
color: #8293a5; color: #8293a5;
font-size: 12.5px; font-size: 12.5px;
white-space: nowrap; white-space: nowrap;
} }
/* 只有一个可见分组时锁定的组名(不可切):筛选行「分组」标签下的静态芯片(2026-11-16 用户口径 /* 只有一个可见分组时锁定的组名(不可切):筛选行「分组」标签下的静态芯片(2026-11-16 用户口径
「做成分组」把下拉从工具栏上移进筛选行后跟着搬),与同排 select 同高同壳(42px/9px 圆角), 「做成分组」把下拉从工具栏上移进筛选行后跟着搬),与同排 el-select 同高同壳(42px/9px 圆角),
"一组锁定"和"多组下拉"两种形态占位一致;组名超宽省略号收口,不把筛选行撑破。 */ "一组锁定"和"多组下拉"两种形态占位一致;组名超宽省略号收口,不把筛选行撑破。 */
.jd-group-locked { .jd-group-locked {
display: flex; display: flex;
@@ -29,6 +29,7 @@ export async function fetchJdProductList(
titleKeyword: params.titleKeyword ?? '', titleKeyword: params.titleKeyword ?? '',
category: params.category ?? '', category: params.category ?? '',
groupId: params.groupId ?? '', groupId: params.groupId ?? '',
classified: (params.classified ?? '') as '' | 'classified' | 'ungrouped',
syncedFrom: params.syncedFrom ?? '', syncedFrom: params.syncedFrom ?? '',
syncedTo: params.syncedTo ?? '', syncedTo: params.syncedTo ?? '',
}, },
@@ -19,6 +19,9 @@ export const JD_PRODUCT_PAGE_SIZE = 20
export const JD_PRODUCT_MAX_PAGE_SIZE = 100 export const JD_PRODUCT_MAX_PAGE_SIZE = 100
/** 页码上限:与后端 MAX_PAGE(CR-18 先例,外观专利同值)对齐,两侧不漂。 */ /** 页码上限:与后端 MAX_PAGE(CR-18 先例,外观专利同值)对齐,两侧不漂。 */
export const JD_PRODUCT_MAX_PAGE = 10_000 export const JD_PRODUCT_MAX_PAGE = 10_000
/** 分类状态快筛的出厂档位(2026-11-17 用户口径「不需要全部分类 默认卡在未分类上就行」):
* 首屏/重置都卡它;「筛选激活」判定也以「是否偏离它」为准。 */
export const JD_PRODUCT_DEFAULT_CLASSIFIED = 'ungrouped' as const
export interface JdProductFilterState { export interface JdProductFilterState {
/** 商品编码,空串不限。 */ /** 商品编码,空串不限。 */
@@ -29,6 +32,14 @@ export interface JdProductFilterState {
category: string category: string
/** 分组 id 文本(分组管理里那一行),空串=全部分组。 */ /** 分组 id 文本(分组管理里那一行),空串=全部分组。 */
groupId: string groupId: string
/** 分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」,同日定默认卡未分类;
* 2026-11-18 用户口径「加个全部选项」恢复全量档):'classified'=已分类(当前分组下有
* 分类),'ungrouped'=未分类,''=全部(当前分组下全部商品);**出厂默认仍='ungrouped'**
* (11-17 口径不动,首屏与「重置」都卡未分类档)。
* 语义按 V203 归属表(当前数据权限分组)判定,与列表分类列同形;不是 11-16 撤掉的
* 旧 grouped/ungrouped 参数(那两档读已停用的 biz_jd_product.group_id 列,后端仍拒收)。
* ''(全部档)序列化时不带 classified 参数=后端跳过谓词查全部;脏值同走该兜底。 */
classified?: '' | 'classified' | 'ungrouped'
/** 同步开始日期(ISO yyyy-MM-dd;空串不限)。 */ /** 同步开始日期(ISO yyyy-MM-dd;空串不限)。 */
syncedFrom: string syncedFrom: string
/** 同步结束日期(ISO yyyy-MM-dd;空串不限)。 */ /** 同步结束日期(ISO yyyy-MM-dd;空串不限)。 */
@@ -36,7 +47,9 @@ export interface JdProductFilterState {
} }
export function createJdProductFilterState(): JdProductFilterState { export function createJdProductFilterState(): JdProductFilterState {
return { productCode: '', titleKeyword: '', category: '', groupId: '', syncedFrom: '', syncedTo: '' } // 分类状态出厂卡「未分类」(2026-11-17 用户口径「默认卡在未分类上就行」,2026-11-18
// 加「全部」档后默认不动):首屏与「重置」都带 classified=false 查,全量走「全部」档。
return { productCode: '', titleKeyword: '', category: '', groupId: '', classified: JD_PRODUCT_DEFAULT_CLASSIFIED, syncedFrom: '', syncedTo: '' }
} }
/** 是否有任一激活筛选条件。 */ /** 是否有任一激活筛选条件。 */
@@ -45,6 +58,9 @@ export function jdProductFilterActive(state: JdProductFilterState): boolean {
if ((state.titleKeyword || '').trim()) return true if ((state.titleKeyword || '').trim()) return true
if ((state.category || '').trim()) return true if ((state.category || '').trim()) return true
if ((state.groupId || '').trim()) return true if ((state.groupId || '').trim()) return true
// 出厂默认本身卡未分类档(2026-11-17 用户口径),所以只有「偏离默认档」才算激活筛选,
// 否则首屏就永远处于"有筛选"状态,空结果提示会误导用户去重置一个没动过的筛选。
if (state.classified && state.classified !== JD_PRODUCT_DEFAULT_CLASSIFIED) return true
if (validIsoDateOrUndefined(state.syncedFrom) || validIsoDateOrUndefined(state.syncedTo)) return true if (validIsoDateOrUndefined(state.syncedFrom) || validIsoDateOrUndefined(state.syncedTo)) return true
return false return false
} }
@@ -59,6 +75,9 @@ export interface JdProductQuery {
category?: string category?: string
/** 自定义分类 id(当前分组下的一个分类;V203 起按归属表 EXISTS 过滤)。 */ /** 自定义分类 id(当前分组下的一个分类;V203 起按归属表 EXISTS 过滤)。 */
group_id?: number group_id?: number
/** 分类状态快筛(2026-11-17):true=已分类、false=未分类,缺省不下发=全部。
* 后端按「当前分组」(owner_group_id)的归属表 EXISTS/NOT EXISTS 在 SQL 侧下推。 */
classified?: boolean
/** 当前数据权限分组 id(分类列/分类筛选都按它取;V203「不同组不能看到跨组的分类」)。 */ /** 当前数据权限分组 id(分类列/分类筛选都按它取;V203「不同组不能看到跨组的分类」)。 */
owner_group_id?: number owner_group_id?: number
synced_from?: string synced_from?: string
@@ -73,6 +92,8 @@ export interface JdProductListParams {
titleKeyword?: string titleKeyword?: string
category?: string category?: string
groupId?: string groupId?: string
/** 分类状态快筛(''/缺省=全部,'classified'/'ungrouped' 见 JdProductFilterState)。 */
classified?: string
/** 当前分组(数据权限分组 id):分类列/分类筛选的作用域,非筛选条件(重置不清它)。 */ /** 当前分组(数据权限分组 id):分类列/分类筛选的作用域,非筛选条件(重置不清它)。 */
ownerGroupId?: number | null ownerGroupId?: number | null
syncedFrom?: string syncedFrom?: string
@@ -90,6 +111,10 @@ function toJdProductFilterQuery(state: JdProductFilterState): Omit<JdProductQuer
if (category) query.category = category if (category) query.category = category
const groupId = Number.parseInt((state.groupId || '').trim(), 10) const groupId = Number.parseInt((state.groupId || '').trim(), 10)
if (Number.isFinite(groupId) && groupId > 0) query.group_id = groupId if (Number.isFinite(groupId) && groupId > 0) query.group_id = groupId
// 分类状态快筛:只认两个显式档位,其余值(含脏值)按「全部」不下发——后端 classified
// 只收 true/false/缺省,不拿脏值冒充档位。
if (state.classified === 'classified') query.classified = true
else if (state.classified === 'ungrouped') query.classified = false
const syncedFrom = validIsoDateOrUndefined(state.syncedFrom) const syncedFrom = validIsoDateOrUndefined(state.syncedFrom)
if (syncedFrom) query.synced_from = syncedFrom if (syncedFrom) query.synced_from = syncedFrom
const syncedTo = validIsoDateOrUndefined(state.syncedTo) const syncedTo = validIsoDateOrUndefined(state.syncedTo)
@@ -170,18 +170,22 @@ onMounted(() => {
</div> </div>
<div class="form-group"> <div class="form-group">
<label>国家</label> <label>国家</label>
<select v-model="filter.country"> <!-- 下拉 2026-11-17 用户口径「和亚马逊不统一」:原生 <select> 的弹层是浏览器直角
<option value="">全部国家</option> 原生物 ⇒ 换 el-select(admin-filter 同壳 42px/9px,弹层 EP 圆角面板)。
<option v-for="code in ASIN_COUNTRY_CODES" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> 「全部国家」保留为空值首行(与旧原生下拉同语义,查询参数仍是空串)。 -->
</select> <el-select v-model="filter.country" class="admin-filter" aria-label="筛选国家">
<el-option label="全部国家" value="" />
<el-option v-for="code in ASIN_COUNTRY_CODES" :key="code" :label="asinCountryLabel(code)" :value="code" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>分组</label> <label>分组</label>
<!-- 分组(主管)选中即查:选完立刻按该主管过滤刷新(回第一页),不必再点查询。 --> <!-- 分组(主管)选中即查:选完立刻按该主管过滤刷新(回第一页),不必再点查询。
<select v-model="filter.groupId" @change="apply"> value 保持字符串形状(下游按字符串比对/透传)。 -->
<option value="">全部分组</option> <el-select v-model="filter.groupId" class="admin-filter" aria-label="筛选分组" @change="apply">
<option v-for="group in groupOptions" :key="group.id" :value="String(group.id)">{{ group.name }}</option> <el-option label="全部分组" value="" />
</select> <el-option v-for="group in groupOptions" :key="group.id" :label="group.name" :value="String(group.id)" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>同步开始日期</label> <label>同步开始日期</label>
@@ -306,8 +310,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -321,12 +324,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -221,6 +221,11 @@ function modeLabel(mode: string): string {
return mode === 'selected' ? '精选' : '全量' return mode === 'selected' ? '精选' : '全量'
} }
/** 终端覆盖下拉的显示文案(el-option 需要显式 label,文案与旧原生 <option> 逐字一致)。 */
function deviceOptionLabel(device: DeviceLogDevice): string {
return `${sourceLabel(device.source)} · ${device.deviceName || device.deviceId}(${device.deviceId})`
}
async function openConfig() { async function openConfig() {
configVisible.value = true configVisible.value = true
await loadConfig() await loadConfig()
@@ -301,16 +306,20 @@ onMounted(() => {
<div class="form-row logs-filter-row"> <div class="form-row logs-filter-row">
<div class="form-group" style="min-width: 150px"> <div class="form-group" style="min-width: 150px">
<label>来源</label> <label>来源</label>
<select v-model="sourceFilter"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option v-for="option in SOURCE_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> 「全部来源」保留为空值首行(value 语义不变,查询参数仍是空串)。 -->
</select> <el-select v-model="sourceFilter" class="admin-filter" aria-label="来源">
<el-option v-for="option in SOURCE_OPTIONS" :key="option.value" :label="option.label" :value="option.value" />
</el-select>
</div> </div>
<div class="form-group" style="min-width: 180px"> <div class="form-group" style="min-width: 180px">
<label>指定用户</label> <label>指定用户</label>
<select v-model="uidFilter" :disabled="usersLoading"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option value="">全部用户</option> 「全部用户」保留为空值首行;用户值仍是 String(id)(下游按字符串判空、落库前再转数字)。 -->
<option v-for="u in userOptions" :key="u.id" :value="String(u.id)">{{ u.username }}</option> <el-select v-model="uidFilter" class="admin-filter" filterable aria-label="指定用户" :disabled="usersLoading">
</select> <el-option label="全部用户" value="" />
<el-option v-for="u in userOptions" :key="u.id" :label="u.username" :value="String(u.id)" />
</el-select>
</div> </div>
<div class="form-group" style="min-width: 150px"> <div class="form-group" style="min-width: 150px">
<label>日志日期(起)</label> <label>日志日期(起)</label>
@@ -425,15 +434,21 @@ onMounted(() => {
<div class="config-block"> <div class="config-block">
<h4>终端覆盖</h4> <h4>终端覆盖</h4>
<div class="override-add"> <div class="override-add">
<select v-model="newOverrideKey" class="override-select"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option value="">选择终端(最近上报的设备)</option> value 仍是 `${source}|${deviceId}` 与 'full'/'selected' 常量,逐字保留(addOverride
<option v-for="device in devices" :key="`${device.source}|${device.deviceId}`" :value="`${device.source}|${device.deviceId}`"> 按 '|' 切分、后端按 mode 常量解析,值形状一动就错单)。 -->
{{ sourceLabel(device.source) }} · {{ device.deviceName || device.deviceId }}({{ device.deviceId }}) <el-select v-model="newOverrideKey" class="admin-filter override-select" filterable aria-label="选择终端">
</option> <el-option label="选择终端(最近上报的设备)" value="" />
</select> <el-option
<select v-model="newOverrideMode"> v-for="device in devices"
<option v-for="option in MODE_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> :key="`${device.source}|${device.deviceId}`"
</select> :label="deviceOptionLabel(device)"
:value="`${device.source}|${device.deviceId}`"
/>
</el-select>
<el-select v-model="newOverrideMode" class="admin-filter override-mode" aria-label="覆盖模式">
<el-option v-for="option in MODE_OPTIONS" :key="option.value" :label="option.label" :value="option.value" />
</el-select>
<button class="btn btn-sm" type="button" @click="addOverride">添加/更新覆盖</button> <button class="btn btn-sm" type="button" @click="addOverride">添加/更新覆盖</button>
</div> </div>
<table class="override-table"> <table class="override-table">
@@ -529,8 +544,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -543,8 +557,7 @@ h3 {
color-scheme: light; color-scheme: light;
outline: none; outline: none;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -743,21 +756,15 @@ td {
gap: 10px; gap: 10px;
margin-bottom: 12px; margin-bottom: 12px;
} }
.override-add select { /* 只管布局:外壳皮肤(42px/9 圆角/#f8fbfd/focus ring)由全局 .admin-filter 提供,
min-height: 38px; 这里不再重复描边(旧 `.override-add select` 那段原生下拉皮肤已随 el-select 删除)。 */
padding: 6px 10px;
border: 1px solid #cbd9e6;
border-radius: 9px;
background: #f8fbfd;
color: #24384d;
font-size: 13px;
font-family: inherit;
color-scheme: light;
}
.override-select { .override-select {
flex: 1; flex: 1;
min-width: 0; min-width: 0;
} }
.override-mode {
flex: 0 0 140px;
}
.override-table td { .override-table td {
vertical-align: middle; vertical-align: middle;
} }
@@ -146,10 +146,12 @@ onMounted(() => {
<div class="form-row"> <div class="form-row">
<div class="form-group" style="min-width: 150px"> <div class="form-group" style="min-width: 150px">
<label>指定用户</label> <label>指定用户</label>
<select v-model="filter.userId" :disabled="userLoading"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option value="">全部用户</option> 「全部用户」保留为空值首行;用户值仍是 String(id)(查询前再 Number() 转数字)。 -->
<option v-for="u in userOptions" :key="u.id" :value="String(u.id)">{{ u.username }}</option> <el-select v-model="filter.userId" class="admin-filter" filterable aria-label="指定用户" :disabled="userLoading">
</select> <el-option label="全部用户" value="" />
<el-option v-for="u in userOptions" :key="u.id" :label="u.username" :value="String(u.id)" />
</el-select>
</div> </div>
<div class="form-group" style="min-width: 176px"> <div class="form-group" style="min-width: 176px">
<label>开始时间</label> <label>开始时间</label>
@@ -294,8 +296,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -309,12 +310,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -379,17 +379,19 @@ onUnmounted(() => {
<label>账号</label> <label>账号</label>
<input v-model="filter.username" type="text" placeholder="模糊搜索账号名" @keyup.enter="search" /> <input v-model="filter.username" type="text" placeholder="模糊搜索账号名" @keyup.enter="search" />
</div> </div>
<!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select
(与下方店铺筛选同形,挂全局 admin-filter 皮肤)。 -->
<div class="form-group" style="min-width: 150px"> <div class="form-group" style="min-width: 150px">
<label>业务</label> <label>业务</label>
<select v-model="filter.moduleType"> <el-select v-model="filter.moduleType" class="admin-filter" aria-label="筛选业务">
<option v-for="option in MODULE_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> <el-option v-for="option in MODULE_OPTIONS" :key="option.value" :value="option.value" :label="option.label" />
</select> </el-select>
</div> </div>
<div class="form-group" style="min-width: 130px"> <div class="form-group" style="min-width: 130px">
<label>状态</label> <label>状态</label>
<select v-model="filter.status"> <el-select v-model="filter.status" class="admin-filter" aria-label="筛选任务状态">
<option v-for="option in TASK_STATUS_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> <el-option v-for="option in TASK_STATUS_OPTIONS" :key="option.value" :value="option.value" :label="option.label" />
</select> </el-select>
</div> </div>
<div class="form-group shop-filter"> <div class="form-group shop-filter">
<label>店铺</label> <label>店铺</label>
@@ -447,9 +449,11 @@ onUnmounted(() => {
<div class="form-row"> <div class="form-row">
<div class="form-group" style="min-width: 150px"> <div class="form-group" style="min-width: 150px">
<label>状态</label> <label>状态</label>
<select v-model="variantFilter.status"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option v-for="option in VARIANT_STATUS_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option> value 原样透传('0'~'3' 是字符串,后端按值比对)。 -->
</select> <el-select v-model="variantFilter.status" class="admin-filter" aria-label="筛选变体状态">
<el-option v-for="option in VARIANT_STATUS_OPTIONS" :key="option.value" :value="option.value" :label="option.label" />
</el-select>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>&nbsp;</label> <label>&nbsp;</label>
@@ -689,8 +693,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -703,8 +706,7 @@ h3 {
color-scheme: light; color-scheme: light;
outline: none; outline: none;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
@@ -253,15 +253,16 @@ onMounted(() => {
</label> </label>
<label class="g-field"> <label class="g-field">
<span>国家</span> <span>国家</span>
<select v-model="form.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。 -->
<option v-for="country in GATING_COUNTRIES" :key="country" :value="country">{{ country }}</option> <el-select v-model="form.country" class="admin-filter" aria-label="表单国家">
</select> <el-option v-for="country in GATING_COUNTRIES" :key="country" :value="country" :label="country" />
</el-select>
</label> </label>
<label class="g-field"> <label class="g-field">
<span>类型</span> <span>类型</span>
<select v-model="form.gatingType"> <el-select v-model="form.gatingType" class="admin-filter" aria-label="表单类型">
<option v-for="type in typeOptions" :key="type" :value="type">{{ type }}</option> <el-option v-for="type in typeOptions" :key="type" :value="type" :label="type" />
</select> </el-select>
</label> </label>
<label class="g-field"> <label class="g-field">
<span>ASIN</span> <span>ASIN</span>
@@ -302,23 +303,25 @@ onMounted(() => {
<div class="g-panel-body"> <div class="g-panel-body">
<div class="g-filters"> <div class="g-filters">
<input v-model="filter.keyword" placeholder="搜索品牌 / ASIN" @keyup.enter="query" /> <input v-model="filter.keyword" placeholder="搜索品牌 / ASIN" @keyup.enter="query" />
<select v-model="filter.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option value="">全部国家</option> 「全部 XX」空值行保留、status 的 '1'/'0' 仍是字符串(后端按值比对)。 -->
<option v-for="country in countryOptions" :key="country" :value="country">{{ country }}</option> <el-select v-model="filter.country" class="admin-filter" style="width: 132px" aria-label="筛选国家">
</select> <el-option value="" label="全部国家" />
<select v-model="filter.gatingType"> <el-option v-for="country in countryOptions" :key="country" :value="country" :label="country" />
<option value="">全部类型</option> </el-select>
<option v-for="type in typeOptions" :key="type" :value="type">{{ type }}</option> <el-select v-model="filter.gatingType" class="admin-filter" style="width: 132px" aria-label="筛选类型">
</select> <el-option value="" label="全部类型" />
<select v-model="filter.status"> <el-option v-for="type in typeOptions" :key="type" :value="type" :label="type" />
<option value="">全部状态</option> </el-select>
<option value="1">生效</option> <el-select v-model="filter.status" class="admin-filter" style="width: 132px" aria-label="筛选状态">
<option value="0">已解除</option> <el-option value="" label="全部状态" />
</select> <el-option value="1" label="生效" />
<select v-model="filter.source"> <el-option value="0" label="已解除" />
<option value="">全部来源</option> </el-select>
<option v-for="source in GATING_SOURCES" :key="source" :value="source">{{ sourceText(source) }}</option> <el-select v-model="filter.source" class="admin-filter" style="width: 132px" aria-label="筛选来源">
</select> <el-option value="" label="全部来源" />
<el-option v-for="source in GATING_SOURCES" :key="source" :value="source" :label="sourceText(source)" />
</el-select>
<button class="g-btn g-btn-primary" type="button" @click="query">查询</button> <button class="g-btn g-btn-primary" type="button" @click="query">查询</button>
<button class="g-btn g-btn-ghost" type="button" @click="resetFilter">重置</button> <button class="g-btn g-btn-ghost" type="button" @click="resetFilter">重置</button>
</div> </div>
@@ -522,10 +525,9 @@ onMounted(() => {
.g-field-wide { .g-field-wide {
grid-column: span 2; grid-column: span 2;
} }
/* 下拉已换 el-select(2026-11-17)⇒ 皮肤走全局 .admin-filter,这里只留原生输入框。 */
.g-field input, .g-field input,
.g-field select, .g-filters input {
.g-filters input,
.g-filters select {
width: 100%; width: 100%;
height: 34px; height: 34px;
padding: 0 10px; padding: 0 10px;
@@ -538,13 +540,28 @@ onMounted(() => {
outline: none; outline: none;
} }
.g-field input:focus, .g-field input:focus,
.g-field select:focus, .g-filters input:focus {
.g-filters input:focus,
.g-filters select:focus {
border-color: var(--g-primary); border-color: var(--g-primary);
box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12); box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12);
background: #fff; background: #fff;
} }
/* 本页表单/筛选行是 34px 紧凑档(输入框与 `.g-btn` 同为 34px、7px 圆角、蓝色 focus)。
新换的 el-select 若照全局 admin-filter(42px/9px/蓝灰 ring)会在同一行里高出一截,
与旁边的输入框错位 ⇒ 在本页把壳压回本地档位(scoped 下 :deep 穿透 EP 内部结构)。 */
.g-field :deep(.el-select__wrapper),
.g-filters :deep(.el-select__wrapper) {
min-height: 34px;
padding: 0 10px;
border-radius: 7px;
background: #fbfcfe;
box-shadow: 0 0 0 1px #d7dce5 inset;
font-size: 13px;
}
.g-field :deep(.el-select__wrapper.is-focused),
.g-filters :deep(.el-select__wrapper.is-focused) {
background: #fff;
box-shadow: 0 0 0 1px var(--g-primary) inset, 0 0 0 3px rgba(46, 91, 230, 0.12);
}
.g-form-actions { .g-form-actions {
display: flex; display: flex;
justify-content: flex-end; justify-content: flex-end;
@@ -580,9 +597,6 @@ onMounted(() => {
.g-filters input { .g-filters input {
width: 190px; width: 190px;
} }
.g-filters select {
width: 132px;
}
.g-btn { .g-btn {
height: 34px; height: 34px;
@@ -447,24 +447,26 @@ onMounted(() => {
</div> </div>
<div class="f-group"> <div class="f-group">
<label>店铺</label> <label>店铺</label>
<select v-model="filter.shop"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
<option value="">全部店铺</option> 「全部 XX」空值行保留,候选值原样透传。 -->
<option v-for="shop in orderedShops" :key="shop.shopName" :value="shop.shopName">{{ shop.shopName }}</option> <el-select v-model="filter.shop" class="admin-filter" filterable style="width: 150px" aria-label="筛选店铺">
</select> <el-option value="" label="全部店铺" />
<el-option v-for="shop in orderedShops" :key="shop.shopName" :value="shop.shopName" :label="shop.shopName" />
</el-select>
</div> </div>
<div v-if="isSuper" class="f-group"> <div v-if="isSuper" class="f-group">
<label>分组</label> <label>分组</label>
<select v-model="filter.group"> <el-select v-model="filter.group" class="admin-filter" filterable style="width: 150px" aria-label="筛选分组">
<option value="">全部分组</option> <el-option value="" label="全部分组" />
<option v-for="group in groupStats" :key="group.name" :value="group.name">{{ group.name }}</option> <el-option v-for="group in groupStats" :key="group.name" :value="group.name" :label="group.name" />
</select> </el-select>
</div> </div>
<div class="f-group"> <div class="f-group">
<label>国家 / 站点</label> <label>国家 / 站点</label>
<select v-model="filter.country"> <el-select v-model="filter.country" class="admin-filter" style="width: 150px" aria-label="筛选国家">
<option value="">全部国家</option> <el-option value="" label="全部国家" />
<option v-for="code in countryOptions" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> <el-option v-for="code in countryOptions" :key="code" :value="code" :label="asinCountryLabel(code)" />
</select> </el-select>
</div> </div>
<div class="f-group"> <div class="f-group">
<label>上架时间开始</label> <label>上架时间开始</label>
@@ -774,7 +776,8 @@ onMounted(() => {
.dup-ref .mono { font-family: var(--mono); } .dup-ref .mono { font-family: var(--mono); }
.dup-ref button { font-family: inherit; cursor: pointer; border: none; background: none; color: inherit; } .dup-ref button { font-family: inherit; cursor: pointer; border: none; background: none; color: inherit; }
.dup-ref button:disabled { opacity: 0.55; cursor: not-allowed; } .dup-ref button:disabled { opacity: 0.55; cursor: not-allowed; }
.dup-ref input, .dup-ref select { font-family: inherit; font-size: 13px; color: var(--text); } /* 原生 select 已换 el-select(2026-11-17)⇒ 选择器里不再列 select。 */
.dup-ref input { font-family: inherit; font-size: 13px; color: var(--text); }
.dup-ref a { color: var(--primary); text-decoration: none; } .dup-ref a { color: var(--primary); text-decoration: none; }
.dup-ref .dim-cell { color: var(--text3); } .dup-ref .dim-cell { color: var(--text3); }
.dup-ref .num-cell { font-variant-numeric: tabular-nums; } .dup-ref .num-cell { font-variant-numeric: tabular-nums; }
@@ -801,14 +804,27 @@ onMounted(() => {
.dup-ref .filter-row { display: flex; align-items: flex-end; gap: 14px; flex-wrap: wrap; } .dup-ref .filter-row { display: flex; align-items: flex-end; gap: 14px; flex-wrap: wrap; }
.dup-ref .f-group { display: flex; flex-direction: column; gap: 6px; } .dup-ref .f-group { display: flex; flex-direction: column; gap: 6px; }
.dup-ref .f-group label { font-size: 12px; color: var(--text2); } .dup-ref .f-group label { font-size: 12px; color: var(--text2); }
.dup-ref .f-group input, .dup-ref .f-group select { /* 下拉已换 el-select(2026-11-17)⇒ 皮肤走全局 .admin-filter。
本页 style 块不是 scoped,`.f-group input` 会连带命中 el-select 内层的
`input.el-select__input`(EP 自己的边框/背景会被这套规则压掉,控件变成框里套框)
⇒ 必须显式排除。 */
.dup-ref .f-group input:not(.el-select__input) {
width: 170px;
height: 34px; border: 1px solid var(--border-strong); border-radius: 7px; padding: 0 10px; background: #FBFCFE; outline: none; height: 34px; border: 1px solid var(--border-strong); border-radius: 7px; padding: 0 10px; background: #FBFCFE; outline: none;
transition: border-color 0.15s, box-shadow 0.15s; transition: border-color 0.15s, box-shadow 0.15s;
} }
.dup-ref .f-group input:focus, .dup-ref .f-group select:focus { border-color: var(--primary); box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12); background: #fff; } .dup-ref .f-group input:not(.el-select__input):focus { border-color: var(--primary); box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12); background: #fff; }
.dup-ref .f-group input { width: 170px; }
.dup-ref .f-group select { width: 150px; cursor: pointer; }
.dup-ref .f-group input[type="date"] { width: 150px; } .dup-ref .f-group input[type="date"] { width: 150px; }
/* 本页筛选行是 34px 紧凑档(输入框与 `.btn` 同为 34px、7px 圆角、蓝色 focus)。
新换的 el-select 若照全局 admin-filter(42px/9px/蓝灰 ring)会与同行输入框错位
⇒ 在本页把壳压回本地档位;本页 style 不 scoped,EP 内部结构可直接选中。 */
.dup-ref .f-group .el-select__wrapper {
min-height: 34px; padding: 0 10px; border-radius: 7px;
background: #FBFCFE; box-shadow: 0 0 0 1px var(--border-strong) inset; font-size: 13px;
}
.dup-ref .f-group .el-select__wrapper.is-focused {
background: #fff; box-shadow: 0 0 0 1px var(--primary) inset, 0 0 0 3px rgba(46, 91, 230, 0.12);
}
.dup-ref .btn { .dup-ref .btn {
height: 34px; border-radius: 7px; padding: 0 16px; font-size: 13px; font-weight: 600; height: 34px; border-radius: 7px; padding: 0 16px; font-size: 13px; font-weight: 600;
display: inline-flex; align-items: center; gap: 6px; transition: background 0.15s, color 0.15s, border-color 0.15s; display: inline-flex; align-items: center; gap: 6px; transition: background 0.15s, color 0.15s, border-color 0.15s;
@@ -185,19 +185,21 @@ onMounted(() => {
<div class="kw-panel-head">筛选条件</div> <div class="kw-panel-head">筛选条件</div>
<div class="kw-panel-body"> <div class="kw-panel-body">
<div class="kw-filters"> <div class="kw-filters">
<!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。
「全部 XX」空值行保留。 -->
<label class="kw-field"> <label class="kw-field">
<span>使用者</span> <span>使用者</span>
<select v-model="filter.user"> <el-select v-model="filter.user" class="admin-filter" filterable aria-label="筛选使用者">
<option value="">全部使用者</option> <el-option value="" label="全部使用者" />
<option v-for="user in userOptions" :key="user" :value="user">{{ user }}</option> <el-option v-for="user in userOptions" :key="user" :value="user" :label="user" />
</select> </el-select>
</label> </label>
<label class="kw-field"> <label class="kw-field">
<span>国家</span> <span>国家</span>
<select v-model="filter.country"> <el-select v-model="filter.country" class="admin-filter" aria-label="筛选国家">
<option value="">全部国家</option> <el-option value="" label="全部国家" />
<option v-for="country in countryOptions" :key="country" :value="country">{{ country }}</option> <el-option v-for="country in countryOptions" :key="country" :value="country" :label="country" />
</select> </el-select>
</label> </label>
<label class="kw-field kw-field-wide"> <label class="kw-field kw-field-wide">
<span>关键词</span> <span>关键词</span>
@@ -205,10 +207,10 @@ onMounted(() => {
</label> </label>
<label class="kw-field"> <label class="kw-field">
<span>场景</span> <span>场景</span>
<select v-model="filter.scene"> <el-select v-model="filter.scene" class="admin-filter" aria-label="筛选场景">
<option value="">全部场景</option> <el-option value="" label="全部场景" />
<option v-for="scene in KEYWORD_USAGE_SCENES" :key="scene" :value="scene">{{ scene }}</option> <el-option v-for="scene in KEYWORD_USAGE_SCENES" :key="scene" :value="scene" :label="scene" />
</select> </el-select>
</label> </label>
<div class="kw-actions"> <div class="kw-actions">
<button class="kw-btn kw-btn-primary" type="button" @click="query">查询</button> <button class="kw-btn kw-btn-primary" type="button" @click="query">查询</button>
@@ -405,8 +407,8 @@ onMounted(() => {
font-size: 12px; font-size: 12px;
color: #5a6474; color: #5a6474;
} }
.kw-field input, /* 下拉已换 el-select(2026-11-17)⇒ 皮肤走全局 .admin-filter,这里只留原生输入框。 */
.kw-field select { .kw-field input {
height: 34px; height: 34px;
padding: 0 10px; padding: 0 10px;
border: 1px solid #d7dce5; border: 1px solid #d7dce5;
@@ -417,12 +419,26 @@ onMounted(() => {
font-size: 13px; font-size: 13px;
outline: none; outline: none;
} }
.kw-field input:focus, .kw-field input:focus {
.kw-field select:focus {
border-color: #2e5be6; border-color: #2e5be6;
box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12); box-shadow: 0 0 0 3px rgba(46, 91, 230, 0.12);
background: #fff; background: #fff;
} }
/* 本页筛选行是 34px 紧凑档(关键词输入框 34px、7px 圆角、蓝色 focus)。
新换的 el-select 若照全局 admin-filter(42px/9px/蓝灰 ring)会与同行输入框错位
⇒ 在本页把壳压回本地档位(scoped 下 :deep 穿透 EP 内部结构)。 */
.kw-field :deep(.el-select__wrapper) {
min-height: 34px;
padding: 0 10px;
border-radius: 7px;
background: #fbfcfe;
box-shadow: 0 0 0 1px #d7dce5 inset;
font-size: 13px;
}
.kw-field :deep(.el-select__wrapper.is-focused) {
background: #fff;
box-shadow: 0 0 0 1px #2e5be6 inset, 0 0 0 3px rgba(46, 91, 230, 0.12);
}
.kw-actions { .kw-actions {
display: flex; display: flex;
gap: 8px; gap: 8px;
@@ -334,10 +334,11 @@ onMounted(load)
</div> </div>
<div class="form-group" style="min-width: 130px"> <div class="form-group" style="min-width: 130px">
<label>国家</label> <label>国家</label>
<select v-model="filter.country"> <!-- 2026-11-17 用户口径「和亚马逊不统一」:原生 select 弹层是直角原生物,换 el-select。 -->
<option value="">全部</option> <el-select v-model="filter.country" class="admin-filter" aria-label="筛选国家">
<option v-for="code in ['UK', 'DE', 'FR', 'ES', 'IT']" :key="code" :value="code">{{ asinCountryLabel(code) }}</option> <el-option value="" label="全部" />
</select> <el-option v-for="code in ['UK', 'DE', 'FR', 'ES', 'IT']" :key="code" :value="code" :label="asinCountryLabel(code)" />
</el-select>
</div> </div>
<div class="form-group" style="min-width: 176px"> <div class="form-group" style="min-width: 176px">
<label>创建开始</label> <label>创建开始</label>
@@ -510,8 +511,7 @@ h3 {
font-size: 12.5px; font-size: 12.5px;
font-weight: 600; font-weight: 600;
} }
.form-group input, .form-group input {
.form-group select {
min-width: 0; min-width: 0;
min-height: 42px; min-height: 42px;
padding: 8px 12px; padding: 8px 12px;
@@ -525,12 +525,10 @@ h3 {
outline: none; outline: none;
transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease; transition: border-color 160ms ease, box-shadow 160ms ease, background 160ms ease;
} }
.form-group input:hover, .form-group input:hover {
.form-group select:hover {
border-color: #9fb7cd; border-color: #9fb7cd;
} }
.form-group input:focus, .form-group input:focus {
.form-group select:focus {
background: #ffffff; background: #ffffff;
border-color: #5f85ad; border-color: #5f85ad;
box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16); box-shadow: 0 0 0 3px rgba(95, 133, 173, 0.16);
+3 -3
View File
@@ -45,10 +45,10 @@ export const adminPages: AdminPageDef[] = [
{ path: 'asin-center/skip-price', menuKey: 'admin_skip_price_asin', title: '最低价ASIN', companyScoped: true, load: () => import('@/pages/asin/SkipPricePage.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') }, { path: 'patent-center/clean-items', menuKey: 'admin_appearance_patent_clean_items', title: '外观专利数据库', companyScoped: true, load: () => import('@/pages/patent/AppearancePatentCleanItemsPage.vue') },
// 京东数据库 2026-11-16 退出公司 tab(参考品牌数据库先例):数据全平台公共,不按公司取数。 // 京东数据库 2026-11-16 退出公司 tab(参考品牌数据库先例):数据全平台公共,不按公司取数。
// 2026-11-17 第二刀:V204 独立「京东分类管理」子菜单页(jd-center/categories)整体并入
// 本页工具栏「分类管理」对话框(JdCategoryManageDialog),路由与菜单行(V208 删 V204 行)
// 一并下线——用户口径「京东分类管理并到京东数据库分类编辑里」。
{ path: 'jd-center/database', menuKey: 'admin_jd_database', title: '京东数据库', companyScoped: false, load: () => import('@/pages/jd/JdDatabasePage.vue') }, { path: 'jd-center/database', menuKey: 'admin_jd_database', title: '京东数据库', companyScoped: false, load: () => import('@/pages/jd/JdDatabasePage.vue') },
// 京东分类管理 2026-11-17(用户口径「店铺分类弹窗下线,加个京东分类管理的子菜单维护 CRUD」):
// 分类建/改名/删除独立成页(V204 菜单行同 key),归类在京东数据库页「批量编辑分类」。
{ path: 'jd-center/categories', menuKey: 'admin_jd_category_manage', title: '京东分类管理', companyScoped: false, load: () => import('@/pages/jd/JdCategoryManagerPage.vue') },
] ]
export function routeOf(page: AdminPageDef): RouteRecordRaw { export function routeOf(page: AdminPageDef): RouteRecordRaw {
+40 -4
View File
@@ -2,6 +2,8 @@ import { defineStore } from 'pinia'
import { fetchCompanies } from '@/api/companies' import { fetchCompanies } from '@/api/companies'
import type { CompanyItem } from '@/api/companies-dto' import type { CompanyItem } from '@/api/companies-dto'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { usePlatformTabStore } from '@/stores/platform-tab'
import type { PlatformTabId } from '@/config/platform-scope'
import { firstSelectableCompanyId, companyIdForRequest } from '@/layout/company-tab-model' import { firstSelectableCompanyId, companyIdForRequest } from '@/layout/company-tab-model'
/** 公司 tab 的状态。成员 user ids **不在这里缓存**——每次请求交后端解析, /** 公司 tab 的状态。成员 user ids **不在这里缓存**——每次请求交后端解析,
@@ -12,6 +14,11 @@ export const useCompanyTabStore = defineStore('company-tab', {
activeId: null as number | null, activeId: null as number | null,
loading: false, loading: false,
loaded: false, loaded: false,
/** 当前这份目录是按哪个平台 tab 拉的(V206 平台分侧,2026-11-17 用户口径「公司 tab
* 条也按平台分侧,两边各看各的公司」)。空串=还没按平台拉过。早退闸拿它对撞当前
* tab:一致才免拉,平台切了就重拉一份;`fetchCompanies` 失败时不翻转它,旧清单
* (可能过时)继续顶着,下一次切台/重进页面会再试。 */
loadedPlatform: '' as PlatformTabId | '',
/** GET /companies 失败时的原因。**只住 store 与 console,不在模板里渲染**—— /** GET /companies 失败时的原因。**只住 store 与 console,不在模板里渲染**——
* §12 第 5 条没批任何新的用户可见提示,接口暴露禁令高于"失败可见"。 * §12 第 5 条没批任何新的用户可见提示,接口暴露禁令高于"失败可见"。
* 取不到目录时 loaded 保持 false ⇒ visibleForOperator 为 false ⇒ tab 条整体不画(fail-closed,观感与改前一致)。 */ * 取不到目录时 loaded 保持 false ⇒ visibleForOperator 为 false ⇒ tab 条整体不画(fail-closed,观感与改前一致)。 */
@@ -35,15 +42,27 @@ export const useCompanyTabStore = defineStore('company-tab', {
}, },
}, },
actions: { actions: {
async initialize() { /** 拉公司目录(按当前平台 tab 过滤,后端 GET /api/admin/companies?platform=…)。
* `force`=绕开「该平台已拉过」的早退闸(公司编辑弹窗翻档/启停后的 refresh 用),
* 旧清单保留到成功那刻再整份替换,取数期间 tab 条不闪空。 */
async initialize(options?: { force?: boolean }) {
const session = useAdminSessionStore() const session = useAdminSessionStore()
if (this.loaded || this.loading || !session.isSuperAdmin) return const platform = usePlatformTabStore().active
const alreadyLoadedForThisPlatform = this.loaded && this.loadedPlatform === platform
if ((!options?.force && alreadyLoadedForThisPlatform) || this.loading || !session.isSuperAdmin) return
this.loading = true this.loading = true
// 失败后 loaded 仍是 false ⇒ 下一次 watch 命中超管会重试;重试前先清掉旧原因,免得留着一条已经翻篇的错误。 // 失败后 loaded 仍是 false ⇒ 下一次 watch 命中超管会重试;重试前先清掉旧原因,免得留着一条已经翻篇的错误。
this.error = '' this.error = ''
try { try {
this.companies = await fetchCompanies() const companies = await fetchCompanies(platform)
this.activeId = firstSelectableCompanyId(this.companies) this.companies = companies
this.loadedPlatform = platform
// 换台重拉后旧选中未必还在新清单里(跨平台公司不重叠):还在就保住(别的页可能正按它取数),
// 不在就回落「id 最小的启用公司」。force 重拉同平台时,选中公司仍在 ⇒ 选中不跳。
const stillListed = this.activeId !== null && companies.some((c) => c.id === this.activeId)
if (!stillListed) {
this.activeId = firstSelectableCompanyId(companies)
}
this.loaded = true this.loaded = true
} catch (error) { } catch (error) {
// 2026-10-05 修复轮 1:改前只有 try/finally ⇒ GET /companies 抛错时零痕迹(loaded 永远 false、 // 2026-10-05 修复轮 1:改前只有 try/finally ⇒ GET /companies 抛错时零痕迹(loaded 永远 false、
@@ -57,8 +76,25 @@ export const useCompanyTabStore = defineStore('company-tab', {
this.loading = false this.loading = false
} }
}, },
/** 公司目录被编辑(公司管理翻档/启停/改名)后的强制重拉:不受 loadedPlatform 早退闸
* 限制。失败语义与 initialize 同口径(error + rethrow),调用方自行决定要不要提示。 */
async refresh() {
await this.initialize({ force: true })
},
setActiveId(id: number) { setActiveId(id: number) {
this.activeId = id this.activeId = id
}, },
}, },
}) })
/** 公司目录失效通知:公司管理页保存(新建/改名/启停/翻档)之后调这里,让全站 tab 条重拉一份。
*
* 为什么是 store 里的具名出口而不是让页面自己持一份 store:公司管理页**不参与公司隔离**
* (控制方 2026-10-06「公司管理不要有 tab」),它要的不是 tab 状态,只是「别让 18 个页面的
* tab 条端着旧名单」这一个动作。页面里一旦出现 `useCompanyTabStore()`,形状就和「给这页上了
* tab」分不开——company-config-entry-super-only 的 pageFiles 分母会当场红(2026-11-17 实测:
* ee613db0 给这页加了保存后重拉,正是踩在这条上)。
* 失败语义同 refresh:error 落 store 再 rethrow,调用方决定要不要提示。 */
export function refreshCompanyDirectory(): Promise<void> {
return useCompanyTabStore().refresh()
}
@@ -38,5 +38,13 @@ export const usePlatformTabStore = defineStore('platform-tab', {
this.active = id this.active = id
writeStoredTab(id) writeStoredTab(id)
}, },
/** 平台锁定(2026-11-18 用户口径「非站点超管只看自己平台侧」):允许集收敛时把 active
* 归位——localStorage 残留的另一侧(超管在同一浏览器切过 tab)自动回落本人平台;
* 允许集为空(会话未就位)不动。 */
syncToAllowed(allowed: readonly PlatformTabId[]) {
if (allowed.length > 0 && !allowed.includes(this.active)) {
this.setActive(allowed[0])
}
},
}, },
}) })
+4 -1
View File
@@ -41,7 +41,10 @@ body {
button, input, textarea, select { font: inherit; } button, input, textarea, select { font: inherit; }
/* ===== 蓝白浅色壳层(对齐 admin.html 末层皮肤) ===== */ /* ===== 蓝白浅色壳层(对齐 admin.html 末层皮肤) ===== */
.admin-shell { display: flex; min-height: 100vh; background: var(--admin-bg); } /* 壳层锁视口高(2026-11-18「菜单加个滚动条」):min-height 会让 flex 高度链失去确定性,
* el-scrollbar 与 .admin-content 的 overflow 全部失效、回落整页滚,侧边栏顶部(品牌区/平台
* tab)被滚出视口。height:100vh 定高后侧边栏与 .admin-content 各自独立滚动、顶栏固定。 */
.admin-shell { display: flex; height: 100vh; overflow: hidden; background: var(--admin-bg); }
.admin-sidebar { .admin-sidebar {
display: flex; flex: 0 0 252px; flex-direction: column; display: flex; flex: 0 0 252px; flex-direction: column;
background: linear-gradient(180deg, var(--admin-sidebar) 0%, var(--admin-sidebar-deep) 100%); background: linear-gradient(180deg, var(--admin-sidebar) 0%, var(--admin-sidebar-deep) 100%);
@@ -2,11 +2,12 @@ import test from 'node:test'
import assert from 'node:assert/strict' import assert from 'node:assert/strict'
import { readSource } from './helpers.ts' import { readSource } from './helpers.ts'
import { import {
eligibleGroupLeaders,
eligibleGroupMembers, eligibleGroupMembers,
groupMemberCandidateHint, groupMemberCandidateHint,
} from '../src/pages/account/shop-group-model.ts' } from '../src/pages/account/shop-group-model.ts'
/** 对齐 admin.js:3020-3028 getEligibleShopManageGroupUsers 与 3179-3182 帮助文案。 */ /** 对齐 admin.js:3020-3028 getEligibleShopManageGroupUsers 与 3179-3182 帮助文案;组长候选为 2026-11-18 新增口径。 */
const USERS = [ const USERS = [
{ id: 1, username: '组长A', role: 'admin', createdById: null }, { id: 1, username: '组长A', role: 'admin', createdById: null },
@@ -63,21 +64,47 @@ test('align_group_candidate_hint_empty_for_admin', () => {
}) })
test('align_group_editor_dialog_ui_wiring', () => { test('align_group_editor_dialog_ui_wiring', () => {
// UI 接线:候选请求 page_size=999;新建时组长恒为当前登录用户(无改选下拉);候选/提示走新模型。 // UI 接线:候选请求 page_size=999;组长默认当前登录用户,新建+站点超管出改选下拉
// (2026-11-18 用户口径「新建分组组长要能下拉选」),编辑与非超管仍只读;候选/提示走新模型。
const dialog = readSource('src/pages/account/GroupEditorDialog.vue') const dialog = readSource('src/pages/account/GroupEditorDialog.vue')
assert.match(dialog, /pageSize:\s*999/, '候选列表按参考 page_size=999 拉取') assert.match(dialog, /pageSize:\s*999/, '候选列表按参考 page_size=999 拉取')
assert.doesNotMatch(dialog, /组长(创建人)/, '新建弹窗不再提供组长改选下拉') assert.match(dialog, /canPickLeader/, '组长下拉按「新建+站点超管」条件渲染')
assert.match(dialog, /当前登录用户/, '新建时组长只读显示当前登录用户') assert.match(dialog, /v-if="canPickLeader"/, '下拉分支挂在 canPickLeader 上')
assert.match(dialog, /eligibleGroupLeaders/, '组长候选走 eligibleGroupLeaders 过滤')
assert.match(dialog, /v-else :model-value="leaderUsername" readonly/, '编辑与非超管新建仍走只读回显')
assert.match(dialog, /当前登录用户/, '只读回显保留当前登录用户兜底')
assert.match(dialog, /memberIds\.value\.filter/, '组长改选后把该人从组员里摘掉(后端拒绝组长重复入组)')
assert.match(dialog, /createShopGroup\(groupName\.value, memberIds\.value, leaderId/,
'创建提交 createdById=所选组长(站点超管改选通道,后端 validateLeaderOperator 放行)')
assert.match(dialog, /eligibleGroupMembers/, '组员候选走归属过滤') assert.match(dialog, /eligibleGroupMembers/, '组员候选走归属过滤')
assert.match(dialog, /groupMemberCandidateHint/, '候选提示文案走对齐逻辑') assert.match(dialog, /groupMemberCandidateHint/, '候选提示文案走对齐逻辑')
assert.match(dialog, /companyId:\s*session\.user\?\.companyId \?\? null/, assert.match(dialog, /companyId:\s*session\.user\?\.companyId \?\? null/,
'候选必须按组长(新建时=当前登录用户)那家取人:不带时后端对站点超管返回全平台账号,别家公司的人会进到这家的候选里') '候选必须按操作者那家取人:组长必须与操作者同公司(后端 ensureLeaderSharesOperatorCompany),不带时站点超管会拿到全平台账号')
assert.doesNotMatch(dialog, /companyTab/, '分组候选不能按公司 tab 取人——超管停在别家 tab 时会列出那家的人,保存必被后端打回') assert.doesNotMatch(dialog, /companyTab/, '分组候选不能按公司 tab 取人——超管停在别家 tab 时会列出那家的人,保存必被后端打回')
const page = readSource('src/pages/account/GroupsPage.vue') const page = readSource('src/pages/account/GroupsPage.vue')
assert.match(page, /创建时间/, '列表补创建时间列') assert.match(page, /创建时间/, '列表补创建时间列')
assert.doesNotMatch(page, /slice\(0,\s*10\)/, '组员 chips 全量渲染不再收 +N') assert.doesNotMatch(page, /slice\(0,\s*10\)/, '组员 chips 全量渲染不再收 +N')
}) })
test('align_group_leader_candidates_site_super_keeps_self_drops_company_super', () => {
// 组长候选:公司超管永不领衔;站点超管只保留操作者本人(保持 admin 自建组的既有能力)。
const result = eligibleGroupLeaders(USERS, 'super_admin', 6)
assert.deepEqual(result.map((u) => u.id), [1, 2, 3, 4, 5, 6])
})
test('align_group_leader_candidates_non_super_operator_drops_all_supers', () => {
// 非站点超管操作者:两档超管全部出局(弹窗此时不出下拉,这里是同池复用方的兜底口径)。
const result = eligibleGroupLeaders(USERS, 'admin', 1)
assert.deepEqual(result.map((u) => u.id), [1, 2, 3, 4, 5])
})
test('align_group_leader_candidates_normal_accounts_can_lead', () => {
// 普通账号可领衔(既有文案背书:「当前账号只能作为组长使用」)。
const normals = USERS.filter((u) => u.role === 'normal')
const result = eligibleGroupLeaders(normals, 'super_admin', 6)
assert.deepEqual(result.map((u) => u.id), [2, 3, 4])
})
test('align_group_backend_gate_super_never_joins_and_leader_shares_company', () => { test('align_group_backend_gate_super_never_joins_and_leader_shares_company', () => {
// 界面收窄只是少踩一次;这两条 403 才是出口。锚在调用点与抛出语句,不锚注释。 // 界面收窄只是少踩一次;这两条 403 才是出口。锚在调用点与抛出语句,不锚注释。
const java = readSource( const java = readSource(
File diff suppressed because it is too large Load Diff
@@ -17,8 +17,10 @@ const KEYWORD_USAGE_MIGRATION = join(process.cwd(), '..', 'backend-java', 'src',
'V175__move_gating_and_add_keyword_usage_menu.sql') 'V175__move_gating_and_add_keyword_usage_menu.sql')
const JD_DATABASE_MIGRATION = join(process.cwd(), '..', 'backend-java', 'src', 'main', 'resources', 'db', const JD_DATABASE_MIGRATION = join(process.cwd(), '..', 'backend-java', 'src', 'main', 'resources', 'db',
'V196__jd_database_menu.sql') 'V196__jd_database_menu.sql')
const JD_CATEGORY_MANAGE_MIGRATION = join(process.cwd(), '..', 'backend-java', 'src', 'main', 'resources', 'db', /** V204 插入的「京东分类管理」菜单行已随 2026-11-17 用户口径「京东分类管理并到京东数据库
'V204__jd_category_manage_menu.sql') * 分类编辑里」由 V208 删除(页面并入 JdDatabasePage 工具栏「分类管理」对话框)。 */
const JD_CATEGORY_MANAGE_DROP_MIGRATION = join(process.cwd(), '..', 'backend-java', 'src', 'main', 'resources', 'db',
'V208__drop_jd_category_manage_menu.sql')
interface MigrationMenu { interface MigrationMenu {
name: string name: string
@@ -124,23 +126,15 @@ test('V196 新增的京东数据库菜单 key 必须在路由注册表登记', (
assert.ok(!sql.includes('user_column_permission'), 'V196 不得预插授权行(默认仅超管可见)') assert.ok(!sql.includes('user_column_permission'), 'V196 不得预插授权行(默认仅超管可见)')
}) })
test('V204 新增的京东分类管理菜单 key 必须在路由注册表登记(2026-11-17 弹窗下线、CRUD 挪子菜单页)', () => { test('V208 删掉 V204 的京东分类管理菜单行,且注册表不再认这个 key(2026-11-17 分类管理并入京东数据库页)', () => {
const sql = readFileSync(JD_CATEGORY_MANAGE_MIGRATION, 'utf8') // V204 本体已应用不可回改(铁律 10,文件原样保留作历史取证);下线动作由 V208 出 DELETE,
const menus = menusInsertedBy(sql) // 页面并入京东数据库页工具栏「分类管理」对话框。
const insertCount = (sql.match(/INSERT INTO `columns`/g) || []).length const sql = readFileSync(JD_CATEGORY_MANAGE_DROP_MIGRATION, 'utf8')
assert.ok(menus.length > 0, 'V204 应当插入后台菜单,一条都没解析出来说明正则失效') assert.ok(sql.includes("DELETE FROM `columns` WHERE `column_key` = 'admin_jd_category_manage'"),
assert.equal(menus.length, insertCount, `解析到 ${menus.length} 条,但迁移有 ${insertCount} 条 INSERT INTO columns`) 'V208 必须 DELETE admin_jd_category_manage 菜单行(授权行随外键 CASCADE)')
const menu = menus.find((item) => item.columnKey === 'admin_jd_category_manage') const registered = adminPages.find((item) => item.menuKey === 'admin_jd_category_manage')
assert.ok(menu, 'V204 必须插入 admin_jd_category_manage 菜单') assert.ok(!registered, 'routes.ts 不得再登记 admin_jd_category_manage(页面已并入京东数据库页,残留=404 入口)')
const page = adminPages.find((item) => item.menuKey === 'admin_jd_category_manage') const jdRouteGone = !adminPages.some((item) => item.path === 'jd-center/categories')
assert.ok(page, 'routes.ts 必须有 admin_jd_category_manage 页面,否则菜单点进去 404') assert.ok(jdRouteGone, 'jd-center/categories 路由必须下线')
assert.equal(page.path, menu.routePath, '库里的 route_path 应与注册表路径一致')
assert.equal(page.title, menu.name, '页面标题应与菜单名一致')
assert.equal(page.companyScoped, false, '分类按数据权限分组隔离(V203),不按公司 tab 取数')
// 每公司一套树,挂数据管理组、排序 69(V196 京东数据库占 68)。
assert.ok(sql.includes("grp.`column_key` = 'admin_group_data'"), 'V204 必须把京东分类管理挂到数据管理组')
assert.ok(/'京东分类管理', 'admin_jd_category_manage', 'admin', 'jd-center\/categories', 69/.test(sql), '京东分类管理排序应为 69')
assert.ok(!sql.includes('user_column_permission'), 'V204 不得预插授权行(默认仅超管可见)')
}) })
@@ -51,7 +51,7 @@ test('请求体:admin/normal 一律不带 companyId;公司超管必须带且
password: 'secret123', password: 'secret123',
role: 'normal', role: 'normal',
columnIds: [3, 1], columnIds: [3, 1],
// V206:所属平台恒下发(弹窗单选默认当前平台 tab,空表单缺省亚马逊)。 // V206:所属平台恒下发(预填当前平台 tab,空表单缺省亚马逊;弹窗不设手选)。
platform: 'amazon', platform: 'amazon',
}) })
// 所属管理员仍按原语义携带(仅 normal 角色) // 所属管理员仍按原语义携带(仅 normal 角色)
@@ -32,14 +32,13 @@ test('routes 注册表出现京东数据库页面且退出公司 tab(2026-11-1
assert.equal(page.companyScoped, false, '京东数据库全平台公共,不画公司 tab(AC-6 已被 11-15/11-16 口径推翻)') assert.equal(page.companyScoped, false, '京东数据库全平台公共,不画公司 tab(AC-6 已被 11-15/11-16 口径推翻)')
}) })
/** 2026-11-17 用户口径「店铺分类弹窗删了,加个京东分类管理的子菜单维护 CRUD」(V204): /** 2026-11-17 用户口径「京东分类管理并到京东数据库分类编辑里」:V204 独立子菜单页下线
* 分类建/改名/删除独立成页,与京东数据库页同在京东平台侧(platform-scope 用例另钉)。 */ * (分类建/改名/删收进京东数据库页工具栏「分类管理」对话框),路由注册表不得再登记该 key。 */
test('routes 注册表出现京东分类管理页面(V204 子菜单),与京东数据库并排退出公司 tab', () => { test('routes 注册表不再登记京东分类管理独立页(V204 页并入京东数据库页,残留=404 入口)', () => {
const page = adminPages.find((item) => item.menuKey === 'admin_jd_category_manage') assert.ok(!adminPages.some((item) => item.menuKey === 'admin_jd_category_manage'),
assert.ok(page, 'routes.ts 缺 menuKey=admin_jd_category_manage 的注册行') 'admin_jd_category_manage 注册行必须已删(页面并入京东数据库页)')
assert.equal(page.path, 'jd-center/categories', 'route_path 必须与 V204 菜单一侧一致') assert.ok(!adminPages.some((item) => item.path === 'jd-center/categories'),
assert.equal(page.title, '京东分类管理', '菜单标题以「京东分类管理」为准') 'jd-center/categories 路由必须下线')
assert.equal(page.companyScoped, false, '分类按数据权限分组隔离(V203),不画公司 tab')
}) })
/** 详情面的 SKU 矩阵解析(V198):后端下发 camelCase,snake 容错;坏行不炸整块。 */ /** 详情面的 SKU 矩阵解析(V198):后端下发 camelCase,snake 容错;坏行不炸整块。 */
@@ -75,9 +75,11 @@ test('京东列表参数——snake 形状:groupId 空→不带、有值→gro
}) })
assert.equal('shop_name' in full, false, '店铺筛选已下线,参数面不再出现 shop_name') assert.equal('shop_name' in full, false, '店铺筛选已下线,参数面不再出现 shop_name')
// 全空态只有分页两项;脏值(非数字分组、非法日期)同罪不下发。 // 出厂态=分页两项+默认未分类档(classified:false,2026-11-17 用户口径「默认卡在未分类上就行」);
// 脏值(非数字分组、非法日期)同罪不下发。
const blank = toJdProductListParams(createJdProductFilterState(), 1, 20) const blank = toJdProductListParams(createJdProductFilterState(), 1, 20)
assert.deepEqual(blank, { page: 1, page_size: 20 }) assert.deepEqual(blank, { page: 1, page_size: 20, classified: false },
'出厂默认必须带 classified:false——首屏就卡未分类,不是全量')
assert.equal('group_id' in blank, false, 'groupId 空串不带 group_id') assert.equal('group_id' in blank, false, 'groupId 空串不带 group_id')
assert.equal('owner_group_id' in blank, false, '没传当前分组就不带 owner_group_id(后端按作用域默认组取)') assert.equal('owner_group_id' in blank, false, '没传当前分组就不带 owner_group_id(后端按作用域默认组取)')
const dirty = toJdProductListParams( const dirty = toJdProductListParams(
@@ -108,6 +110,25 @@ test('京东列表参数——page 钳制防 (page-1)*page_size 溢出(铁律
assert.equal(offset, 999_900) assert.equal(offset, 999_900)
}) })
/** 分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」,同日定默认卡未分类;
* 2026-11-18 用户口径「加个全部选项」恢复全量档):界面三档,'classified'→true、
* 'ungrouped'→false、''(全部)→ 不带 classified 参数;出厂默认与「重置」仍卡 ungrouped。
* ''/缺省/脏值同走「全部」兜底(不拿脏值冒充档位)。
* 参数名是新档 classified——不是后端仍拒收的旧 grouped/ungrouped 查询参数。 */
test('京东列表参数——classified 默认卡未分类:已分类→true、未分类→false、脏值兜底不下发', () => {
const yes = toJdProductListParams({ ...createJdProductFilterState(), classified: 'classified' }, 1, 20, 11)
assert.equal(yes.classified, true)
assert.equal(yes.owner_group_id, 11, 'classified 与当前分组成对下发(后端按组判已/未分类)')
assert.equal(createJdProductFilterState().classified, 'ungrouped',
'出厂态与重置都必须卡未分类档(用户口径:默认卡在未分类上)')
for (const blank of ['', undefined, 'grouped', 'nonsense'] as const) {
const q = toJdProductListParams({ ...createJdProductFilterState(), classified: blank }, 1, 20)
assert.equal('classified' in q, false, `classified=${String(blank)} 按「全部」兜底处理,不拿脏值冒充档位`)
}
})
test('详情解析——attrGroups/images 结构化解析(snake 容错、缺 url 弃行)', () => { test('详情解析——attrGroups/images 结构化解析(snake 容错、缺 url 弃行)', () => {
const detail = parseJdProductDetail({ const detail = parseJdProductDetail({
code: 0, code: 0,
@@ -0,0 +1,217 @@
/**
* 账户域三页的原生 <select> → el-select(2026-11-17 用户口径「和亚马逊不统一」:
* 原生 select 的弹层是浏览器直角原生物 ⇒ 换 EP 圆角弹层,外壳走全局 .admin-filter)。
*
* 钉住换壳最容易错的两件事:
* 1. **值形状逐字不变**——菜单类型/密钥状态仍是 '' / 'admin' / 'app' / 'passed'…(空串=不筛),
* 分组仍是 null 或数字 id(下游 `groupId: groupFilter.value || undefined` 一字不动);
* 2. **「全部 XX」空值行还在**,且选中它就是"不改筛选条件",不是筛一个叫空的类型。
*
* aria-label 由 EP 落在内层 combobox input 上;选项清单走组件树读,点选走「点开→点选项」真实路径
* (弹层 teleport 到 body)。页面模板靠 main.ts 全局注册 EP 组件,挂载测试不跑 main.ts ⇒
* 这里必须显式把 ElSelect/ElOption 传进 plugins。
*
* 跑法:`npx vitest run tests/mount/account-select-el.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { DOMWrapper, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { ElOption, ElSelect } from 'element-plus'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import MenusPage from '@/pages/account/MenusPage.vue'
import UserSecretsPage from '@/pages/account/UserSecretsPage.vue'
import UserSecretUsagePage from '@/pages/account/UserSecretUsagePage.vue'
import { useAdminSessionStore } from '@/stores/admin-session'
import { useCompanyTabStore } from '@/stores/company-tab'
const menuApi = vi.hoisted(() => ({
loadMenuManageTree: vi.fn(),
createMenu: vi.fn(),
updateMenu: vi.fn(),
deleteMenu: vi.fn(),
reorderMenus: vi.fn(),
}))
const secretsApi = vi.hoisted(() => ({
fetchUserSecretList: vi.fn(),
fetchAdminSecretBalances: vi.fn(),
checkUserSecret: vi.fn(),
deleteUserSecret: vi.fn(),
saveUserSecretModule: vi.fn(),
clearUserSecretModule: vi.fn(),
}))
const usageApi = vi.hoisted(() => ({ fetchUserSecretUsage: vi.fn() }))
vi.mock('@/pages/account/menu-manage-api', () => menuApi)
vi.mock('@/api/user-secrets', () => secretsApi)
vi.mock('@/api/user-secret-usage', () => usageApi)
const GROUPS = [
{ id: 7, groupName: '甲组' },
{ id: 9, groupName: '乙组' },
]
const MENU_ROWS = [
{ id: 1, name: '后台菜单', columnKey: 'admin-col', parentId: null, menuType: 'admin', routePath: '/a', sortOrder: 0, children: [] },
{ id: 2, name: '软件菜单', columnKey: 'app-col', parentId: null, menuType: 'app', routePath: '/b', sortOrder: 1, children: [] },
]
// ---------------- el-select 交互助手(与京东数据库页/亚马逊面同一套口径) ----------------
/** 按 aria-label 找对应的 ElSelect 实例(EP 把该属性落在内层 combobox input 上)。 */
function selectByLabel(wrapper: VueWrapper<Element>, label: string) {
const found = wrapper.findAllComponents(ElSelect).find((s) => s.find(`[aria-label="${label}"]`).exists())
expect(found, `应存在 aria-label="${label}" 的下拉`).toBeTruthy()
return found!
}
/** 某颗下拉的全部选项文案(读 el-option 的 label prop,不依赖插槽文本)。 */
function optionLabels(wrapper: VueWrapper<Element>, label: string): string[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('label') as string)
}
/** 某颗下拉的全部选项 value(形状判据:空串/数字 id/null 逐字对撞)。 */
function optionValues(wrapper: VueWrapper<Element>, label: string): unknown[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('value'))
}
/** 点开指定下拉并点选目标文案的选项(触发 update:modelValue + change,与真实用户一致)。
* 面板按内层 input 的 aria-controls 圈定,避免另一颗(可能仍挂着的)弹层串台。 */
async function pickSelectOption(wrapper: VueWrapper<Element>, label: string, optionText: string): Promise<void> {
const input = wrapper.get(`[aria-label="${label}"]`)
await input.trigger('click')
await flushPromises()
const contentId = input.attributes('aria-controls')
const scope = (contentId && document.getElementById(contentId)) ?? document.body
const items = [...scope.querySelectorAll('.el-select-dropdown__item')].filter((el) => !el.classList.contains('is-hidden'))
const target = items.find((el) => (el.textContent ?? '').trim() === optionText)
expect(target, `下拉应弹出「${optionText}」选项`).toBeTruthy()
await new DOMWrapper(target as Element).trigger('click')
await flushPromises()
}
/** 按文案点按钮(筛选条上的查询/重置)。 */
async function clickButton(wrapper: VueWrapper<Element>, text: string): Promise<void> {
const button = wrapper.findAll('button').find((b) => b.text().trim() === text)
expect(button, `应存在「${text}」按钮`).toBeTruthy()
await button!.trigger('click')
await flushPromises()
await flushPromises()
}
/** 最近一次调用的入参(首屏 + 公司 tab watch 可能各发一次,判"选完落什么参"只认最后一次)。 */
function lastArgs(fn: { mock: { calls: unknown[][] } }): Record<string, unknown> {
const calls = fn.mock.calls
expect(calls.length, '接口应至少被调用一次').toBeGreaterThan(0)
return calls[calls.length - 1][0] as Record<string, unknown>
}
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
pinia = createPinia()
setActivePinia(pinia)
useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' }
useCompanyTabStore().setActiveId(1)
})
async function mountMenus(): Promise<VueWrapper<Element>> {
menuApi.loadMenuManageTree.mockResolvedValue(MENU_ROWS)
const wrapper = mount(MenusPage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises()
return wrapper
}
async function mountSecrets(): Promise<VueWrapper<Element>> {
secretsApi.fetchUserSecretList.mockResolvedValue({ items: [], total: 0, page: 1, pageSize: 15, groupOptions: GROUPS })
secretsApi.fetchAdminSecretBalances.mockResolvedValue({ items: [] })
const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises()
return wrapper
}
async function mountUsage(): Promise<VueWrapper<Element>> {
usageApi.fetchUserSecretUsage.mockResolvedValue({ items: [], total: 0, groupOptions: GROUPS })
const wrapper = mount(UserSecretUsagePage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises()
return wrapper
}
/** 菜单表格里正在显示的行名(顺序=树展平顺序)。 */
function visibleMenuNames(wrapper: VueWrapper<Element>): string[] {
return wrapper.findAll('.menu-name-text').map((el) => el.text().trim())
}
describe('菜单管理页 × el-select', () => {
it('菜单类型下拉:空值行仍是空串,另两档仍是 admin/app', async () => {
const wrapper = await mountMenus()
expect(optionLabels(wrapper, '筛选菜单类型')).toEqual(['全部', '后台', '软件'])
expect(optionValues(wrapper, '筛选菜单类型')).toEqual(['', 'admin', 'app'])
})
it('选「软件」按 menuType 筛表,选回「全部」恢复全量(空串不参与筛选)', async () => {
const wrapper = await mountMenus()
expect(visibleMenuNames(wrapper)).toEqual(['后台菜单', '软件菜单'])
await pickSelectOption(wrapper, '筛选菜单类型', '软件')
expect(visibleMenuNames(wrapper)).toEqual(['软件菜单'])
await pickSelectOption(wrapper, '筛选菜单类型', '全部')
expect(visibleMenuNames(wrapper)).toEqual(['后台菜单', '软件菜单'])
})
})
describe('密钥管理页 × el-select', () => {
it('状态下拉:「全部状态」是空串档,其余各档码逐一在案', async () => {
const wrapper = await mountSecrets()
expect(optionLabels(wrapper, '筛选密钥状态')).toEqual([
'全部状态',
'检测通过',
'检测失败',
'未配齐',
'无法判定/可重试',
'未检测',
])
expect(optionValues(wrapper, '筛选密钥状态')).toEqual(['', 'passed', 'failed', 'incomplete', 'error', 'unknown'])
})
it('分组下拉:「全部分组」仍是 null,组选项是数字 id', async () => {
const wrapper = await mountSecrets()
expect(optionLabels(wrapper, '筛选分组')).toEqual(['全部分组', '甲组', '乙组'])
expect(optionValues(wrapper, '筛选分组')).toEqual([null, 7, 9])
})
it('落参:checkStatus 是状态码、groupId 是数字;选回空值行后两者都不出现', async () => {
const wrapper = await mountSecrets()
await pickSelectOption(wrapper, '筛选密钥状态', '检测失败')
await pickSelectOption(wrapper, '筛选分组', '甲组')
await clickButton(wrapper, '查询')
const selected = lastArgs(secretsApi.fetchUserSecretList)
expect(selected.checkStatus).toBe('failed')
expect(selected.groupId).toBe(7)
// 空值行=不筛:'' / null 都落回 undefined,查询参数与换壳前逐字一致
await pickSelectOption(wrapper, '筛选密钥状态', '全部状态')
await pickSelectOption(wrapper, '筛选分组', '全部分组')
await clickButton(wrapper, '查询')
const cleared = lastArgs(secretsApi.fetchUserSecretList)
expect(cleared.checkStatus).toBeUndefined()
expect(cleared.groupId).toBeUndefined()
})
})
describe('密钥用量页 × el-select', () => {
it('分组下拉与密钥页同口径(全部分组=null),落参仍是数字 id / 缺省', async () => {
const wrapper = await mountUsage()
expect(optionLabels(wrapper, '筛选分组')).toEqual(['全部分组', '甲组', '乙组'])
expect(optionValues(wrapper, '筛选分组')).toEqual([null, 7, 9])
await pickSelectOption(wrapper, '筛选分组', '乙组')
await clickButton(wrapper, '查询')
expect(lastArgs(usageApi.fetchUserSecretUsage).groupId).toBe(9)
await pickSelectOption(wrapper, '筛选分组', '全部分组')
await clickButton(wrapper, '查询')
expect(lastArgs(usageApi.fetchUserSecretUsage).groupId).toBeUndefined()
})
})
@@ -0,0 +1,164 @@
/**
* AdminLayout × 平台锁定(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、
* 亚马逊看不了」)的挂载契约:
* - 京东用户(company_super_admin + platform=jd)即使 localStorage 残留另一侧 tab,挂载后
* active 归位本人平台(syncToAllowed),单侧时平台 tab 条整个隐藏;
* - 站点超管不受限:双平台 tab 照画、active 保持残留值(超管切过的侧照记);
* - 京东用户当前路由落在被禁侧(直达 URL):跳回本人平台第一可见页。
* menuTree 模拟后端裁剪后的下发树(京东用户树里本来就没有亚马逊叶子)。
* 不用 readFileSync(source-pin-ratchet 对台账外新文件带读点即红),全部走真实挂载断言。
*
* 跑法:`npx vitest run tests/mount/admin-layout-platform-lock.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import ElementPlus from 'element-plus'
import { createMemoryHistory, createRouter, type Router } from 'vue-router'
import AdminLayout from '@/layout/AdminLayout.vue'
import { usePlatformTabStore } from '@/stores/platform-tab'
import { useAdminSessionStore } from '@/stores/admin-session'
import { adminPages } from '@/router/routes'
import type { AdminMenuNode } from '@/types/admin'
// AdminLayout 的顶栏/告警子组件各带定时器或远端拉取,与本契约无关,替身化。
vi.mock('@/components/NotificationBell.vue', () => ({ default: { template: '<div class="bell-stub" />' } }))
vi.mock('@/components/ExpiryNotice.vue', () => ({ default: { template: '<div class="expiry-stub" />' } }))
vi.mock('@/layout/OperationGuide.vue', () => ({ default: { template: '<div class="guide-stub" />' } }))
vi.mock('@/layout/CompanyTabs.vue', () => ({ default: { template: '<div class="company-tabs-stub" />' } }))
vi.mock('@/layout/GlobalErrorContainer.vue', () => ({ default: { template: '<div class="error-stub" />' } }))
/** 后端裁剪后下发给京东用户的树形状:双侧账号域六页 + 京东数据库(无任何亚马逊叶子)。 */
const JD_TREE: AdminMenuNode[] = [
{
key: 'admin_group_account',
name: '账号与权限',
children: [
{ key: 'admin_users', name: '用户管理', route: '/account/users' },
{ key: 'admin_group_manage', name: '分组管理', route: '/account/groups' },
{ key: 'admin_columns', name: '菜单权限配置', route: '/account/menus' },
{ key: 'admin_user_secrets', name: '密钥管理', route: '/account/user-secrets' },
{ key: 'admin_user_secret_usage', name: '密钥用量统计', route: '/account/user-secret-usage' },
],
},
{
key: 'admin_group_data',
name: '数据管理',
children: [{ key: 'admin_jd_database', name: '京东数据库', route: '/jd-center/database' }],
},
]
/** 站点超管的树:亚马逊业务页 + 京东页 + 双侧账号域(现状全量形状)。 */
const SUPER_TREE: AdminMenuNode[] = [
{
key: 'admin_group_account',
name: '账号与权限',
children: [{ key: 'admin_users', name: '用户管理', route: '/account/users' }],
},
{
key: 'admin_group_data',
name: '数据管理',
children: [
{ key: 'admin_query_asin', name: '查询ASIN', route: '/asin-center/query' },
{ key: 'admin_jd_database', name: '京东数据库', route: '/jd-center/database' },
],
},
]
let pinia: Pinia
let router: Router
beforeEach(async () => {
vi.clearAllMocks()
window.localStorage.removeItem('admin-platform-tab')
pinia = createPinia()
setActivePinia(pinia)
// adminPages 是相对 /admin-vue/ 的子路径注册表(不带前导斜杠),这里按 memory history
// 补 "/" 建表:路由 meta 带上 menuKey,AdminLayout 的 tab 跟随/replace 判定吃真实 meta。
// component 全部换同步桩——真实页面是懒 import,导航确认会卡在组件 promise 上,
// 而本契约只盯 AdminLayout 的 tab/replace 行为,页面本体无关。
router = createRouter({
history: createMemoryHistory(),
routes: adminPages.map((page) => ({
path: `/${page.path}`,
component: { template: '<div class="page-stub" />' },
meta: { title: page.title, menuKey: page.menuKey },
})),
})
await router.push('/')
await router.isReady()
})
async function mountLayout() {
const wrapper = mount(AdminLayout, { global: { plugins: [pinia, router, ElementPlus] } })
await flushPromises()
return wrapper
}
describe('AdminLayout × 平台锁定(2026-11-18)', () => {
it('京东用户挂载:残留的亚马逊 tab 归位京东侧,tab 条隐藏,侧边栏只画本人平台菜单', async () => {
window.localStorage.setItem('admin-platform-tab', 'amazon')
const session = useAdminSessionStore()
session.user = { id: 10, username: '阿华66', role: 'company_super_admin', platform: 'jd' }
session.menuTree = JD_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('jd')
expect(wrapper.findAll('.admin-platform-tab').length).toBe(0)
const texts = wrapper.findAll('.admin-menu .el-menu-item').map((item) => item.text())
expect(texts).toContain('京东数据库')
expect(texts).not.toContain('查询ASIN')
// 双侧账号域照画(2026-11-18 扩双侧后含菜单权限配置/密钥管理/密钥用量统计)
expect(texts).toContain('菜单权限配置')
expect(texts).toContain('密钥管理')
wrapper.unmount()
})
it('站点超管挂载:双平台 tab 照画、残留 active 保持(不受平台锁定影响)', async () => {
window.localStorage.setItem('admin-platform-tab', 'jd')
const session = useAdminSessionStore()
session.user = { id: 1, username: 'admin', role: 'super_admin', platform: 'amazon' }
session.menuTree = SUPER_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('jd')
const tabs = wrapper.findAll('.admin-platform-tab').map((tab) => tab.text())
expect(tabs).toEqual(['亚马逊', '京东'])
expect(tabs[1]).toBe('京东')
wrapper.unmount()
})
it('京东用户直达被禁侧 URL(/asin-center/query):挂载后跳回本人平台第一可见页', async () => {
const session = useAdminSessionStore()
session.user = { id: 10, username: '阿华66', role: 'company_super_admin', platform: 'jd' }
session.menuTree = JD_TREE
session.initialized = true
await router.push('/asin-center/query')
const wrapper = await mountLayout()
expect(router.currentRoute.value.path).toBe('/account/users')
wrapper.unmount()
})
it('亚马逊存量用户(platform 缺省兜底亚马逊):锁亚马逊侧,京东页不可达', async () => {
const session = useAdminSessionStore()
session.user = { id: 8, username: '存量号', role: 'admin' }
session.menuTree = SUPER_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('amazon')
expect(wrapper.findAll('.admin-platform-tab').length).toBe(0)
wrapper.unmount()
})
})
@@ -14,8 +14,9 @@
import { readFileSync } from 'node:fs' import { readFileSync } from 'node:fs'
import { resolve } from 'node:path' import { resolve } from 'node:path'
import { beforeEach, describe, expect, it, vi } from 'vitest' import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils' import { DOMWrapper, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia' import { createPinia, setActivePinia, type Pinia } from 'pinia'
import { ElOption, ElSelect } from 'element-plus'
import AppearancePatentCleanItemsPage from '@/pages/patent/AppearancePatentCleanItemsPage.vue' import AppearancePatentCleanItemsPage from '@/pages/patent/AppearancePatentCleanItemsPage.vue'
import { adminPages } from '@/router/routes' import { adminPages } from '@/router/routes'
@@ -74,12 +75,40 @@ beforeEach(() => {
async function mountWith(payload: unknown): Promise<VueWrapper<Element>> { async function mountWith(payload: unknown): Promise<VueWrapper<Element>> {
cleanApi.fetchAppearancePatentCleanList.mockImplementation(() => Promise.resolve(payload)) cleanApi.fetchAppearancePatentCleanList.mockImplementation(() => Promise.resolve(payload))
const wrapper = mount(AppearancePatentCleanItemsPage, { global: { plugins: [pinia] } }) const wrapper = mount(AppearancePatentCleanItemsPage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises() await flushPromises()
await flushPromises() await flushPromises()
return wrapper return wrapper
} }
// ---------------- el-select 交互助手(2026-11-17 筛选行/分页条下拉换 el-select,与亚马逊面统一) ----------------
// aria-label 经 EP 的 ariaLabel prop 落在内层 combobox input 上;弹层 teleport 到 body,
// ElOption 仍在挂载树里 ⇒ 选项清单走组件树读,点选走「点开→点选项」真实路径。
function selectByLabel(wrapper: VueWrapper<Element>, label: string) {
const found = wrapper.findAllComponents(ElSelect).find((s) => s.find(`[aria-label="${label}"]`).exists())
expect(found, `应存在 aria-label="${label}" 的下拉`).toBeTruthy()
return found!
}
function optionLabels(wrapper: VueWrapper<Element>, label: string): string[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('label') as string)
}
async function pickSelectOption(wrapper: VueWrapper<Element>, label: string, optionText: string): Promise<void> {
const input = wrapper.get(`[aria-label="${label}"]`)
await input.trigger('click')
await flushPromises()
const contentId = input.attributes('aria-controls')
const scope = (contentId && document.getElementById(contentId)) ?? document.body
const items = [...scope.querySelectorAll('.el-select-dropdown__item')]
.filter((el) => !el.classList.contains('is-hidden'))
const target = items.find((el) => (el.textContent ?? '').trim() === optionText)
expect(target, `下拉应弹出「${optionText}」选项`).toBeTruthy()
await new DOMWrapper(target as Element).trigger('click')
await flushPromises()
}
describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那个格式」)', () => { describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那个格式」)', () => {
it('页面组件落位:明细表 + 明细端点 + 导出,卡片视图与删除入口已下架', () => { it('页面组件落位:明细表 + 明细端点 + 导出,卡片视图与删除入口已下架', () => {
const src = readFileSync(resolve(process.cwd(), PAGE_PATH), 'utf-8') const src = readFileSync(resolve(process.cwd(), PAGE_PATH), 'utf-8')
@@ -215,14 +244,13 @@ describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那
cleanApi.fetchDedupeTotalGroups.mockResolvedValue([{ id: 7, name: '甲组', leaderUserId: 9 }]) cleanApi.fetchDedupeTotalGroups.mockResolvedValue([{ id: 7, name: '甲组', leaderUserId: 9 }])
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 }) const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 })
const textInputs = wrapper.findAll('.form-group input[type="text"]') const textInputs = wrapper.findAll('.form-group input[type="text"]:not(.el-select__input)')
expect(textInputs).toHaveLength(2, '任务号+ASIN 两个筛选框恢复(客户要一目了然)') expect(textInputs).toHaveLength(2, '任务号+ASIN 两个筛选框恢复(客户要一目了然)')
await textInputs[0].setValue('33874') await textInputs[0].setValue('33874')
await textInputs[1].setValue('B0CLEAN') await textInputs[1].setValue('B0CLEAN')
const selects = wrapper.findAll('select') await pickSelectOption(wrapper, '筛选国家', '德国') // 国家排在前(模板顺序:任务号/ASIN/国家/分组)
await selects[0].setValue('DE') // 国家排在前(模板顺序:任务号/ASIN/国家/分组) await pickSelectOption(wrapper, '筛选分组', '甲组') // 分组(主管=组长)
await selects[1].setValue('7') // 分组(主管=组长)
const dateInputs = wrapper.findAll('input[type="date"]') const dateInputs = wrapper.findAll('input[type="date"]')
await dateInputs[0].setValue('2026-11-01') await dateInputs[0].setValue('2026-11-01')
await dateInputs[1].setValue('2026-11-09') await dateInputs[1].setValue('2026-11-09')
@@ -249,13 +277,12 @@ describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 }) const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 })
expect(cleanApi.fetchDedupeTotalGroups).toHaveBeenCalledWith(1) expect(cleanApi.fetchDedupeTotalGroups).toHaveBeenCalledWith(1)
const groupSelect = wrapper.findAll('select')[1] // 模板顺序:国家在前、分组在后 const groups = optionLabels(wrapper, '筛选分组')
const optionTexts = groupSelect.findAll('option').map((o) => o.text()) expect(groups).toContain('全部分组')
expect(optionTexts).toContain('全部分组') expect(groups).toContain('甲组')
expect(optionTexts).toContain('甲组')
const callsBeforeSelect = cleanApi.fetchAppearancePatentCleanList.mock.calls.length const callsBeforeSelect = cleanApi.fetchAppearancePatentCleanList.mock.calls.length
await groupSelect.setValue('7') await pickSelectOption(wrapper, '筛选分组', '甲组')
await flushPromises() await flushPromises()
expect(cleanApi.fetchAppearancePatentCleanList.mock.calls.length).toBe(callsBeforeSelect + 1, expect(cleanApi.fetchAppearancePatentCleanList.mock.calls.length).toBe(callsBeforeSelect + 1,
'选中分组必须立刻重查') '选中分组必须立刻重查')
@@ -267,7 +294,7 @@ describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那
it('重置把筛选面回空并回第一页重取', async () => { it('重置把筛选面回空并回第一页重取', async () => {
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 }) const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 10 })
const textInputs = wrapper.findAll('.form-group input[type="text"]') const textInputs = wrapper.findAll('.form-group input[type="text"]:not(.el-select__input)')
await textInputs[0].setValue('33874') await textInputs[0].setValue('33874')
await textInputs[1].setValue('B0CLEAN') await textInputs[1].setValue('B0CLEAN')
const callsBefore = cleanApi.fetchAppearancePatentCleanList.mock.calls.length const callsBefore = cleanApi.fetchAppearancePatentCleanList.mock.calls.length
@@ -288,8 +315,9 @@ describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那
expect(cleanApi.fetchAppearancePatentCleanList).toHaveBeenCalledTimes(2) expect(cleanApi.fetchAppearancePatentCleanList).toHaveBeenCalledTimes(2)
expect(cleanApi.fetchAppearancePatentCleanList.mock.calls[1][0].page).toBe(3) expect(cleanApi.fetchAppearancePatentCleanList.mock.calls[1][0].page).toBe(3)
const sizeSelect = wrapper.find('.page-size-select') // 每页条数下拉 2026-11-17 随分页条一起换 el-select(OldPagination 内局部注册)。
await sizeSelect.setValue('50') expect(wrapper.find('.page-size-select').exists()).toBe(true, '分页条下拉保留 .page-size-select 定位类')
await pickSelectOption(wrapper, '每页条数', '50条/页')
await flushPromises() await flushPromises()
const last = cleanApi.fetchAppearancePatentCleanList.mock.calls.at(-1)![0] const last = cleanApi.fetchAppearancePatentCleanList.mock.calls.at(-1)![0]
expect(last.pageSize).toBe(50) expect(last.pageSize).toBe(50)
@@ -314,11 +342,10 @@ describe('外观专利数据库页(明细表,2026-11-11 恢复「昨天那
it('切公司 Tab 重取并清掉上一家的筛选(company-tab-wiring 同口径)', async () => { it('切公司 Tab 重取并清掉上一家的筛选(company-tab-wiring 同口径)', async () => {
cleanApi.fetchDedupeTotalGroups.mockResolvedValue([{ id: 7, name: '甲组', leaderUserId: 9 }]) cleanApi.fetchDedupeTotalGroups.mockResolvedValue([{ id: 7, name: '甲组', leaderUserId: 9 }])
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 10 }) const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 10 })
const textInputs = wrapper.findAll('.form-group input[type="text"]') const textInputs = wrapper.findAll('.form-group input[type="text"]:not(.el-select__input)')
await textInputs[0].setValue('33874') await textInputs[0].setValue('33874')
await textInputs[1].setValue('B0CLEAN') await textInputs[1].setValue('B0CLEAN')
const groupSelect = wrapper.findAll('select')[1] await pickSelectOption(wrapper, '筛选分组', '甲组')
await groupSelect.setValue('7')
const callsBefore = cleanApi.fetchAppearancePatentCleanList.mock.calls.length const callsBefore = cleanApi.fetchAppearancePatentCleanList.mock.calls.length
useCompanyTabStore().setActiveId(2) useCompanyTabStore().setActiveId(2)
@@ -0,0 +1,115 @@
/**
* 公司 tab 条 × 平台 tab(2026-11-17 用户口径「亚马逊侧别再挂京东-团队,京东侧同理」)的挂载契约:
* 目录请求必须带 platform=当前平台;切平台 tab 重拉一份;跨平台旧选中不在新清单里 ⇒ 回落「id 最小启用公司」;
* 同平台 force 重拉(公司编辑保存后的 refresh)不跳选中。京东侧只有一家公司时 tab 条整体不画
* (visibleForOperator 的 length > 1 既有语义),但 activeId 仍落在那一家 ⇒ 各页取数照样按它收窄。
* 不用 readFileSync(source-pin-ratchet 对台账外新文件带读点即红),全部走真实挂载断言。
*
* 跑法:`npx vitest run tests/mount/company-tabs-platform.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import CompanyTabs from '@/layout/CompanyTabs.vue'
import { usePlatformTabStore } from '@/stores/platform-tab'
import { useAdminSessionStore } from '@/stores/admin-session'
import { useCompanyTabStore } from '@/stores/company-tab'
const companiesApi = vi.hoisted(() => ({
fetchCompanies: vi.fn(),
}))
vi.mock('@/api/companies', () => companiesApi)
vi.mock('vue-router', () => ({
useRoute: () => ({ meta: { menuKey: 'admin_group_manage' } }),
}))
const AMAZON_COMPANIES = [
{ id: 1, companyName: '厦门米椿花', status: 1, platform: 'amazon' },
{ id: 2, companyName: '德阳-团队', status: 1, platform: 'amazon' },
{ id: 3, companyName: '先锋-团队', status: 1, platform: 'amazon' },
]
const JD_COMPANIES = [{ id: 4, companyName: '京东-团队', status: 1, platform: 'jd' }]
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
window.localStorage.removeItem('admin-platform-tab')
pinia = createPinia()
setActivePinia(pinia)
const session = useAdminSessionStore()
session.user = { id: 1, username: 'root', role: 'super_admin' }
companiesApi.fetchCompanies.mockImplementation(async (platform?: string) =>
platform === 'jd' ? JD_COMPANIES : AMAZON_COMPANIES)
})
function tabTexts(wrapper: ReturnType<typeof mount>) {
return wrapper.findAll('.company-tab').map((b) => b.text())
}
describe('CompanyTabs × 平台 tab', () => {
it('亚马逊 tab(默认):目录请求带 platform=amazon,只画亚马逊公司的 tab', async () => {
const wrapper = mount(CompanyTabs)
await flushPromises()
expect(companiesApi.fetchCompanies).toHaveBeenCalledWith('amazon')
expect(tabTexts(wrapper)).toEqual(['厦门米椿花', '德阳-团队', '先锋-团队'])
expect(useCompanyTabStore().activeId).toBe(1)
wrapper.unmount()
})
it('切到京东 tab:重拉 platform=jd;京东侧仅一家 ⇒ tab 条不画,但 activeId 落在京东-团队(各页取数按它收窄)', async () => {
const wrapper = mount(CompanyTabs)
await flushPromises()
usePlatformTabStore().setActive('jd')
await flushPromises()
expect(companiesApi.fetchCompanies).toHaveBeenLastCalledWith('jd')
expect(wrapper.find('.company-tabs').exists()).toBe(false)
const tabStore = useCompanyTabStore()
expect(tabStore.companies.map((c) => c.companyName)).toEqual(['京东-团队'])
expect(tabStore.activeId).toBe(4)
expect(tabStore.requestCompanyId).toBe(4)
wrapper.unmount()
})
it('切回亚马逊:再拉 platform=amazon,旧选中(京东-团队)不在清单 ⇒ 回落 id 最小的启用公司', async () => {
const wrapper = mount(CompanyTabs)
await flushPromises()
usePlatformTabStore().setActive('jd')
await flushPromises()
usePlatformTabStore().setActive('amazon')
await flushPromises()
expect(tabTexts(wrapper)).toEqual(['厦门米椿花', '德阳-团队', '先锋-团队'])
expect(useCompanyTabStore().activeId).toBe(1)
wrapper.unmount()
})
it('同平台 force 重拉(公司保存后的 refresh):选中公司仍在 ⇒ 选中不跳;请求带当前平台', async () => {
const wrapper = mount(CompanyTabs)
await flushPromises()
const tabStore = useCompanyTabStore()
tabStore.setActiveId(2)
await tabStore.refresh()
await flushPromises()
expect(companiesApi.fetchCompanies).toHaveBeenLastCalledWith('amazon')
expect(tabStore.activeId).toBe(2)
expect(tabStore.companies).toHaveLength(3)
wrapper.unmount()
})
it('非超管不发目录请求:切平台 tab 也不发', async () => {
const session = useAdminSessionStore()
session.user = { id: 5, username: '公司管理员', role: 'admin' }
const wrapper = mount(CompanyTabs)
await flushPromises()
usePlatformTabStore().setActive('jd')
await flushPromises()
expect(companiesApi.fetchCompanies).not.toHaveBeenCalled()
wrapper.unmount()
})
})
@@ -0,0 +1,364 @@
/**
* 京东分类管理对话框(JdCategoryManageDialog)的挂载契约。
*
* 2026-11-17 用户口径「京东分类管理并到京东数据库分类编辑里,做一个搜索和添加 删除
* 编辑 分类名称即可」:V204 独立子菜单页(JdCategoryManagerPage,已删)整体并入本对话框,
* 从京东数据库页工具栏「分类管理」打开。原页面契约逐条承接:当前数据权限分组的
* 分类建/改名/删除;新增名称搜索(本地过滤)。商品归类不在这里(去「批量编辑分类」)。
* 权限口径(V203)不变:editable 才渲染写控件;同组普通号只读可看。
*
* 跑法:`npx vitest run tests/mount/jd-category-manage-dialog.mount.test.ts`
*/
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 JdCategoryManageDialog from '@/pages/jd/JdCategoryManageDialog.vue'
import { useAdminSessionStore } from '@/stores/admin-session'
const jdApi = vi.hoisted(() => ({
fetchJdProductGroups: vi.fn(),
createJdProductGroup: vi.fn(),
updateJdProductGroup: vi.fn(),
deleteJdProductGroup: vi.fn(),
}))
const groupApi = vi.hoisted(() => ({
createShopGroup: vi.fn(),
}))
const confirmMock = vi.hoisted(() => vi.fn())
vi.mock('@/pages/jd/jd-product-api.ts', () => jdApi)
vi.mock('@/pages/account/shop-group-api.ts', () => groupApi)
vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock }))
/** 分组 id 常量:默认作用域就这一个可见且可写的组(组长档形状)。 */
const GROUP_A = 11
function group(id: number, name: string, productCount = 0, sortOrder = 0) {
return { id, name, ownerGroupId: GROUP_A, sortOrder, productCount }
}
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
pinia = createPinia()
setActivePinia(pinia)
// 空态直建分组(2026-11-17 用户口径「admin 权限最大」)需要当前登录人做组长。
useAdminSessionStore().user = { id: 9, username: 'admin', role: 'super_admin' } as never
jdApi.fetchJdProductGroups.mockResolvedValue([])
groupApi.createShopGroup.mockResolvedValue({ id: 21, name: '京东-团队', ownerGroupId: 21, sortOrder: 0, productCount: 0 })
confirmMock.mockResolvedValue(true)
})
async function mountDialog(editable = true): Promise<VueWrapper<Element>> {
const wrapper = mount(JdCategoryManageDialog, {
global: { plugins: [pinia] },
props: {
visible: true,
ownerGroupId: GROUP_A,
ownerGroupName: '甲组',
editable,
},
})
await flushPromises()
await flushPromises()
return wrapper
}
describe('京东分类管理对话框(V204 独立页 2026-11-17 并入京东数据库页)', () => {
it('打开即按当前分组取分类(ownerGroupId 必带);标题不带分组名(2026-11-17 用户口径「不要显示周丽娥」)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledWith(GROUP_A)
expect(wrapper.get('.manage-modal').text()).toContain('分类管理')
expect(wrapper.find('.modal-sub').exists()).toBe(false, '标题后缀(· 分组名)已删,不得长回来')
expect(wrapper.get('.manage-modal').text()).not.toContain('甲组', '分组名不进标题')
expect(wrapper.findAll('.option-row')).toHaveLength(1)
wrapper.unmount()
})
it('新建分类:落当前分组归属(ownerGroupId 必带),成功后清输入重取并通知父页刷新', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
await wrapper.get('.group-create input').setValue('上新区')
await wrapper.findAll('button').find((b) => b.text() === '新建')!.trigger('click')
await flushPromises()
expect(jdApi.createJdProductGroup).toHaveBeenCalledWith({ name: '上新区', sortOrder: 0, ownerGroupId: GROUP_A })
expect((wrapper.get('.group-create input').element as HTMLInputElement).value).toBe('')
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledTimes(2, '成功后重取分类列表')
expect(wrapper.emitted('changed'), '写成功必须 emit changed 让父页刷筛选下拉').toBeTruthy()
wrapper.unmount()
})
it('搜索:按名称包含本地过滤(不发额外请求),命中后新建会清关键字', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3), group(8, '裤装', 1), group(9, '配饰', 0)])
const wrapper = await mountDialog()
const callsBefore = jdApi.fetchJdProductGroups.mock.calls.length
await wrapper.get('.search-input').setValue('裙')
await flushPromises()
expect(wrapper.findAll('.option-row')).toHaveLength(1, '「裙」只命中裙装')
expect(wrapper.findAll('.option-row')[0].text()).toContain('裙装')
expect(jdApi.fetchJdProductGroups.mock.calls.length).toBe(callsBefore, '搜索是本地过滤,不另发请求')
expect(wrapper.text()).not.toContain('裤装', '不匹配项不出现')
await wrapper.get('.group-create input').setValue('上新区')
await wrapper.findAll('button').find((b) => b.text() === '新建')!.trigger('click')
await flushPromises()
expect((wrapper.get('.search-input').element as HTMLInputElement).value).toBe('',
'新建成功清关键字(新分类不被旧搜索藏住)')
wrapper.unmount()
})
it('搜索无命中给显式空态文案(不是空列表静默)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
await wrapper.get('.search-input').setValue('不存在的分类')
expect(wrapper.get('.manage-empty').text()).toBe('没有匹配的分类')
wrapper.unmount()
})
it('分页:每页 6 条、翻页只换当前页、改搜索回第一页(2026-11-17 用户口径「分类这也要加分页」)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue(
Array.from({ length: 11 }, (_, index) => group(100 + index, `分类${index + 1}`)),
)
const wrapper = await mountDialog()
expect(wrapper.findAll('.option-row')).toHaveLength(6, '第一页只渲染 6 行')
expect(wrapper.text()).not.toContain('分类7', '第 7 条以后不在第一页')
const pagerText = wrapper.get('.manage-pager').text()
expect(pagerText).toContain('第 1 / 2 页')
expect(pagerText).toContain('共 11 个分类', '总数取搜索命中集,不是当前页行数')
await wrapper.findAll('.manage-pager button').find((b) => b.text() === '下一页')!.trigger('click')
await flushPromises()
expect(wrapper.findAll('.option-row')).toHaveLength(5, '第二页剩 5 行')
expect(wrapper.text()).toContain('分类11')
expect(wrapper.get('.manage-pager').text()).toContain('第 2 / 2 页')
await wrapper.get('.search-input').setValue('分类1')
await flushPromises()
expect(wrapper.find('.manage-pager').exists()).toBe(false, '命中 3 条不足一页 ⇒ 不渲染页码条')
expect(wrapper.findAll('.option-row')).toHaveLength(3, '搜索回第一页(不是停在旧页码的空白处)')
wrapper.unmount()
})
it('分页:一屏装得下就不出页码条(不白占一行)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3), group(8, '裤装', 1)])
const wrapper = await mountDialog()
expect(wrapper.findAll('.option-row')).toHaveLength(2)
expect(wrapper.find('.manage-pager').exists()).toBe(false)
wrapper.unmount()
})
it('搜索与新建行同属 manage-bar 的一排(搜索在左、新建在右,2026-11-17 用户口径「弄成一排呗」)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
const bar = wrapper.get('.manage-bar')
const children = Array.from(bar.element.children)
expect(children).toHaveLength(2, '一排只有两件:搜索框、新建行(新建行内=输入框+新建按钮)')
expect(children[0].classList.contains('search-input')).toBe(true, '搜索框在左')
expect(children[1].classList.contains('group-create')).toBe(true, '新建行在右')
expect(children[1].children).toHaveLength(2, '新建行只有输入框+按钮(排序输入 11-15 已下线,不得长出第三个框)')
wrapper.unmount()
})
it('改名:行内编辑后按 (id, {name, sortOrder}) 提交并 emit changed', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
await wrapper.findAll('button').find((b) => b.text() === '改名')!.trigger('click')
await wrapper.get('.rename-input').setValue('长裙')
await wrapper.findAll('button').find((b) => b.text() === '保存')!.trigger('click')
await flushPromises()
expect(jdApi.updateJdProductGroup).toHaveBeenCalledWith(7, { name: '长裙', sortOrder: 0 })
expect(wrapper.emitted('changed')).toBeTruthy()
wrapper.unmount()
})
it('删除:二次确认文案点名商品数(删除不删商品,只解挂归属),确认后调端点重取', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
await wrapper.findAll('button').find((b) => b.text() === '删除')!.trigger('click')
await flushPromises()
expect(confirmMock).toHaveBeenCalledTimes(1)
const options = confirmMock.mock.calls[0][0]
expect(options.title).toBe('删除分类')
expect(options.message).toContain('确定删除分类「裙装」吗')
expect(options.message).toContain('3 个商品回到未分类', '文案点名该分类下的商品数')
expect(options.danger).toBe(true)
expect(jdApi.deleteJdProductGroup).toHaveBeenCalledWith(7)
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledTimes(2, '删除成功后重取列表')
expect(wrapper.emitted('changed')).toBeTruthy()
wrapper.unmount()
})
it('删除确认点取消就不发请求(防误删第一道闸)', async () => {
confirmMock.mockResolvedValue(false)
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
await wrapper.findAll('button').find((b) => b.text() === '删除')!.trigger('click')
await flushPromises()
expect(confirmMock).toHaveBeenCalledTimes(1)
expect(jdApi.deleteJdProductGroup).not.toHaveBeenCalled()
wrapper.unmount()
})
it('只读档(editable=false):无新建行、无搜索仍可用、无改名/删除按钮', async () => {
const wrapper = await mountDialog(false)
expect(wrapper.find('.group-create').exists()).toBe(false, '只读账号不渲染新建行')
expect(wrapper.findAll('button').some((b) => b.text() === '改名')).toBe(false)
expect(wrapper.findAll('button').some((b) => b.text() === '删除')).toBe(false)
expect(wrapper.get('.search-input').exists()).toBe(true, '搜索是读面,只读档保留')
wrapper.unmount()
})
it('不属于任何数据权限分组(ownerGroupId<=0):不发取数请求,空态直说', async () => {
const wrapper = mount(JdCategoryManageDialog, {
global: { plugins: [pinia] },
props: { visible: true, ownerGroupId: 0, ownerGroupName: '', editable: false },
})
await flushPromises()
await flushPromises()
expect(jdApi.fetchJdProductGroups).not.toHaveBeenCalled()
expect(wrapper.get('.manage-empty').text()).toBe('你还不属于任何数据权限分组')
expect(wrapper.find('.group-create').exists()).toBe(false)
wrapper.unmount()
})
it('本组暂无分类:可写档文案引导新建,只读档直说', async () => {
const writable = await mountDialog(true)
expect(writable.get('.manage-empty').text()).toBe('本组暂无分类,先新建一个')
writable.unmount()
const readonly = await mountDialog(false)
expect(readonly.get('.manage-empty').text()).toBe('本组暂无分类')
readonly.unmount()
})
it('加载失败:红条可见且重试真能重跑(取数页硬规矩)', async () => {
jdApi.fetchJdProductGroups.mockRejectedValueOnce(new Error('上游 502'))
const wrapper = mount(JdCategoryManageDialog, {
global: { plugins: [pinia] },
props: { visible: true, ownerGroupId: GROUP_A, ownerGroupName: '甲组', editable: true },
})
await flushPromises()
await flushPromises()
const bar = wrapper.find('.load-failure-bar')
expect(bar.exists()).toBe(true, '失败态必须可见(不是一闪而过的 toast)')
expect(bar.text()).toContain('分类列表加载失败')
expect(bar.text()).toContain('上游 502', '后端/网络原因要进文案')
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
await bar.find('button').trigger('click')
await flushPromises()
await flushPromises()
expect(wrapper.find('.load-failure-bar').exists()).toBe(false, '重试成功后红条消失')
expect(wrapper.text()).toContain('裙装')
wrapper.unmount()
})
it('页面职责边界(反向钉):归类不在本对话框——不出现批量归类/删除勾选入口', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountDialog()
expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '归类入口在京东数据库页')
expect(wrapper.text()).not.toContain('批量编辑分类',
'指路小字已随 2026-11-17 用户口径「小字不需要」删除,弹窗里不该再出现这句')
expect(jdApi.deleteJdProductGroup).not.toHaveBeenCalled()
wrapper.unmount()
})
})
/** 平台超管空态直建分组(2026-11-17 用户口径「admin 权限最大」):京东侧还没有任何
* 数据权限分组时(平台闸上线后 jd 档组全空,B117-02 前置未做),平台超管在弹窗里
* 直接建第一个京东档分组,不再死在「你还不属于任何数据权限分组」。 */
describe('平台超管空态直建京东档分组', () => {
function mountEmpty(platformSuperAdmin: boolean): VueWrapper<Element> {
return mount(JdCategoryManageDialog, {
global: { plugins: [pinia] },
props: { visible: true, ownerGroupId: 0, ownerGroupName: '', editable: false, platformSuperAdmin },
})
}
it('平台超管空态:出直建表单(不是死路文案),提交走分组管理同一条 POST 且 platform 恒 jd、组长=当前登录人', async () => {
const wrapper = mountEmpty(true)
await flushPromises()
await flushPromises()
expect(jdApi.fetchJdProductGroups).not.toHaveBeenCalled()
expect(wrapper.get('.manage-empty').find('[aria-label="新分组名称"]').exists()).toBe(true,
'空态直建表单就在空态区里(引导语小字已删,表单本身还在)')
const input = wrapper.get('[aria-label="新分组名称"]')
await input.setValue('京东-团队')
await wrapper.findAll('button').find((b) => b.text() === '新建分组')!.trigger('click')
await flushPromises()
await flushPromises()
expect(groupApi.createShopGroup).toHaveBeenCalledTimes(1)
expect(groupApi.createShopGroup).toHaveBeenCalledWith('京东-团队', [], 9, 'jd')
expect(wrapper.emitted('group-created'), '建组成功即通知父页重取作用域').toBeTruthy()
expect((input.element as HTMLInputElement).value).toBe('', '成功后清输入')
wrapper.unmount()
})
it('没有当前登录人就不发请求并给可见错误(组长缺了这单没法建)', async () => {
useAdminSessionStore().user = null
const wrapper = mountEmpty(true)
await flushPromises()
await wrapper.get('[aria-label="新分组名称"]').setValue('京东-团队')
await wrapper.findAll('button').find((b) => b.text() === '新建分组')!.trigger('click')
await flushPromises()
expect(groupApi.createShopGroup).not.toHaveBeenCalled()
expect(wrapper.text()).toContain('无法获取当前登录用户')
wrapper.unmount()
})
it('建组失败:错误进红条、不发 group-created(父页作用域不动)', async () => {
groupApi.createShopGroup.mockRejectedValueOnce(new Error('分组名称已存在'))
const wrapper = mountEmpty(true)
await flushPromises()
await wrapper.get('[aria-label="新分组名称"]').setValue('京东-团队')
await wrapper.findAll('button').find((b) => b.text() === '新建分组')!.trigger('click')
await flushPromises()
await flushPromises()
expect(wrapper.text()).toContain('分组名称已存在')
expect(wrapper.emitted('group-created')).toBeFalsy()
wrapper.unmount()
})
it('父页把 ownerGroupId 翻到新组后:直建表单消失、按新组重取分类(不用关弹窗重开)', async () => {
const wrapper = mountEmpty(true)
await flushPromises()
await wrapper.get('[aria-label="新分组名称"]').setValue('京东-团队')
await wrapper.findAll('button').find((b) => b.text() === '新建分组')!.trigger('click')
await flushPromises()
const emittedBefore = wrapper.emitted('group-created')?.length ?? 0
await wrapper.setProps({ ownerGroupId: 21, ownerGroupName: '京东-团队', editable: true })
await flushPromises()
await flushPromises()
expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(21)
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledWith(21)
expect(wrapper.find('[aria-label="新分组名称"]').exists()).toBe(false, '有组了直建口子就关')
expect(wrapper.emitted('group-created')?.length).toBe(emittedBefore, '翻组重取不再重复通知父页')
wrapper.unmount()
})
it('非平台超管的空态维持原状:死路文案照旧、无直建表单(口子不开给组长/公司超管)', async () => {
const wrapper = mountEmpty(false)
await flushPromises()
expect(wrapper.get('.manage-empty').text()).toBe('你还不属于任何数据权限分组')
expect(wrapper.find('[aria-label="新分组名称"]').exists()).toBe(false)
wrapper.unmount()
})
it('平台超管但已有分组(ownerGroupId>0):直建口子不出现(完整分组管理归「分组管理」页)', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = mount(JdCategoryManageDialog, {
global: { plugins: [pinia] },
props: { visible: true, ownerGroupId: GROUP_A, ownerGroupName: '甲组', editable: true, platformSuperAdmin: true },
})
await flushPromises()
await flushPromises()
expect(wrapper.find('[aria-label="新分组名称"]').exists()).toBe(false)
expect(wrapper.find('.group-bootstrap').exists()).toBe(false, '有组时直建表单整体不渲染')
wrapper.unmount()
})
})
@@ -1,172 +0,0 @@
/**
* 京东分类管理页(V204,2026-11-17 用户口径「店铺分类弹窗删了,加个京东分类管理的子菜单
* 维护 CRUD」)的挂载契约:当前数据权限分组的分类建/改名/删除独立成页;分组作用域与
* 京东数据库页同一套(京东侧分组,非亚马逊——platform-scope JD_MENU_KEYS);
* 商品归类不在这里(去京东数据库页「批量编辑分类」)。
*
* 跑法:`npx vitest run tests/mount/jd-category-manager-page.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import JdCategoryManagerPage from '@/pages/jd/JdCategoryManagerPage.vue'
const jdApi = vi.hoisted(() => ({
fetchJdCategoryScope: vi.fn(),
fetchJdProductGroups: vi.fn(),
createJdProductGroup: vi.fn(),
updateJdProductGroup: vi.fn(),
deleteJdProductGroup: vi.fn(),
}))
const confirmMock = vi.hoisted(() => vi.fn())
vi.mock('@/pages/jd/jd-product-api.ts', () => jdApi)
vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock }))
/** 分组 id 常量:默认作用域就这一个可见且可写的组(组长档形状)。 */
const GROUP_A = 11
function singleGroupScope(editable = true) {
return {
platformSuperAdmin: false,
defaultGroupId: GROUP_A,
groups: [{ id: GROUP_A, name: '甲组', label: '甲组', editable }],
}
}
function group(id: number, name: string, productCount = 0, sortOrder = 0) {
return { id, name, ownerGroupId: GROUP_A, sortOrder, productCount }
}
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
pinia = createPinia()
setActivePinia(pinia)
jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope())
jdApi.fetchJdProductGroups.mockResolvedValue([])
confirmMock.mockResolvedValue(true)
})
async function mountPage(): Promise<ReturnType<typeof mount>> {
const wrapper = mount(JdCategoryManagerPage, { global: { plugins: [pinia] } })
await flushPromises()
await flushPromises()
return wrapper
}
describe('京东分类管理(V204 子菜单页)', () => {
it('首屏按默认组取分类;多组可见出「分组」下拉,切组重取', async () => {
jdApi.fetchJdCategoryScope.mockResolvedValue({
platformSuperAdmin: true,
defaultGroupId: GROUP_A,
groups: [
{ id: GROUP_A, name: 'A组', label: '甲公司 / A组', editable: true },
{ id: 12, name: 'B组', label: '甲公司 / B组', editable: false },
],
})
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountPage()
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledWith(GROUP_A)
const picker = wrapper.get('[aria-label="当前分组"]')
expect((picker.element as HTMLSelectElement).closest('.form-group')?.querySelector('label')?.textContent).toBe('分组',
'分组是带标签的表单控件(与京东数据库页筛选行同口径)')
expect(picker.findAll('option').map((o) => o.text())).toEqual(['甲公司 / A组', '甲公司 / B组'])
await picker.setValue('12')
await flushPromises()
// 切组后分类按新组重取(跨组不可见,V203)。
expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(12)
wrapper.unmount()
})
it('新建分类:落当前分组归属(ownerGroupId 必带),成功后清输入并重取', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountPage()
await wrapper.get('.group-create input').setValue('上新区')
await wrapper.findAll('button').find((b) => b.text() === '新建')!.trigger('click')
await flushPromises()
expect(jdApi.createJdProductGroup).toHaveBeenCalledWith({ name: '上新区', sortOrder: 0, ownerGroupId: GROUP_A })
expect((wrapper.get('.group-create input').element as HTMLInputElement).value).toBe('')
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledTimes(2, '成功后重取分类列表')
wrapper.unmount()
})
it('改名:行内编辑后按 (id, {name, sortOrder}) 提交', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountPage()
await wrapper.findAll('button').find((b) => b.text() === '改名')!.trigger('click')
await wrapper.get('.rename-input').setValue('长裙')
await wrapper.findAll('button').find((b) => b.text() === '保存')!.trigger('click')
await flushPromises()
expect(jdApi.updateJdProductGroup).toHaveBeenCalledWith(7, { name: '长裙', sortOrder: 0 })
wrapper.unmount()
})
it('删除:二次确认文案点名商品数(删除不删商品,只解挂归属),确认后调端点重取', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountPage()
await wrapper.findAll('button').find((b) => b.text() === '删除')!.trigger('click')
await flushPromises()
expect(confirmMock).toHaveBeenCalledTimes(1)
const options = confirmMock.mock.calls[0][0]
expect(options.title).toBe('删除分类')
expect(options.message).toContain('确定删除分类「裙装」吗')
expect(options.message).toContain('3 个商品回到未分类', '文案点名该分类下的商品数')
expect(options.danger).toBe(true)
expect(jdApi.deleteJdProductGroup).toHaveBeenCalledWith(7)
wrapper.unmount()
})
it('只读档(editable=false):无新建行、无改名/删除按钮,空表文案不带「先新建」', async () => {
jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope(false))
jdApi.fetchJdProductGroups.mockResolvedValue([])
const wrapper = await mountPage()
expect(wrapper.find('.group-create').exists()).toBe(false, '只读账号不渲染新建行')
expect(wrapper.findAll('button').some((b) => b.text() === '改名')).toBe(false)
expect(wrapper.findAll('button').some((b) => b.text() === '删除')).toBe(false)
expect(wrapper.find('thead').text()).not.toContain('操作', '只读档连操作列表头都不渲染')
expect(wrapper.find('.empty-tip').text()).toBe('本组暂无分类')
wrapper.unmount()
})
it('不属于任何数据权限分组:锁定芯片直说空态,不出下拉与新建行', async () => {
jdApi.fetchJdCategoryScope.mockResolvedValue({ platformSuperAdmin: false, defaultGroupId: null, groups: [] })
const wrapper = await mountPage()
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false)
expect(wrapper.get('.group-locked').text()).toBe('你还不属于任何数据权限分组')
expect(wrapper.find('.group-create').exists()).toBe(false)
expect(wrapper.find('.empty-tip').text()).toBe('你还不属于任何数据权限分组')
wrapper.unmount()
})
it('加载失败:红条可见且重试真能重跑(取数页硬规矩),切组后重取成功即清', async () => {
jdApi.fetchJdProductGroups.mockRejectedValueOnce(new Error('上游 502'))
const wrapper = mount(JdCategoryManagerPage, { global: { plugins: [pinia] } })
await flushPromises()
await flushPromises()
const bar = wrapper.find('.load-failure-bar')
expect(bar.exists()).toBe(true, '失败态必须可见(不是一闪而过的 toast)')
expect(bar.text()).toContain('分类列表加载失败')
expect(bar.text()).toContain('上游 502', '后端/网络原因要进文案')
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
await bar.find('button').trigger('click')
await flushPromises()
await flushPromises()
expect(wrapper.find('.load-failure-bar').exists()).toBe(false, '重试成功后红条消失')
expect(wrapper.text()).toContain('裙装')
wrapper.unmount()
})
it('页面职责边界(反向钉):归类不在本页——页面不出现批量归类/商品列表入口', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([group(7, '裙装', 3)])
const wrapper = await mountPage()
expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '归类入口在京东数据库页')
expect(wrapper.text()).toContain('京东数据库', '页内提示指路「京东数据库」页')
expect(jdApi.deleteJdProductGroup).not.toHaveBeenCalled()
wrapper.unmount()
})
})
@@ -4,8 +4,11 @@
* 形态:panel-box + 筛选行(商品编码/标题关键字/类目/分组/同步起止 date 对)+ * 形态:panel-box + 筛选行(商品编码/标题关键字/类目/分组/同步起止 date 对)+
* 查询/重置 + 自绘明细表(点行开详情抽屉)+ OldPagination; * 查询/重置 + 自绘明细表(点行开详情抽屉)+ OldPagination;
* 分组下拉 2026-11-16 用户口径「做成分组」上移进筛选行=带标签的表单控件(不再是工具栏裸下拉); * 分组下拉 2026-11-16 用户口径「做成分组」上移进筛选行=带标签的表单控件(不再是工具栏裸下拉);
* 店铺分类弹窗 2026-11-17 用户口径下线:工具栏改「批量编辑分类」(勾选跨页累计+归入/移出), * 店铺分类弹窗 2026-11-17 用户口径下线:工具栏改「批量编辑分类」(勾选跨页累计+归入/移出);
* 分类建/改名/删除挪「京东分类管理」子菜单页(V204,另见 jd-category-manager-page.mount.test.ts)。 * 同日第二刀「京东分类管理并到京东数据库分类编辑里」:V204 独立子菜单页下线
* (jd-category-manager-page.mount.test.ts 随之删除),建/改名/删分类+搜索收进工具栏
* 「分类管理」对话框(另见 jd-category-manage-dialog.mount.test.ts);
* 「清除勾选」按钮同日用户口径删除(勾选只在批量操作成功后自动清)。
* 公司维度 2026-11-16 整页摘除(「删除掉公司 tab,参考品牌数据库」):页面不消费公司 tab * 公司维度 2026-11-16 整页摘除(「删除掉公司 tab,参考品牌数据库」):页面不消费公司 tab
* store、列表/类目下拉不带 company_id(反向钉在 company-tab-wiring「公司维度不得回流」)。 * store、列表/类目下拉不带 company_id(反向钉在 company-tab-wiring「公司维度不得回流」)。
* 商品状态筛选/列与导出按钮已随 2026-11-15 客户口径从前端下线(后端端点保留); * 商品状态筛选/列与导出按钮已随 2026-11-15 客户口径从前端下线(后端端点保留);
@@ -15,8 +18,9 @@
* 跑法:`npx vitest run tests/mount/jd-database-page.mount.test.ts` * 跑法:`npx vitest run tests/mount/jd-database-page.mount.test.ts`
*/ */
import { beforeEach, describe, expect, it, vi } from 'vitest' import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils' import { DOMWrapper, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia' import { createPinia, setActivePinia, type Pinia } from 'pinia'
import { ElOption, ElSelect } from 'element-plus'
import JdDatabasePage from '@/pages/jd/JdDatabasePage.vue' import JdDatabasePage from '@/pages/jd/JdDatabasePage.vue'
import OldPagination from '@/components/OldPagination.vue' import OldPagination from '@/components/OldPagination.vue'
@@ -41,7 +45,12 @@ const jdApi = vi.hoisted(() => ({
const confirmMock = vi.hoisted(() => vi.fn()) const confirmMock = vi.hoisted(() => vi.fn())
const groupApi = vi.hoisted(() => ({
createShopGroup: vi.fn(),
}))
vi.mock('@/pages/jd/jd-product-api.ts', () => jdApi) vi.mock('@/pages/jd/jd-product-api.ts', () => jdApi)
vi.mock('@/pages/account/shop-group-api.ts', () => groupApi)
vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock })) vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock }))
function item(id: number, over: Record<string, unknown> = {}) { function item(id: number, over: Record<string, unknown> = {}) {
@@ -99,56 +108,84 @@ beforeEach(() => {
jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope()) jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope())
jdApi.fetchJdProductGroups.mockResolvedValue([]) jdApi.fetchJdProductGroups.mockResolvedValue([])
jdApi.fetchJdProductCategories.mockResolvedValue([]) jdApi.fetchJdProductCategories.mockResolvedValue([])
groupApi.createShopGroup.mockResolvedValue({ id: 21, name: '京东-团队', ownerGroupId: 21, sortOrder: 0, productCount: 0 })
confirmMock.mockResolvedValue(true) confirmMock.mockResolvedValue(true)
}) })
async function mountWith(payload: unknown): Promise<VueWrapper<Element>> { async function mountWith(payload: unknown): Promise<VueWrapper<Element>> {
jdApi.fetchJdProductList.mockImplementation(() => Promise.resolve(payload)) jdApi.fetchJdProductList.mockImplementation(() => Promise.resolve(payload))
const wrapper = mount(JdDatabasePage, { global: { plugins: [pinia] } }) const wrapper = mount(JdDatabasePage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises() await flushPromises()
await flushPromises() await flushPromises()
return wrapper return wrapper
} }
// ---------------- el-select 交互助手(2026-11-17 两颗下拉换 el-select,与亚马逊面统一) ----------------
// aria-label 经 EP 的 ariaLabel prop 落在内层 combobox input 上;选项弹层 teleport 到 body,
// 但 ElOption/ElSelect 组件仍在挂载树里 ⇒ 选项清单走组件树读,点选走「点开→点选项」真实路径。
/** 按 aria-label 找对应的 ElSelect 组件实例(页面有两颗下拉,靠内层 input 的 aria-label 区分)。 */
function selectByLabel(wrapper: VueWrapper<Element>, label: string) {
const found = wrapper.findAllComponents(ElSelect).find((s) => s.find(`[aria-label="${label}"]`).exists())
expect(found, `应存在 aria-label="${label}" 的下拉`).toBeTruthy()
return found!
}
/** 读某颗下拉的全部选项文案(label prop;组件树查询不受弹层 teleport 影响)。 */
function optionLabels(wrapper: VueWrapper<Element>, label: string): string[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('label') as string)
}
/** 点开指定下拉并点选目标文案的选项(触发 update:modelValue + change,与真实用户一致)。
* 面板按内层 input 的 aria-controls 圈定,避免另一颗(可能仍挂着的)弹层串台。 */
async function pickSelectOption(wrapper: VueWrapper<Element>, label: string, optionText: string): Promise<void> {
const input = wrapper.get(`[aria-label="${label}"]`)
await input.trigger('click')
await flushPromises()
const contentId = input.attributes('aria-controls')
const scope = (contentId && document.getElementById(contentId)) ?? document.body
const items = [...scope.querySelectorAll('.el-select-dropdown__item')]
.filter((el) => !el.classList.contains('is-hidden'))
const target = items.find((el) => (el.textContent ?? '').trim() === optionText)
expect(target, `下拉应弹出「${optionText}」选项`).toBeTruthy()
await new DOMWrapper(target as Element).trigger('click')
await flushPromises()
}
/** 批量编辑分类(2026-11-17 用户口径「店铺分类弹窗删了,加个批量编辑分类」): /** 批量编辑分类(2026-11-17 用户口径「店铺分类弹窗删了,加个批量编辑分类」):
* 勾选跨页累计记忆(翻页/重取不清)→ 对话框选目标分类归入或移出 → 按 (ids, groupId, * 勾选跨页累计记忆(翻页/重取不清)→ 对话框选目标分类归入或移出 → 按 (ids, groupId,
* ownerGroupId) 提交;成功后清勾选并重取。旧弹窗的「勾选翻页即清」口径同日废止。 */ * ownerGroupId) 提交;成功后清勾选并重取。旧弹窗的「勾选翻页即清」口径同日废止。 */
describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代入口)', () => { describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代入口)', () => {
it('勾选跨页记忆:第 1 页勾 1 行翻到第 2 页再勾 1 行,删除按累计 2 行提交,清除勾选可显式清零', async () => { it('勾选跨页记忆:第 1 页勾 1 行翻到第 2 页再勾 1 行,删除按累计 2 行提交;「清除勾选」按钮已删(2026-11-17 用户口径)', async () => {
jdApi.fetchJdProductList jdApi.fetchJdProductList
.mockImplementationOnce(() => Promise.resolve({ items: [item(1)], total: 40, page: 1, pageSize: 20 })) .mockImplementationOnce(() => Promise.resolve({ items: [item(1)], total: 40, page: 1, pageSize: 20 }))
.mockImplementation(() => Promise.resolve({ items: [item(2)], total: 40, page: 2, pageSize: 20 })) .mockImplementation(() => Promise.resolve({ items: [item(2)], total: 40, page: 2, pageSize: 20 }))
const wrapper = mount(JdDatabasePage, { global: { plugins: [pinia] } }) const wrapper = mount(JdDatabasePage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises() await flushPromises()
await flushPromises() await flushPromises()
const deleteBtn = () => wrapper.get('.jd-delete-btn') const deleteBtn = () => wrapper.get('.jd-delete-btn')
const clearBtn = () => wrapper.findAll('button').find((b) => b.text() === '清除勾选')
await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true) await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true)
expect(deleteBtn().text()).toContain('删除勾选(1)') expect(deleteBtn().text()).toContain('批量删除(1)')
// 翻页:勾选不清(2026-11-17 口径「支持勾选翻页也要记住」)。 // 翻页:勾选不清(2026-11-17 口径「支持勾选翻页也要记住」)。
await wrapper.findAll('button').find((b) => b.text() === '下一页')!.trigger('click') await wrapper.findAll('button').find((b) => b.text() === '下一页')!.trigger('click')
await flushPromises() await flushPromises()
expect(deleteBtn().text()).toContain('删除勾选(1)', '翻页后第 1 页的勾选仍在累计集里') expect(deleteBtn().text()).toContain('批量删除(1)', '翻页后第 1 页的勾选仍在累计集里')
await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true) await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true)
expect(deleteBtn().text()).toContain('删除勾选(2)', '第 2 页再勾 1 行,累计 2 行') expect(deleteBtn().text()).toContain('批量删除(2)', '第 2 页再勾 1 行,累计 2 行')
expect(clearBtn(), '有勾选时「清除勾选」出现').toBeTruthy() expect(wrapper.findAll('button').some((b) => b.text() === '清除勾选')).toBe(false,
'「清除勾选」按钮 2026-11-17 用户口径删除(显式反悔口没了,勾选只在批量操作成功后自动清)')
// 累计勾选直达删除:跨页的行一起删(确认弹窗点名总数)。 // 累计勾选直达删除:跨页的行一起删(确认弹窗点名总数)。
jdApi.deleteJdProducts.mockResolvedValueOnce({ deleted: 2, imagesDeleted: 0, objectsDeleted: 0, objectsKept: 0, objectsSkipped: 0 }) jdApi.deleteJdProducts.mockResolvedValueOnce({ deleted: 2, imagesDeleted: 0, objectsDeleted: 0, objectsKept: 0, objectsSkipped: 0 })
await deleteBtn().trigger('click') await deleteBtn().trigger('click')
await flushPromises() await flushPromises()
await flushPromises() await flushPromises()
expect(confirmMock.mock.calls.at(-1)![0].message).toContain('确定删除勾选的 2 个商品吗', '确认文案点名累计总数') expect(confirmMock.mock.calls.at(-1)![0].message).toContain('确定批量删除选中的 2 个商品吗', '确认文案点名累计总数')
// 跨页累计的 id 一起提交。 // 跨页累计的 id 一起提交。
expect(jdApi.deleteJdProducts).toHaveBeenLastCalledWith([1, 2]) expect(jdApi.deleteJdProducts).toHaveBeenLastCalledWith([1, 2])
expect(deleteBtn().text()).toContain('批量删除(0)', '批量删除成功后自动清勾选')
// 显式反悔口:清除勾选后按钮回置灰。
await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true)
await clearBtn()!.trigger('click')
expect(deleteBtn().text()).toContain('删除勾选(0)')
expect(wrapper.findAll('button').some((b) => b.text() === '清除勾选')).toBe(false, '勾选 0 时清除按钮消失')
wrapper.unmount() wrapper.unmount()
}) })
@@ -161,7 +198,7 @@ describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代
const wrapper = await mountWith({ items: [item(1), item(2)], total: 2, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1), item(2)], total: 2, page: 1, pageSize: 20 })
const editBtn = () => wrapper.findAll('button').find((b) => b.text() === '批量编辑分类')! const editBtn = () => wrapper.findAll('button').find((b) => b.text() === '批量编辑分类')!
expect(editBtn().attributes('disabled')).toBeDefined('勾选 0 时置灰(与删除勾选同款常显口径)') expect(editBtn().attributes('disabled')).toBeDefined('勾选 0 时置灰(与批量删除同款常显口径)')
const boxes = wrapper.findAll('tbody input[type="checkbox"]') const boxes = wrapper.findAll('tbody input[type="checkbox"]')
await boxes[0].setValue(true) await boxes[0].setValue(true)
await boxes[1].setValue(true) await boxes[1].setValue(true)
@@ -185,7 +222,7 @@ describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代
expect(document.body.textContent).toContain('已把 2 个商品归入「甲组」') expect(document.body.textContent).toContain('已把 2 个商品归入「甲组」')
expect(wrapper.find('.batch-modal').exists()).toBe(false, '成功后对话框自动关闭') expect(wrapper.find('.batch-modal').exists()).toBe(false, '成功后对话框自动关闭')
expect(jdApi.fetchJdProductList.mock.calls.length).toBeGreaterThan(callsBefore, '成功后重取列表(groupName 变了)') expect(jdApi.fetchJdProductList.mock.calls.length).toBeGreaterThan(callsBefore, '成功后重取列表(groupName 变了)')
expect(wrapper.get('.jd-delete-btn').text()).toContain('删除勾选(0)', '成功后清勾选') expect(wrapper.get('.jd-delete-btn').text()).toContain('批量删除(0)', '成功后清勾选')
wrapper.unmount() wrapper.unmount()
}) })
@@ -206,7 +243,7 @@ describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代
wrapper.unmount() wrapper.unmount()
}) })
it('本组暂无分类:对话框只留提示不给提交(移出对未分类行是无谓操作),引导去分类管理页', async () => { it('本组暂无分类:对话框只留提示不给提交(移出对未分类行是无谓操作),引导去工具栏「分类管理」新建', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([]) jdApi.fetchJdProductGroups.mockResolvedValue([])
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true) await wrapper.findAll('tbody input[type="checkbox"]')[0].setValue(true)
@@ -214,7 +251,7 @@ describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代
await flushPromises() await flushPromises()
const modal = wrapper.get('.batch-modal') const modal = wrapper.get('.batch-modal')
expect(modal.text()).toContain('本组暂无分类') expect(modal.text()).toContain('本组暂无分类')
expect(modal.text()).toContain('京东分类管理', '空态把维护入口指向「京东分类管理」') expect(modal.text()).toContain('分类管理', '空态把维护入口指向工具栏「分类管理」(独立页 2026-11-17 并入本页)')
expect(modal.findAll('button').some((b) => b.text() === '移出分类' && b.attributes('disabled') === undefined)).toBe(false, expect(modal.findAll('button').some((b) => b.text() === '移出分类' && b.attributes('disabled') === undefined)).toBe(false,
'无分类时移出不可提交') '无分类时移出不可提交')
expect(jdApi.batchAssignJdProductGroup).not.toHaveBeenCalled() expect(jdApi.batchAssignJdProductGroup).not.toHaveBeenCalled()
@@ -231,6 +268,148 @@ describe('批量编辑分类(店铺分类弹窗 2026-11-17 下线后的替代
}) })
}) })
/** 分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」+同日定默认卡未分类;
* 2026-11-18 用户口径「加个全部选项」恢复全量档):工具栏「筛选分类状态」下拉三档
* (全部/已分类/未分类),出厂默认与「重置」仍卡未分类(11-17 口径不动);
* 「全部」(value='')选中即查当前分组全部商品——序列化不下发 classified 参数;
* 页面发的是筛选态字符串(''/classified/ungrouped),布尔换算收在 jd-product-filter
* 单一出口(纯测试钉形状)。 */
describe('分类状态快筛(三档,默认卡未分类)', () => {
it('下拉三档且首屏就卡「未分类」(classified="ungrouped" 随首取下发)', async () => {
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(optionLabels(wrapper, '筛选分类状态')).toEqual(['全部', '已分类', '未分类'])
expect(jdApi.fetchJdProductList.mock.calls[0][0].classified).toBe('ungrouped',
'首屏默认档=未分类——用户口径「默认卡在未分类上就行」')
wrapper.unmount()
})
it('选「全部」下发不带 classified 键(查当前分组全部商品);选「已分类」下发 classified 态', async () => {
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
await pickSelectOption(wrapper, '筛选分类状态', '全部')
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).not.toHaveProperty('classified',
'value=\'\' 序列化不下发 classified 参数=后端跳过谓词查全部')
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ page: 1 }, '选中即查回第一页')
await pickSelectOption(wrapper, '筛选分类状态', '已分类')
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0].classified).toBe('classified')
wrapper.unmount()
})
it('「重置」不放开筛选,而是回默认未分类档', async () => {
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
await pickSelectOption(wrapper, '筛选分类状态', '已分类')
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0].classified).toBe('classified')
await wrapper.findAll('button').find((b) => b.text() === '重置')!.trigger('click')
await flushPromises()
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0].classified).toBe('ungrouped',
'重置回出厂默认档(未分类),「全部」只是可选项不接默认')
wrapper.unmount()
})
})
/** 分类管理入口(2026-11-17 用户口径「京东分类管理并到京东数据库分类编辑里」):
* V204 独立子菜单页下线,工具栏「分类管理」打开 JdCategoryManageDialog(搜索+新建+
* 改名+删除);入口对所有人渲染(同组普通号只读可看),写控件由对话框按 editable 分档;
* 对话框 CRUD 成功 emit changed ⇒ 父页刷分类筛选下拉。 */
describe('分类管理入口(V204 独立页并入京东数据库页)', () => {
it('工具栏「分类管理」入口常显(勾选 0 也可用),点开渲染对话框且按当前分组取分类', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '裙装', sortOrder: 0, productCount: 3 }])
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
const manageBtn = () => wrapper.findAll('button').find((b) => b.text() === '分类管理')
expect(manageBtn(), '入口常显(不等勾选)').toBeTruthy()
expect(wrapper.find('.manage-modal').exists()).toBe(false, '未点开时不渲染对话框')
const callsBefore = jdApi.fetchJdProductGroups.mock.calls.length
await manageBtn()!.trigger('click')
await flushPromises()
const modal = wrapper.get('.manage-modal')
expect(modal.text()).toContain('分类管理')
expect(modal.text()).not.toContain('甲组', '标题不带分组名后缀(ea9dca3f 用户口径「不要显示周丽娥」)')
expect(modal.get('.search-input').exists()).toBe(true, '搜索框是本对话框新能力')
expect(modal.text()).toContain('裙装')
expect(jdApi.fetchJdProductGroups.mock.calls.length).toBeGreaterThan(callsBefore,
'对话框打开时按当前分组自取列表')
wrapper.unmount()
})
it('对话框内删分类成功(emit changed)后父页重取分类下拉(筛选选项与商品数徽标同步刷新)', async () => {
// 取数按次序变形:页面首屏=裙装;对话框打开与 changed 后的重取=删后列表(只剩裤装)。
let groupFetchCount = 0
jdApi.fetchJdProductGroups.mockImplementation(() => {
groupFetchCount += 1
return groupFetchCount === 1
? Promise.resolve([{ id: 7, name: '裙装', sortOrder: 0, productCount: 3 }])
: Promise.resolve([{ id: 8, name: '裤装', sortOrder: 1, productCount: 1 }])
})
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(optionLabels(wrapper, '筛选店铺分类')).toContain('裙装', '首屏下拉含首取分类')
await wrapper.findAll('button').find((b) => b.text() === '分类管理')!.trigger('click')
await flushPromises()
const modal = wrapper.get('.manage-modal')
confirmMock.mockResolvedValue(true)
jdApi.deleteJdProductGroup.mockResolvedValueOnce(undefined)
await modal.findAll('button').find((b) => b.text() === '删除')!.trigger('click')
await flushPromises()
await flushPromises()
expect(jdApi.deleteJdProductGroup, '删除按钮属于当前列表行').toHaveBeenCalledWith(8)
// changed → 父页 loadGroupOptions:下拉按新列表重取(最后一次调用拿到删后列表)。
expect(optionLabels(wrapper, '筛选店铺分类')).toContain('裤装', '下拉刷新出新一轮分类')
expect(optionLabels(wrapper, '筛选店铺分类')).not.toContain('裙装', '删掉的分类不再出现在筛选下拉')
wrapper.unmount()
})
})
/** 平台超管空态直建分组(2026-11-17 用户口径「admin 权限最大」):京东侧还没有任何
* 数据权限分组时,分类管理弹窗给平台超管开直建口子;建完 group-created ⇒ 父页整条
* 作用域重取,当前分组翻到新组、分类下拉与弹窗列表随新组走——从「死路」到「接着建
* 分类」一气呵成。scope.platformSuperAdmin 是这条链的唯一开关,非超管维持空态文案。 */
describe('平台超管空态直建分组(页面级链路)', () => {
it('超管 + 京东侧零分组:弹窗出直建表单,建组走 POST(jd 档) 且作用域重取翻到新组', async () => {
let scopeFetchCount = 0
jdApi.fetchJdCategoryScope.mockImplementation(() => {
scopeFetchCount += 1
return scopeFetchCount === 1
? Promise.resolve({ platformSuperAdmin: true, defaultGroupId: null, groups: [] })
: Promise.resolve({
platformSuperAdmin: true,
defaultGroupId: 21,
groups: [{ id: 21, name: '京东-团队', label: '京东-团队', editable: true }],
})
})
const wrapper = await mountWith({ items: [item(1, { groupId: null, groupName: '' })], total: 1, page: 1, pageSize: 20 })
await wrapper.findAll('button').find((b) => b.text() === '分类管理')!.trigger('click')
await flushPromises()
const modal = wrapper.get('.manage-modal')
expect(modal.get('[aria-label="新分组名称"]').exists()).toBe(true, '超管空态不是死路文案')
await modal.get('[aria-label="新分组名称"]').setValue('京东-团队')
await modal.findAll('button').find((b) => b.text() === '新建分组')!.trigger('click')
await flushPromises()
await flushPromises()
await flushPromises()
expect(groupApi.createShopGroup).toHaveBeenCalledWith('京东-团队', [], 1, 'jd')
expect(jdApi.fetchJdCategoryScope).toHaveBeenCalledTimes(2, 'group-created ⇒ 父页整条作用域重取')
expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(21)
expect(wrapper.find('[aria-label="新分组名称"]').exists()).toBe(false, '有组了直建口子关掉')
expect(wrapper.get('.manage-modal').text()).toContain('本组暂无分类,先新建一个', '接着就能建分类')
wrapper.unmount()
})
it('非超管 + 京东侧零分组:弹窗维持空态文案,无直建表单(口子不开给组长/公司超管)', async () => {
jdApi.fetchJdCategoryScope.mockResolvedValue({ platformSuperAdmin: false, defaultGroupId: null, groups: [] })
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
await wrapper.findAll('button').find((b) => b.text() === '分类管理')!.trigger('click')
await flushPromises()
const modal = wrapper.get('.manage-modal')
expect(modal.text()).toContain('你还不属于任何数据权限分组')
expect(modal.find('[aria-label="新分组名称"]').exists()).toBe(false)
expect(groupApi.createShopGroup).not.toHaveBeenCalled()
wrapper.unmount()
})
})
describe('京东数据库页(v1.4 Phase 5)', () => { describe('京东数据库页(v1.4 Phase 5)', () => {
it('挂载后按首屏分页参数取列表(pageSize 默认 20、不带公司维度),行数=本页条数', async () => { it('挂载后按首屏分页参数取列表(pageSize 默认 20、不带公司维度),行数=本页条数', async () => {
const wrapper = await mountWith({ items: [item(1), item(2), item(3)], total: 42, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1), item(2), item(3)], total: 42, page: 1, pageSize: 20 })
@@ -241,7 +420,8 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
// 公司维度 2026-11-16 整页摘除:入参层不再有 companyId 键(单参 toHaveProperty 才是「键不存在」的真判据)。 // 公司维度 2026-11-16 整页摘除:入参层不再有 companyId 键(单参 toHaveProperty 才是「键不存在」的真判据)。
expect(firstCall).not.toHaveProperty('companyId') expect(firstCall).not.toHaveProperty('companyId')
expect(wrapper.findAll('tbody tr')).toHaveLength(3) expect(wrapper.findAll('tbody tr')).toHaveLength(3)
expect(wrapper.find('.jd-summary').text()).toContain('共 42 条京东商品') // 汇总条(共 X 条京东商品)2026-11-17 用户口径删除:不再渲染(反钉)。
expect(wrapper.find('.jd-summary').exists()).toBe(false, '汇总条已按 2026-11-17 用户口径删除')
}) })
it('行列字段与顺序(2026-11-15 用户口径;状态列+创建/修改两列 2026-11-16 客户口径「不需要采集/不要」下线仍收详情抽屉;操作置末「操作放最后一列」):勾选/分组/商品信息(图+标题+编码+货号+品牌·类目+SKU/信息分)/总库存/价格/同步/操作(7 列;店铺列 2026-11-15 下线)', async () => { it('行列字段与顺序(2026-11-15 用户口径;状态列+创建/修改两列 2026-11-16 客户口径「不需要采集/不要」下线仍收详情抽屉;操作置末「操作放最后一列」):勾选/分组/商品信息(图+标题+编码+货号+品牌·类目+SKU/信息分)/总库存/价格/同步/操作(7 列;店铺列 2026-11-15 下线)', async () => {
@@ -366,7 +546,7 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
expect(textInputs).toHaveLength(2, '商品编码+标题关键字两个文本筛选框(店铺/商品状态已下线)') expect(textInputs).toHaveLength(2, '商品编码+标题关键字两个文本筛选框(店铺/商品状态已下线)')
await textInputs[0].setValue('JD-1001') await textInputs[0].setValue('JD-1001')
await textInputs[1].setValue('保温杯') await textInputs[1].setValue('保温杯')
await wrapper.get('[aria-label="筛选店铺分类"]').setValue('7') await pickSelectOption(wrapper, '筛选店铺分类', '甲组')
const dateInputs = wrapper.findAll('input[type="date"]') const dateInputs = wrapper.findAll('input[type="date"]')
await dateInputs[0].setValue('2026-11-01') await dateInputs[0].setValue('2026-11-01')
await dateInputs[1].setValue('2026-11-09') await dateInputs[1].setValue('2026-11-09')
@@ -489,9 +669,8 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
it('重置把筛选面回空并回第一页重取', async () => { it('重置把筛选面回空并回第一页重取', async () => {
jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }]) jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }])
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 20 })
const select = wrapper.get('[aria-label="筛选店铺分类"]') expect(optionLabels(wrapper, '筛选店铺分类')[0]).toBe('全部分类', '「全部分类」常驻列表首位(与旧原生下拉同语义)')
expect(select.text()).toContain('全部分类') await pickSelectOption(wrapper, '筛选店铺分类', '甲组')
await select.setValue('7')
await wrapper.get('.cat-trigger').trigger('click') await wrapper.get('.cat-trigger').trigger('click')
await wrapper.get('.cat-search').setValue('艺考') await wrapper.get('.cat-search').setValue('艺考')
await wrapper.get('.cat-col-search .cat-row').trigger('click') await wrapper.get('.cat-col-search .cat-row').trigger('click')
@@ -506,7 +685,7 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
expect(jdApi.fetchJdProductList.mock.calls.length).toBeGreaterThan(callsBefore) expect(jdApi.fetchJdProductList.mock.calls.length).toBeGreaterThan(callsBefore)
const last = jdApi.fetchJdProductList.mock.calls.at(-1)![0] const last = jdApi.fetchJdProductList.mock.calls.at(-1)![0]
expect(last).toMatchObject({ productCode: '', titleKeyword: '', groupId: '', category: '', page: 1 }, '重置后筛选全空、回第一页') expect(last).toMatchObject({ productCode: '', titleKeyword: '', groupId: '', category: '', page: 1 }, '重置后筛选全空、回第一页')
expect((select.element as HTMLSelectElement).value).toBe('') expect(selectByLabel(wrapper, '筛选店铺分类').props('modelValue')).toBe('', '重置后分类筛选回「全部分类」')
}) })
it('翻页与改每页条数都重发请求,改条数回第一页', async () => { it('翻页与改每页条数都重发请求,改条数回第一页', async () => {
@@ -517,8 +696,10 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
expect(jdApi.fetchJdProductList).toHaveBeenCalledTimes(2) expect(jdApi.fetchJdProductList).toHaveBeenCalledTimes(2)
expect(jdApi.fetchJdProductList.mock.calls[1][0].page).toBe(3) expect(jdApi.fetchJdProductList.mock.calls[1][0].page).toBe(3)
const sizeSelect = wrapper.find('.page-size-select') // 每页条数下拉 2026-11-17 随分页条一起换 el-select(OldPagination 内局部注册):
await sizeSelect.setValue('50') // 点开→点选项,不再走原生 setValue。
expect(wrapper.find('.page-size-select').exists()).toBe(true, '分页条下拉保留 .page-size-select 定位类')
await pickSelectOption(wrapper, '每页条数', '50条/页')
await flushPromises() await flushPromises()
const last = jdApi.fetchJdProductList.mock.calls.at(-1)![0] const last = jdApi.fetchJdProductList.mock.calls.at(-1)![0]
expect(last.pageSize).toBe(50) expect(last.pageSize).toBe(50)
@@ -631,7 +812,7 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
const wrapper = await mountWith({ items: [item(1), item(2)], total: 2, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1), item(2)], total: 2, page: 1, pageSize: 20 })
// 批量删除常显(2026-11-16 客户口径「不要勾选后才显示」):未勾选时就在,只是置灰。 // 批量删除常显(2026-11-16 客户口径「不要勾选后才显示」):未勾选时就在,只是置灰。
expect(wrapper.find('.jd-delete-btn').exists()).toBe(true, '工具栏「删除勾选」常显') expect(wrapper.find('.jd-delete-btn').exists()).toBe(true, '「批量删除」常显')
expect(wrapper.find('.jd-delete-btn').attributes('disabled')).toBeDefined() expect(wrapper.find('.jd-delete-btn').attributes('disabled')).toBeDefined()
const boxes = wrapper.findAll('tbody input[type="checkbox"]') const boxes = wrapper.findAll('tbody input[type="checkbox"]')
await boxes[0].setValue(true) await boxes[0].setValue(true)
@@ -644,7 +825,7 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
expect(confirmMock).toHaveBeenCalledTimes(1) expect(confirmMock).toHaveBeenCalledTimes(1)
const options = confirmMock.mock.calls[0][0] const options = confirmMock.mock.calls[0][0]
expect(options.title).toBe('删除京东商品') expect(options.title).toBe('删除京东商品')
expect(options.message).toContain('确定删除勾选的 2 个商品吗') expect(options.message).toContain('确定批量删除选中的 2 个商品吗')
expect(options.message).toContain('jd-products 桶内图片文件一并删除', '确认弹窗必须点名「桶文件也会删」') expect(options.message).toContain('jd-products 桶内图片文件一并删除', '确认弹窗必须点名「桶文件也会删」')
expect(options.danger).toBe(true) expect(options.danger).toBe(true)
@@ -698,15 +879,15 @@ describe('京东数据库页(v1.4 Phase 5)', () => {
}) })
}) })
/** 写权限分档(2026-11-16 用户口径收窄商品行写;2026-11-17 弹窗下线后更新): /** 写权限分档(2026-11-17 用户口径「超管+管理员都可以,只有普通员工不能操作」,推翻
* 商品行写(编辑/删除/勾选批量删)只对平台超管渲染;分类写(批量编辑分类)由 scope 的 * 2026-11-16 的平台超管单档):商品行写(编辑/删除/勾选批量删)对管理员级(超管/admin 档)
* 每组 editable 决定(本组管理员/公司超管/平台超管)——同组普通号在本页只读, * 渲染,普通账号只读;分类写(批量编辑分类、分类管理)由 scope 的每组 editable 决定
* 只读查看入口在「京东分类管理」子菜单页(V204)。勾选列 2026-11-17 起对本组可写 * (本组管理员/公司超管/平台超管)。同日口径「超管可以有分组筛选,管理员及以下则没有」:
* 分类管理员开放(服务批量归类),商品行按钮仍只归平台超管。 */ * 筛选行「分组」控件整块只对超管档(超级管理员/公司超级管理员)渲染。 */
describe('京东数据库写权限分档(商品行写=平台超管;分类写=本组 editable)', () => { describe('京东数据库写权限分档(商品行写=超管+管理员;分组筛选=超管档;分类写=本组 editable)', () => {
it('非超管且本组不可写:无勾选列、无操作列、无删除勾选、无批量编辑分类;列表/筛选/详情照常', async () => { it('普通员工且本组不可写:无勾选列、无操作列、无批量删除、无批量编辑分类、无分组控件;列表/筛选/详情照常', async () => {
useAdminSessionStore().user = { id: 2, username: 'ops', role: 'admin' } useAdminSessionStore().user = { id: 2, username: 'ops', role: 'normal' }
// 同组普通号:可见但不可写(editable=false)。 // 普通员工:可见但不可写(editable=false)。
jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope(false)) jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope(false))
jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }]) jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }])
jdApi.fetchJdProductDetail.mockImplementation(() => jdApi.fetchJdProductDetail.mockImplementation(() =>
@@ -714,16 +895,21 @@ describe('京东数据库写权限分档(商品行写=平台超管;分类
) )
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(wrapper.findAll('tbody input[type="checkbox"]')).toHaveLength(0, '不可写分类的普通号没有勾选列') expect(wrapper.findAll('tbody input[type="checkbox"]')).toHaveLength(0, '不可写分类的普通员工没有勾选列')
expect(wrapper.find('.jd-delete-btn').exists()).toBe(false, '批量删除按钮不渲染') expect(wrapper.find('.jd-delete-btn').exists()).toBe(false, '批量删除按钮不渲染')
expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '分类写入口不渲染(本组不可写)') expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '分类写入口不渲染(本组不可写)')
expect(wrapper.findAll('button').some((b) => b.text() === '分类管理')).toBe(true,
'分类管理入口是读面,普通员工也能打开看(写控件由对话框按 editable 分档)')
expect(wrapper.find('thead').text()).not.toContain('操作', '操作列(编辑/删除)不渲染') expect(wrapper.find('thead').text()).not.toContain('操作', '操作列(编辑/删除)不渲染')
expect(wrapper.text()).toContain('只读:编辑/删除仅超级管理员可用', '只读提示必须看得见并区分两类写权限') expect(wrapper.text()).toContain('只读:编辑/删除需超级管理员或管理员', '只读提示必须看得见并区分两类写权限')
expect(wrapper.text()).toContain('京东分类管理', '提示把分类维护入口指向「京东分类管理」子菜单页') expect(wrapper.text()).toContain('分类在本页「分类管理」查看与维护', '提示把分类维护入口指向本页「分类管理」(独立页已并入)')
// 分组筛选=超管档专属(2026-11-17 口径):普通员工连单组锁定芯片都不出。
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false, '普通员工不出分组下拉')
expect(wrapper.find('.jd-group-locked').exists()).toBe(false, '普通员工不出分组锁定芯片')
// 读面不受影响:筛选下拉、列表行、点行开详情都还在。 // 读面不受影响:筛选下拉、列表行、点行开详情都还在。
expect(wrapper.get('[aria-label="筛选店铺分类"]').exists()).toBe(true, '分类筛选是读面,保留') expect(wrapper.get('[aria-label="筛选店铺分类"]').exists()).toBe(true, '分类筛选是读面,保留')
expect(wrapper.findAll('tbody tr')[0].findAll('td')).toHaveLength(5, '普通号列表 5 列:分类/商品信息/总库存/价格/同步时间') expect(wrapper.findAll('tbody tr')[0].findAll('td')).toHaveLength(5, '普通员工列表 5 列:分类/商品信息/总库存/价格/同步时间')
await wrapper.findAll('tbody tr')[0].trigger('click') await wrapper.findAll('tbody tr')[0].trigger('click')
await flushPromises() await flushPromises()
await flushPromises() await flushPromises()
@@ -732,7 +918,7 @@ describe('京东数据库写权限分档(商品行写=平台超管;分类
wrapper.unmount() wrapper.unmount()
}) })
it('超管保留全部写入口(勾选列+操作列+删除勾选+批量编辑分类),且不显示只读提示', async () => { it('超管保留全部写入口(勾选列+操作列+批量删除+批量编辑分类),且不显示只读提示', async () => {
// beforeEach 默认 super_admin;这里显式再钉一次,防默认值漂移把这条闸门变成恒绿。 // beforeEach 默认 super_admin;这里显式再钉一次,防默认值漂移把这条闸门变成恒绿。
useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' } useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' }
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
@@ -742,18 +928,35 @@ describe('京东数据库写权限分档(商品行写=平台超管;分类
expect(wrapper.find('.jd-delete-btn').exists()).toBe(true) expect(wrapper.find('.jd-delete-btn').exists()).toBe(true)
expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(true) expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(true)
expect(wrapper.text()).not.toContain('只读:') expect(wrapper.text()).not.toContain('只读:')
expect(wrapper.find('.jd-group-locked').exists()).toBe(true, '超管档保留分组控件(单组=锁定芯片)')
wrapper.unmount() wrapper.unmount()
}) })
it('本组管理员(非平台超管):商品行按钮仍无,但勾选列随批量编辑分类放开(6 列形状)', async () => { it('公司超级管理员属超管档:写入口齐+分组控件在(单组=锁定芯片)', async () => {
useAdminSessionStore().user = { id: 4, username: 'company-root', role: 'company_super_admin' }
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(wrapper.findAll('tbody input[type="checkbox"]')).toHaveLength(1)
expect(wrapper.findAll('tbody tr')[0].findAll('td')).toHaveLength(7, '公司超管 7 列:含操作列')
expect(wrapper.find('.jd-delete-btn').exists()).toBe(true, '批量删除对公司超管渲染')
expect(wrapper.text()).not.toContain('只读:')
expect(wrapper.find('.jd-group-locked').exists()).toBe(true, '公司超管保留分组控件')
wrapper.unmount()
})
it('管理员(admin 档):商品行写全放开(7 列+批量删除),分组控件整块不渲染', async () => {
useAdminSessionStore().user = { id: 3, username: 'leader', role: 'admin' } useAdminSessionStore().user = { id: 3, username: 'leader', role: 'admin' }
// 组长档形状:可见组可写 ⇒ editable=true;商品行写仍按 isSuperAdmin 判(不受 editable 影响)。 // 组长档形状:可见组可写 ⇒ editable=true;商品行写按管理员档判(2026-11-17 口径)。
jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope(true)) jdApi.fetchJdCategoryScope.mockResolvedValue(singleGroupScope(true))
jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }]) jdApi.fetchJdProductGroups.mockResolvedValue([{ id: 7, name: '甲组', sortOrder: 0, productCount: 1 }])
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(wrapper.findAll('tbody tr')[0].findAll('td')).toHaveLength(6, '管理员 6 列:勾选/分类/商品信息/总库存/价格/同步时间(无操作列)') expect(wrapper.findAll('tbody tr')[0].findAll('td')).toHaveLength(7, '管理员 7 列:勾选/分类/商品信息/总库存/价格/同步/操作')
expect(wrapper.find('.jd-delete-btn').exists()).toBe(false, '批量删除(商品行写)仍只归平台超管') expect(wrapper.find('.jd-delete-btn').exists()).toBe(true, '批量删除(商品行写)对管理员渲染')
expect(wrapper.find('thead').text()).not.toContain('操作') expect(wrapper.find('thead').text()).toContain('操作', '操作列(编辑/删除)对管理员渲染')
expect(wrapper.text()).not.toContain('只读:')
// 分组筛选=超管档专属:管理员即使本组可写分类,也不出下拉/锁定芯片。
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false, '管理员不出分组下拉')
expect(wrapper.find('.jd-group-locked').exists()).toBe(false, '管理员不出分组锁定芯片')
const editBtn = wrapper.findAll('button').find((b) => b.text() === '批量编辑分类') const editBtn = wrapper.findAll('button').find((b) => b.text() === '批量编辑分类')
expect(editBtn, '本组管理员有批量编辑分类入口').toBeTruthy() expect(editBtn, '本组管理员有批量编辑分类入口').toBeTruthy()
@@ -771,6 +974,48 @@ describe('京东数据库写权限分档(商品行写=平台超管;分类
expect(jdApi.batchAssignJdProductGroup).toHaveBeenCalledWith([1], 7, GROUP_A) expect(jdApi.batchAssignJdProductGroup).toHaveBeenCalledWith([1], 7, GROUP_A)
wrapper.unmount() wrapper.unmount()
}) })
it('管理员多组可见也不出「分组」下拉(超管档专属),写入口与默认组取数照常', async () => {
useAdminSessionStore().user = { id: 3, username: 'leader', role: 'admin' }
jdApi.fetchJdCategoryScope.mockResolvedValue({
platformSuperAdmin: false,
defaultGroupId: 11,
groups: [
{ id: 11, name: 'A组', label: '甲公司 / A组', editable: true },
{ id: 12, name: 'B组', label: '甲公司 / B组', editable: false },
],
})
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
// 多组对管理员也不渲染切换下拉(作用域静默落在默认组)。
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false, '多组也不给管理员出分组下拉')
// 写入口不受影响:操作列+批量删除都在,列表按默认组取。
expect(wrapper.find('thead').text()).toContain('操作')
expect(wrapper.find('.jd-delete-btn').exists()).toBe(true)
expect(jdApi.fetchJdProductGroups).toHaveBeenCalledWith(11)
expect(jdApi.fetchJdProductList.mock.calls[0][0]).toMatchObject({ ownerGroupId: 11 })
wrapper.unmount()
})
it('公司超级管理员多组可见:分组下拉在(超管档专属),可切组取数', async () => {
useAdminSessionStore().user = { id: 4, username: 'company-root', role: 'company_super_admin' }
jdApi.fetchJdCategoryScope.mockResolvedValue({
platformSuperAdmin: false,
defaultGroupId: 11,
groups: [
{ id: 11, name: 'A组', label: '甲公司 / A组', editable: true },
{ id: 12, name: 'B组', label: '甲公司 / B组', editable: true },
],
})
const wrapper = await mountWith({ items: [item(1)], total: 1, page: 1, pageSize: 20 })
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(true, '公司超管保留分组下拉')
await pickSelectOption(wrapper, '当前分组', '甲公司 / B组')
await flushPromises()
expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(12)
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12, page: 1 })
wrapper.unmount()
})
}) })
describe('京东数据库分类按数据权限分组隔离(V203)', () => { describe('京东数据库分类按数据权限分组隔离(V203)', () => {
@@ -791,12 +1036,12 @@ describe('京东数据库分类按数据权限分组隔离(V203)', () => {
const picker = wrapper.get('[aria-label="当前分组"]') const picker = wrapper.get('[aria-label="当前分组"]')
// 2026-11-16 用户口径「做成分组」:分组在筛选行里是带标签的表单控件(与其他筛选同壳同圆角), // 2026-11-16 用户口径「做成分组」:分组在筛选行里是带标签的表单控件(与其他筛选同壳同圆角),
// 不再是工具栏裸下拉——钉住形状,防止搬回工具栏或丢标签。 // 不再是工具栏裸下拉——钉住形状,防止搬回工具栏或丢标签。
const groupField = (picker.element as HTMLSelectElement).closest('.form-group') const groupField = picker.element.closest('.form-group')
expect(groupField?.querySelector('label')?.textContent).toBe('分组') expect(groupField?.querySelector('label')?.textContent).toBe('分组')
expect(picker.findAll('option').map((o) => o.text())).toEqual(['甲公司 / A组', '甲公司 / B组'], expect(optionLabels(wrapper, '当前分组')).toEqual(['甲公司 / A组', '甲公司 / B组'],
'跨公司组名由后端拼进 label,前端不解析公司字段') '跨公司组名由后端拼进 label,前端不解析公司字段')
await picker.setValue('12') await pickSelectOption(wrapper, '当前分组', '甲公司 / B组')
await flushPromises() await flushPromises()
expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(12) expect(jdApi.fetchJdProductGroups).toHaveBeenLastCalledWith(12)
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12, page: 1 }, expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12, page: 1 },
@@ -822,24 +1067,23 @@ describe('京东数据库分类按数据权限分组隔离(V203)', () => {
], ],
}) })
const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [], total: 0, page: 1, pageSize: 20 })
const picker = wrapper.get('[aria-label="当前分组"]') await pickSelectOption(wrapper, '当前分组', '甲公司 / B组')
await picker.setValue('12')
await flushPromises() await flushPromises()
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12 }) expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12 })
await wrapper.findAll('button').find((b) => b.text() === '重置')!.trigger('click') await wrapper.findAll('button').find((b) => b.text() === '重置')!.trigger('click')
await flushPromises() await flushPromises()
expect((picker.element as HTMLSelectElement).value).toBe('12', '重置不清当前分组(作用域语义,搬进筛选行也不变)') expect(selectByLabel(wrapper, '当前分组').props('modelValue')).toBe(12, '重置不清当前分组(作用域语义,搬进筛选行也不变)')
expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12 }, expect(jdApi.fetchJdProductList.mock.calls.at(-1)![0]).toMatchObject({ ownerGroupId: 12 },
'重置后的重取仍带当前分组') '重置后的重取仍带当前分组')
wrapper.unmount() wrapper.unmount()
}) })
it('不属于任何数据权限分组:分类全空、不给切换也不给批量归类入口(空态兜底在「京东分类管理」页)', async () => { it('不属于任何数据权限分组:分类全空、不给切换也不给批量归类入口', async () => {
jdApi.fetchJdCategoryScope.mockResolvedValue({ platformSuperAdmin: false, defaultGroupId: null, groups: [] }) jdApi.fetchJdCategoryScope.mockResolvedValue({ platformSuperAdmin: false, defaultGroupId: null, groups: [] })
const wrapper = await mountWith({ items: [item(1, { groupId: null, groupName: '' })], total: 1, page: 1, pageSize: 20 }) const wrapper = await mountWith({ items: [item(1, { groupId: null, groupName: '' })], total: 1, page: 1, pageSize: 20 })
expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false) expect(wrapper.find('[aria-label="当前分组"]').exists()).toBe(false)
expect(wrapper.find('.jd-group-locked').exists()).toBe(false, '没有分组就没有可锁定的组名') expect(wrapper.find('.jd-group-locked').exists()).toBe(false, '没有分组就没有可锁定的组名')
expect(wrapper.find('[aria-label="筛选店铺分类"]').text()).toContain('全部分类', '分类筛选只剩「全部分类」') expect(optionLabels(wrapper, '筛选店铺分类')).toEqual(['全部分类'], '分类筛选只剩「全部分类」')
expect(wrapper.findAll('tbody tr')[0].findAll('td')[1].text()).toBe('未分类') expect(wrapper.findAll('tbody tr')[0].findAll('td')[1].text()).toBe('未分类')
expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '没有分组就没有可写的分类面') expect(wrapper.findAll('button').some((b) => b.text() === '批量编辑分类')).toBe(false, '没有分组就没有可写的分类面')
expect(jdApi.batchAssignJdProductGroup).not.toHaveBeenCalled() expect(jdApi.batchAssignJdProductGroup).not.toHaveBeenCalled()
@@ -0,0 +1,215 @@
/**
* 日志管理页 / 生成记录页的原生 <select> → el-select(2026-11-17 用户口径「和亚马逊不统一」:
* 原生 select 的弹层是浏览器直角原生物 ⇒ 换 EP 圆角弹层,外壳走全局 .admin-filter)。
*
* 这里钉住换壳时最容易错的两件事:
* 1. **值形状逐字不变**——「全部来源」/「全部用户」空行仍是 ''、用户仍是 String(id)、
* 终端仍是 `${source}|${deviceId}`、模式仍是 'full'/'selected' 常量(后端按这些字符串解析,
* 形状一动就错单,而界面上看起来只是"选了个下拉");
* 2. **选中 → 落参的链路仍只有一处**——来源 source、用户 Number(uid)、终端 '|' 切分与 mode 常量。
*
* aria-label 经 EP 的 ariaLabel prop 落在内层 combobox input 上,选项清单走组件树读
* (弹层 teleport 到 body),点选走「点开→点选项」真实路径。
* 不用 readFileSync(source-pin-ratchet 对台账外新文件带读点即红),全部走真实挂载断言。
*
* 跑法:`npx vitest run tests/mount/records-select-el.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { DOMWrapper, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import { defineComponent, h } from 'vue'
import { ElOption, ElSelect } from 'element-plus'
import DeviceLogsPage from '@/pages/records/DeviceLogsPage.vue'
import RecordsHistoryPage from '@/pages/records/RecordsHistoryPage.vue'
import { useAdminSessionStore } from '@/stores/admin-session'
const deviceLogsApi = vi.hoisted(() => ({
fetchDeviceLogFiles: vi.fn(),
fetchDeviceLogContent: vi.fn(),
fetchDeviceLogConfig: vi.fn(),
fetchDeviceLogDevices: vi.fn(),
deviceLogDownloadUrl: vi.fn((id: number) => `/api/admin/device-logs/${id}/download`),
deleteDeviceLogFile: vi.fn(),
deleteDeviceLogOverride: vi.fn(),
updateDeviceLogGlobalMode: vi.fn(),
updateDeviceLogOverride: vi.fn(),
}))
const historyApi = vi.hoisted(() => ({
fetchHistoryList: vi.fn(),
fetchHistoryUserOptions: vi.fn(),
}))
vi.mock('@/api/device-logs', () => deviceLogsApi)
vi.mock('@/pages/records/history-api.ts', () => historyApi)
/** 采集配置弹窗(el-dialog)用桩:真实 dialog 把内容 teleport 到 body,wrapper 里就查不到;
* 桩只留一层 div 并把默认插槽摊在挂载树里,modelValue 与真实一样控制开关。 */
const DialogStub = defineComponent({
name: 'ElDialogStub',
props: { modelValue: { type: Boolean, default: false } },
setup(props, { slots }) {
return () => (props.modelValue ? h('div', { class: 'dialog-stub' }, slots.default?.()) : null)
},
})
// ---------------- el-select 交互助手(与京东数据库页/亚马逊面同一套口径) ----------------
/** 按 aria-label 找对应的 ElSelect 组件实例(页面里还有 OldPagination 的「每页条数」,靠 aria-label 区分)。 */
function selectByLabel(wrapper: VueWrapper<Element>, label: string) {
const found = wrapper.findAllComponents(ElSelect).find((s) => s.find(`[aria-label="${label}"]`).exists())
expect(found, `应存在 aria-label="${label}" 的下拉`).toBeTruthy()
return found!
}
/** 读某颗下拉的全部选项文案(label prop;组件树查询不受弹层 teleport 影响)。 */
function optionLabels(wrapper: VueWrapper<Element>, label: string): string[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('label') as string)
}
/** 读某颗下拉的全部选项 value(形状判据:空串/字符串 id/`source|deviceId`/mode 常量)。 */
function optionValues(wrapper: VueWrapper<Element>, label: string): unknown[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('value'))
}
/** 点开指定下拉并点选目标文案的选项(触发 update:modelValue + change,与真实用户一致)。
* 面板按内层 input 的 aria-controls 圈定,避免另一颗(可能仍挂着的)弹层串台。 */
async function pickSelectOption(wrapper: VueWrapper<Element>, label: string, optionText: string): Promise<void> {
const input = wrapper.get(`[aria-label="${label}"]`)
await input.trigger('click')
await flushPromises()
const contentId = input.attributes('aria-controls')
const scope = (contentId && document.getElementById(contentId)) ?? document.body
const items = [...scope.querySelectorAll('.el-select-dropdown__item')].filter((el) => !el.classList.contains('is-hidden'))
const target = items.find((el) => (el.textContent ?? '').trim() === optionText)
expect(target, `下拉应弹出「${optionText}」选项`).toBeTruthy()
await new DOMWrapper(target as Element).trigger('click')
await flushPromises()
}
/** 按文案点按钮(筛选条上的查询/重置、弹窗里的添加/更新覆盖)。 */
async function clickButton(wrapper: VueWrapper<Element>, text: string): Promise<void> {
const button = wrapper.findAll('button').find((b) => b.text().trim() === text)
expect(button, `应存在「${text}」按钮`).toBeTruthy()
await button!.trigger('click')
await flushPromises()
await flushPromises()
}
/** 最近一次调用的入参(首屏 + 公司 tab watch 可能各发一次,判"选完落什么参"只认最后一次)。 */
function lastArgs(fn: { mock: { calls: unknown[][] } }): Record<string, unknown> {
const calls = fn.mock.calls
expect(calls.length, '接口应至少被调用一次').toBeGreaterThan(0)
return calls[calls.length - 1][0] as Record<string, unknown>
}
const USERS = [
{ id: 7, username: '张三' },
{ id: 8, username: '李四' },
]
let pinia: Pinia
beforeEach(() => {
vi.clearAllMocks()
pinia = createPinia()
setActivePinia(pinia)
useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' }
historyApi.fetchHistoryUserOptions.mockResolvedValue(USERS)
})
async function mountDeviceLogs(): Promise<VueWrapper<Element>> {
deviceLogsApi.fetchDeviceLogFiles.mockResolvedValue({ items: [], total: 0, page: 1, pageSize: 15, retentionDays: 7 })
deviceLogsApi.fetchDeviceLogConfig.mockResolvedValue({ globalMode: 'full', overrides: [] })
deviceLogsApi.fetchDeviceLogDevices.mockResolvedValue([
{ source: 'client', deviceId: 'dev-1', deviceName: '工位A', lastUploadAt: null },
])
const wrapper = mount(DeviceLogsPage, {
global: { plugins: [pinia, ElSelect, ElOption], stubs: { ElDialog: DialogStub } },
})
await flushPromises()
await flushPromises()
return wrapper
}
describe('日志管理页 × el-select', () => {
it('筛选条两颗下拉:空行/字符串 id/来源常量逐字不变', async () => {
const wrapper = await mountDeviceLogs()
expect(optionLabels(wrapper, '来源')).toEqual(['全部来源', '桌面客户端', '麦象采集机'])
expect(optionValues(wrapper, '来源')).toEqual(['', 'client', 'maixiang'])
// 用户清单很长 ⇒ filterable;值仍是 String(id)(下游 `uidFilter.value ? Number(...)` 判空)
expect(selectByLabel(wrapper, '指定用户').props('filterable')).toBe(true)
expect(optionLabels(wrapper, '指定用户')).toEqual(['全部用户', '张三', '李四'])
expect(optionValues(wrapper, '指定用户')).toEqual(['', '7', '8'])
wrapper.unmount()
})
it('选中来源/用户后查询:source 走常量、uid 仍是数字', async () => {
const wrapper = await mountDeviceLogs()
await pickSelectOption(wrapper, '来源', '麦象采集机')
await pickSelectOption(wrapper, '指定用户', '李四')
await clickButton(wrapper, '查询')
const args = lastArgs(deviceLogsApi.fetchDeviceLogFiles)
expect(args.source).toBe('maixiang')
expect(args.uid).toBe(8)
expect(typeof args.uid).toBe('number')
wrapper.unmount()
})
it('重置回到空值首行:不发 source、不发 uid(空串的「全部」语义不变)', async () => {
const wrapper = await mountDeviceLogs()
await pickSelectOption(wrapper, '来源', '桌面客户端')
await pickSelectOption(wrapper, '指定用户', '张三')
await clickButton(wrapper, '重置')
const args = lastArgs(deviceLogsApi.fetchDeviceLogFiles)
expect(args.source).toBeUndefined()
expect(args.uid).toBeUndefined()
wrapper.unmount()
})
it('采集配置弹窗:终端值仍是 `source|deviceId`、模式仍是 full/selected 常量', async () => {
const wrapper = await mountDeviceLogs()
await clickButton(wrapper, '采集配置')
expect(optionLabels(wrapper, '选择终端')).toEqual(['选择终端(最近上报的设备)', '桌面客户端 · 工位A(dev-1)'])
expect(optionValues(wrapper, '选择终端')).toEqual(['', 'client|dev-1'])
expect(optionLabels(wrapper, '覆盖模式')).toEqual(['全量采集', '精选采集'])
expect(optionValues(wrapper, '覆盖模式')).toEqual(['full', 'selected'])
await pickSelectOption(wrapper, '选择终端', '桌面客户端 · 工位A(dev-1)')
await pickSelectOption(wrapper, '覆盖模式', '全量采集')
await clickButton(wrapper, '添加/更新覆盖')
expect(deviceLogsApi.updateDeviceLogOverride).toHaveBeenCalledWith('client', 'dev-1', '工位A', 'full')
wrapper.unmount()
})
})
describe('生成记录页 × el-select', () => {
async function mountHistory(): Promise<VueWrapper<Element>> {
historyApi.fetchHistoryList.mockResolvedValue({ items: [], total: 0, page: 1, pageSize: 10 })
const wrapper = mount(RecordsHistoryPage, { global: { plugins: [pinia, ElSelect, ElOption] } })
await flushPromises()
await flushPromises()
return wrapper
}
it('指定用户下拉:空行 + String(id) 值形状不变', async () => {
const wrapper = await mountHistory()
expect(selectByLabel(wrapper, '指定用户').props('filterable')).toBe(true)
expect(optionLabels(wrapper, '指定用户')).toEqual(['全部用户', '张三', '李四'])
expect(optionValues(wrapper, '指定用户')).toEqual(['', '7', '8'])
wrapper.unmount()
})
it('选用户查询发数字 userId;选回「全部用户」不发 userId', async () => {
const wrapper = await mountHistory()
await pickSelectOption(wrapper, '指定用户', '李四')
await clickButton(wrapper, '查询')
expect(lastArgs(historyApi.fetchHistoryList).userId).toBe(8)
await pickSelectOption(wrapper, '指定用户', '全部用户')
await clickButton(wrapper, '查询')
expect(lastArgs(historyApi.fetchHistoryList).userId).toBeUndefined()
wrapper.unmount()
})
})
@@ -9,6 +9,7 @@
import { beforeEach, describe, expect, it, vi } from 'vitest' import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils' import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia' import { createPinia, setActivePinia, type Pinia } from 'pinia'
import { ElOption, ElSelect } from 'element-plus'
import KeywordUsagePage from '@/pages/tasks/KeywordUsagePage.vue' import KeywordUsagePage from '@/pages/tasks/KeywordUsagePage.vue'
import BrandGatingPanel from '@/pages/tasks/BrandGatingPanel.vue' import BrandGatingPanel from '@/pages/tasks/BrandGatingPanel.vue'
@@ -50,7 +51,9 @@ const loadingDirective = { mounted() {}, updated() {} }
function mountPage(component: Parameters<typeof mount>[0], pinia: Pinia): VueWrapper { function mountPage(component: Parameters<typeof mount>[0], pinia: Pinia): VueWrapper {
return mount(component, { return mount(component, {
global: { global: {
plugins: [pinia], // 筛选下拉 2026-11-17 换成 el-select(原生 select 弹层是直角原生物,与亚马逊页不统一),
// 两支页面都要把 EP 组件注册进来,否则渲染成未解析标签。
plugins: [pinia, ElSelect, ElOption],
directives: { loading: loadingDirective }, directives: { loading: loadingDirective },
}, },
}) })
@@ -17,12 +17,30 @@
*/ */
import { beforeEach, describe, expect, it, vi } from 'vitest' import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils' import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { ElOption, ElSelect } from 'element-plus'
import { createPinia, setActivePinia, type Pinia } from 'pinia' import { createPinia, setActivePinia, type Pinia } from 'pinia'
import UserSecretsPage from '@/pages/account/UserSecretsPage.vue' import UserSecretsPage from '@/pages/account/UserSecretsPage.vue'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
import { useCompanyTabStore } from '@/stores/company-tab' import { useCompanyTabStore } from '@/stores/company-tab'
/* 筛选下拉 2026-11-17 起是 el-select(原生 select 的弹层是浏览器直角原生物,用户要求与亚马逊统一)。
页面模板不带局部 import、靠 main.ts 全局注册,挂载测试不跑 main.ts ⇒ 必须在这里显式注册,
否则拿到的是未解析的空壳,`findAllComponents(ElSelect)` 一条也找不到。 */
const EL_PLUGINS = [ElSelect, ElOption]
/** 按 aria-label 找下拉:EP 把该属性落在内层 combobox input 上,比按节点顺序取更稳。 */
function selectByLabel(wrapper: VueWrapper<Element>, label: string) {
const found = wrapper.findAllComponents(ElSelect).find((s) => s.find(`[aria-label="${label}"]`).exists())
expect(found, `应存在 aria-label="${label}" 的下拉`).toBeTruthy()
return found!
}
/** 下拉里每一档的文案(读 el-option 的 label prop,不依赖插槽文本)。 */
function optionLabels(wrapper: VueWrapper<Element>, label: string): string[] {
return selectByLabel(wrapper, label).findAllComponents(ElOption).map((o) => o.props('label') as string)
}
const secretsApi = vi.hoisted(() => ({ const secretsApi = vi.hoisted(() => ({
fetchUserSecretList: vi.fn(), fetchUserSecretList: vi.fn(),
fetchAdminSecretBalances: vi.fn(), fetchAdminSecretBalances: vi.fn(),
@@ -106,7 +124,7 @@ describe('密钥管理页:检测结果按 check_code 分档渲染', () => {
async function mountWith(rowValue: Record<string, unknown>) { async function mountWith(rowValue: Record<string, unknown>) {
secretsApi.fetchUserSecretList.mockResolvedValue({ items: [rowValue], total: 1, page: 1, pageSize: 15, groupOptions: [] }) secretsApi.fetchUserSecretList.mockResolvedValue({ items: [rowValue], total: 1, page: 1, pageSize: 15, groupOptions: [] })
const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia] } }) const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia, ...EL_PLUGINS] } })
await flushPromises() await flushPromises()
return wrapper return wrapper
} }
@@ -239,7 +257,7 @@ describe('密钥管理页:检测结果按 check_code 分档渲染', () => {
it('筛选项把 error 这一档的两个可能读法都点名(选了要能筛到无可用通道的行)', async () => { it('筛选项把 error 这一档的两个可能读法都点名(选了要能筛到无可用通道的行)', async () => {
const wrapper = await mountWith(busyRow()) const wrapper = await mountWith(busyRow())
const options = wrapper.findAll('.secrets-filter-row select')[0].findAll('option').map((option) => option.text().trim()) const options = optionLabels(wrapper, '筛选密钥状态')
expect(options).toContain('无法判定/可重试') expect(options).toContain('无法判定/可重试')
expect(options).not.toContain('无法判定') expect(options).not.toContain('无法判定')
}) })
@@ -249,7 +267,7 @@ describe('密钥管理页:检测结果按 check_code 分档渲染', () => {
secretsApi.checkUserSecret.mockResolvedValue([ secretsApi.checkUserSecret.mockResolvedValue([
{ moduleKey: 'proxy', checkStatus: 'error', checkCode: 'channel_busy', checkMessage: BUSY_MESSAGE, checkLatencyMs: 30, checkedAt: '2026-11-02T15:51:07', viaProxy: false }, { moduleKey: 'proxy', checkStatus: 'error', checkCode: 'channel_busy', checkMessage: BUSY_MESSAGE, checkLatencyMs: 30, checkedAt: '2026-11-02T15:51:07', viaProxy: false },
]) ])
const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia] } }) const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia, ...EL_PLUGINS] } })
await flushPromises() await flushPromises()
const checkButton = wrapper.findAll('button').find((button) => button.text().trim() === '立即检测') const checkButton = wrapper.findAll('button').find((button) => button.text().trim() === '立即检测')
expect(checkButton, '行内应有「立即检测」入口').toBeDefined() expect(checkButton, '行内应有「立即检测」入口').toBeDefined()
@@ -19,7 +19,14 @@ const messageMock = vi.hoisted(() => ({ success: vi.fn() }))
vi.mock('@/pages/records/workbench-client-api.ts', () => api) vi.mock('@/pages/records/workbench-client-api.ts', () => api)
vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock })) vi.mock('@/components/admin-confirm', () => ({ openAdminConfirm: confirmMock }))
vi.mock('@/components/admin-feedback-ui', () => ({ showAdminFeedback: feedbackMock })) vi.mock('@/components/admin-feedback-ui', () => ({ showAdminFeedback: feedbackMock }))
vi.mock('element-plus', () => ({ ElMessage: messageMock })) // 整包 mock element-plus 时,凡被挂载树里其它组件「局部 import」的 EP 组件都要一并给桩:
// OldPagination 2026-11-17 起用 ElSelect/ElOption 渲染每页条数下拉,缺桩会
// 让 render 拿到 undefined 抛 shapeFlag 错(本文件曾因此红)。样式与弹层不参与本页断言。
vi.mock('element-plus', () => ({
ElMessage: messageMock,
ElSelect: { name: 'ElSelect', render: () => null },
ElOption: { name: 'ElOption', render: () => null },
}))
const SHA = 'c'.repeat(64) const SHA = 'c'.repeat(64)
const row = { const row = {
@@ -36,8 +36,8 @@ const OPS_MIN_COL_PX: Record<string, number> = {
'src/pages/asin/ProductCategoryPage.vue': 138, 'src/pages/asin/ProductCategoryPage.vue': 138,
'src/pages/asin/QueryAsinPage.vue': 138, 'src/pages/asin/QueryAsinPage.vue': 138,
'src/pages/asin/SkipPricePage.vue': 138, 'src/pages/asin/SkipPricePage.vue': 138,
// 京东分类管理(V204):改名/删除两颗 btn-sm(两字 53×2+gap+左右 padding 24)。 // 京东分类管理页(V204)2026-11-17 下线:CRUD 并入京东数据库页「分类管理」对话框
'src/pages/jd/JdCategoryManagerPage.vue': 138, // (对话框无表格操作列,不进本表)。
'src/pages/records/DeviceLogsPage.vue': 138, 'src/pages/records/DeviceLogsPage.vue': 138,
'src/pages/records/RecordsDigitalHumanVersionPage.vue': 287, 'src/pages/records/RecordsDigitalHumanVersionPage.vue': 287,
'src/pages/records/RecordsSoftwareVersionPage.vue': 77, 'src/pages/records/RecordsSoftwareVersionPage.vue': 77,
@@ -13,20 +13,22 @@ import { toCompanyPayload } from '../src/api/companies-dto.ts'
/** /**
* 账号域三页按平台 tab 分列(V206,2026-11-17 用户口径「这些亚马逊这边也要有……数据都是新的 * 账号域三页按平台 tab 分列(V206,2026-11-17 用户口径「这些亚马逊这边也要有……数据都是新的
* 别把亚马逊的带过来」):users/company/biz_shop_manage_group 三表加 platform 列,存量默认亚马逊; * 别把亚马逊的带过来」):users/company/biz_shop_manage_group 三表加 platform 列,存量默认亚马逊;
* 前端同一套组件两 tab 共显,请求带 platform=当前 tab,弹窗单选默认当前平台、可翻档归侧。 * 前端同一套组件两 tab 共显,请求带 platform=当前 tab。
* 平台不设手选(2026-11-17 用户口径「有京东就不需要亚马逊了,亚马逊那边也是」):弹窗不再出
* 「所属平台」单选——新建取当前平台 tab,编辑保持行值;值仍随保存下发(后端契约不变)。
* 上架上限(jd_publish_quota)只属京东口径:编辑弹窗隐藏 + 校验/下发都跳过 + 列表列仅京东侧。 * 上架上限(jd_publish_quota)只属京东口径:编辑弹窗隐藏 + 校验/下发都跳过 + 列表列仅京东侧。
*/ */
// ---------- 纯函数:payload 的 platform 下发与翻档 ---------- // ---------- 纯函数:payload 的 platform 下发 ----------
test('建号 payload 恒带 platform:京东 tab 建的号默认归京东,单选翻档即改归属', () => { test('建号 payload 恒带 platform:京东 tab 建的号默认归京东(平台跟随当前 tab,弹窗不手选)', () => {
const jd = toCreateUserRequest({ ...createEmptyCreateUserForm(), username: 'a', password: 'secret123', platform: 'jd' }) const jd = toCreateUserRequest({ ...createEmptyCreateUserForm(), username: 'a', password: 'secret123', platform: 'jd' })
assert.equal(jd.platform, 'jd') assert.equal(jd.platform, 'jd')
const amazon = toCreateUserRequest({ ...createEmptyCreateUserForm(), username: 'a', password: 'secret123' }) const amazon = toCreateUserRequest({ ...createEmptyCreateUserForm(), username: 'a', password: 'secret123' })
assert.equal(amazon.platform, 'amazon', '空表单缺省亚马逊(存量口径),后端 normalizeOrCreate 同口径兜底') assert.equal(amazon.platform, 'amazon', '空表单缺省亚马逊(存量口径),后端 normalizeOrCreate 同口径兜底')
}) })
test('编辑回填 platform:行值 jd→jd,缺省/未知→amazon;请求体恒下发 platform(翻档即挪列)', () => { test('编辑回填 platform:行值 jd→jd,缺省/未知→amazon;请求体恒下发 platform(编辑保持行值)', () => {
const jdForm = fillEditUserForm({ id: 7, username: '京东号', role: 'normal', platform: 'jd' }) const jdForm = fillEditUserForm({ id: 7, username: '京东号', role: 'normal', platform: 'jd' })
assert.equal(jdForm.platform, 'jd') assert.equal(jdForm.platform, 'jd')
assert.equal(toEditUserUpdateRequest(jdForm).platform, 'jd') assert.equal(toEditUserUpdateRequest(jdForm).platform, 'jd')
@@ -34,7 +36,7 @@ test('编辑回填 platform:行值 jd→jd,缺省/未知→amazon;请求
const legacy = fillEditUserForm({ id: 8, username: '存量号', role: 'normal' }) const legacy = fillEditUserForm({ id: 8, username: '存量号', role: 'normal' })
assert.equal(legacy.platform, 'amazon', '旧负载没有 platform 时归亚马逊(存量默认),不许渲染成空串') assert.equal(legacy.platform, 'amazon', '旧负载没有 platform 时归亚马逊(存量默认),不许渲染成空串')
assert.equal(toEditUserUpdateRequest(legacy).platform, 'amazon', 'platform 恒下发:单选恒渲染,后端显式才落') assert.equal(toEditUserUpdateRequest(legacy).platform, 'amazon', 'platform 恒下发:编辑保持行值,后端显式才落')
}) })
test('includeQuota=false(亚马逊侧编辑):不下发 jdPublishQuota,校验也跳过;platform 照常下发', () => { test('includeQuota=false(亚马逊侧编辑):不下发 jdPublishQuota,校验也跳过;platform 照常下发', () => {
@@ -97,7 +99,7 @@ test('CompaniesPage:公司列表带平台、切平台重取数、编辑弹窗
assert.match(page, /:platform="platformTab\.active"/, '新建公司弹窗默认落当前平台') assert.match(page, /:platform="platformTab\.active"/, '新建公司弹窗默认落当前平台')
}) })
test('EditUserDialog:上架上限仅京东侧显示且不参与亚马逊侧提交;所属平台单选恒在', () => { test('EditUserDialog:上架上限仅京东侧显示且不参与亚马逊侧提交;所属平台不设手选', () => {
const dialog = readSource('src/pages/account/EditUserDialog.vue') const dialog = readSource('src/pages/account/EditUserDialog.vue')
assert.match(dialog, /v-if="includeQuota && \(targetIsCompanySuperAdmin \|\| form\.role === 'admin'\)"/, assert.match(dialog, /v-if="includeQuota && \(targetIsCompanySuperAdmin \|\| form\.role === 'admin'\)"/,
'quota 项必须叠上 includeQuota(京东侧)条件——只按角色判断会把该项带进亚马逊侧弹窗') 'quota 项必须叠上 includeQuota(京东侧)条件——只按角色判断会把该项带进亚马逊侧弹窗')
@@ -105,26 +107,30 @@ test('EditUserDialog:上架上限仅京东侧显示且不参与亚马逊侧提
'提交必须透传 includeQuota:亚马逊侧校验与下发都跳过 quota') '提交必须透传 includeQuota:亚马逊侧校验与下发都跳过 quota')
assert.match(dialog, /validateEditUserForm\(form, \{ includeQuota: includeQuota\.value \}\)/, assert.match(dialog, /validateEditUserForm\(form, \{ includeQuota: includeQuota\.value \}\)/,
'校验与下发同口径(校验过了但不下发 = 静默改值)') '校验与下发同口径(校验过了但不下发 = 静默改值)')
assert.match(dialog, /v-model="form\.platform"/, '所属平台单选恒在:翻档是把记录挪到另一平台列表的唯一入口') assert.doesNotMatch(dialog, /v-model="form\.platform"/,
'所属平台不设手选(2026-11-17 用户口径):平台跟随当前平台 tab,把单选写回来即红')
assert.match(dialog, /props\.platform === 'jd'/, 'includeQuota 取自页面透传的当前平台') assert.match(dialog, /props\.platform === 'jd'/, 'includeQuota 取自页面透传的当前平台')
assert.match(dialog, /form\.platform = base\.platform/, '打开弹窗必须回填行值(旧负载缺省归亚马逊)') assert.match(dialog, /form\.platform = base\.platform/, '打开弹窗必须回填行值(旧负载缺省归亚马逊;保存原样下发)')
}) })
test('CreateUserDialog/GroupEditorDialog/CompanyEditorDialog:新建默认当前平台、编辑回填行值', () => { test('CreateUserDialog/GroupEditorDialog/CompanyEditorDialog:平台不设手选,新建默认当前平台、编辑回填行值', () => {
const create = readSource('src/pages/account/CreateUserDialog.vue') const create = readSource('src/pages/account/CreateUserDialog.vue')
assert.match(create, /form\.platform = props\.platform \?\? 'amazon'/, '建号默认当前平台 tab') assert.match(create, /form\.platform = props\.platform \?\? 'amazon'/, '建号默认当前平台 tab')
assert.match(create, /v-model="form\.platform"/, '所属平台单选在') assert.doesNotMatch(create, /v-model="form\.platform"/,
'建号弹窗不设平台手选(2026-11-17 用户口径):把单选写回来即红')
const group = readSource('src/pages/account/GroupEditorDialog.vue') const group = readSource('src/pages/account/GroupEditorDialog.vue')
assert.match(group, /groupPlatform\.value = props\.platform \?\? 'amazon'/, '新建分组默认当前平台 tab') assert.match(group, /groupPlatform\.value = props\.platform \?\? 'amazon'/, '新建分组默认当前平台 tab')
assert.match(group, /props\.group\.platform === 'jd' \? 'jd' : 'amazon'/, '编辑分组回填行值') assert.match(group, /props\.group\.platform === 'jd' \? 'jd' : 'amazon'/, '编辑分组回填行值')
assert.match(group, /createShopGroup\(groupName\.value, memberIds\.value, operatorId, groupPlatform\.value\)/, assert.doesNotMatch(group, /v-model="groupPlatform"/, '分组弹窗不设平台手选:把单选写回来即红')
'创建分组必须带平台') assert.match(group, /createShopGroup\(groupName\.value, memberIds\.value, leaderId, groupPlatform\.value\)/,
'创建分组必须带平台(createdById=所选组长,2026-11-18 起超管可改选)')
assert.match(group, /updateShopGroup\(props\.group\.id, groupName\.value, memberIds\.value, groupPlatform\.value\)/, assert.match(group, /updateShopGroup\(props\.group\.id, groupName\.value, memberIds\.value, groupPlatform\.value\)/,
'更新分组必须带平台(翻档归侧)') '更新分组必须带平台(编辑保持行值下发)')
assert.doesNotMatch(group, /companyTab/, '分组弹窗不读公司 tab(既有口径:候选按组长公司取人)') assert.doesNotMatch(group, /companyTab/, '分组弹窗不读公司 tab(既有口径:候选按组长公司取人)')
const company = readSource('src/pages/account/CompanyEditorDialog.vue') const company = readSource('src/pages/account/CompanyEditorDialog.vue')
assert.match(company, /platform: props\.platform \?\? 'amazon'/, '新建公司默认当前平台 tab') assert.match(company, /platform: props\.platform \?\? 'amazon'/, '新建公司默认当前平台 tab')
assert.match(company, /props\.company\.platform === 'jd' \? 'jd' : 'amazon'/, '编辑公司回填行值') assert.match(company, /props\.company\.platform === 'jd' \? 'jd' : 'amazon'/, '编辑公司回填行值')
assert.doesNotMatch(company, /v-model="form\.platform"/, '公司弹窗不设平台手选:把单选写回来即红')
}) })
@@ -3,18 +3,19 @@ import assert from 'node:assert/strict'
import type { AdminMenuNode } from '../src/types/admin.ts' import type { AdminMenuNode } from '../src/types/admin.ts'
import { import {
BOTH_PLATFORM_MENU_KEYS, BOTH_PLATFORM_MENU_KEYS,
JD_APP_MENU_KEYS,
JD_MENU_KEYS, JD_MENU_KEYS,
PLATFORM_TABS, PLATFORM_TABS,
platformsOfMenuKey, platformsOfMenuKey,
} from '../src/config/platform-scope.ts' } from '../src/config/platform-scope.ts'
import { filterMenuTreeByPlatform, visiblePlatformsFor } from '../src/layout/platform-menu-filter.ts' import { allowedPlatformsForUser, filterMenuTreeByPlatform, visiblePlatformsFor } from '../src/layout/platform-menu-filter.ts'
import { adminPages } from '../src/router/routes.ts' import { adminPages } from '../src/router/routes.ts'
/** 2026-11-16 用户定案「亚马逊/京东不混一起」:侧边栏顶部加平台 tab,京东侧=截图圈定 /** 2026-11-16 用户定案「亚马逊/京东不混一起」:侧边栏顶部加平台 tab,京东侧=截图圈定
* 数据页(京东数据库/分类管理)。2026-11-17 用户口径「这些亚马逊这边也要有」:账号域三页 * 数据页(京东数据库/分类管理)。2026-11-17 用户口径「这些亚马逊这边也要有」:账号域三页
* (用户管理/分组管理/公司管理)改为双侧显示(BOTH_PLATFORM_MENU_KEYS),同一组件按当前 * (用户管理/分组管理/公司管理)改为双侧显示(BOTH_PLATFORM_MENU_KEYS),同一组件按当前
* tab 传 platform 过滤各自数据。tab 只做显示分组——菜单可见性仍由 session.menuTree(后端 * tab 传 platform 过滤各自数据。tab 只做显示分组——菜单可见性仍由 session.menuTree(后端
* 按权限裁剪)决定,这里钉的是「分侧归属」与「空侧隐藏」两条形状。 * 按权限裁剪)决定,这里钉的是「分侧归属」「空侧隐藏」与「登录用户平台锁定」三条形状。
* 辅助定义在所有 test 之前:node:test 的用例回调按声明序执行,挪到文件尾会踩 TDZ。 */ * 辅助定义在所有 test 之前:node:test 的用例回调按声明序执行,挪到文件尾会踩 TDZ。 */
const node = (key: string, name: string, route?: string, children?: AdminMenuNode[]): AdminMenuNode => { const node = (key: string, name: string, route?: string, children?: AdminMenuNode[]): AdminMenuNode => {
@@ -40,7 +41,6 @@ const TREE: AdminMenuNode[] = [
node('admin_query_asin', '查询ASIN', '/asin-center/query'), node('admin_query_asin', '查询ASIN', '/asin-center/query'),
node('admin_appearance_patent_clean_items', '外观专利数据库', '/patent-center/clean-items'), node('admin_appearance_patent_clean_items', '外观专利数据库', '/patent-center/clean-items'),
node('admin_jd_database', '京东数据库', '/jd-center/database'), node('admin_jd_database', '京东数据库', '/jd-center/database'),
node('admin_jd_category_manage', '京东分类管理', '/jd-center/categories'),
node('admin_product_categories', '商品类目', '/asin-center/categories'), node('admin_product_categories', '商品类目', '/asin-center/categories'),
]), ]),
] ]
@@ -54,30 +54,27 @@ test('menuKey 平台归属:京东独占即 [jd],双侧清单即两侧,其
for (const key of JD_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['jd'], key) for (const key of JD_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['jd'], key)
for (const key of BOTH_PLATFORM_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['amazon', 'jd'], key) for (const key of BOTH_PLATFORM_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['amazon', 'jd'], key)
assert.deepEqual(platformsOfMenuKey('admin_query_asin'), ['amazon']) assert.deepEqual(platformsOfMenuKey('admin_query_asin'), ['amazon'])
assert.deepEqual(platformsOfMenuKey('admin_columns'), ['amazon']) assert.deepEqual(platformsOfMenuKey('admin_columns'), ['amazon', 'jd'])
assert.deepEqual(platformsOfMenuKey('admin_group_account'), ['amazon']) assert.deepEqual(platformsOfMenuKey('admin_group_account'), ['amazon'])
assert.deepEqual(platformsOfMenuKey('admin_jd_unknown_future'), ['amazon']) assert.deepEqual(platformsOfMenuKey('admin_jd_unknown_future'), ['amazon'])
assert.deepEqual(platformsOfMenuKey(''), ['amazon']) assert.deepEqual(platformsOfMenuKey(''), ['amazon'])
}) })
test('京东 tab:账号与权限只余双侧三项,数据管理只余京东两页(数据库+分类管理);顺序与 route 原样透传', () => { test('京东 tab:账号与权限只余双侧六项(2026-11-18 平台隔离把三个账号域管理页也标双侧),数据管理只余京东独占页(2026-11-17 分类管理并入京东数据库页后只剩数据库一页);顺序与 route 原样透传', () => {
const filtered = filterMenuTreeByPlatform(TREE, 'jd') const filtered = filterMenuTreeByPlatform(TREE, 'jd')
assert.deepEqual(filtered.map((item) => item.key), ['admin_group_account', 'admin_group_data']) assert.deepEqual(filtered.map((item) => item.key), ['admin_group_account', 'admin_group_data'])
assert.deepEqual(groupChildKeys(filtered, 'admin_group_account'), assert.deepEqual(groupChildKeys(filtered, 'admin_group_account'),
['admin_users', 'admin_group_manage', 'admin_companies']) ['admin_columns', 'admin_users', 'admin_group_manage', 'admin_user_secrets',
// 2026-11-17 用户口径「这边分组是京东的分组管理的而不是亚马逊的」:分类管理子菜单 'admin_user_secret_usage', 'admin_companies'])
// 归京东侧(JD_MENU_KEYS),亚马逊 tab 侧看不到它(亚马逊用例反向钉住)。 // 2026-11-17 晚用户口径「京东分类管理并到京东数据库分类编辑里」:分类管理子菜单
assert.deepEqual(groupChildKeys(filtered, 'admin_group_data'), // (V204)下线,京东侧数据管理组只剩京东数据库一页。
['admin_jd_database', 'admin_jd_category_manage']) assert.deepEqual(groupChildKeys(filtered, 'admin_group_data'), ['admin_jd_database'])
const jd = filtered[1].children![0] const jd = filtered[1].children![0]
assert.equal(jd.route, '/jd-center/database') assert.equal(jd.route, '/jd-center/database')
assert.equal(jd.name, '京东数据库') assert.equal(jd.name, '京东数据库')
const categoryManage = filtered[1].children![1]
assert.equal(categoryManage.route, '/jd-center/categories', 'V204 菜单行的 route_path 与注册表一致')
assert.equal(categoryManage.name, '京东分类管理')
}) })
test('亚马逊 tab:除京东独占两页外全数保留(含 2026-11-17 回归的双侧账号域三页),分组结构不变', () => { test('亚马逊 tab:除京东独占页外全数保留(含 2026-11-17 回归的双侧账号域三页),分组结构不变', () => {
const filtered = filterMenuTreeByPlatform(TREE, 'amazon') const filtered = filterMenuTreeByPlatform(TREE, 'amazon')
assert.deepEqual(groupChildKeys(filtered, 'admin_group_account'), assert.deepEqual(groupChildKeys(filtered, 'admin_group_account'),
['admin_columns', 'admin_users', 'admin_group_manage', 'admin_user_secrets', ['admin_columns', 'admin_users', 'admin_group_manage', 'admin_user_secrets',
@@ -120,15 +117,19 @@ test('tab 显示依据:两侧都有可见页才画 tab 条,仅一侧授权
assert.deepEqual(visiblePlatformsFor(null), []) assert.deepEqual(visiblePlatformsFor(null), [])
}) })
test('平台 tab 定义与两份菜单清单钉死(防清单漂移):京东独占两页、双侧共用账号域三页', () => { test('平台 tab 定义与菜单清单钉死(防清单漂移):京东独占后台仅数据库一页、双侧共用账号域三页、桌面端京东工具台三件(V209)', () => {
assert.deepEqual(PLATFORM_TABS, [ assert.deepEqual(PLATFORM_TABS, [
{ id: 'amazon', label: '亚马逊' }, { id: 'amazon', label: '亚马逊' },
{ id: 'jd', label: '京东' }, { id: 'jd', label: '京东' },
]) ])
assert.deepEqual([...JD_MENU_KEYS].sort(), // 2026-11-17 晚分类管理(admin_jd_category_manage)并入京东数据库页后从清单摘除。
['admin_jd_category_manage', 'admin_jd_database']) assert.deepEqual([...JD_MENU_KEYS], ['admin_jd_database'])
assert.deepEqual([...BOTH_PLATFORM_MENU_KEYS].sort(), assert.deepEqual([...BOTH_PLATFORM_MENU_KEYS].sort(),
['admin_companies', 'admin_group_manage', 'admin_users']) ['admin_columns', 'admin_companies', 'admin_group_manage', 'admin_user_secret_usage',
'admin_user_secrets', 'admin_users'])
// 桌面端(app)清单与 JD_MENU_KEYS 分列:app 菜单没有 admin 路由,不得混进
// 「与 routes.ts 对撞」的那份(下方护栏用例只扫 JD_MENU_KEYS/BOTH 两份是刻意的)。
assert.deepEqual([...JD_APP_MENU_KEYS].sort(), ['jd-collect', 'jd-publish', 'jd_tools'])
}) })
test('两份清单的每一条都必须在路由注册表登记(同 company-menu-route 护栏形状:少登记=看得见点进去404)', () => { test('两份清单的每一条都必须在路由注册表登记(同 company-menu-route 护栏形状:少登记=看得见点进去404)', () => {
@@ -137,3 +138,34 @@ test('两份清单的每一条都必须在路由注册表登记(同 company-me
assert.ok(registered.has(key), `平台侧菜单 key "${key}" 未在 src/router/routes.ts 登记 menuKey`) assert.ok(registered.has(key), `平台侧菜单 key "${key}" 未在 src/router/routes.ts 登记 menuKey`)
} }
}) })
test('allowedPlatformsForUser:站点超管随菜单树分布;其余用户锁 users.platform 一侧(未知/缺省按亚马逊)', () => {
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'super_admin', platform: 'jd' }), ['amazon', 'jd'],
'站点超管不限侧:双平台 tab 照画')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'company_super_admin', platform: 'jd' }), ['jd'],
'京东用户锁京东侧:亚马逊 tab 消失(单侧时 tab 条整个隐藏)')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'admin', platform: 'amazon' }), ['amazon'])
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'normal', platform: undefined }), ['amazon'],
'platform 缺省按亚马逊存量口径(与后端 AdminMenuPlatformScope.normalize 同形)')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'company_super_admin', platform: 'weird' }), ['amazon'],
'未知平台值同样兜底亚马逊,不得读成京东侧')
assert.deepEqual(allowedPlatformsForUser(TREE, null), ['amazon', 'jd'],
'会话未就位(user 为空)按可见分布:锁定的收窄由 AdminLayout 在 user 就位后再做')
})
test('allowedPlatformsForUser:菜单树缺本平台页时仍锁死本人平台(宁空侧不放开被禁侧)', () => {
const amazonOnlyTree: AdminMenuNode[] = [
node('admin_group_data', '数据管理', undefined, [
node('admin_dedupe_total_data', '去重数据汇总', '/asin-center/registry'),
]),
]
assert.deepEqual(
allowedPlatformsForUser(amazonOnlyTree, { role: 'company_super_admin', platform: 'amazon' }),
['amazon'],
)
assert.deepEqual(
allowedPlatformsForUser(amazonOnlyTree, { role: 'company_super_admin', platform: 'jd' }),
['jd'],
'交集空回落单侧:管理角色必有双侧账号域页所以实际非空,异常形状下宁可空侧也不放开被禁侧',
)
})
@@ -10,6 +10,12 @@ test('test_task_243_shell_normal_primary_path', () => {
assert.match(css, /\.admin-sidebar\s*\{[^}]*flex:\s*0\s*0\s*252px/, '侧栏宽度应为 252px') assert.match(css, /\.admin-sidebar\s*\{[^}]*flex:\s*0\s*0\s*252px/, '侧栏宽度应为 252px')
assert.match(css, /\.admin-topbar\s*\{[^}]*min-height:\s*76px/, '顶栏高度应为 76px') assert.match(css, /\.admin-topbar\s*\{[^}]*min-height:\s*76px/, '顶栏高度应为 76px')
assert.match(css, /linear-gradient\(180deg,\s*var\(--admin-sidebar\)\s*0%,/, '侧栏应为浅色渐变底') assert.match(css, /linear-gradient\(180deg,\s*var\(--admin-sidebar\)\s*0%,/, '侧栏应为浅色渐变底')
// 壳层锁视口高(2026-11-18「菜单加个滚动条」绊线):.admin-shell 必须 height:100vh +
// overflow:hidden——侧边栏固定、菜单区 el-scrollbar 与内容区 overflow:auto 才能各自独立滚动;
// 改回 min-height 会把整条 flex 高度链放软、回落整页滚(侧边栏顶部被滚出视口)。
assert.match(css, /\.admin-shell\s*\{[^}]*height:\s*100vh/, '.admin-shell 必须锁视口高')
assert.match(css, /\.admin-shell\s*\{[^}]*overflow:\s*hidden/, '.admin-shell 必须 overflow:hidden')
assert.equal(/\.admin-shell\s*\{[^}]*min-height:\s*100vh/.test(css), false, '.admin-shell 不得回退 min-height:100vh')
}) })
test('test_task_243_shell_normal_variant_input', () => { test('test_task_243_shell_normal_variant_input', () => {
+1 -1
View File
@@ -20,7 +20,7 @@ test('test_task_253_group_list_normal_variant_input', () => {
assert.match(page, /leaderUserId/, '判定依赖组长 leaderUserId') assert.match(page, /leaderUserId/, '判定依赖组长 leaderUserId')
const editor = readSource('src/pages/account/GroupEditorDialog.vue') const editor = readSource('src/pages/account/GroupEditorDialog.vue')
assert.match(editor, /组长/, '编辑弹窗含组长展示') assert.match(editor, /组长/, '编辑弹窗含组长展示')
assert.match(editor, /当前登录用户/, '新建时组长只读为当前登录用户') assert.match(editor, /当前登录用户/, '组长默认当前登录用户(超管新建可改选,编辑/非超管只读回显)')
}) })
test('test_task_253_group_list_normal_repeated_operation_is_idempotent', () => { test('test_task_253_group_list_normal_repeated_operation_is_idempotent', () => {
+3 -4
View File
@@ -88,10 +88,9 @@ test('test_task_048_normal_role_wording_agrees_across_all_exits', () => {
const buttons = [...dialog.matchAll(/<el-radio-button\s+value="([a-z_]+)">([^<]*)</g)].map( const buttons = [...dialog.matchAll(/<el-radio-button\s+value="([a-z_]+)">([^<]*)</g)].map(
(m) => [m[1], m[2]] as const, (m) => [m[1], m[2]] as const,
) )
// 2026-11-17 V206:弹窗新增「所属平台」单选(amazon/jd 两档)——角色按钮仍是前两枚, // 2026-11-17 V206 曾加「所属平台」单选;同日晚按用户口径「有京东就不需要亚马逊了」撤掉——
// 平台按钮单独钉,四出口文案对平的意图不变。 // 平台跟随当前平台 tab,弹窗回到只剩角色两枚按钮(平台手选回流会在这里红)。
assert.deepEqual(buttons.slice(0, 2), [['normal', word], ['admin', '管理员']], '编辑用户弹窗的角色按钮文案') assert.deepEqual(buttons, [['normal', word], ['admin', '管理员']], '编辑用户弹窗的角色按钮文案(且平台单选不得回流)')
assert.deepEqual(buttons.slice(2), [['amazon', '亚马逊'], ['jd', '京东']], '所属平台单选两档(V206 翻档归侧的唯一入口)')
}) })
/** /**
+16 -6
View File
@@ -1,7 +1,7 @@
import test from 'node:test' import test from 'node:test'
import assert from 'node:assert/strict' import assert from 'node:assert/strict'
import { readSource } from './helpers.ts' import { readSource } from './helpers.ts'
import { groupKeysForActive, toSidebarEntries } from '../src/layout/menu-mapper.ts' import { allGroupKeys, toSidebarEntries } from '../src/layout/menu-mapper.ts'
import type { AdminMenuNode } from '../src/types/admin.ts' import type { AdminMenuNode } from '../src/types/admin.ts'
function node(partial: Partial<AdminMenuNode> & { key: string; name: string }): AdminMenuNode { function node(partial: Partial<AdminMenuNode> & { key: string; name: string }): AdminMenuNode {
@@ -89,11 +89,21 @@ test('test_task_006_menu_sidebar_mapping_invalid_input_rejected', () => {
}) })
test('test_task_006_menu_sidebar_mapping_dependency_failure_returns_actionable_message', () => { test('test_task_006_menu_sidebar_mapping_dependency_failure_returns_actionable_message', () => {
// 依赖失败:壳层消费映射模块;激活分组展开按当前路由命中。 // 依赖失败:壳层消费映射模块;父菜单默认全展开(2026-11-17 用户口径「父菜单不要默认折叠」),
// 不再按激活路由命中展开;entries 变化后必须命令式补开(el-menu 的 default-openeds 只在挂载读一次)。
const layout = readSource('src/layout/AdminLayout.vue') const layout = readSource('src/layout/AdminLayout.vue')
assert.match(layout, /toSidebarEntries/) assert.match(layout, /toSidebarEntries/)
assert.match(layout, /groupKeysForActive/) assert.match(layout, /allGroupKeys/)
const active = toSidebarEntries(TREE) assert.doesNotMatch(layout, /groupKeysForActive/, '按激活路由展开的旧行为不得回流')
assert.deepEqual(groupKeysForActive(active, '/account/menus'), ['account']) assert.match(layout, /watch\(openedKeys/, 'entries 变化后必须命令式补开,否则切平台 tab 新组收起')
assert.deepEqual(groupKeysForActive(active, '/account/nope'), [], '未命中路由不展开任何分组') assert.match(layout, /nextTick/)
const entries = toSidebarEntries(TREE)
assert.deepEqual(allGroupKeys(entries), ['account'])
const mix = toSidebarEntries([
node({ key: 'g1', name: '分组一', children: [node({ key: 'c1', name: '子一', route: '/x/c' })] }),
node({ key: 'leaf', name: '顶级页', route: '/top' }),
node({ key: 'g2', name: '分组二', children: [node({ key: 'c2', name: '子二', route: '/y/c' })] }),
])
assert.deepEqual(allGroupKeys(mix), ['g1', 'g2'], '分组全部展开、顶级叶项不产生展开键')
assert.deepEqual(allGroupKeys(toSidebarEntries([])), [], '空菜单不产生展开键')
}) })
@@ -0,0 +1,110 @@
import { test } from 'node:test'
import assert from 'node:assert/strict'
import {
filterMenuTreeNodesByPlatform,
JD_APP_MENU_KEYS,
platformsOfMenuKey,
} from '../src/config/platform-scope.ts'
import { filterMenuTreeByPlatform } from '../src/layout/platform-menu-filter.ts'
import type { MenuOptionNode } from '../src/pages/account/user-menu-auth.ts'
import { pruneCheckedIdsToTree } from '../src/pages/account/user-menu-auth.ts'
/**
* 授权树按平台过滤(2026-11-17 用户口径「这边也没有去掉亚马逊的」):建号/编辑弹窗的
* 菜单权限树在选「京东」时只留京东侧菜单(京东数据库+双侧账号域件),亚马逊菜单整枝
* 隐藏;切平台时勾选集收敛进可见树(pruneCheckedIdsToTree),否则京东档账号保存后仍带
* 亚马逊授权,平台分侧被静默架空。
*
* 算法与侧边栏同源(platform-scope.filterMenuTreeNodesByPlatform 唯一出口)——本文件
* 同时钉「两个消费方同形」:同一夹具喂侧边栏版与授权树版,逐层 key 序列必须一致
* (B79-12 同款钉法:一句判据在册有多份正本时,同形性本身要有人钉)。
*/
const node = (id: number, key: string, children?: MenuOptionNode[]): MenuOptionNode => {
const out: MenuOptionNode = { id, key, name: `菜单${id}`, sort: id, parentId: null, type: 'admin' }
if (children) out.children = children
return out
}
/** 授权树实测形状缩影:混编分组(京东库+亚马逊页混在一个分组下)+两侧叶子。 */
const TREE: MenuOptionNode[] = [
node(1, 'admin_group_account', [
node(11, 'admin_users'),
node(12, 'admin_group_manage'),
node(13, 'admin_companies'),
node(14, 'admin_columns'),
]),
node(2, 'admin_jd_database'),
node(3, 'admin_group_shop', [
node(31, 'admin_shop_keys'),
node(32, 'admin_shop_manage'),
]),
]
const keysOf = (nodes: MenuOptionNode[]): string[] =>
nodes.map((n) => (n.children?.length ? `${n.key}(${keysOf(n.children).join(',')})` : n.key))
test('京东侧:只剩京东数据库+双侧账号域件(2026-11-18 扩双侧后菜单权限配置也归京东侧),亚马逊分组整枝消失', () => {
const jd = filterMenuTreeNodesByPlatform(TREE, 'jd')
assert.deepEqual(keysOf(jd), [
'admin_group_account(admin_users,admin_group_manage,admin_companies,admin_columns)',
'admin_jd_database',
])
})
test('亚马逊侧:京东独占菜单消失,亚马逊菜单与账号域分组原样', () => {
const amazon = filterMenuTreeNodesByPlatform(TREE, 'amazon')
assert.deepEqual(keysOf(amazon), [
'admin_group_account(admin_users,admin_group_manage,admin_companies,admin_columns)',
'admin_group_shop(admin_shop_keys,admin_shop_manage)',
])
})
test('与侧边栏过滤同形:同一夹具两个消费方逐层 key 一致(B79-12 钉法)', () => {
for (const platform of ['amazon', 'jd'] as const) {
const viaSidebar = keysOf(filterMenuTreeByPlatform(TREE as never, platform) as never)
const viaAuthTree = keysOf(filterMenuTreeNodesByPlatform(TREE, platform))
assert.deepEqual(viaAuthTree, viaSidebar, `platform=${platform} 两处消费方必须同形`)
}
})
test('判定出口不变:京东独占/双侧/默认亚马逊三个档位原样(改档位先改这里再改清单)', () => {
assert.deepEqual(platformsOfMenuKey('admin_jd_database'), ['jd'])
assert.deepEqual(platformsOfMenuKey('admin_users'), ['amazon', 'jd'])
assert.deepEqual(platformsOfMenuKey('admin_shop_keys'), ['amazon'])
})
/** 桌面端(app)分区缩影:V209 京东工具台组+两工具子行,旁置亚马逊侧 app 菜单。 */
const APP_TREE: MenuOptionNode[] = [
node(51, 'jd_tools', [node(511, 'jd-collect'), node(512, 'jd-publish')]),
node(52, 'app_variant_collection'),
]
test('桌面端京东侧不再整组消失:jd_tools 组+两工具保留,亚马逊 app 菜单剪掉(2026-11-17「前台的京东少了」回归钉)', () => {
for (const key of JD_APP_MENU_KEYS) {
assert.deepEqual(platformsOfMenuKey(key), ['jd'], `V209 app 菜单 ${key} 必须判京东侧`)
}
const jd = filterMenuTreeNodesByPlatform(APP_TREE, 'jd')
assert.deepEqual(keysOf(jd), ['jd_tools(jd-collect,jd-publish)'],
'选京东时桌面端分区必须保留京东工具台整组(叶子 key 认京东,组按存活子项去留)')
})
test('桌面端亚马逊侧:京东工具台消失,亚马逊 app 菜单原样', () => {
const amazon = filterMenuTreeNodesByPlatform(APP_TREE, 'amazon')
assert.deepEqual(keysOf(amazon), ['app_variant_collection'])
})
test('pruneCheckedIdsToTree:勾选集收敛进可见树,隐藏侧 id 被剔除且原数组不动', () => {
const jd = filterMenuTreeNodesByPlatform(TREE, 'jd')
const checked = [11, 12, 2, 31, 99]
const snapshot = checked.slice()
const pruned = pruneCheckedIdsToTree(checked, jd)
assert.deepEqual(pruned, [2, 11, 12], '只留可见树内的 id(31=亚马逊店务、99=不存在)')
assert.deepEqual(checked, snapshot, '入参数组不被改写')
})
test('pruneCheckedIdsToTree:空树全剪、空勾选原样空、非法 id 不复活', () => {
assert.deepEqual(pruneCheckedIdsToTree([1, 2], []), [], '可见树为空=无可保留')
assert.deepEqual(pruneCheckedIdsToTree([], TREE), [])
assert.deepEqual(pruneCheckedIdsToTree([0, -3, 'x', 11.7], TREE), [11], '非法 id 按 normalizeMenuIds 口径收敛(丢弃/取整),不会原样漏进提交集')
})
@@ -73,7 +73,14 @@ public final class TaskModuleRegistry {
// 照常按天清理(商品行在 biz_jd_product 独立保留,不被清);Phase 2 判死登记定型: // 照常按天清理(商品行在 biz_jd_product 独立保留,不被清);Phase 2 判死登记定型:
// JdStaleTaskService 自带 @Scheduled(60 分钟超时线,selfScheduledStaleCheck=true, // JdStaleTaskService 自带 @Scheduled(60 分钟超时线,selfScheduledStaleCheck=true,
// 同 publish/collect-data 先例),京麦登录态失效判死由回传侧经它落终态。 // 同 publish/collect-data 先例),京麦登录态失效判死由回传侧经它落终态。
new Module("JD_SHOP_COLLECT", "京东店铺采集", false, true, false, true, Optional.empty()) new Module("JD_SHOP_COLLECT", "京东店铺采集", false, true, false, true, Optional.empty()),
// v1.5 京东商品上架(蓝图 docs/ITERATION_PLAN.md §4 Phase 2):resultFileJob=false——
// 不出 Excel 结果文件,行级结果落 biz_jd_publish_item(V210),行状态由客户端 chunk
// 回传推进;ageCleanup=true——任务行照常按天清理(发布明细行独立保留不随清,溯源);
// selfScheduledStaleCheck=true——JdPublishStaleTaskService 自带 @Scheduled(发布逐商品
// 页面自动化节奏慢,60 分钟超时线自管,同 JD_SHOP_COLLECT 先例);submitSecret=empty——
// 发布由桌面机已登录京麦的 Chrome 直连执行,无代理无 LLM(铁律 27c 登记结论)。
new Module("JD_PUBLISH", "京东上架", false, true, false, true, Optional.empty())
); );
private TaskModuleRegistry() { private TaskModuleRegistry() {
@@ -0,0 +1,157 @@
package com.nanri.aiimage.common.service;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 后台/桌面端菜单 key → 平台归属的唯一出处(2026-11-18 用户口径「隔离下除站点超管外,
* 京东用户只看京东菜单、亚马逊看不了」)。字面量与 admin-frontend-vue
* {@code src/config/platform-scope.ts} 同源同值:京东独占、双侧共用、其余(未知 key 在内)
* 默认亚马逊——前端对未知 key 也是默认亚马逊,两端口径必须同形。
*
* <p>语义边界:平台裁剪只挂在「菜单下发出口」({@code /api/admin/current-user/menus} 与登录 VO
* 的 adminColumns/appColumns)与逐页门 {@code requireConsolePageAccess};授权管理读/写接口
* (/permission-users/{uid}/column-permissions 与整树替换保存)**不裁**——授权行保留,
* 用户日后翻档(platform 改回另一侧)授权仍在,不因「打开编辑弹窗又保存」被静默清掉。</p>
*
* <p>过滤算法与前端 {@code filterMenuTreeNodesByPlatform} 同形:叶子按 key 归属保留;
* 分组节点自身的 key 不参与平台判定,按「有存活的子项」去留——否则京东侧「账号与权限」
* 这类混合分组(双侧页面 + 亚马逊页混编)会被整组误剪。扁平 VO 过滤会保留被保留节点的
* 祖先链,保证下游 {@code AdminMenuTreeBuilder.build} 组树完整。</p>
*/
public final class AdminMenuPlatformScope {
/** 京东后台独占菜单 key(与前端 JD_MENU_KEYS 逐字一致,用例钉住)。 */
public static final Set<String> JD_MENU_KEYS = Set.of("admin_jd_database");
/** 桌面端(app 树)京东菜单 key(与前端 JD_APP_MENU_KEYS 逐字一致,V209:组行 + 两工具子行)。 */
public static final Set<String> JD_APP_MENU_KEYS = Set.of("jd_tools", "jd-collect", "jd-publish");
/**
* 双侧共用菜单 key(与前端 BOTH_PLATFORM_MENU_KEYS 逐字一致):账号域基础三页 +
* 2026-11-18 用户口径补进的三个账号域管理页(菜单权限配置/密钥管理/密钥用量统计)——
* 它们是账号域功能而非亚马逊业务,京东侧公司超管被锁单侧后仍要能配菜单、管密钥。
*/
public static final Set<String> BOTH_MENU_KEYS = Set.of(
"admin_users", "admin_group_manage", "admin_companies",
"admin_columns", "admin_user_secrets", "admin_user_secret_usage");
private AdminMenuPlatformScope() {
}
/**
* 平台归一:null/空白按 {@code amazon}(与 users.platform 列 DEFAULT 'amazon' 同口径,
* 也与前端 {@code user.platform === 'jd' ? 'jd' : 'amazon'} 同形)——实体没带平台值的
* 账号一律按亚马逊侧放行,不得把「没带」读成「京东侧全拦」。
*/
public static String normalize(String platform) {
return platform == null || platform.isBlank() ? AdminPlatformScope.AMAZON : platform;
}
/**
* menuKey → 平台归属:京东独占(后台或桌面端清单)→ {jd};双侧清单 → {amazon,jd};
* 其余(未知 key 在内)默认 {amazon}。key 缺省(null/空白)同样默认亚马逊,与前端
* {@code platformsOfMenuKey(node.key || '')} 对齐。
*/
public static Set<String> platformsOfMenuKey(String key) {
if (key == null || key.isBlank()) {
return Set.of(AdminPlatformScope.AMAZON);
}
if (JD_MENU_KEYS.contains(key) || JD_APP_MENU_KEYS.contains(key)) {
return Set.of(AdminPlatformScope.JD);
}
if (BOTH_MENU_KEYS.contains(key)) {
return Set.of(AdminPlatformScope.AMAZON, AdminPlatformScope.JD);
}
return Set.of(AdminPlatformScope.AMAZON);
}
/**
* 逐页门用:columnKeys 里是否存在「不归属该平台」的 key。双侧 key 两个平台都放行;
* 空 keys 返回 false(不构成越侧证据,交给原有授权判定处理)。
*/
public static boolean hasCrossPlatformKey(List<String> columnKeys, String platform) {
if (columnKeys == null || columnKeys.isEmpty()) {
return false;
}
String own = normalize(platform);
for (String key : columnKeys) {
if (!platformsOfMenuKey(key).contains(own)) {
return true;
}
}
return false;
}
/**
* 扁平菜单 VO 按平台过滤(下发出口专用):叶子按 key 归属保留;分组节点(有子项者)
* 按存活子项去留;被保留节点的祖先链一并保留,保证组树完整。null/空回空列表。
* 入参不被修改。
*/
public static List<PermissionMenuItemVo> filterMenuVosByPlatform(List<PermissionMenuItemVo> menus,
String platform) {
if (menus == null || menus.isEmpty()) {
return List.of();
}
String own = normalize(platform);
Map<Long, PermissionMenuItemVo> byId = new HashMap<>();
Map<Long, List<PermissionMenuItemVo>> childrenOf = new HashMap<>();
for (PermissionMenuItemVo menu : menus) {
if (menu == null || menu.getId() == null) {
continue;
}
byId.put(menu.getId(), menu);
if (menu.getParentId() != null) {
childrenOf.computeIfAbsent(menu.getParentId(), k -> new ArrayList<>()).add(menu);
}
}
Set<Long> keepIds = new LinkedHashSet<>();
for (PermissionMenuItemVo menu : byId.values()) {
if (subtreeHasPlatformLeaf(menu, childrenOf, own)) {
keepWithAncestors(menu, byId, keepIds);
}
}
if (keepIds.isEmpty()) {
return List.of();
}
List<PermissionMenuItemVo> out = new ArrayList<>();
for (PermissionMenuItemVo menu : menus) {
if (menu != null && menu.getId() != null && keepIds.contains(menu.getId())) {
out.add(menu);
}
}
return List.copyOf(out);
}
/** 叶子:key 归属判定;分组节点:任一子树存活即存活(孤儿/空分组随之被裁)。 */
private static boolean subtreeHasPlatformLeaf(PermissionMenuItemVo menu,
Map<Long, List<PermissionMenuItemVo>> childrenOf,
String platform) {
List<PermissionMenuItemVo> children = childrenOf.get(menu.getId());
if (children == null || children.isEmpty()) {
return platformsOfMenuKey(menu.getColumnKey()).contains(platform);
}
for (PermissionMenuItemVo child : children) {
if (child != null && subtreeHasPlatformLeaf(child, childrenOf, platform)) {
return true;
}
}
return false;
}
private static void keepWithAncestors(PermissionMenuItemVo menu,
Map<Long, PermissionMenuItemVo> byId,
Set<Long> keepIds) {
PermissionMenuItemVo current = menu;
while (current != null && current.getId() != null && keepIds.add(current.getId())) {
Long parent = current.getParentId();
current = parent == null ? null : byId.get(parent);
}
}
}
@@ -118,6 +118,11 @@ public class ApiGuardCoverageAuditor implements SmartInitializingSingleton {
* requireOwnershipUserId(fail-closed 401),chunk 与 heartbeat 和 collect-data/delete-brand * requireOwnershipUserId(fail-closed 401),chunk 与 heartbeat 和 collect-data/delete-brand
* 同形状(本机桌面执行器不带凭据,行归属以任务 owner 投影);chunk 的 error 上报已接整单 * 同形状(本机桌面执行器不带凭据,行归属以任务 owner 投影);chunk 的 error 上报已接整单
* 判死,其 owner 对撞收口随 v1.4 Phase 6.1 落,判死口凭据化后随统一批进名单</li> * 判死,其 owner 对撞收口随 v1.4 Phase 6.1 落,判死口凭据化后随统一批进名单</li>
* <li>{@code /api/jd-publish} —— v1.5 京东商品上架任务面(建单/activate/items/progress/chunk/
* heartbeat):与 /api/jd-collect 逐形状同族——建单等五端点方法体已有 requireOwnershipUserId
* (fail-closed 401,B98-07 同形债预防),chunk 判死口凭据化(isTrustedInternalToken,
* 匿名一律拒绝判死),行级落库与 jd-collect 同形状(本机桌面执行器不带凭据,行归属以
* 任务 owner 投影);判死口凭据化后随统一批进名单</li>
* </ul> * </ul>
*/ */
static final Set<String> PENDING_CONVERGENCE = Set.of( static final Set<String> PENDING_CONVERGENCE = Set.of(
@@ -127,7 +132,8 @@ public class ApiGuardCoverageAuditor implements SmartInitializingSingleton {
"/api/delete-brand", "/api/delete-brand",
"/api/module-templates", "/api/module-templates",
"/api/split", "/api/split",
"/api/jd-collect"); "/api/jd-collect",
"/api/jd-publish");
private final RequestMappingHandlerMapping handlerMapping; private final RequestMappingHandlerMapping handlerMapping;
@@ -28,6 +28,9 @@ public class CollectRoutingProperties {
/** 京东店铺采集模块名(v1.4;紫鸟只在本机 Windows,默认通道必须 LOCAL,铁律 19 同形)。 */ /** 京东店铺采集模块名(v1.4;紫鸟只在本机 Windows,默认通道必须 LOCAL,铁律 19 同形)。 */
public static final String MODULE_JD_SHOP_COLLECT = "JD_SHOP_COLLECT"; public static final String MODULE_JD_SHOP_COLLECT = "JD_SHOP_COLLECT";
/** 京东商品上架模块名(v1.5;京麦登录态在用户桌面机 19899 Chrome profile,默认通道必须 LOCAL,铁律 19 同形)。 */
public static final String MODULE_JD_PUBLISH = "JD_PUBLISH";
/** LOCAL 通道的任务在 PENDING 超过多少分钟后允许 Linux 兜底认领。 */ /** LOCAL 通道的任务在 PENDING 超过多少分钟后允许 Linux 兜底认领。 */
private long linuxFallbackMinutes = 30L; private long linuxFallbackMinutes = 30L;
@@ -3,7 +3,9 @@ package com.nanri.aiimage.modules.admin.controller;
import com.nanri.aiimage.common.api.ApiResponse; import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AccountExpiryService; import com.nanri.aiimage.common.security.AccountExpiryService;
import com.nanri.aiimage.common.security.AdminAuthSupport; import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity; import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.company.service.CompanyService; import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo; import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService; import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
@@ -76,6 +78,9 @@ public class AdminConsoleController {
// 所以这些键要与既有 companyId/companyName 的形状一致(前端 || '' 兜底) // 所以这些键要与既有 companyId/companyName 的形状一致(前端 || '' 兜底)
item.put("companyId", operator.getCompanyId()); item.put("companyId", operator.getCompanyId());
item.put("companyName", companyService.nameOrEmpty(operator.getCompanyId())); item.put("companyName", companyService.nameOrEmpty(operator.getCompanyId()));
// 所属平台(V206):前端据它把平台 tab 锁到本人一侧(2026-11-18 用户口径「隔离下
// 非站点超管只看自己平台侧」);站点超管前端不限侧,此值对它只是标记。
item.put("platform", operator.getPlatform());
// 到期续费提醒(V146):只反映自身 expires_at,不级联——续费是账号自己的事。 // 到期续费提醒(V146):只反映自身 expires_at,不级联——续费是账号自己的事。
// expiresAt 为 yyyy-MM-dd HH:mm 或 null;daysToExpire 为剩余整天数或 null。 // expiresAt 为 yyyy-MM-dd HH:mm 或 null;daysToExpire 为剩余整天数或 null。
item.put("expiresAt", operator.getExpiresAt() == null ? null item.put("expiresAt", operator.getExpiresAt() == null ? null
@@ -93,6 +98,13 @@ public class AdminConsoleController {
List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions( List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions(
operator, operator.getId(), PermissionMenuService.MENU_TYPE_ADMIN, true); operator, operator.getId(), PermissionMenuService.MENU_TYPE_ADMIN, true);
menus = AdminMenuTreeBuilder.filterByMenuType(menus, PermissionMenuService.MENU_TYPE_ADMIN); menus = AdminMenuTreeBuilder.filterByMenuType(menus, PermissionMenuService.MENU_TYPE_ADMIN);
// 平台隔离(2026-11-18 用户口径「除站点超管外,京东用户只看京东菜单、亚马逊看不了」):
// 非站点超管按自身 users.platform 收窄下发树(京东用户只留京东侧+双侧账号域,其余
// 默认亚马逊侧裁掉;路由守卫随树拦截直达 URL)。只裁下发出口——授权管理读/写接口不裁,
// 整树替换保存语义不变,授权行保留(AdminMenuPlatformScope 类注释)。
if (!DeviceSessionPolicy.isSuperAdmin(operator.getRole(), operator.getIsAdmin(), operator.getCreatedById())) {
menus = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, operator.getPlatform());
}
List<Map<String, Object>> items = AdminMenuTreeBuilder.toMapList(AdminMenuTreeBuilder.build(menus)); List<Map<String, Object>> items = AdminMenuTreeBuilder.toMapList(AdminMenuTreeBuilder.build(menus));
return ApiResponse.success(Map.of("items", items)); return ApiResponse.success(Map.of("items", items));
} }
@@ -10,8 +10,10 @@ import com.nanri.aiimage.modules.auth.model.dto.LoginRequest;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity; import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo; import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo;
import com.nanri.aiimage.common.security.DeviceSessionPolicy; import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder; import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService; import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService; import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import io.jsonwebtoken.Claims; import io.jsonwebtoken.Claims;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@@ -23,6 +25,7 @@ import java.time.Duration;
import java.time.Instant; import java.time.Instant;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import com.nanri.aiimage.common.security.JwtService; import com.nanri.aiimage.common.security.JwtService;
@@ -279,8 +282,19 @@ public class AuthService {
vo.setDeviceId(deviceId); vo.setDeviceId(deviceId);
vo.setToken(token); vo.setToken(token);
vo.setExpiresIn(jwtService.ttlSeconds()); vo.setExpiresIn(jwtService.ttlSeconds());
vo.setAppColumns(permissionMenuService.getUserColumnPermissions(user.getId(), PermissionMenuService.MENU_TYPE_APP)); // 平台隔离(2026-11-18 用户口径「后管+桌面端一起」):非站点超管按 users.platform 收窄
vo.setAdminColumns(permissionMenuService.getUserColumnPermissions(user.getId(), PermissionMenuService.MENU_TYPE_ADMIN)); // 登录下发菜单——adminColumns(后管)与 appColumns(桌面端)一并裁,京东用户的桌面端
// 只见京东工具;站点超管不限侧全量。只裁下发出口,授权行不动(AdminMenuPlatformScope 类注释)。
List<PermissionMenuItemVo> appColumns = permissionMenuService.getUserColumnPermissions(
user.getId(), PermissionMenuService.MENU_TYPE_APP);
List<PermissionMenuItemVo> adminColumns = permissionMenuService.getUserColumnPermissions(
user.getId(), PermissionMenuService.MENU_TYPE_ADMIN);
if (!DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById())) {
appColumns = AdminMenuPlatformScope.filterMenuVosByPlatform(appColumns, user.getPlatform());
adminColumns = AdminMenuPlatformScope.filterMenuVosByPlatform(adminColumns, user.getPlatform());
}
vo.setAppColumns(appColumns);
vo.setAdminColumns(adminColumns);
return vo; return vo;
} }
@@ -803,6 +803,21 @@ public class OssStorageService {
return buildDownloadPublicUrl(location.objectKey(), location.bucket()); return buildDownloadPublicUrl(location.objectKey(), location.bucket());
} }
/**
* 指定桶对象的下载预签名 GET URL(公开出口):内网写入、公网签名({@link #applyDownloadHost}
* 换 download-endpoint,SigV4 只对服务端收到的 host 验签、签名保持不变)。
*
* <p>调用方(v1.5 京东发布明细下发)持有的是对象 key 与桶名——jd-products 是私有桶,
* {@code generateFreshDownloadUrl} 的公开直链不适用,必须走签名;上传侧对应
* {@link #presignObjectUpload}(presign PUT 直传),读写两向对称。</p>
*/
public String presignObjectDownload(String bucket, String objectKey, int expirySeconds) {
if (bucket == null || bucket.isBlank() || objectKey == null || objectKey.isBlank()) {
throw new IllegalArgumentException("presign download requires bucket and objectKey");
}
return applyDownloadHost(presignDownloadUrl(objectKey, bucket, expirySeconds));
}
private void uploadFile(File file, String bucket, String objectKey) { private void uploadFile(File file, String bucket, String objectKey) {
if (file == null || !file.isFile()) { if (file == null || !file.isFile()) {
throw new IllegalArgumentException("upload file must exist"); throw new IllegalArgumentException("upload file must exist");
@@ -61,16 +61,18 @@ import java.util.List;
* <p>鉴权照外观专利只读页私有 {@code requireXxxAccess} 形状:JWT → 内部令牌回退 → 超管放行 → * <p>鉴权照外观专利只读页私有 {@code requireXxxAccess} 形状:JWT → 内部令牌回退 → 超管放行 →
* 非超管菜单权限(column_key/route_path 双匹配)。菜单行由 V196 只插 columns 不预授权 * 非超管菜单权限(column_key/route_path 双匹配)。菜单行由 V196 只插 columns 不预授权
* ⇒ 默认仅 super_admin 可见可访问,其余角色由超管在权限页手工勾授后才放行。 * ⇒ 默认仅 super_admin 可见可访问,其余角色由超管在权限页手工勾授后才放行。
* <b>2026-11-16 起读/写分档</b>:读(列表/类目/详情)按上面的菜单口径放行;写(编辑/上传图片/ * <b>2026-11-16 起读/写分档(2026-11-17 口径放宽)</b>:读(列表/类目/详情)按上面的菜单
* 删除/批量删除/批量归类)在菜单口径之上再要求平台超管,非超管一律 403(前端同窗隐藏写入口)。</p> * 口径放行;商品行写(编辑/上传图片/删除/批量删除)在菜单口径之上再走管理员级写闸
* (平台超管+公司超管+admin 档放行,普通账号 403,见 {@code requireJdProductWrite});
* 批量归类走 V203 的按组判(requireWritableGroup)。</p>
* *
* <p><b>公司口径(2026-11-16 用户定案「删除掉公司 tab,参考品牌数据库」)</b>:读侧零公司 * <p><b>公司口径(2026-11-16 用户定案「删除掉公司 tab,参考品牌数据库」)</b>:读侧零公司
* 维度——company_id 请求参数与 {@code superAdminScopedCompanyId} 谓词已随公共化收尾整批 * 维度——company_id 请求参数与 {@code superAdminScopedCompanyId} 谓词已随公共化收尾整批
* 摘除(2026-11-15 定案「京东数据库不区分公司、属于公共的」的最后一截),行上的 company_id * 摘除(2026-11-15 定案「京东数据库不区分公司、属于公共的」的最后一截),行上的 company_id
* 只剩「哪家公司客户端同步的」来源标记,不构成可见性边界;每个拿到本页菜单权限的管理员 * 只剩「哪家公司客户端同步的」来源标记,不构成可见性边界;每个拿到本页菜单权限的管理员
* (含站点超管)看到同一份全量公共库。详情与写侧(编辑/删除)同样没有公司维度: * (含站点超管)看到同一份全量公共库。详情与写侧(编辑/删除)同样没有公司维度:
* 对全部公共行可编辑可删除,但<b>写动作只对平台超管开放</b>(2026-11-16 用户口径 * 对全部公共行可编辑可删除,但<b>写动作只对管理员级开放</b>(2026-11-17 用户口径
* 「京东数据库只有超管有编辑删除权限」,见 {@code requirePlatformSuperAdminWrite}), * 「超管+管理员都可以,只有普通员工不能」,见 {@code requireJdProductWrite}),
* 写侧端点的 company_id 传参已随 2026-11-15 公共化摘除。</p> * 写侧端点的 company_id 传参已随 2026-11-15 公共化摘除。</p>
* *
* <p>导出端点已随 2026-11-15 客户口径「导出也不用」整段下线(控制器/服务/mapper 参数一起删); * <p>导出端点已随 2026-11-15 客户口径「导出也不用」整段下线(控制器/服务/mapper 参数一起删);
@@ -120,6 +122,9 @@ public class AdminJdProductController {
@RequestParam(name = "synced_from", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime syncedFrom, @RequestParam(name = "synced_from", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime syncedFrom,
@Parameter(description = "同步结束时间(包含,ISO datetime)") @Parameter(description = "同步结束时间(包含,ISO datetime)")
@RequestParam(name = "synced_to", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime syncedTo, @RequestParam(name = "synced_to", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime syncedTo,
@Parameter(description = "分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」):"
+ "true=当前分组下有分类,false=未分类,缺省=全部;按 V203 归属表 SQL 侧下推")
@RequestParam(name = "classified", required = false) Boolean classified,
HttpServletRequest request) { HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request); RequestOperator operator = requireJdAccess(request);
if (request.getParameter("grouped") != null || request.getParameter("ungrouped") != null) { if (request.getParameter("grouped") != null || request.getParameter("ungrouped") != null) {
@@ -131,7 +136,8 @@ public class AdminJdProductController {
requireVisibleCategory(scope, groupId); requireVisibleCategory(scope, groupId);
} }
return ApiResponse.success(jdProductQueryService.page(page, pageSize, return ApiResponse.success(jdProductQueryService.page(page, pageSize,
productCode, titleKeyword, category, groupId, syncedFrom, syncedTo, scopedOwnerGroupId)); productCode, titleKeyword, category, groupId, syncedFrom, syncedTo, classified,
scopedOwnerGroupId));
} }
@GetMapping("/categories") @GetMapping("/categories")
@@ -168,7 +174,7 @@ public class AdminJdProductController {
@Parameter(description = "商品行 id") @PathVariable("id") Long id, @Parameter(description = "商品行 id") @PathVariable("id") Long id,
@Valid @RequestBody JdProductUpdateRequest body, @Valid @RequestBody JdProductUpdateRequest body,
HttpServletRequest request) { HttpServletRequest request) {
RequestOperator operator = requirePlatformSuperAdminWrite(request); RequestOperator operator = requireJdProductWrite(request);
Long updatedId = jdProductUpdateService.update(id, body); Long updatedId = jdProductUpdateService.update(id, body);
log.info("[jd-product] 编辑商品 operatorId={} id={} title={}", log.info("[jd-product] 编辑商品 operatorId={} id={} title={}",
operator.id(), updatedId, body.getTitle()); operator.id(), updatedId, body.getTitle());
@@ -192,7 +198,7 @@ public class AdminJdProductController {
@Parameter(description = "替换目标图片登记行 id(缺省=新增)") @Parameter(description = "替换目标图片登记行 id(缺省=新增)")
@RequestParam(value = "replace_image_id", required = false) Long replaceImageId, @RequestParam(value = "replace_image_id", required = false) Long replaceImageId,
HttpServletRequest request) { HttpServletRequest request) {
RequestOperator operator = requirePlatformSuperAdminWrite(request); RequestOperator operator = requireJdProductWrite(request);
Long updatedId = jdProductUpdateService.uploadImage(id, file, imageType, attrName, replaceImageId); Long updatedId = jdProductUpdateService.uploadImage(id, file, imageType, attrName, replaceImageId);
log.info("[jd-product] 上传图片 operatorId={} id={} replaceImageId={} imageType={}", log.info("[jd-product] 上传图片 operatorId={} id={} replaceImageId={} imageType={}",
operator.id(), updatedId, replaceImageId, imageType); operator.id(), updatedId, replaceImageId, imageType);
@@ -207,7 +213,7 @@ public class AdminJdProductController {
public ApiResponse<JdProductDeleteVo> delete( public ApiResponse<JdProductDeleteVo> delete(
@Parameter(description = "商品行 id") @PathVariable("id") Long id, @Parameter(description = "商品行 id") @PathVariable("id") Long id,
HttpServletRequest request) { HttpServletRequest request) {
RequestOperator operator = requirePlatformSuperAdminWrite(request); RequestOperator operator = requireJdProductWrite(request);
JdProductDeleteVo vo = jdProductDeleteService.delete(List.of(id)); JdProductDeleteVo vo = jdProductDeleteService.delete(List.of(id));
// 管理端破坏性动作必须留痕:谁、删了哪些行、桶里清了几个对象(同分组删除口径)。 // 管理端破坏性动作必须留痕:谁、删了哪些行、桶里清了几个对象(同分组删除口径)。
log.info("[jd-product] 删除商品 operatorId={} id={} deleted={} objectsDeleted={}", log.info("[jd-product] 删除商品 operatorId={} id={} deleted={} objectsDeleted={}",
@@ -242,7 +248,7 @@ public class AdminJdProductController {
public ApiResponse<JdProductDeleteVo> batchDelete( public ApiResponse<JdProductDeleteVo> batchDelete(
@Valid @RequestBody JdProductBatchDeleteRequest body, @Valid @RequestBody JdProductBatchDeleteRequest body,
HttpServletRequest request) { HttpServletRequest request) {
RequestOperator operator = requirePlatformSuperAdminWrite(request); RequestOperator operator = requireJdProductWrite(request);
JdProductDeleteVo vo = jdProductDeleteService.delete(body.getIds()); JdProductDeleteVo vo = jdProductDeleteService.delete(body.getIds());
log.info("[jd-product] 批量删除商品 operatorId={} requested={} deleted={} objectsDeleted={} kept={}", log.info("[jd-product] 批量删除商品 operatorId={} requested={} deleted={} objectsDeleted={} kept={}",
operator.id(), body.getIds().size(), vo.getDeleted(), operator.id(), body.getIds().size(), vo.getDeleted(),
@@ -263,23 +269,27 @@ public class AdminJdProductController {
} }
/** /**
* 写端点的越权闸(2026-11-16 用户口径「京东数据库只有超管有编辑删除权限」)。 * 写端点的越权闸(2026-11-17 用户口径「超管+管理员都可以,只有普通员工不能操作」,
* 推翻 2026-11-16「只有超管有编辑删除权限」的单档)。
* *
* <p>读保持菜单权限口径(拿到 {@code admin_jd_database} 列权限的管理员可见同一份公共库), * <p>读保持菜单权限口径(拿到 {@code admin_jd_database} 列权限的管理员可见同一份公共库);
* 写(编辑 / 上传图片 / 单行删除 / 批量删除 / 批量归类)收窄到<b>平台超级管理员</b>: * 商品行写(编辑 / 上传图片 / 单行删除 / 批量删除)放宽到<b>管理员级</b>:平台超级管理员、
* 与 {@code BrandGatingController#requirePlatformSuperAdmin}、 * 公司超级管理员、admin 角色三档放行,普通账号(role 归不出档)403。分类写不在此闸——
* {@code AdminDeviceLogController#requireSuperAdmin} 同一判据( * {@code batch-assign-group} 沿用 V203 的 {@code requireWritableGroup}(本组管理员/
* {@code DeviceSessionPolicy#isSuper} 只认站点 super_admin,公司超管不在内)。</p> * 公司超管/平台超管,按组判)。</p>
* *
* <p>写动作会置人工编辑锁({@code manual_locked=1})并物理删除桶内图片,属影响全平台公共 * <p>写动作会置人工编辑锁({@code manual_locked=1})并物理删除桶内图片;普通账号拿到 403
* 数据的动作,故不随读权限下放;非超管拿到 403 时前端已不渲染这些入口,本闸是兜底。</p> * 时前端已不渲染这些入口,本闸是兜底。</p>
*/ */
private RequestOperator requirePlatformSuperAdminWrite(HttpServletRequest request) { private RequestOperator requireJdProductWrite(HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request); RequestOperator operator = requireJdAccess(request);
if (!operator.superAdmin()) { String role = adminAuthSupport.currentRole(operator.user());
log.warn("[jd-product] 非平台超管写操作被拒 operatorId={} role={}", boolean adminTier = operator.superAdmin()
operator.id(), adminAuthSupport.currentRole(operator.user())); || DeviceSessionPolicy.isCompanySuperAdmin(role)
throw new BusinessException(403, "仅平台超级管理员可以编辑或删除京东数据库数据"); || "admin".equals(role);
if (!adminTier) {
log.warn("[jd-product] 普通账号写操作被拒 operatorId={} role={}", operator.id(), role);
throw new BusinessException(403, "仅超级管理员或管理员可以编辑或删除京东数据库数据");
} }
return operator; return operator;
} }
@@ -0,0 +1,137 @@
package com.nanri.aiimage.modules.jd.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishChunkVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemsPageVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishProgressVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishTaskVo;
import com.nanri.aiimage.modules.jd.service.JdPublishIngestService;
import com.nanri.aiimage.modules.jd.service.JdPublishTaskService;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo;
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 lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
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;
/**
* 京东商品上架任务面(v1.5 Phase 2,蓝图 docs/ITERATION_PLAN.md §3)。
*
* <p>五个入口:建单(用户端登录用户,uid 按会话身份回填;响应体带 queuePayload 供页面
* {@code api.enqueue_json} 推送,DELETE_BRAND 同形)、激活(页面推送前 PENDING→RUNNING)、
* 明细分批下发(客户端按游标拉 PENDING 行)、行级回传(本机执行器直调,判死口凭据化)、
* 心跳(归属校验前置——B98-07 同形债预防:用户域校验在闸门处按可信 uid 对比任务 owner)。
* 全局 {@code /api/tasks/{taskId}/heartbeat} 同时可用,本端点只是给执行器一个模块内聚的 URL。</p>
*/
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/jd-publish")
@Tag(name = "京东商品上架", description = "京东数据库存量商品 → 京麦店铺发布:建单 → 本机已登录京麦的 Chrome 逐商品发布 → 行级回传落明细。")
public class JdPublishController {
private final JdPublishTaskService publishTaskService;
private final JdPublishIngestService ingestService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/tasks")
@Operation(summary = "创建京东商品上架任务", description = "勾选京东数据库商品(归属校验)+可选统一改价规则建单;"
+ "任务落 PENDING、执行通道显式 LOCAL(本机已登录京麦的 Chrome 执行)、明细快照行随建单落库。"
+ "响应体带 queuePayload(type=jd-product-publish-run),页面原样投 api.enqueue_json。")
public ApiResponse<JdPublishTaskVo> createTask(@Valid @RequestBody JdPublishTaskCreateRequest request,
HttpServletRequest httpRequest) {
// uid 不由请求体说了算:解析不出会话身份就 401(fail-closed,与采集建单同口径)。
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@PostMapping("/tasks/{taskId}/activate")
@Operation(summary = "激活京东上架任务", description = "页面把 jd-product-publish-run 载荷推给本机客户端前调用:"
+ "PENDING→RUNNING 条件更新。漏掉这一步,客户端第一个回传会被「任务不在运行中(PENDING)」拒收"
+ "(2026-11-14 采集链真机实录同形)。")
public ApiResponse<Void> activate(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.activateTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@GetMapping("/tasks/{taskId}/items")
@Operation(summary = "分批下发发布明细", description = "按游标分批返回未发布(PENDING)行的发布数据"
+ "(标题/最终价/库存/SKU/属性/图片预签名 GET URL/categoryPath)——派发载荷只带 taskId+改价规则,"
+ "明细按需拉取(载荷尺寸可控、断点友好)。已回传行被状态谓词跳过,断点重连不重发。")
public ApiResponse<JdPublishItemsPageVo> items(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "游标(上一页最后一行 id;首页传 0 或省略)", required = false, example = "0")
@RequestParam(value = "cursor", required = false) Long cursor,
@Parameter(description = "批大小(默认 20,上限 100)", required = false, example = "20")
@RequestParam(value = "limit", required = false) Integer limit,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.pullItems(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), cursor, limit));
}
@GetMapping("/tasks/{taskId}/progress")
@Operation(summary = "查询京东上架进度", description = "任务状态 + 行级分组计数(待发布/发布中/成功/失败)。"
+ "归属校验与建单同口径:uid 按会话身份回填,任务 owner 与 uid 不一致即 403。")
public ApiResponse<JdPublishProgressVo> progress(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.queryProgress(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@PostMapping("/tasks/{taskId}/chunk")
@Operation(summary = "提交行级发布结果回传", description = "执行器按批次回传行级状态(PUBLISHING/SUCCESS/FAILED"
+ " +真实失败原因 + wareId);isEnd=true 任务按行级状态汇总落终态。error 字段按铁律 31 分档"
+ "(京麦登录态失效整单 FAILED;非致命只记录)——判定只信 X-Internal-Token,匿名一律拒绝判死。")
public ApiResponse<JdPublishChunkVo> submitChunk(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@RequestBody JdPublishChunkRequest request,
HttpServletRequest httpRequest) {
// 判死口凭据化(JdCollectController.submitChunk 同口径):error 上报是唯一能触发整单
// 判死的入口,匿名一律拒绝判死;行级结果落库不要求内部令牌(采集端按任务拉单)。
boolean trustedErrorReporter = adminAuthSupport.isTrustedInternalToken(httpRequest);
return ApiResponse.success(ingestService.submitChunk(taskId, request, trustedErrorReporter));
}
@PostMapping("/tasks/{taskId}/heartbeat")
@Operation(summary = "上报发布心跳", description = "沿用全局任务心跳语义:任务终态时回 alive=false,"
+ "执行端下一跳收手。归属校验前置:uid 与任务 owner 不一致即 403(B98-07 同形债预防——"
+ "任意用户不可给任意任务刷心跳续命)。处理位置一并记入心跳位置表供判死文案使用。")
public ApiResponse<TaskHeartbeatVo> heartbeat(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
@RequestBody(required = false) TaskHeartbeatRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.heartbeat(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), request));
}
}
@@ -49,13 +49,18 @@ public interface JdProductMapper extends BaseMapper<JdProductEntity> {
* 「分类不要了,全部整合到类目里」撤掉(独立「分类」筛选框前端下线, * 「分类不要了,全部整合到类目里」撤掉(独立「分类」筛选框前端下线,
* {@code groupId} 改由类目面板「自定义分类」选中驱动)。 * {@code groupId} 改由类目面板「自定义分类」选中驱动)。
* 店铺名过滤参数已随 2026-11-15 客户口径「店铺不需要」同窗撤掉(DB 列与详情/回传链不动)。 * 店铺名过滤参数已随 2026-11-15 客户口径「店铺不需要」同窗撤掉(DB 列与详情/回传链不动)。
* {@code classified}+{@code ownerGroupId}(2026-11-17 用户口径「加个已分类和未分类的筛选」):
* 按 V203 归属表 EXISTS/NOT EXISTS 快筛分类状态,NULL=不过滤;与 11-16 撤掉的旧
* grouped/ungrouped(读已停用的 biz_jd_product.group_id 列)不是一回事。
*/ */
long countProducts(@Param("productCode") String productCode, long countProducts(@Param("productCode") String productCode,
@Param("titleKeyword") String titleKeyword, @Param("titleKeyword") String titleKeyword,
@Param("category") String category, @Param("category") String category,
@Param("groupId") Long groupId, @Param("groupId") Long groupId,
@Param("syncedFrom") LocalDateTime syncedFrom, @Param("syncedFrom") LocalDateTime syncedFrom,
@Param("syncedTo") LocalDateTime syncedTo); @Param("syncedTo") LocalDateTime syncedTo,
@Param("classified") Boolean classified,
@Param("ownerGroupId") Long ownerGroupId);
/** /**
* 商品上架配额计数({@code JdPublishQuotaService}):按 owner uid 集(管理员本人+ * 商品上架配额计数({@code JdPublishQuotaService}):按 owner uid 集(管理员本人+
@@ -95,6 +100,8 @@ public interface JdProductMapper extends BaseMapper<JdProductEntity> {
@Param("groupId") Long groupId, @Param("groupId") Long groupId,
@Param("syncedFrom") LocalDateTime syncedFrom, @Param("syncedFrom") LocalDateTime syncedFrom,
@Param("syncedTo") LocalDateTime syncedTo, @Param("syncedTo") LocalDateTime syncedTo,
@Param("classified") Boolean classified,
@Param("ownerGroupId") Long ownerGroupId,
@Param("offset") long offset, @Param("offset") long offset,
@Param("limit") int limit); @Param("limit") int limit);
@@ -0,0 +1,35 @@
package com.nanri.aiimage.modules.jd.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 京东商品上架发布明细(biz_jd_publish_item,V210)数据访问口。
*
* <p>行级状态推进({@code updateById}/条件更新)走 MyBatis-Plus 既有通道;分批下发与
* 状态聚合两条具名 SQL 落 {@code mapper/jd/JdPublishItemMapper.xml}(铁律 1)。</p>
*/
@Mapper
public interface JdPublishItemMapper extends BaseMapper<JdPublishItemEntity> {
/**
* 明细分批下发页(断点友好,铁律 20 SQL 侧下推):只出<b>未发布</b>(PENDING)行,
* 按 id 升序、{@code id > cursor} 之后取 {@code limit} 行——已回传的行(SUCCESS/FAILED/
* PUBLISHING)被状态谓词天然跳过,客户端断点重连时把 cursor 置 0 也不会重发已发布商品
* (AC-4 服务端半边)。{@code cursor}/{@code limit} 必须是服务侧钳制后的值。
*/
List<JdPublishItemEntity> selectPublishableItems(@Param("taskId") Long taskId,
@Param("cursor") long cursor,
@Param("limit") int limit);
/**
* 行级状态聚合(进度与终态汇总共用):按 publish_status 分组计数。
* 行数上界=该任务商品行数(建单口钳 500),无分页问题。
*/
List<Map<String, Object>> countByPublishStatus(@Param("taskId") Long taskId);
}
@@ -0,0 +1,56 @@
package com.nanri.aiimage.modules.jd.model.dto;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import java.util.List;
/**
* 京东发布行级回传请求(v1.5 蓝图 §3:POST /api/jd-publish/tasks/{taskId}/chunk)。
*
* <p>顶层键集 {@code batchId / items / isEnd}(外加 {@code error} 失败上报);行内键集
* {@code itemId / productId / publishStatus / publishError / jdWareId}。行状态是唯一
* 行级真源({@code biz_jd_publish_item.publish_status});{@code error} 按铁律 31 分档
* (京麦登录态失效→整单 FAILED,代理/LLM 凭据致命词→{@code CredentialFatalClassifier},
* 其余技术性故障只记录不判死)——判定只信 X-Internal-Token(匿名 error 一律拒绝判死,
* 照 JdCollectController.submitChunk 同口径)。</p>
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class JdPublishChunkRequest {
/** 批次号(客户端生成,溯源用)。 */
private String batchId;
/** 本批行级结果。 */
private List<ItemResult> items;
/** true=本任务全部行已回传,任务按行级状态汇总落终态。 */
private Boolean isEnd;
/**
* 客户端失败上报(非空时按铁律 31 分档;可信判定单一出口 X-Internal-Token)。
*/
private String error;
/** 单行回传结果。 */
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class ItemResult {
/** 明细行 id(items 下发时的 itemId;productId 作为对撞锚点)。 */
private Long itemId;
/** 商品行 id(uk_task_product 定位锚点)。 */
private Long productId;
/** 行级状态:PUBLISHING / SUCCESS / FAILED。 */
private String publishStatus;
/** 行级失败真实原因(FAILED 行必填,R6 单行失败隔离)。 */
private String publishError;
/** 京麦发布成功回执的商品 id(SUCCESS 行回传)。 */
private String jdWareId;
}
}
@@ -0,0 +1,40 @@
package com.nanri.aiimage.modules.jd.model.dto;
import lombok.Data;
import java.util.List;
/**
* 京东商品上架建单请求(v1.5 蓝图 §3 建单契约)。
*
* <p>用户在用户端「京东工具台 → 商品上架」页选自定义分类(消费 {@code GET /api/jd-collect/groups},
* B113-01 分类口唯一,AC-9)→ 分页拉该分类下归属自己的商品 → 勾选 → 可选统一改价规则 → 提交建单。
* 服务端按 productIds 落 {@code biz_jd_publish_item} 快照行;{@code request_json} 整体进
* {@code biz_file_task} 供兜底拉取回读({@code readCreateRequest} 同形)。</p>
*/
@Data
public class JdPublishTaskCreateRequest {
/** 提交人 uid(Controller 侧按会话身份回填,请求体自带值不采信)。 */
private Long userId;
/** 自定义分类 id(biz_jd_product_group.id,记录与展示用;商品勾选集才是发布范围)。 */
private Long categoryId;
/** 要上架的商品行 id 集(biz_jd_product.id,必填非空;全部必须归属当前用户,AC-9 归属半边)。 */
private List<Long> productIds;
/** 统一改价规则(可选;null=按原价,mode=none)。 */
private PriceRule priceRule;
/** 统一改价规则:none 原价 / percent 加价百分比(value=百分数) / fixed 固定加价(value=金额)。 */
@Data
public static class PriceRule {
/** none / percent / fixed(空缺省按 none 处理)。 */
private String mode;
/** percent 的百分数或 fixed 的加价金额;mode=none 时忽略。 */
private java.math.BigDecimal value;
}
}
@@ -0,0 +1,58 @@
package com.nanri.aiimage.modules.jd.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;
/**
* 京东商品上架发布明细行({@code biz_jd_publish_item},V210,v1.5 蓝图 §3)。
*
* <p>每任务每商品一行(唯一键 {@code uk_task_product}):建单即按 {@code biz_jd_product}
* 快照落行(商品库有 ageCleanup 清理语义,发布记录不随商品删除丢失溯源);行级状态机
* {@code PENDING → PUBLISHING → SUCCESS/FAILED} 由客户端 chunk 回传逐行推进——服务端
* 不预测发布结果,行状态的唯一写入口是 {@code JdPublishIngestService}(单客户端串行
* 回传,无并发竞争)。任务级行为复用 {@code biz_file_task}(module_type=JD_PUBLISH),
* 本表只承载行级明细与快照。</p>
*/
@Data
@TableName("biz_jd_publish_item")
public class JdPublishItemEntity {
@TableId(type = IdType.AUTO)
private Long id;
/** 任务行 id(biz_file_task.id,module_type=JD_PUBLISH)。 */
private Long taskId;
/** 物化归属分公司(owner 的 users.company_id;读不出落 NULL 不回填,铁律 30)。 */
private Long companyId;
/** 任务 owner uid(biz_file_task.user_id 投影)。 */
private Long userId;
/** 商品行 id(biz_jd_product.id)。 */
private Long productId;
/** 京东商品编码快照。 */
private String productCode;
/** 来源店铺名快照。 */
private String shopName;
/** 商品标题快照。 */
private String title;
/** 京麦类目路径快照(A &gt; B &gt; C)。 */
private String categoryPath;
/** 改价快照 JSON({"mode","value","sourcePrice","finalPrice"},finalPrice=主档价按规则折算)。 */
private String priceRuleJson;
/** 库存快照 JSON({"total":n})。 */
private String stockJson;
/** 行级状态机:PENDING/PUBLISHING/SUCCESS/FAILED(客户端 chunk 回传推进)。 */
private String publishStatus;
/** 行级失败真实原因(客户端回传原文,R6 单行失败隔离)。 */
private String publishError;
/** 京麦发布成功回执的商品 id(wareId,AC-3 真机核对锚点)。 */
private String jdWareId;
/** 主图 objectKey 快照(biz_jd_product_image MAIN 档 sortNo 最小行)。 */
private String mainImageObjectKey;
/** 建单落行时刻。 */
private LocalDateTime createdAt;
/** 最近回传/复位时刻。 */
private LocalDateTime updatedAt;
}
@@ -0,0 +1,19 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
/**
* 京东发布行级回传响应(v1.5):已接受行数 + 未发布余量;任务落终态时带终态状态。
*/
@Data
public class JdPublishChunkVo {
/** 本批接受行数。 */
private int acceptedCount;
/** 该任务剩余未发布(PENDING)行数。 */
private long pendingCount;
/** 任务终态状态(isEnd=true 且落了终态时回填;非终态回 null)。 */
private String taskStatus;
}
@@ -0,0 +1,93 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
/**
* 明细分批下发的单商品发布载荷(v1.5 蓝图 §3:标题/最终价/库存/SKU/属性/图片/categoryPath)。
*
* <p>图片按 objectKey 发预签名 GET URL(jd-products 桶既有 presign 模式复用,蓝图 §3);
* 属性 {@code attrs} 是采集链原样透传的 key/label/value 三元组 JSON(服务端不裁剪不转写);
* SKU 行价已按统一改价规则折算({@code finalPrice}),执行器直接填表不再二次计算。</p>
*/
@Data
public class JdPublishItemPayloadVo {
/** 明细行 id(biz_jd_publish_item.id,客户端回传 chunk 时定位行)。 */
private Long itemId;
/** 商品行 id(biz_jd_product.id)。 */
private Long productId;
private String productCode;
/** 商品标题快照(发布页标题栏)。 */
private String title;
/** 京麦类目路径快照(A &gt; B &gt; C,授权树内定位节点)。 */
private String categoryPath;
/** 主档源价(biz_jd_product.priceMin 快照)。 */
private BigDecimal sourcePrice;
/** 主档最终价(源价 ± 改价规则折算)。 */
private BigDecimal finalPrice;
/** 库存总数快照。 */
private Integer stockTotal;
/** 商品属性全集(原始 key/label/value 三元组 JSON 原样透传)。 */
private String attrs;
/** SKU 矩阵(销售属性组合行,价已按规则折算)。 */
private List<SkuVo> skus;
/** 主图(预签名 GET URL,sortNo 升序)。 */
private List<ImageView> mainImages;
/** 销售属性图(attrName 维度,预签名 GET URL)。 */
private List<ImageView> attrImages;
/** 详情长图(预签名 GET URL,sortNo 升序,直铺详情编辑器)。 */
private List<ImageView> detailImages;
/** SKU 矩阵行。 */
@Data
public static class SkuVo {
private String skuId;
private String skuName;
/** SKU 源价(采集快照)。 */
private BigDecimal sourcePrice;
/** SKU 最终价(源价 ± 改价规则折算)。 */
private BigDecimal finalPrice;
private Integer stock;
/** 销售属性组合 JSON([{"name":"颜色","value":"上衣"},…])。 */
private String saleAttrsJson;
private Integer sortNo;
}
/** 图片下发视图(objectKey 留档 + 预签名 GET URL 直取)。 */
@Data
public static class ImageView {
/** 自有桶对象 key(留档;URL 过期时可凭它重签)。 */
private String objectKey;
/** 预签名 GET URL(客户端执行器直接下载/上传京麦)。 */
private String url;
/** 销售属性名(ATTR 档专用)。 */
private String attrName;
private Integer sortNo;
}
}
@@ -0,0 +1,30 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.util.List;
/**
* 明细分批下发页(v1.5 蓝图 §3:GET /api/jd-publish/tasks/{taskId}/items)。
*
* <p>游标语义:{@code nextCursor}=本页最后一行 id,客户端带它取下一页;{@code hasMore}
* 由「本页取满批大小」判定(SQL 侧 {@code id > cursor AND publish_status='PENDING'}
* 下推,铁律 20——已回传行被状态谓词跳过,断点重连 cursor 归零也不会重发)。</p>
*/
@Data
public class JdPublishItemsPageVo {
private Long taskId;
/** 本页明细行。 */
private List<JdPublishItemPayloadVo> items;
/** 下一页游标(本页最后一行 id;空页时保持请求 cursor)。 */
private Long nextCursor;
/** true=可能还有下一页(本页取满批大小)。 */
private boolean hasMore;
/** 该任务剩余未发布行数(PENDING 计数,进度参考)。 */
private long pendingCount;
}
@@ -0,0 +1,41 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 京东发布任务进度(v1.5 用户端实时面板数据源,R7)。
*
* <p>行级分组计数(PENDING/PUBLISHING/SUCCESS/FAILED)来自 {@code biz_jd_publish_item}
* 聚合 SQL;任务级状态/终态原因来自 {@code biz_file_task}。归属校验按 {@code (taskId, userId)}
* (铁律 11):管理员代客时 userId 与任务 owner 不一致一律拒。</p>
*/
@Data
public class JdPublishProgressVo {
private Long taskId;
/** 任务状态(biz_file_task.status)。 */
private String status;
/** 终态原因(error_message;非终态为 null)。 */
private String message;
/** 总行数(该任务商品明细行数)。 */
private long totalCount;
/** 待发布行数。 */
private long pendingCount;
/** 发布中行数。 */
private long publishingCount;
/** 成功行数。 */
private long successCount;
/** 失败行数。 */
private long failedCount;
private LocalDateTime updatedAt;
}
@@ -0,0 +1,27 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.util.Map;
/**
* 京东商品上架建单响应(v1.5 蓝图 §3)。
*
* <p>{@code queuePayload} 是页面推送载体(DELETE_BRAND {@code delete-brand-run} 同形先例):
* 建单成功后用户端页面 JS 把它原样投进 {@code api.enqueue_json}——载荷 type 与
* {@code JdPublishTaskPullSpiImpl.QUEUE_TYPE} 逐字同值(铁律 32 第三件:enqueue 页面推送;
* 兜底拉取线由 SPI 组装同形载荷,两处漂移任务永不执行)。</p>
*/
@Data
public class JdPublishTaskVo {
private Long taskId;
private String taskNo;
/** 执行通道(建单显式写 LOCAL,铁律 19:京麦登录态只在用户桌面机)。 */
private String collectChannel;
/** 页面推送载荷:{"type":"jd-product-publish-run","data":{"taskId":n,"priceRule":{...}}}。 */
private Map<String, Object> queuePayload;
}
@@ -8,6 +8,7 @@ import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity; import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport; import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy; import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.AdminPlatformScope;
import com.nanri.aiimage.common.service.DataReadScope; import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper; import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity; import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
@@ -27,11 +28,13 @@ import java.util.Set;
* 京东数据库分类的「当前分组」作用域解析(V203,2026-11-16 用户口径)。 * 京东数据库分类的「当前分组」作用域解析(V203,2026-11-16 用户口径)。
* *
* <p>口径:「组」=公司内的<b>数据权限分组</b>({@code biz_shop_manage_group}),公司→组两级隔离。 * <p>口径:「组」=公司内的<b>数据权限分组</b>({@code biz_shop_manage_group}),公司→组两级隔离。
* 四档:</p> * 2026-11-17 用户口径「同理京东那边也是」加一条平台闸:<b>只有京东档({@code platform='jd'},
* V206 列)的分组才进京东侧作用域</b>——亚马逊档与 NULL 一律不进下拉(四档角色先各自圈完
* 可见集,最后统一过这道闸)。四档:</p>
* <ul> * <ul>
* <li><b>平台超管</b>:全部公司全部组可读可写;</li> * <li><b>平台超管</b>:全部公司全部<b>京东档</b>组可读可写;</li>
* <li><b>公司超管</b>:本公司全部组可读可写(与「公司超管看本公司全部成员」同源);</li> * <li><b>公司超管</b>:本公司全部<b>京东档</b>组可读可写(与「公司超管看本公司全部成员」同源);</li>
* <li><b>管理员(组长)</b>:可见=自己带的组 + 自己所属组的组长;可写=自己带的组;</li> * <li><b>管理员(组长)</b>:可见=自己带的组 + 自己所属组的组长(过平台闸后);可写=自己带的组;</li>
* <li><b>普通号</b>:可见同上,可写空(能开弹窗看,不能增删改分类、不能归类)。</li> * <li><b>普通号</b>:可见同上,可写空(能开弹窗看,不能增删改分类、不能归类)。</li>
* </ul> * </ul>
* *
@@ -144,39 +147,49 @@ public class JdCategoryScopeService {
String role = adminAuthSupport.currentRole(user); String role = adminAuthSupport.currentRole(user);
Map<Long, ShopManageGroupEntity> visible = new LinkedHashMap<>(); Map<Long, ShopManageGroupEntity> visible = new LinkedHashMap<>();
Set<Long> writable = new LinkedHashSet<>(); Set<Long> writable = new LinkedHashSet<>();
if (dataReadScope.isPlatformSuperAdmin(user)) { boolean platformSuperAdmin = dataReadScope.isPlatformSuperAdmin(user);
if (platformSuperAdmin) {
collect(visible, shopManageGroupMapper.selectAllGroups()); collect(visible, shopManageGroupMapper.selectAllGroups());
writable.addAll(visible.keySet()); writable.addAll(visible.keySet());
return assemble(true, user.getCompanyId(), visible, writable); } else if (DeviceSessionPolicy.isCompanySuperAdmin(role)) {
}
if (DeviceSessionPolicy.isCompanySuperAdmin(role)) {
Long companyId = user.getCompanyId(); Long companyId = user.getCompanyId();
if (companyId != null && companyId > 0) { if (companyId != null && companyId > 0) {
collect(visible, companyGroups(companyId)); collect(visible, companyGroups(companyId));
writable.addAll(visible.keySet()); writable.addAll(visible.keySet());
} }
return assemble(false, companyId, visible, writable); } else {
} // 管理员(组长):自己带的组可写;自己所属组的组长带的分组只读可见。
// 管理员(组长):自己带的组可写;自己所属组的组长带的分组只读可见。 List<ShopManageGroupEntity> led = ledGroups(user.getId());
List<ShopManageGroupEntity> led = ledGroups(user.getId()); collect(visible, led);
collect(visible, led); if ("admin".equals(role)) {
if ("admin".equals(role)) { for (ShopManageGroupEntity group : led) {
for (ShopManageGroupEntity group : led) { if (group.getId() != null) {
if (group.getId() != null) { writable.add(group.getId());
writable.add(group.getId()); }
}
}
if (user.getCreatedById() != null && user.getCreatedById() > 0) {
collect(visible, ledGroups(user.getCreatedById()));
}
List<Long> memberOfLeaders = shopManageGroupMapper.selectLeaderIdsByMemberUserId(user.getId());
if (memberOfLeaders != null) {
for (Long leaderId : memberOfLeaders) {
collect(visible, ledGroups(leaderId));
} }
} }
} }
if (user.getCreatedById() != null && user.getCreatedById() > 0) { // 2026-11-17 用户口径「同理京东那边也是」:京东侧作用域只认京东档(platform='jd')的
collect(visible, ledGroups(user.getCreatedById())); // 数据权限分组——亚马逊档与 NULL 一律不进下拉。V206 存量默认 amazon、京东侧数据由编辑
} // 弹窗翻档,这里不做「NULL/缺列当 jd」的宽判:宽了会把没翻档的存量整批带进京东侧,
List<Long> memberOfLeaders = shopManageGroupMapper.selectLeaderIdsByMemberUserId(user.getId()); // 等于平台分侧白做。
if (memberOfLeaders != null) { retainJdPlatformGroups(visible, writable);
for (Long leaderId : memberOfLeaders) { return assemble(platformSuperAdmin, user.getCompanyId(), visible, writable);
collect(visible, ledGroups(leaderId)); }
}
} /** 只留京东档分组,并让可写集跟着可见集收缩(writable ⊆ visible 的既有不变量保持)。 */
return assemble(false, user.getCompanyId(), visible, writable); private static void retainJdPlatformGroups(Map<Long, ShopManageGroupEntity> visible, Set<Long> writable) {
visible.values().removeIf(group -> !AdminPlatformScope.JD.equals(group.getPlatform()));
writable.retainAll(visible.keySet());
} }
private List<ShopManageGroupEntity> companyGroups(Long companyId) { private List<ShopManageGroupEntity> companyGroups(Long companyId) {
@@ -79,14 +79,18 @@ public class JdProductQueryService {
* 分页查询商品行({@code synced_at} 倒序)。 * 分页查询商品行({@code synced_at} 倒序)。
* *
* <p>过滤面:商品编码 contains、标题关键词 contains、类目 eq、分组 eq(2026-11-16 起 * <p>过滤面:商品编码 contains、标题关键词 contains、类目 eq、分组 eq(2026-11-16 起
* 由类目面板「自定义分类」选中驱动)、同步起止(datetime 闭区间)。 * 由类目面板「自定义分类」选中驱动)、同步起止(datetime 闭区间)、分类状态档
* 未分类/已分类两档(ungrouped/grouped)与独立「分类」筛选框随同日口径 * {@code classified}(2026-11-17 用户口径「加个已分类和未分类的筛选」:true=当前分组下
* 「分类不要了,全部整合到类目里」整批撤掉。 * 有分类、false=没有、null=全部;按 V203 归属表 EXISTS/NOT EXISTS 在 SQL 侧下推,
* 判据与 {@link #fillGroupNames} 填分类列的条件同形——「筛选说未分类的行,列表分类列
* 也必须是未分类」)。
* 2026-11-16 撤掉的旧 ungrouped/grouped 两档读的是已停用的 biz_jd_product.group_id 列,
* 与本档不是一回事;独立「分类」筛选框的撤掉口径不变。
* 公司维过滤已随 2026-11-16 摘公司 tab 整批撤掉(全平台公共)。</p> * 公司维过滤已随 2026-11-16 摘公司 tab 整批撤掉(全平台公共)。</p>
*/ */
public JdProductPageVo page(Long page, Long pageSize, public JdProductPageVo page(Long page, Long pageSize,
String productCode, String titleKeyword, String category, Long groupId, String productCode, String titleKeyword, String category, Long groupId,
LocalDateTime syncedFrom, LocalDateTime syncedTo, Long ownerGroupId) { LocalDateTime syncedFrom, LocalDateTime syncedTo, Boolean classified, Long ownerGroupId) {
if (syncedFrom != null && syncedTo != null && syncedFrom.isAfter(syncedTo)) { if (syncedFrom != null && syncedTo != null && syncedFrom.isAfter(syncedTo)) {
throw new BusinessException("开始时间不能晚于结束时间"); throw new BusinessException("开始时间不能晚于结束时间");
} }
@@ -94,14 +98,14 @@ public class JdProductQueryService {
long safeSize = pageSize == null ? PageDefaults.JD_PRODUCTS_PAGE_SIZE_INT long safeSize = pageSize == null ? PageDefaults.JD_PRODUCTS_PAGE_SIZE_INT
: Math.min(Math.max(pageSize, 1), MAX_PAGE_SIZE); : Math.min(Math.max(pageSize, 1), MAX_PAGE_SIZE);
Filter filter = filter(productCode, titleKeyword, category, Filter filter = filter(productCode, titleKeyword, category,
groupId, syncedFrom, syncedTo); groupId, syncedFrom, syncedTo, classified);
long total = jdProductMapper.countProducts(filter.productCode(), long total = jdProductMapper.countProducts(filter.productCode(),
filter.titleKeyword(), filter.category(), filter.groupId(), filter.titleKeyword(), filter.category(), filter.groupId(),
filter.syncedFrom(), filter.syncedTo()); filter.syncedFrom(), filter.syncedTo(), filter.classified(), ownerGroupId);
List<JdProductEntity> rows = total <= 0 ? List.of() List<JdProductEntity> rows = total <= 0 ? List.of()
: jdProductMapper.selectProductPage(filter.productCode(), : jdProductMapper.selectProductPage(filter.productCode(),
filter.titleKeyword(), filter.category(), filter.groupId(), filter.titleKeyword(), filter.category(), filter.groupId(),
filter.syncedFrom(), filter.syncedTo(), filter.syncedFrom(), filter.syncedTo(), filter.classified(), ownerGroupId,
(safePage - 1) * safeSize, (int) safeSize); (safePage - 1) * safeSize, (int) safeSize);
List<JdProductListItemVo> items = rows.stream().map(this::toListItem).toList(); List<JdProductListItemVo> items = rows.stream().map(this::toListItem).toList();
fillGroupNames(items, ownerGroupId); fillGroupNames(items, ownerGroupId);
@@ -176,18 +180,19 @@ public class JdProductQueryService {
// ---------------------------------------------------------------- 过滤面 // ---------------------------------------------------------------- 过滤面
/** 服务侧过滤面归一:groupId ≤0 按没选处理,文本 trim 后空串归 null(无公司维,2026-11-16 摘)。 */ /** 服务侧过滤面归一:groupId ≤0 按没选处理,文本 trim 后空串归 null(无公司维,2026-11-16 摘);
* classified 原样直传(null=不过滤该面,2026-11-17 分类状态快筛)。 */
private record Filter(String productCode, String titleKeyword, private record Filter(String productCode, String titleKeyword,
String category, Long groupId, String category, Long groupId,
LocalDateTime syncedFrom, LocalDateTime syncedTo) { LocalDateTime syncedFrom, LocalDateTime syncedTo, Boolean classified) {
} }
private static Filter filter(String productCode, String titleKeyword, private static Filter filter(String productCode, String titleKeyword,
String category, Long groupId, String category, Long groupId,
LocalDateTime syncedFrom, LocalDateTime syncedTo) { LocalDateTime syncedFrom, LocalDateTime syncedTo, Boolean classified) {
Long safeGroupId = groupId != null && groupId > 0 ? groupId : null; Long safeGroupId = groupId != null && groupId > 0 ? groupId : null;
return new Filter(trimToNull(productCode), trimToNull(titleKeyword), return new Filter(trimToNull(productCode), trimToNull(titleKeyword),
trimToNull(category), safeGroupId, syncedFrom, syncedTo); trimToNull(category), safeGroupId, syncedFrom, syncedTo, classified);
} }
// ---------------------------------------------------------------- 列表/详情搬运 // ---------------------------------------------------------------- 列表/详情搬运
@@ -0,0 +1,229 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest.ItemResult;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishChunkVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* 京东发布行级回传(v1.5 蓝图 §3 chunk 通道:POST /api/jd-publish/tasks/{taskId}/chunk)。
*
* <p>行状态是唯一行级真源({@code biz_jd_publish_item.publish_status},uk_task_product 定位);
* {@code isEnd=true} 时按行级状态汇总任务终态(失败行 &gt; 0 ⇒ 任务 FAILED、其余 SUCCESS,
* successFileCount/failedFileCount 落真实行数——R6 单行失败隔离、任务终态汇总成败数)。
* CAS 只认 RUNNING(铁律 14:已终态的任务不改写;可重入)。</p>
*
* <p>{@code error} 上报按铁律 31 分档(判死口凭据化,匿名一律拒绝判死——照
* {@code JdCollectController#submitChunk} 同口径):京麦登录态失效 →
* {@link JdPublishStaleTaskService#terminalizeOnJdLoginFatal}(词表复用
* {@code JdStaleTaskService#isJdLoginStateFailure},京东域两链同一族);代理/LLM 凭据
* 致命词 → {@code CredentialFatalTaskCloser};其余技术性故障只记录不判死。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishIngestService {
private static final String LOG_TAG = "jd-publish";
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
/** chunk 可写回的行级状态(PENDING 是建单初值,不接受回传写回)。 */
private static final Set<String> WRITABLE_STATUSES =
Set.of(JdPublishTaskService.ITEM_PUBLISHING, JdPublishTaskService.ITEM_SUCCESS,
JdPublishTaskService.ITEM_FAILED);
/** publish_error 列宽(V210 VARCHAR(1024)),超长截断不炸批。 */
private static final int MAX_ERROR_LENGTH = 1024;
private final FileTaskMapper fileTaskMapper;
private final JdPublishItemMapper jdPublishItemMapper;
private final JdPublishStaleTaskService staleTaskService;
private final TaskProgressSnapshotService taskProgressSnapshotService;
public JdPublishChunkVo submitChunk(Long taskId, JdPublishChunkRequest request, boolean trustedErrorReporter) {
if (taskId == null || taskId <= 0) {
throw new BusinessException("任务 ID 不合法");
}
if (request == null) {
throw new BusinessException("回传体为空");
}
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !TaskFinalizeSupport.belongsToModule(JdPublishTaskService.MODULE_TYPE, task.getModuleType())) {
throw new BusinessException("任务不存在: " + taskId);
}
if (TaskStatuses.FileTask.TERMINAL.contains(task.getStatus())) {
throw new BusinessException("任务已结束(" + task.getStatus() + "),不再接受回传");
}
if (request.getError() != null && !request.getError().isBlank()) {
return handleErrorReport(task, request.getError(), trustedErrorReporter);
}
if (!STATUS_RUNNING.equals(task.getStatus())) {
// PENDING 拒收(页面推送漏 activate 时客户端第一个回传在此被拒,2026-11-14 同形实录)。
throw new BusinessException("任务不在运行中(" + task.getStatus() + "),请先激活任务再回传");
}
int accepted = 0;
if (request.getItems() != null) {
for (ItemResult item : request.getItems()) {
accepted += applyRowResult(taskId, item);
}
}
JdPublishChunkVo vo = new JdPublishChunkVo();
vo.setAcceptedCount(accepted);
vo.setPendingCount(statusCounts(taskId).getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L));
if (Boolean.TRUE.equals(request.getIsEnd())) {
vo.setTaskStatus(summarizeTerminal(taskId));
}
log.info("[{}] chunk 回传 taskId={} batchId={} accepted={} pending={} isEnd={}",
LOG_TAG, taskId, request.getBatchId(), accepted, vo.getPendingCount(),
Boolean.TRUE.equals(request.getIsEnd()));
return vo;
}
/** 行级结果落库:按 uk_task_product(task_id + product_id)定位,单行失败不炸批。 */
private int applyRowResult(Long taskId, ItemResult item) {
if (item == null || item.getProductId() == null) {
return 0;
}
String status = item.getPublishStatus() == null ? null : item.getPublishStatus().trim().toUpperCase();
if (status == null || !WRITABLE_STATUSES.contains(status)) {
log.warn("[{}] 回传行状态不识别,跳过 taskId={} productId={} status={}",
LOG_TAG, taskId, item.getProductId(), item.getPublishStatus());
return 0;
}
LambdaUpdateWrapper<JdPublishItemEntity> wrapper = new LambdaUpdateWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.eq(JdPublishItemEntity::getProductId, item.getProductId())
.set(JdPublishItemEntity::getPublishStatus, status)
.set(JdPublishItemEntity::getPublishError,
JdPublishTaskService.ITEM_FAILED.equals(status)
? truncate(item.getPublishError()) : null)
.set(JdPublishItemEntity::getJdWareId, item.getJdWareId())
.set(JdPublishItemEntity::getUpdatedAt, LocalDateTime.now());
int updated = jdPublishItemMapper.update(null, wrapper);
if (updated == 0) {
log.warn("[{}] 回传行未命中明细行(商品不在本任务?)taskId={} productId={}",
LOG_TAG, taskId, item.getProductId());
}
return updated;
}
/** 铁律 31 分档判死口:只信 X-Internal-Token,匿名 error 一律拒绝判死(不碰状态)。 */
private JdPublishChunkVo handleErrorReport(FileTaskEntity task, String error, boolean trustedErrorReporter) {
JdPublishChunkVo vo = new JdPublishChunkVo();
vo.setAcceptedCount(0);
vo.setPendingCount(statusCounts(task.getId()).getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L));
if (!trustedErrorReporter) {
log.warn("[{}] 匿名 error 上报拒绝判死 taskId={} err={}", LOG_TAG, task.getId(), abbreviate(error));
return vo;
}
// 京东域凭据词(京麦登录态)先判——采集/发布共用 19899 同一 profile,同一族同一判据。
if (JdStaleTaskService.isJdLoginStateFailure(error)) {
staleTaskService.terminalizeOnJdLoginFatal(task, error);
vo.setTaskStatus(TaskStatuses.FileTask.FAILED);
return vo;
}
// 代理/LLM 凭据致命词 → 公共判定档(发布面无代理无 LLM 消费,客户端报什么分什么档)。
boolean closed = new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, null)
.closeIfFatal(task, error);
if (closed) {
vo.setTaskStatus(TaskStatuses.FileTask.FAILED);
return vo;
}
log.warn("[{}] 非致命失败上报,只记录不判死 taskId={} err={}", LOG_TAG, task.getId(), abbreviate(error));
return vo;
}
/** isEnd 终态汇总:按行级真源聚合落任务终态(R6),CAS 只认 RUNNING(铁律 14)。 */
private String summarizeTerminal(Long taskId) {
Map<String, Long> counts = statusCounts(taskId);
long success = counts.getOrDefault(JdPublishTaskService.ITEM_SUCCESS, 0L);
long failed = counts.getOrDefault(JdPublishTaskService.ITEM_FAILED, 0L);
long unpublished = counts.getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L)
+ counts.getOrDefault(JdPublishTaskService.ITEM_PUBLISHING, 0L);
boolean anyFailed = failed > 0;
String status = anyFailed ? TaskStatuses.FileTask.FAILED : TaskStatuses.FileTask.SUCCESS;
StringBuilder reason = new StringBuilder("发布完成:成功 ").append(success).append(" 行,失败 ")
.append(failed).append(" 行");
if (unpublished > 0) {
reason.append(",未发布 ").append(unpublished).append(" 行");
}
LocalDateTime now = LocalDateTime.now();
// 文案先落局部变量再配对写列(B51-R1 守卫「写的列与文案同一个来源」:列由同一句文案派生,
// 三元里各写各的表达式会被 TaskFailureCategoryGuardrailTest 判为不同源即红)。
String message = anyFailed ? reason.toString() : null;
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, taskId)
.eq(FileTaskEntity::getModuleType, JdPublishTaskService.MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, status)
.set(FileTaskEntity::getSuccessFileCount, success)
.set(FileTaskEntity::getFailedFileCount, failed)
.set(FileTaskEntity::getErrorMessage, message)
.set(FileTaskEntity::getFailureCategory, message == null ? null : TaskFailureLedger.categoryOf(message))
.set(FileTaskEntity::getUpdatedAt, now)
.set(FileTaskEntity::getFinishedAt, now));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(taskId, JdPublishTaskService.MODULE_TYPE, status,
anyFailed ? reason.toString() : null);
log.info("[{}] 任务落终态 {} taskId={}", LOG_TAG, status, taskId);
}
return status;
}
/** 行级状态聚合(XML 具名 SQL):status → 行数。 */
private Map<String, Long> statusCounts(Long taskId) {
Map<String, Long> counts = new LinkedHashMap<>();
for (Map<String, Object> row : jdPublishItemMapper.countByPublishStatus(taskId)) {
Object status = row.get("publishStatus");
Object cnt = row.get("cnt");
if (status != null && cnt instanceof Number number) {
counts.put(String.valueOf(status), number.longValue());
}
}
return counts;
}
private String truncate(String value) {
if (value == null) {
return null;
}
String trimmed = value.trim();
return trimmed.length() <= MAX_ERROR_LENGTH ? trimmed : trimmed.substring(0, MAX_ERROR_LENGTH);
}
private String abbreviate(String value) {
if (value == null) {
return "";
}
return value.length() <= 200 ? value : value.substring(0, 200) + "…";
}
/** 供测试确认行级形状(按任务取全部明细行)。 */
public java.util.List<JdPublishItemEntity> findItemRows(Long taskId) {
return jdPublishItemMapper.selectList(new LambdaQueryWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.orderByAsc(JdPublishItemEntity::getId));
}
}
@@ -0,0 +1,156 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.common.task.LockSkipWitness;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 京东商品上架判活(v1.5 蓝图 §4 Phase 2,形状照 {@code JdStaleTaskService} 同形)。
*
* <p>两件事,登记形态不同:① <b>心跳超时兜底判死</b>——自带 {@code @Scheduled} 巡检
* (注册表 {@code selfScheduledStaleCheck=true},同 JD_SHOP_COLLECT 先例:发布是逐商品页面
* 自动化,节奏比采集还慢,60 分钟超时线({@code aiimage.jd.publish.stale-minutes},按发布
* 时长重估)并入 2 分钟集中巡检线没有额外收益,自管判死时延即可);② <b>京麦登录态失效
* 判死</b>——客户端在回传 {@code error} 里报「京麦未登录 / 登录态失效」时由回传侧
* ({@code JdPublishIngestService})调 {@link #terminalizeOnJdLoginFatal} 整单落终态
* (铁律 31:凭据不可自愈 ⇒ 行失败 + 整单终态,让心跳对采集端回 {@code alive=false} 收手),
* 判死出口集中在本类。</p>
*
* <p>「京麦登录态」词表是京东域两链共用的同一族凭据词(采集/发布共用 19899 同一 profile,
* 登录态失效的形状相同)——判据直接复用 {@code JdStaleTaskService#isJdLoginStateFailure},
* 不另抄一份词表(两份词表各改各的就是分叉判据);代理/LLM 凭据致命词的分档不在本类——
* 那是 {@code CredentialFatalClassifier} 的公共词表,回传侧直接用。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishStaleTaskService {
public static final String MODULE_TYPE = JdPublishTaskService.MODULE_TYPE;
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
private static final String STATUS_FAILED = TaskStatuses.FileTask.FAILED;
private static final String LOG_TAG = "jd-publish";
private final FileTaskMapper fileTaskMapper;
private final TaskDistributedLockService taskDistributedLockService;
private final DistributedJobLockService distributedJobLockService;
private final StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy;
private final TaskProgressSnapshotService taskProgressSnapshotService;
/** 心跳超时线(分钟),按发布时长重估(蓝图 §3);下限钳 1。 */
@Value("${aiimage.jd.publish.stale-minutes:60}")
private long staleMinutes;
/** 心跳超时兜底判死(自带调度;分布式锁保证 A/B 双实例单跑;秒位 45 与采集面 40 错开)。 */
@Scheduled(cron = "${aiimage.jd.publish.stale-check-cron:45 */2 * * * *}")
public void finalizeStaleTasks() {
DistributedJobLockService.LockHandle lock =
distributedJobLockService.tryLock("jd-publish:stale-check", java.time.Duration.ofMinutes(10));
if (lock == null) {
LockSkipWitness.abandoned("jd-publish:stale-check");
return;
}
try (lock) {
long minutes = Math.max(1L, staleMinutes);
LocalDateTime threshold = LocalDateTime.now().minusMinutes(minutes);
List<FileTaskEntity> candidates = fileTaskMapper.selectList(new LambdaQueryWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.lt(FileTaskEntity::getUpdatedAt, threshold)
.last("limit 200"));
for (FileTaskEntity task : candidates) {
if (staleTaskHeartbeatPolicy.isStillQueuedBeforeFirstHeartbeat(
task.getId(), 0L, task.getUpdatedAt(), LocalDateTime.now())) {
// 首次心跳之前不判死:任务还在客户端队列排队,updated_at 停在认领时刻不是卡死证据。
log.info("[{}] 未收到首次心跳、排队宽限内暂不判死 taskId={} updatedAt={} timeoutMinutes={}",
LOG_TAG, task.getId(), task.getUpdatedAt(), minutes);
continue;
}
TaskDistributedLockService.LockHandle taskLock =
taskDistributedLockService.acquire(MODULE_TYPE, task.getId(), 0L);
if (taskLock == null) {
LockSkipWitness.recordAbandoned("jd-publish:stale-finalize", MODULE_TYPE, task.getId());
continue;
}
try (taskLock) {
failStale(task, minutes);
}
}
}
}
private void failStale(FileTaskEntity task, long minutes) {
String reason = "京东上架心跳超时超过 " + minutes + " 分钟,任务已自动失败";
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, task.getId())
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, STATUS_FAILED)
.set(FileTaskEntity::getErrorMessage, reason)
.set(FileTaskEntity::getFailureCategory, TaskFailureLedger.categoryOf(reason))
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now())
.set(FileTaskEntity::getFinishedAt, LocalDateTime.now()));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(task.getId(), MODULE_TYPE, STATUS_FAILED, reason);
log.warn("[{}] 心跳超时改判死 taskId={} updatedAt={} timeoutMinutes={}",
LOG_TAG, task.getId(), task.getUpdatedAt(), minutes);
}
}
/**
* 京麦登录态失效整单判死(铁律 31):CAS RUNNING→FAILED,终态文案点名「京麦未登录」与
* 「登录态失效」并给动作句(不写「稍后重试」)。已终态的任务 CAS 自然不命中,可重入。
*
* @return true=本次真的把任务写成了终态
*/
public boolean terminalizeOnJdLoginFatal(FileTaskEntity task, String rawError) {
if (task == null || task.getId() == null) {
return false;
}
String message = terminalLoginMessage(rawError);
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, task.getId())
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, STATUS_FAILED)
.set(FileTaskEntity::getSuccessFileCount, 0)
.set(FileTaskEntity::getFailedFileCount, 1)
.set(FileTaskEntity::getErrorMessage, message)
.set(FileTaskEntity::getFailureCategory, TaskFailureLedger.categoryOf(message))
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now())
.set(FileTaskEntity::getFinishedAt, LocalDateTime.now()));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(task.getId(), MODULE_TYPE, STATUS_FAILED, message);
log.warn("[{}] 京麦登录态失效,任务落终态 FAILED taskId={} err={}", LOG_TAG, task.getId(), message);
}
return updated > 0;
}
/** 终态文案:生产者原文 + 点名两句判据词(「京麦未登录」「登录态失效」都在,AC-5 口径)+ 动作句。 */
static String terminalLoginMessage(String rawError) {
String raw = rawError == null ? "" : rawError.trim();
StringBuilder message = new StringBuilder();
if (!raw.isEmpty()) {
message.append(raw).append(";");
}
message.append("京麦未登录(登录态失效),请在客户端重新登录京麦后重试");
return message.toString();
}
}
@@ -0,0 +1,59 @@
package com.nanri.aiimage.modules.jd.service;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.TaskModuleHeartbeatSpi;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 京东商品上架的心跳 SPI 接线(v1.5,形状照 {@code JdCollectTaskHeartbeatSpi} 同形)。
*
* <p>京东模块没有独立的任务缓存(进度由全局心跳位置表、{@code biz_jd_publish_item}
* 行级真源与 {@code biz_task_progress_snapshot} 承载),所以 {@link #touchHeartbeat} 是
* 语义上的空实现——挂这个 Bean 的目的:① 心跳契约测试按注册表校验每个 moduleType 都有
* SPI,缺了会红;② 显式声明 {@code heartbeatNeedsFullTaskEntity()=false},心跳热路径不捞
* {@code request_json}/{@code result_json} 整行(AC-19 同款省钱口径);③ <b>override
* {@link #ensureOwnership}</b>——B98-07 同形债预防(采集面 JdCollectTaskHeartbeatSpi 未
* override,任意用户可给任意京东任务刷心跳续命,在册 P3)。</p>
*
* <p><b>为什么不在 SPI 里做实例域拒绝</b>:publish/shop-data-crawl 的任务由服务端 worker
* 执行、心跳来自执行线程自身(认领实例),按 {@code owner_instance_id} 拒绝安全;京东发布
* 是 LOCAL 单机任务、心跳来自用户桌面机客户端——公网入口可能落到 A/B 任一实例,按实例域
* 拒绝会把「心跳落到非认领实例」误杀成断连。用户域归属校验落在
* {@code JdPublishController#heartbeat}(可信 uid 只在会话层拿得到),本 override 做
* 任务在飞的轻校验并留审核痕迹。</p>
*/
@Slf4j
@Component
public class JdPublishTaskHeartbeatSpi implements TaskModuleHeartbeatSpi {
@Override
public String moduleType() {
return JdPublishTaskService.MODULE_TYPE;
}
@Override
public void touchHeartbeat(Long taskId, TaskHeartbeatRequest request) {
// 京东发布无模块缓存可刷:行级进度由 chunk 回传侧写,心跳只走 task 侧的通用通道。
}
/**
* B98-07 同形债预防(override=债已接,不是漏接):任务为空或模块不归属即拒绝;
* 实例域判据刻意不做(LOCAL 客户端心跳会落任一实例,见类注释)——用户域归属校验
* 在控制器层按可信 uid 执行。
*/
@Override
public void ensureOwnership(FileTaskEntity task, String operation) {
if (task == null || task.getId() == null
|| !JdPublishTaskService.MODULE_TYPE.equals(task.getModuleType())) {
throw new IllegalArgumentException("心跳目标不是京东上架任务 taskId="
+ (task == null ? null : task.getId()) + " operation=" + operation);
}
}
@Override
public boolean heartbeatNeedsFullTaskEntity() {
return false;
}
}
@@ -0,0 +1,46 @@
package com.nanri.aiimage.modules.jd.service;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.ClientTaskPullSpi;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* 京东商品上架的客户端兜底拉取实现(v1.5,铁律 32 派发三件套第一件)。
*
* <p>页面推送缺失(只建单没推送 / 推送前关页面 / 纯浏览器打开)时任务会停在 PENDING,
* {@code TaskClientPullService} 认领后由本实现组装可直接入队的载荷。载荷组装单一出处=
* {@link JdPublishTaskService#buildQueuePayload}(建单响应体与兜底拉取共用),type 与
* 客户端分发键逐字同值 <b>jd-product-publish-run</b>({@code QUEUE_TYPE})——
* 两处漂移任务客户端不识别(铁律 32:领了任务却「未知任务类型」)。</p>
*
* <p>明细(标题/价格/SKU/图片预签名)不在派发载荷里——载荷只带 taskId+改价规则
* (蓝图 §3:载荷尺寸可控、断点友好),客户端拿到后按游标分批拉
* {@code GET /api/jd-publish/tasks/{taskId}/items}。</p>
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class JdPublishTaskPullSpiImpl implements ClientTaskPullSpi {
/** 与客户端 amazon/jd/publish 的 QUEUE_TYPE 逐字同值(改这里必须同轮改客户端)。 */
public static final String QUEUE_TYPE = "jd-product-publish-run";
private final JdPublishTaskService publishTaskService;
@Override
public String moduleType() {
return JdPublishTaskService.MODULE_TYPE;
}
@Override
public Map<String, Object> buildQueuePayload(FileTaskEntity task) {
// 载荷组装单一出处:与建单响应的 queuePayload 同源(铁律 32 三件同值判据)。
Map<String, Object> payload = publishTaskService.buildQueuePayload(task);
log.info("[jd-publish] 兜底载荷已组装 taskId={}", task.getId());
return payload;
}
}
@@ -0,0 +1,537 @@
package com.nanri.aiimage.modules.jd.service;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.config.CollectRoutingProperties;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.jd.mapper.JdProductImageMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductSkuMapper;
import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest.PriceRule;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductImageEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductSkuEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemPayloadVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemsPageVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishProgressVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishTaskVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.CollectChannel;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 京东商品上架建单(v1.5 蓝图 docs/ITERATION_PLAN.md §4 Phase 2:建单/配额/归属/生命周期/明细下发)。
*
* <p>形状照 {@code JdCollectTaskService} 同形:Mapper {@code insert} +
* taskNo={@code MODULE_TYPE-Snowflake} + 载荷整体进 {@code request_json}。京东发布特有:
* ① 执行通道恒 {@code LOCAL} 且<b>建单显式写库</b>(铁律 19:京麦登录态只在用户桌面机
* 19899 Chrome profile,执行方没有"界面选 ONLINE"的自由度);② 建单口<b>不接</b>
* {@code requireSubmitSecret}——发布由桌面机已登录京麦的 Chrome 直连执行,无代理无 LLM
* ({@code TaskModuleRegistry} 登记 {@code Optional.empty()},铁律 27c 登记结论);
* ③ 建单前置闸门按铁律 27b 排在一切昂贵动作前:未选商品 / 选了他人商品(AC-9 归属,
* 业务码 403)/ 超配额(AC-8,{@code JdPublishQuotaService#assertWithinQuota} 原语接线)
* 逐条点名拒绝;④ 建单即按商品快照落 {@code biz_jd_publish_item} 行(V210,商品库有
* 清理语义,发布记录不随商品删除丢失溯源)。</p>
*
* <p>建单成功页面推送与兜底拉取共用同一份载荷组装 {@link #buildQueuePayload}:
* type=<b>jd-product-publish-run</b>(与 {@link JdPublishTaskPullSpiImpl#QUEUE_TYPE}
* 逐字同值,铁律 32 第三件——两处漂移任务永不执行)。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishTaskService {
public static final String MODULE_TYPE = CollectRoutingProperties.MODULE_JD_PUBLISH;
private static final String STATUS_PENDING = TaskStatuses.FileTask.PENDING;
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
/** 行级状态词表(V210 publish_status 列,与客户端 chunk 回传同词表)。 */
public static final String ITEM_PENDING = "PENDING";
public static final String ITEM_PUBLISHING = "PUBLISHING";
public static final String ITEM_SUCCESS = "SUCCESS";
public static final String ITEM_FAILED = "FAILED";
/** 单任务商品勾选上限(防 request_json/明细行膨胀;建单口拦注定失败的输入)。 */
private static final int MAX_PRODUCT_IDS = 500;
/** items 下发批大小上限(服务侧钳制,防一次拉满 500 行把载荷撑爆)。 */
private static final int MAX_ITEMS_BATCH = 100;
/** 图片预签名 GET 有效期(秒):发布一批跑得久,24h 同 InternalAudio 先例。 */
private static final int IMAGE_PRESIGN_EXPIRY_SECONDS = 86_400;
private final FileTaskMapper fileTaskMapper;
private final JdProductMapper jdProductMapper;
private final JdProductImageMapper jdProductImageMapper;
private final JdProductSkuMapper jdProductSkuMapper;
private final JdPublishItemMapper jdPublishItemMapper;
private final JdPublishQuotaService jdPublishQuotaService;
private final AdminUserMapper adminUserMapper;
private final OssStorageService ossStorageService;
private final ObjectMapper objectMapper;
private final TaskHeartbeatService taskHeartbeatService;
private final TaskHeartbeatPositionService taskHeartbeatPositionService;
/** 下发批大小出厂值(aiimage.jd.publish.items-batch-size,服务侧钳制上限 100)。 */
@Value("${aiimage.jd.publish.items-batch-size:20}")
private int itemsBatchSize = 20;
/** jd-products 独立桶(V194 同源配置,商品图/详情长图都在这里,铁律 17)。 */
@Value("${aiimage.jd.oss.bucket:jd-products}")
private String bucket;
public JdPublishTaskVo createTask(JdPublishTaskCreateRequest request, String deviceId) {
validate(request);
// AC-8 配额闸:前置在一切昂贵动作前(铁律 27b),超配额当场业务码拒绝并点名额度文案。
AdminUserEntity operator = adminUserMapper.selectById(request.getUserId());
jdPublishQuotaService.assertWithinQuota(operator, request.getProductIds().size());
// AC-9 归属半边:按主键批量取商品行(建单勾选集上界 500,非取页分页),存在性
// 与归属一起 fail-closed——缺行与选了他人商品都当场拒,不让一半商品静默混进任务。
List<JdProductEntity> products = jdProductMapper.selectBatchIds(request.getProductIds());
if (products.size() != request.getProductIds().size()) {
throw new BusinessException("部分商品不存在或已从京东数据库清理,请刷新后重新勾选");
}
for (JdProductEntity product : products) {
if (!Objects.equals(product.getUserId(), request.getUserId())) {
throw new BusinessException(403, "勾选的商品不属于当前账号,不能上架他人数据库的商品");
}
}
LocalDateTime now = LocalDateTime.now();
FileTaskEntity task = new FileTaskEntity();
task.setTaskNo(MODULE_TYPE + "-" + IdUtil.getSnowflakeNextIdStr());
task.setModuleType(MODULE_TYPE);
task.setTaskMode("PYTHON_QUEUE");
// 铁律 19:建单入口显式写通道。京东发布只能在本机已登录京麦的 Chrome 执行。
task.setCollectChannel(CollectChannel.LOCAL.name());
task.setStatus(STATUS_PENDING);
task.setSourceFileCount(request.getProductIds().size());
task.setSuccessFileCount(0);
task.setFailedFileCount(0);
task.setCreatedBy("user:" + request.getUserId());
task.setUserId(request.getUserId());
task.setDeviceId(AdminAuthSupport.normalizeDeviceId(deviceId));
task.setCreatedAt(now);
task.setUpdatedAt(now);
try {
task.setRequestJson(objectMapper.writeValueAsString(request));
task.setResultJson("{}");
} catch (Exception ex) {
throw new BusinessException("序列化建单载荷失败", ex);
}
fileTaskMapper.insert(task);
// 建单即落明细快照行(蓝图 §3):标题/类目/价格折算/库存/店铺/编码随行固化,
// 商品行被清理后发布记录仍可溯源;uk_task_product 防同任务重复勾选落两行。
Map<Long, String> mainImageByProduct = loadMainImageObjectKeys(products);
for (JdProductEntity product : products) {
jdPublishItemMapper.insert(buildSnapshotItem(task, product, request,
mainImageByProduct.get(product.getId()), now));
}
JdPublishTaskVo vo = new JdPublishTaskVo();
vo.setTaskId(task.getId());
vo.setTaskNo(task.getTaskNo());
vo.setCollectChannel(task.getCollectChannel());
vo.setQueuePayload(buildQueuePayload(task));
log.info("[jd-publish] 建单成功 taskId={} taskNo={} products={} userId={} channel={}",
task.getId(), task.getTaskNo(), request.getProductIds().size(),
request.getUserId(), task.getCollectChannel());
return vo;
}
/**
* 激活任务(PENDING→RUNNING)——页面把载荷推给本机客户端<b>之前</b>调用。
*
* <p>形状照 {@code JdCollectTaskService#activateTask} 同形(2026-11-14 真机实录:漏掉
* 这一步,客户端第一个回传会被「任务不在运行中(PENDING)」拒收)。只允许
* PENDING→RUNNING 条件更新:与客户端兜底拉取的原子认领互斥,谁先翻转谁执行。
*/
public void activateTask(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
// 归属谓词走公共出口(TaskLifecycleDebtRatchetTest 棘轮只许降:新增手写遍数即红)。
if (task == null || !TaskFinalizeSupport.belongsToModule(MODULE_TYPE, task.getModuleType())
|| (userId != null && task.getUserId() != null && !Objects.equals(userId, task.getUserId()))) {
throw new BusinessException("任务不存在");
}
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, taskId)
.eq(FileTaskEntity::getStatus, STATUS_PENDING)
.set(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now()));
if (updated == 0) {
FileTaskEntity latest = fileTaskMapper.selectById(taskId);
if (latest != null && STATUS_RUNNING.equals(latest.getStatus())) {
throw new BusinessException("任务已在执行中(可能已由客户端自动接管),无需重复启动");
}
throw new BusinessException("任务已结束");
}
log.info("[jd-publish] 已激活(PENDING→RUNNING) taskId={} userId={}", taskId, task.getUserId());
}
/**
* 明细分批下发(GET /items):只出 PENDING 行(已回传行被 SQL 状态谓词跳过,断点
* 重连 cursor 归零也不会重发已发布商品,AC-4 服务端半边);SKU 价按改价规则折算;
* 图片发 jd-products 桶预签名 GET URL(蓝图 §3)。
*/
public JdPublishItemsPageVo pullItems(Long taskId, Long userId, Long cursor, Integer limit) {
requireOwnedTask(taskId, userId);
int safeLimit = Math.min(Math.max(limit == null ? itemsBatchSize : limit, 1), MAX_ITEMS_BATCH);
long safeCursor = cursor == null ? 0L : Math.max(0L, cursor);
List<JdPublishItemEntity> rows = jdPublishItemMapper.selectPublishableItems(taskId, safeCursor, safeLimit);
// 页内商品行批量取(attrs 原样透传),不逐行 selectById。
Map<Long, JdProductEntity> productsByPid = rows.isEmpty() ? Map.of()
: jdProductMapper.selectBatchIds(rows.stream().map(JdPublishItemEntity::getProductId).toList())
.stream().collect(Collectors.toMap(JdProductEntity::getId, Function.identity(), (a, b) -> a));
JdPublishItemsPageVo vo = new JdPublishItemsPageVo();
vo.setTaskId(taskId);
vo.setItems(rows.isEmpty() ? List.of() : rows.stream()
.map(row -> buildItemPayload(row, productsByPid.get(row.getProductId())))
.toList());
vo.setNextCursor(rows.isEmpty() ? safeCursor : rows.get(rows.size() - 1).getId());
vo.setHasMore(rows.size() == safeLimit);
vo.setPendingCount(aggregateStatusCounts(taskId).getOrDefault(ITEM_PENDING, 0L));
return vo;
}
/** 行级进度(R7 实时面板):任务级状态/终态原因 + 行级分组计数。 */
public JdPublishProgressVo queryProgress(Long taskId, Long userId) {
FileTaskEntity task = requireOwnedTask(taskId, userId);
JdPublishProgressVo vo = new JdPublishProgressVo();
vo.setTaskId(task.getId());
vo.setStatus(task.getStatus());
vo.setMessage(task.getErrorMessage());
vo.setUpdatedAt(task.getUpdatedAt());
Map<String, Long> counts = aggregateStatusCounts(taskId);
vo.setPendingCount(counts.getOrDefault(ITEM_PENDING, 0L));
vo.setPublishingCount(counts.getOrDefault(ITEM_PUBLISHING, 0L));
vo.setSuccessCount(counts.getOrDefault(ITEM_SUCCESS, 0L));
vo.setFailedCount(counts.getOrDefault(ITEM_FAILED, 0L));
vo.setTotalCount(vo.getPendingCount() + vo.getPublishingCount() + vo.getSuccessCount() + vo.getFailedCount());
return vo;
}
/** 回传/兜底拉取侧读建单载荷(request_json 整体);缺失/损坏按异常拒绝,不静默兜。 */
public JdPublishTaskCreateRequest readCreateRequest(FileTaskEntity task) {
try {
JdPublishTaskCreateRequest request = objectMapper.readValue(task.getRequestJson(),
JdPublishTaskCreateRequest.class);
if (request == null || request.getProductIds() == null || request.getProductIds().isEmpty()) {
throw new BusinessException("任务载荷缺少 productIds,无法下发发布明细");
}
return request;
} catch (BusinessException ex) {
throw ex;
} catch (Exception ex) {
throw new BusinessException("任务载荷解析失败 taskId=" + task.getId(), ex);
}
}
/** 建单成功页面推送载荷(铁律 32 第三件;type 与 JdPublishTaskPullSpiImpl.QUEUE_TYPE 同值)。 */
public Map<String, Object> buildQueuePayload(FileTaskEntity task) {
JdPublishTaskCreateRequest create = readCreateRequest(task);
Map<String, Object> data = new LinkedHashMap<>();
data.put("taskId", task.getId());
data.put("priceRule", create.getPriceRule() == null ? Map.of("mode", "none") : create.getPriceRule());
return Map.of("type", JdPublishTaskPullSpiImpl.QUEUE_TYPE, "data", data);
}
/**
* 心跳上报(B98-07 同形债预防,用户域半边):归属校验在调全局心跳通道<b>之前</b>——
* 可信 uid 按 (taskId, userId) 对比任务 owner,不一致一律拒;比对放服务层让全局
* {@code /api/tasks/{taskId}/heartbeat} 与本模块内聚端点共用同一闸(B98-07 的债是
* 「任意用户可给任意任务刷心跳续命」,实例域判据对 LOCAL 客户端心跳不适用,
* 见 {@code JdPublishTaskHeartbeatSpi} 类注释)。
*/
public TaskHeartbeatVo heartbeat(Long taskId, Long userId, TaskHeartbeatRequest request) {
requireOwnedTask(taskId, userId);
taskHeartbeatPositionService.record(taskId, request);
return taskHeartbeatService.heartbeat(taskId, request);
}
/** 供测试确认快照行形状。 */
public List<JdPublishItemEntity> findItemRows(Long taskId) {
return jdPublishItemMapper.selectList(new LambdaQueryWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.orderByAsc(JdPublishItemEntity::getId));
}
/** 归属校验唯一出口:模块归属谓词走公共出口 + (taskId, userId) 归属对比(铁律 11)。 */
private FileTaskEntity requireOwnedTask(Long taskId, Long userId) {
if (taskId == null || taskId <= 0) {
throw new BusinessException("任务 ID 不合法");
}
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !TaskFinalizeSupport.belongsToModule(MODULE_TYPE, task.getModuleType())) {
throw new BusinessException("任务不存在: " + taskId);
}
if (userId != null && task.getUserId() != null && !Objects.equals(userId, task.getUserId())) {
throw new BusinessException(403, "无权查看该任务");
}
return task;
}
private void validate(JdPublishTaskCreateRequest request) {
if (request.getUserId() == null || request.getUserId() <= 0) {
throw new BusinessException("user_id 不合法");
}
if (request.getProductIds() == null || request.getProductIds().isEmpty()) {
throw new BusinessException("请勾选要上架的商品");
}
// 保序去重:同一次提交里重复勾选同一商品,落一行而不是两行(uk_task_product 同义)。
request.setProductIds(request.getProductIds().stream()
.filter(Objects::nonNull)
.filter(id -> id > 0)
.distinct()
.toList());
if (request.getProductIds().isEmpty()) {
throw new BusinessException("请勾选要上架的商品");
}
if (request.getProductIds().size() > MAX_PRODUCT_IDS) {
throw new BusinessException("单次上架最多选 " + MAX_PRODUCT_IDS + " 个商品,当前 "
+ request.getProductIds().size() + " 个");
}
normalizePriceRule(request);
}
/** 改价规则归一化写回请求体:request_json 里的值必须就是闸门认可的值(铁律 27a 同源)。 */
private void normalizePriceRule(JdPublishTaskCreateRequest request) {
PriceRule rule = request.getPriceRule();
if (rule == null || rule.getMode() == null || rule.getMode().isBlank()) {
request.setPriceRule(null);
return;
}
String mode = rule.getMode().trim().toLowerCase(Locale.ROOT);
if (!Set.of("none", "percent", "fixed").contains(mode)) {
throw new BusinessException("改价规则不识别: " + rule.getMode() + "(只支持 none/percent/fixed)");
}
if (!"none".equals(mode)) {
if (rule.getValue() == null) {
throw new BusinessException("改价规则 mode=" + mode + " 时必须填写加价值");
}
if (rule.getValue().compareTo(BigDecimal.ZERO) < 0) {
throw new BusinessException("加价值不能为负数");
}
}
rule.setMode(mode);
request.setPriceRule(rule);
}
/** 最终价:none 原值;percent 按百分比上浮;fixed 固定加价。2 位小数 HALF_UP。 */
static BigDecimal finalPriceOf(BigDecimal source, PriceRule rule) {
if (source == null) {
return null;
}
if (rule == null || rule.getValue() == null || "none".equals(rule.getMode())) {
return source.setScale(2, RoundingMode.HALF_UP);
}
if ("percent".equals(rule.getMode())) {
BigDecimal uplifted = source.add(source.multiply(rule.getValue()).movePointLeft(2));
return uplifted.setScale(2, RoundingMode.HALF_UP);
}
return source.add(rule.getValue()).setScale(2, RoundingMode.HALF_UP);
}
/** 快照明细行:商品主档列随行固化,改价折算进 price_rule_json(蓝图 §3)。 */
private JdPublishItemEntity buildSnapshotItem(FileTaskEntity task, JdProductEntity product,
JdPublishTaskCreateRequest request,
String mainImageObjectKey, LocalDateTime now) {
JdPublishItemEntity item = new JdPublishItemEntity();
item.setTaskId(task.getId());
item.setCompanyId(product.getCompanyId());
item.setUserId(task.getUserId());
item.setProductId(product.getId());
item.setProductCode(product.getProductCode());
item.setShopName(product.getShopName());
item.setTitle(product.getTitle());
item.setCategoryPath(product.getCategoryPath());
PriceRule rule = request.getPriceRule();
BigDecimal sourcePrice = product.getPriceMin();
Map<String, Object> priceJson = new LinkedHashMap<>();
priceJson.put("mode", rule == null ? "none" : rule.getMode());
priceJson.put("value", rule == null ? null : rule.getValue());
priceJson.put("sourcePrice", sourcePrice);
priceJson.put("finalPrice", finalPriceOf(sourcePrice, rule));
item.setPriceRuleJson(toJson(priceJson));
Map<String, Object> stockJson = new LinkedHashMap<>();
stockJson.put("total", product.getStockTotal());
item.setStockJson(toJson(stockJson));
item.setPublishStatus(ITEM_PENDING);
item.setMainImageObjectKey(mainImageObjectKey);
item.setCreatedAt(now);
item.setUpdatedAt(now);
return item;
}
private String toJson(Map<String, Object> value) {
try {
return objectMapper.writeValueAsString(value);
} catch (Exception ex) {
throw new BusinessException("序列化快照列失败", ex);
}
}
/** MAIN 档主图 objectKey(每商品取 sortNo 最小行);图片行缺失/无 key 的商品不落主图列。 */
private Map<Long, String> loadMainImageObjectKeys(List<JdProductEntity> products) {
List<Long> productIds = products.stream().map(JdProductEntity::getId).toList();
List<JdProductImageEntity> images = jdProductImageMapper.selectList(
new LambdaQueryWrapper<JdProductImageEntity>()
.in(JdProductImageEntity::getProductId, productIds)
.eq(JdProductImageEntity::getImageType, "MAIN")
.orderByAsc(JdProductImageEntity::getSortNo, JdProductImageEntity::getId));
Map<Long, String> result = new LinkedHashMap<>();
for (JdProductImageEntity image : images) {
if (image.getObjectKey() != null && !image.getObjectKey().isBlank()) {
result.putIfAbsent(image.getProductId(), image.getObjectKey());
}
}
return result;
}
/** 行级状态聚合(XML 具名 SQL):status → 行数。 */
private Map<String, Long> aggregateStatusCounts(Long taskId) {
Map<String, Long> counts = new LinkedHashMap<>();
for (Map<String, Object> row : jdPublishItemMapper.countByPublishStatus(taskId)) {
Object status = row.get("publishStatus");
Object cnt = row.get("cnt");
if (status != null && cnt instanceof Number number) {
counts.put(String.valueOf(status), number.longValue());
}
}
return counts;
}
/** 单行下发载荷:SKU 折算价 + 图片预签名 GET(商品行由页内批量预取传入)。 */
private JdPublishItemPayloadVo buildItemPayload(JdPublishItemEntity row, JdProductEntity product) {
JdPublishItemPayloadVo vo = new JdPublishItemPayloadVo();
vo.setItemId(row.getId());
vo.setProductId(row.getProductId());
vo.setProductCode(row.getProductCode());
vo.setTitle(row.getTitle());
vo.setCategoryPath(row.getCategoryPath());
vo.setSourcePrice(sourcePriceOf(row));
vo.setFinalPrice(finalPriceOf(row));
vo.setStockTotal(stockTotalOf(row));
vo.setAttrs(product == null ? null : product.getAttrJson());
PriceRule rule = priceRuleOf(row);
vo.setSkus(loadSkuPayloads(row.getProductId(), rule));
vo.setMainImages(loadImagePayloads(row.getProductId(), "MAIN"));
vo.setAttrImages(loadImagePayloads(row.getProductId(), "ATTR"));
vo.setDetailImages(loadImagePayloads(row.getProductId(), "DETAIL"));
return vo;
}
private PriceRule priceRuleOf(JdPublishItemEntity row) {
Map<String, Object> json = readJson(row.getPriceRuleJson());
PriceRule rule = new PriceRule();
Object mode = json.get("mode");
Object value = json.get("value");
rule.setMode(mode == null ? "none" : String.valueOf(mode));
rule.setValue(decimalOf(value));
return rule;
}
private BigDecimal sourcePriceOf(JdPublishItemEntity row) {
return decimalOf(readJson(row.getPriceRuleJson()).get("sourcePrice"));
}
private BigDecimal finalPriceOf(JdPublishItemEntity row) {
return decimalOf(readJson(row.getPriceRuleJson()).get("finalPrice"));
}
private Integer stockTotalOf(JdPublishItemEntity row) {
Object total = readJson(row.getStockJson()).get("total");
return total instanceof Number number ? number.intValue() : null;
}
private Map<String, Object> readJson(String value) {
if (value == null || value.isBlank()) {
return Map.of();
}
try {
return objectMapper.readValue(value,
objectMapper.getTypeFactory().constructMapType(LinkedHashMap.class, String.class, Object.class));
} catch (Exception ex) {
log.warn("[jd-publish] 快照 JSON 解析失败,按空快照下发 err={}", ex.getMessage());
return Map.of();
}
}
private BigDecimal decimalOf(Object value) {
return value instanceof Number number ? BigDecimal.valueOf(number.doubleValue()) : null;
}
/** SKU 矩阵按 sortNo 升序下发,价按改价规则从 SKU 源价折算(与主档价同一规则同一函数)。 */
private List<JdPublishItemPayloadVo.SkuVo> loadSkuPayloads(Long productId, PriceRule rule) {
List<JdProductSkuEntity> skus = jdProductSkuMapper.selectList(
new LambdaQueryWrapper<JdProductSkuEntity>()
.eq(JdProductSkuEntity::getProductId, productId)
.orderByAsc(JdProductSkuEntity::getSortNo, JdProductSkuEntity::getId));
return skus.stream().map(sku -> {
JdPublishItemPayloadVo.SkuVo vo = new JdPublishItemPayloadVo.SkuVo();
vo.setSkuId(sku.getSkuId());
vo.setSkuName(sku.getSkuName());
vo.setSourcePrice(sku.getPrice());
vo.setFinalPrice(finalPriceOf(sku.getPrice(), rule));
vo.setStock(sku.getStock());
vo.setSaleAttrsJson(sku.getSaleAttrsJson());
vo.setSortNo(sku.getSortNo());
return vo;
}).toList();
}
/** 指定档图片按 sortNo 升序发预签名 GET URL(objectKey 留档可重签)。 */
private List<JdPublishItemPayloadVo.ImageView> loadImagePayloads(Long productId, String imageType) {
List<JdProductImageEntity> images = jdProductImageMapper.selectList(
new LambdaQueryWrapper<JdProductImageEntity>()
.eq(JdProductImageEntity::getProductId, productId)
.eq(JdProductImageEntity::getImageType, imageType)
.orderByAsc(JdProductImageEntity::getSortNo, JdProductImageEntity::getId));
return images.stream().map(image -> {
JdPublishItemPayloadVo.ImageView view = new JdPublishItemPayloadVo.ImageView();
view.setObjectKey(image.getObjectKey());
view.setUrl(ossStorageService.presignObjectDownload(bucket, image.getObjectKey(),
IMAGE_PRESIGN_EXPIRY_SECONDS));
view.setAttrName(image.getAttrName());
view.setSortNo(image.getSortNo());
return view;
}).toList();
}
}
@@ -11,6 +11,7 @@ import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuCreateReques
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuUpdateRequest; import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuUpdateRequest;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest; import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.common.model.entity.AdminUserEntity; import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity; import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity; import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo; import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo;
@@ -777,9 +778,23 @@ public class PermissionMenuService {
* <p>入口放开不等于逐页放开。现网 46 个普通账号持有后台菜单授权(只读实查 2026-10-06),若逐页门只看入口,它们顺手就能读到同公司的密钥页与扣次数的 ASIN 查询页——勾菜单的人本意是给一页,不是给全部。 * <p>入口放开不等于逐页放开。现网 46 个普通账号持有后台菜单授权(只读实查 2026-10-06),若逐页门只看入口,它们顺手就能读到同公司的密钥页与扣次数的 ASIN 查询页——勾菜单的人本意是给一页,不是给全部。
* 判据与 {@link #hasAnyAdminMenu} 同一套(本公司树 + 直接授权递归展开),所以勾父分组 * 判据与 {@link #hasAnyAdminMenu} 同一套(本公司树 + 直接授权递归展开),所以勾父分组
* 覆盖后代的语义在这里照样成立。</p> * 覆盖后代的语义在这里照样成立。</p>
*
* <p>2026-11-18 平台隔离:管理员角色链的「恒可进」收窄为「恒可进<b>本人平台侧</b>」——
* 非站点超管传入越侧 key 一律 403(见方法体平台门),下发树裁剪之外的第二道防线。</p>
*/ */
public void requireConsolePageAccess(AdminUserEntity operator, String denialMessage, String... columnKeys) { public void requireConsolePageAccess(AdminUserEntity operator, String denialMessage, String... columnKeys) {
if (operator == null || isAdmin(operator)) { if (operator == null) {
return;
}
// 平台门(2026-11-18 用户口径「隔离下非站点超管只看自己平台侧」):与下发树裁剪同口径——
// 站点超管直通之外,其余角色(含公司超管/管理员,故须放在 isAdmin 直通之前)传入的页面
// key 必须归属自身 users.platform;双侧 key 两平台都放行,越侧直调一律 403。
if (!DeviceSessionPolicy.isSuperAdmin(operator.getRole(), operator.getIsAdmin(), operator.getCreatedById())
&& columnKeys != null && columnKeys.length > 0
&& AdminMenuPlatformScope.hasCrossPlatformKey(List.of(columnKeys), operator.getPlatform())) {
throw new BusinessException(403, denialMessage);
}
if (isAdmin(operator)) {
return; return;
} }
if (columnKeys != null && columnKeys.length > 0 if (columnKeys != null && columnKeys.length > 0
@@ -13,7 +13,7 @@ import java.util.Locale;
* 只剩兜底窗口,不再决定执行方。 * 只剩兜底窗口,不再决定执行方。
* *
* <p>列可空,且**不回填**:空值按模块默认解释,外观专利/相似ASIN/京东店铺采集 * <p>列可空,且**不回填**:空值按模块默认解释,外观专利/相似ASIN/京东店铺采集
* (v1.4 起)读作 {@link #LOCAL}、其余模块读作 {@link #ONLINE},与 V183 之前 * (v1.4 起)/京东商品上架(v1.5 起)读作 {@link #LOCAL}、其余模块读作 {@link #ONLINE},与 V183 之前
* {@code AIIMAGE_COLLECT_LOCAL_*} 的出厂值 {@code true} 逐字等价。未升级的客户端与 * {@code AIIMAGE_COLLECT_LOCAL_*} 的出厂值 {@code true} 逐字等价。未升级的客户端与
* 全部历史任务因此行为不变。京东采集只能在本机 Windows + 紫鸟窗口执行,不加进本清单 * 全部历史任务因此行为不变。京东采集只能在本机 Windows + 紫鸟窗口执行,不加进本清单
* 就会默认 ONLINE ⇒ 任务被推给无紫鸟的 Linux worker,永不执行(铁律 19 同形)。 * 就会默认 ONLINE ⇒ 任务被推给无紫鸟的 Linux worker,永不执行(铁律 19 同形)。
@@ -29,7 +29,8 @@ public enum CollectChannel {
private static final List<String> LOCAL_DEFAULT_MODULES = List.of( private static final List<String> LOCAL_DEFAULT_MODULES = List.of(
CollectRoutingProperties.MODULE_APPEARANCE_PATENT, CollectRoutingProperties.MODULE_APPEARANCE_PATENT,
CollectRoutingProperties.MODULE_SIMILAR_ASIN, CollectRoutingProperties.MODULE_SIMILAR_ASIN,
CollectRoutingProperties.MODULE_JD_SHOP_COLLECT); CollectRoutingProperties.MODULE_JD_SHOP_COLLECT,
CollectRoutingProperties.MODULE_JD_PUBLISH);
/** /**
* 未登记通道时读作 {@link #LOCAL} 的模块清单。 * 未登记通道时读作 {@link #LOCAL} 的模块清单。
@@ -43,7 +43,10 @@ AIIMAGE_JD_COLLECT_IMAGE_MAX_PER_PRODUCT=200
AIIMAGE_JD_COLLECT_STALE_MINUTES=60 AIIMAGE_JD_COLLECT_STALE_MINUTES=60
# SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN。 # SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN。
AIIMAGE_JD_SKU_MAX_PER_PRODUCT=200 AIIMAGE_JD_SKU_MAX_PER_PRODUCT=200
# 京东采集的客户端兜底拉取白名单(v1.4 P0-1):默认值已含 JD_SHOP_COLLECT(见 application.yml)。 # 京东商品上架(v1.5):对应 application.yml 的 aiimage.jd: publish 段。
AIIMAGE_JD_PUBLISH_STALE_MINUTES=60
AIIMAGE_JD_PUBLISH_ITEMS_BATCH_SIZE=20
# 京东采集/上架的客户端兜底拉取白名单(v1.4 P0-1 / v1.5):默认值已含 JD_SHOP_COLLECT、JD_PUBLISH(见 application.yml)。
# ⚠ 只有真的要覆盖整个白名单时才设 AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES——env 变量存在即生效, # ⚠ 只有真的要覆盖整个白名单时才设 AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES——env 变量存在即生效,
# 设成空串会把白名单清空(兜底拉取对 JD 形同关闭)。打开 AIIMAGE_CLIENT_TASK_PULL_ENABLED # 设成空串会把白名单清空(兜底拉取对 JD 形同关闭)。打开 AIIMAGE_CLIENT_TASK_PULL_ENABLED
# 前先确认客户端版本带兜底拉取线程。 # 前先确认客户端版本带兜底拉取线程。
@@ -177,6 +177,11 @@ aiimage:
# SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN, # SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN,
# 防脏回传把整批撑爆。显式写在这里,不许只活在代码默认值里。 # 防脏回传把整批撑爆。显式写在这里,不许只活在代码默认值里。
sku-max-per-product: ${AIIMAGE_JD_SKU_MAX_PER_PRODUCT:200} sku-max-per-product: ${AIIMAGE_JD_SKU_MAX_PER_PRODUCT:200}
# 京东商品上架(v1.5):发布是逐商品页面自动化,节奏比采集慢——判死窗口独立可调
# (按发布时长重估,蓝图 §3);items 下发批大小钳制在服务侧(上限 100)。
publish:
stale-minutes: ${AIIMAGE_JD_PUBLISH_STALE_MINUTES:60}
items-batch-size: ${AIIMAGE_JD_PUBLISH_ITEMS_BATCH_SIZE:20}
# 设备日志对象存储:主机B 独立 MinIO(与业务 OSS 隔离,日志只保留 7 天)。 # 设备日志对象存储:主机B 独立 MinIO(与业务 OSS 隔离,日志只保留 7 天)。
# endpoint 未配置时日志上报/管理接口不可用(宁可失败也不静默落到业务桶)。 # endpoint 未配置时日志上报/管理接口不可用(宁可失败也不静默落到业务桶)。
# 桶的 7 天过期规则由运维用 mc 配置(与 retention-days 口径一致)。 # 桶的 7 天过期规则由运维用 mc 配置(与 retention-days 口径一致)。
@@ -300,7 +305,7 @@ aiimage:
enabled: ${AIIMAGE_MODULE_CLEANUP_ENABLED:true} enabled: ${AIIMAGE_MODULE_CLEANUP_ENABLED:true}
cron: ${AIIMAGE_MODULE_CLEANUP_CRON:0 0 0 * * *} cron: ${AIIMAGE_MODULE_CLEANUP_CRON:0 0 0 * * *}
retention-days: ${AIIMAGE_MODULE_CLEANUP_RETENTION_DAYS:7} 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} 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,JD_PUBLISH}
# 以下为各业务表的保留期清理(2026-09-16 统一补齐):这些表此前只增不删, # 以下为各业务表的保留期清理(2026-09-16 统一补齐):这些表此前只增不删,
# 或只有"读的时候顺手删一行"这类碰运气的清理。全部按天分批删除、带分布式锁单实例执行。 # 或只有"读的时候顺手删一行"这类碰运气的清理。全部按天分批删除、带分布式锁单实例执行。
device-log: device-log:
@@ -405,7 +410,9 @@ aiimage:
# 2026-11-14 v1.4 加 JD_SHOP_COLLECT(P0-1):京东采集只能在本机客户端执行(紫鸟/京麦 # 2026-11-14 v1.4 加 JD_SHOP_COLLECT(P0-1):京东采集只能在本机客户端执行(紫鸟/京麦
# 登录态在桌面机),页面推送缺失时任务会永久停在 PENDING——兜底拉取是它的唯一出路; # 登录态在桌面机),页面推送缺失时任务会永久停在 PENDING——兜底拉取是它的唯一出路;
# queuePayload 由 JdTaskPullSpiImpl 组装(type=jd-shop-collect-run,与客户端同值)。 # queuePayload 由 JdTaskPullSpiImpl 组装(type=jd-shop-collect-run,与客户端同值)。
module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT} # 2026-11-17 v1.5 加 JD_PUBLISH:京麦登录态在用户桌面机 19899 Chrome profile,发布同样
# 只能由客户端执行;queuePayload 由 JdPublishTaskPullSpiImpl 组装(type=jd-product-publish-run)。
module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT,JD_PUBLISH}
min-pending-minutes: ${AIIMAGE_CLIENT_TASK_PULL_MIN_PENDING_MINUTES:5} min-pending-minutes: ${AIIMAGE_CLIENT_TASK_PULL_MIN_PENDING_MINUTES:5}
limit: ${AIIMAGE_CLIENT_TASK_PULL_LIMIT:5} limit: ${AIIMAGE_CLIENT_TASK_PULL_LIMIT:5}
# 服务端内部认领(/api/internal/tasks/pull-pending,Linux 后台 worker 专用), # 服务端内部认领(/api/internal/tasks/pull-pending,Linux 后台 worker 专用),

Some files were not shown because too many files have changed in this diff Show More