feat:加一个网站发布公告会弹出来点确定我已知晓的弹窗;mock数据自动匹配接单模板;本地访问模式修改

2026-10-25 12:27:32 +08:00
parent 0d3dd3eacd
commit a7a8634a96
12 changed files with 403 additions and 6 deletions
@@ -9,6 +9,7 @@ import {
  createWorkOrderEvent,
  getWorkCategoryById,
  listWorkOrdersByPlatformOrderId,
+  listWorkProductRules,
 } from '../../repositories/worker-platform/index.js'
 import type { JsonObject } from '../../types/json.js'
 import { createHttpError } from '../../utils/http.js'
@@ -27,6 +28,7 @@ import {
  normalizeRequirementFields,
 } from './mappers.js'
 import { rememberAdminMockCustomShop } from './admin-mock-custom-shop-service.js'
+import { resolveMockWorkOrderProductRule } from './mock-work-order-rule-match.js'
 import { ensureWorkerPlatformDefaults } from './worker-platform-defaults.js'
 import { normalizeWorkOrderTimeoutPolicy } from './work-order-timeout-policy.js'

@@ -64,6 +66,14 @@ export async function createAdminMockWorkOrder(payload: JsonObject = {}) {
  const materialComplete = payload.materialComplete === true || payload.materialComplete === 'true'
  const fields = normalizeRequirementFields(payload.fields)
  const { platformOrderId, productName, shop } = input
+  // Mock 工单同样要挂到接单模板上：后台「同步模板价格」按 product_rule_id 精确匹配，
+  // 不绑定的话改模板价永远命中不到 Mock 单（真实单在 sync-worker-orders-service 已绑定）。
+  // 这里只做商品名文本匹配，命中多条同分视为歧义、宁可不绑定。
+  const productRuleMatch = resolveMockWorkOrderProductRule({
+    rules: await listWorkProductRules({ enabled: true }),
+    productName,
+    categoryId,
+  })
  // 订单号全局唯一：与自动同步的真实工单也不能撞号，否则打手按单号回填资料会命中多条。
  const existingOrders = await listWorkOrdersByPlatformOrderId(platformOrderId)
  if (existingOrders.length > 0) {
@@ -104,6 +114,7 @@ export async function createAdminMockWorkOrder(payload: JsonObject = {}) {
  }
  const workOrder = await createWorkOrder({
    workOrderNo: generateWorkOrderNo(),
+    productRuleId: productRuleMatch.rule ? Number(productRuleMatch.rule.id) : null,
    platformOrderId,
    productName,
    categoryId,
@@ -143,6 +154,9 @@ export async function createAdminMockWorkOrder(payload: JsonObject = {}) {
      rewardAmount,
      sellerId: String(shop.sellerId || '').trim(),
      shopName: String(shop.shopName || '').trim(),
+      productRuleId: productRuleMatch.rule ? Number(productRuleMatch.rule.id) : 0,
+      productRuleKey: productRuleMatch.rule ? String(productRuleMatch.rule.rule_key || '') : '',
+      productRuleMatch: productRuleMatch.reason,
    }),
    now,
  })
@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { WorkProductRuleRow } from '../../repositories/worker-platform/types.js'
+import { resolveMockWorkOrderProductRule } from './mock-work-order-rule-match.js'
+
+function rule(
+  input: Partial<WorkProductRuleRow> & { id: number; product_name: string },
+): WorkProductRuleRow {
+  return {
+    id: input.id,
+    rule_key: input.rule_key ?? `rule-${input.id}`,
+    product_name: input.product_name,
+    category_id: input.category_id ?? null,
+    enabled: input.enabled ?? true,
+    sort_order: input.sort_order ?? 100,
+    unit_price_fen: input.unit_price_fen ?? 0,
+    reward_amount: input.reward_amount ?? 0,
+    sharing_enabled: input.sharing_enabled ?? false,
+    sharing_total_quantity: input.sharing_total_quantity ?? 1,
+    sharing_unit_reward: input.sharing_unit_reward ?? 0,
+    sharing_auto_from_order: input.sharing_auto_from_order ?? false,
+    timeout_minutes: input.timeout_minutes ?? 0,
+    timeout_policy: input.timeout_policy ?? 'reopen',
+  } as WorkProductRuleRow
+}
+
+test('Mock 模板匹配：商品名互相包含即命中（忽略空白）', () => {
+  const rules = [rule({ id: 9, product_name: '指挥官密钥', category_id: 1, unit_price_fen: 1100 })]
+  const result = resolveMockWorkOrderProductRule({
+    rules,
+    productName: '指挥官密钥10个',
+    categoryId: 1,
+  })
+  assert.equal(result.reason, 'matched')
+  assert.equal(result.rule?.id, 9)
+
+  const withSpaces = resolveMockWorkOrderProductRule({
+    rules,
+    productName: ' 指挥官 密钥 3个 ',
+    categoryId: 1,
+  })
+  assert.equal(withSpaces.rule?.id, 9)
+})
+
+test('Mock 模板匹配：同分类优先，其次更具体的商品名', () => {
+  const rules = [
+    rule({ id: 1, product_name: '指挥官密钥', category_id: 5, sort_order: 1 }),
+    rule({ id: 2, product_name: '指挥官密钥', category_id: 1, sort_order: 9 }),
+    rule({ id: 3, product_name: '指挥官密钥-皮肤链接', category_id: 1, sort_order: 9 }),
+  ]
+  const base = resolveMockWorkOrderProductRule({
+    rules,
+    productName: '指挥官密钥10个',
+    categoryId: 1,
+  })
+  assert.equal(base.rule?.id, 2, '同分类的模板必须优先于其他分类')
+
+  const specific = resolveMockWorkOrderProductRule({
+    rules,
+    productName: '指挥官密钥-皮肤链接1个',
+    categoryId: 1,
+  })
+  assert.equal(specific.rule?.id, 3, '更长的商品名（更具体）优先')
+})
+
+test('Mock 模板匹配：歧义或未命中不绑定', () => {
+  const ambiguous = resolveMockWorkOrderProductRule({
+    rules: [
+      rule({ id: 1, product_name: '指挥官密钥', category_id: 1 }),
+      rule({ id: 2, product_name: '指挥官密钥', category_id: 1 }),
+    ],
+    productName: '指挥官密钥10个',
+    categoryId: 1,
+  })
+  assert.equal(ambiguous.rule, null)
+  assert.equal(ambiguous.reason, 'ambiguous')
+
+  const unmatched = resolveMockWorkOrderProductRule({
+    rules: [rule({ id: 9, product_name: '指挥官密钥', category_id: 1 })],
+    productName: '指挥官9999',
+    categoryId: 1,
+  })
+  assert.equal(unmatched.rule, null)
+  assert.equal(unmatched.reason, 'unmatched')
+
+  const empty = resolveMockWorkOrderProductRule({ rules: [], productName: '  ', categoryId: 1 })
+  assert.equal(empty.reason, 'unmatched')
+})
+
+test('Mock 模板匹配：停用的模板不参与匹配', () => {
+  const result = resolveMockWorkOrderProductRule({
+    rules: [rule({ id: 9, product_name: '指挥官密钥', category_id: 1, enabled: false })],
+    productName: '指挥官密钥10个',
+    categoryId: 1,
+  })
+  assert.equal(result.rule, null)
+  assert.equal(result.reason, 'unmatched')
+})
@@ -0,0 +1,76 @@
+import type { WorkProductRuleRow } from '../../repositories/worker-platform/types.js'
+
+/**
+ * Mock 工单的接单模板匹配（文本匹配）。
+ *
+ * 快手真实单走 `resolveMatchingProductRule`（依赖 sellerId/itemId/skuId 等平台字段），
+ * 而本地 Mock 单只有商品名和分类，所以这里用**商品名文本**做确定性匹配，
+ * 让 Mock 单也能挂上 `product_rule_id`，从而被「同步模板价格」命中。
+ *
+ * 规则：
+ *   - 只考虑启用中的模板；
+ *   - 模板商品名与 Mock 商品名互相包含即视为命中（忽略大小写/空白）；
+ *   - 同分类优先，其次更长的商品名（更具体）优先，最后按 sort_order；
+ *   - 同分类且同长度的多条模板属于歧义，宁可不绑定，避免把 Mock 单挂到错误模板上。
+ */
+export type MockWorkOrderRuleMatchReason = 'matched' | 'unmatched' | 'ambiguous'
+
+export type MockWorkOrderRuleMatch = {
+  rule: WorkProductRuleRow | null
+  reason: MockWorkOrderRuleMatchReason
+  candidates: string[]
+}
+
+export function normalizeMockProductMatchText(value: unknown): string {
+  return String(value || '')
+    .replace(/[\s\u3000]+/g, '')
+    .trim()
+    .toLowerCase()
+}
+
+export function resolveMockWorkOrderProductRule(input: {
+  rules: WorkProductRuleRow[]
+  productName: string
+  categoryId?: number | null
+}): MockWorkOrderRuleMatch {
+  const productName = normalizeMockProductMatchText(input.productName)
+  if (!productName) return { rule: null, reason: 'unmatched', candidates: [] }
+  const categoryId = Number(input.categoryId || 0)
+
+  const scored = input.rules
+    .filter((rule) => rule.enabled !== false)
+    .map((rule) => {
+      const ruleName = normalizeMockProductMatchText(rule.product_name)
+      if (!ruleName) return null
+      if (!productName.includes(ruleName) && !ruleName.includes(productName)) return null
+      return {
+        rule,
+        categoryMatch: categoryId > 0 && Number(rule.category_id || 0) === categoryId ? 1 : 0,
+        nameLength: ruleName.length,
+        sortOrder: Number(rule.sort_order || 100),
+      }
+    })
+    .filter((item): item is NonNullable<typeof item> => item !== null)
+
+  if (scored.length === 0) return { rule: null, reason: 'unmatched', candidates: [] }
+
+  scored.sort(
+    (a, b) =>
+      b.categoryMatch - a.categoryMatch ||
+      b.nameLength - a.nameLength ||
+      a.sortOrder - b.sortOrder ||
+      Number(a.rule.id) - Number(b.rule.id),
+  )
+  const [best] = scored
+  if (!best) return { rule: null, reason: 'unmatched', candidates: [] }
+  const candidates = scored.map((item) => String(item.rule.rule_key || item.rule.id))
+
+  const equallySpecific = scored.filter(
+    (item) => item.categoryMatch === best.categoryMatch && item.nameLength === best.nameLength,
+  )
+  if (new Set(equallySpecific.map((item) => Number(item.rule.id))).size > 1) {
+    return { rule: null, reason: 'ambiguous', candidates }
+  }
+
+  return { rule: best.rule, reason: 'matched', candidates }
+}