删除咸鱼旧链路

This commit is contained in:
yml
2026-05-25 21:46:39 +08:00
parent 9aafddd624
commit e7aa194dde
142 changed files with 539 additions and 17373 deletions
@@ -1,149 +0,0 @@
import { Router } from "express";
import {
createAdminInventoryItem,
importAdminInventoryItems,
invalidateAdminInventoryItem,
releaseAdminInventoryItem,
} from "../../services/admin/write/inventory.js";
import {
getAdminInventoryItems,
getAdminInventorySkuSuggestions,
} from "../../services/admin/admin-read-service.js";
import { createJsonHandler, requireAdminRoles } from "./shared.js";
import type {
AdminInventoryCreateRouteBody,
AdminInventoryImportRouteBody,
AdminInventoryInvalidateRouteBody,
AdminInventoryRouteParams,
AdminInventoryRouteQuery,
AdminInventorySkuSuggestionRouteQuery,
} from "../../types/admin-route-inputs.js";
import type { AdminInventoryMutationResponse } from "../../types/admin-write-models.js";
const router = Router();
router.use("/inventory", requireAdminRoles(["admin", "operator"]));
router.get(
"/inventory",
createJsonHandler(
(req) =>
getAdminInventoryItems(
req.query as AdminInventoryRouteQuery,
req.adminSession || null
),
{
successMessage: "ok",
errorMessage: "读取库存列表失败",
scope: "[admin-kuaishou/inventory]",
}
)
);
router.get(
"/inventory/sku-suggestions",
createJsonHandler(
(req) =>
getAdminInventorySkuSuggestions(
req.query as AdminInventorySkuSuggestionRouteQuery,
req.adminSession || null
),
{
successMessage: "ok",
errorMessage: "读取内部 SKU 建议失败",
scope: "[admin-kuaishou/inventory/sku-suggestions]",
}
)
);
router.post(
"/inventory",
createJsonHandler(
(req) => createAdminInventoryItem(req.body as AdminInventoryCreateRouteBody),
{
successMessage: "库存项已新增",
errorMessage: "新增库存项失败",
scope: "[admin-kuaishou/inventory]",
}
)
);
router.post(
"/inventory/import",
createJsonHandler(
(req) => importAdminInventoryItems(req.body as AdminInventoryImportRouteBody),
{
successMessage: "导入完成",
errorMessage: "导入库存凭据失败",
scope: "[admin-kuaishou/inventory/import]",
}
)
);
router.post(
"/inventory/:inventoryItemId/release",
requireAdminRoles(["admin"]),
createJsonHandler(
(req) =>
releaseAdminInventoryItem(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
{
successMessage: "库存项已释放",
errorMessage: "释放库存项失败",
scope: "[admin-kuaishou/inventory/:inventoryItemId/release]",
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse;
return {
action: "inventory_item_released",
targetType: "inventory_item",
targetId: String(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
displayValue: result.inventoryItem?.displayValue,
},
};
},
}
)
);
router.post(
"/inventory/:inventoryItemId/invalidate",
requireAdminRoles(["admin"]),
createJsonHandler(
(req) =>
invalidateAdminInventoryItem(
(req.params as AdminInventoryRouteParams).inventoryItemId,
req.body as AdminInventoryInvalidateRouteBody
),
{
successMessage: "库存项已作废",
errorMessage: "作废库存项失败",
scope: "[admin-kuaishou/inventory/:inventoryItemId/invalidate]",
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse;
return {
action: "inventory_item_invalidated",
targetType: "inventory_item",
targetId: String(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
invalidReason: result.inventoryItem?.invalidReason,
},
};
},
}
)
);
export default router;
+124 -92
View File
@@ -1,16 +1,16 @@
import { Router } from 'express'
import { Router } from "express";
import {
createAdminInventoryItem,
importAdminInventoryItems,
invalidateAdminInventoryItem,
releaseAdminInventoryItem,
} from '../../services/admin/admin-write-service.js'
} from "../../services/admin/write/inventory.js";
import {
getAdminInventoryItems,
getAdminInventorySkuSuggestions,
} from '../../services/admin/admin-read-service.js'
import { createJsonHandler, requireAdminRoles } from './shared.js'
} from "../../services/admin/admin-read-service.js";
import { createJsonHandler, requireAdminRoles } from "./shared.js";
import type {
AdminInventoryCreateRouteBody,
AdminInventoryImportRouteBody,
@@ -18,100 +18,132 @@ import type {
AdminInventoryRouteParams,
AdminInventoryRouteQuery,
AdminInventorySkuSuggestionRouteQuery,
} from '../../types/admin-route-inputs.js'
import type { AdminInventoryMutationResponse } from '../../types/admin-write-models.js'
} from "../../types/admin-route-inputs.js";
import type { AdminInventoryMutationResponse } from "../../types/admin-write-models.js";
const router = Router()
const router = Router();
router.use('/inventory', requireAdminRoles(['admin', 'operator']))
router.use("/inventory", requireAdminRoles(["admin", "operator"]));
router.get('/inventory', createJsonHandler(
(req) => getAdminInventoryItems(
req.query as AdminInventoryRouteQuery,
req.adminSession || null,
),
{
successMessage: 'ok',
errorMessage: '读取库存列表失败',
scope: '[admin/inventory]',
},
))
router.get(
"/inventory",
createJsonHandler(
(req) =>
getAdminInventoryItems(
req.query as AdminInventoryRouteQuery,
req.adminSession || null
),
{
successMessage: "ok",
errorMessage: "读取库存列表失败",
scope: "[admin/inventory]",
}
)
);
router.get('/inventory/sku-suggestions', createJsonHandler(
(req) => getAdminInventorySkuSuggestions(
req.query as AdminInventorySkuSuggestionRouteQuery,
req.adminSession || null,
),
{
successMessage: 'ok',
errorMessage: '读取内部 SKU 建议失败',
scope: '[admin/inventory/sku-suggestions]',
},
))
router.get(
"/inventory/sku-suggestions",
createJsonHandler(
(req) =>
getAdminInventorySkuSuggestions(
req.query as AdminInventorySkuSuggestionRouteQuery,
req.adminSession || null
),
{
successMessage: "ok",
errorMessage: "读取内部 SKU 建议失败",
scope: "[admin/inventory/sku-suggestions]",
}
)
);
router.post('/inventory', createJsonHandler(
(req) => createAdminInventoryItem(req.body as AdminInventoryCreateRouteBody),
{
successMessage: '库存项已新增',
errorMessage: '新增库存项失败',
scope: '[admin/inventory]',
},
))
router.post(
"/inventory",
createJsonHandler(
(req) => createAdminInventoryItem(req.body as AdminInventoryCreateRouteBody),
{
successMessage: "库存项已新增",
errorMessage: "新增库存项失败",
scope: "[admin/inventory]",
}
)
);
router.post('/inventory/import', createJsonHandler(
(req) => importAdminInventoryItems(req.body as AdminInventoryImportRouteBody),
{
successMessage: '导入完成',
errorMessage: '导入库存凭据失败',
scope: '[admin/inventory/import]',
},
))
router.post(
"/inventory/import",
createJsonHandler(
(req) => importAdminInventoryItems(req.body as AdminInventoryImportRouteBody),
{
successMessage: "导入完成",
errorMessage: "导入库存凭据失败",
scope: "[admin/inventory/import]",
}
)
);
router.post('/inventory/:inventoryItemId/release', requireAdminRoles(['admin']), createJsonHandler(
(req) => releaseAdminInventoryItem((req.params as AdminInventoryRouteParams).inventoryItemId),
{
successMessage: '库存项已释放',
errorMessage: '释放库存项失败',
scope: '[admin/inventory/:inventoryItemId/release]',
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse
return {
action: 'inventory_item_released',
targetType: 'inventory_item',
targetId: String((req.params as AdminInventoryRouteParams).inventoryItemId),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
displayValue: result.inventoryItem?.displayValue,
},
}
},
},
))
router.post(
"/inventory/:inventoryItemId/release",
requireAdminRoles(["admin"]),
createJsonHandler(
(req) =>
releaseAdminInventoryItem(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
{
successMessage: "库存项已释放",
errorMessage: "释放库存项失败",
scope: "[admin/inventory/:inventoryItemId/release]",
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse;
router.post('/inventory/:inventoryItemId/invalidate', requireAdminRoles(['admin']), createJsonHandler(
(req) => invalidateAdminInventoryItem(
(req.params as AdminInventoryRouteParams).inventoryItemId,
req.body as AdminInventoryInvalidateRouteBody,
),
{
successMessage: '库存项已作废',
errorMessage: '作废库存项失败',
scope: '[admin/inventory/:inventoryItemId/invalidate]',
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse
return {
action: 'inventory_item_invalidated',
targetType: 'inventory_item',
targetId: String((req.params as AdminInventoryRouteParams).inventoryItemId),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
invalidReason: result.inventoryItem?.invalidReason,
},
}
},
},
))
return {
action: "inventory_item_released",
targetType: "inventory_item",
targetId: String(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
displayValue: result.inventoryItem?.displayValue,
},
};
},
}
)
);
export default router
router.post(
"/inventory/:inventoryItemId/invalidate",
requireAdminRoles(["admin"]),
createJsonHandler(
(req) =>
invalidateAdminInventoryItem(
(req.params as AdminInventoryRouteParams).inventoryItemId,
req.body as AdminInventoryInvalidateRouteBody
),
{
successMessage: "库存项已作废",
errorMessage: "作废库存项失败",
scope: "[admin/inventory/:inventoryItemId/invalidate]",
audit: (req, data) => {
const result = data as AdminInventoryMutationResponse;
return {
action: "inventory_item_invalidated",
targetType: "inventory_item",
targetId: String(
(req.params as AdminInventoryRouteParams).inventoryItemId
),
data: {
inventoryItemId: result.inventoryItem?.inventoryItemId,
skuCode: result.inventoryItem?.skuCode,
invalidReason: result.inventoryItem?.invalidReason,
},
};
},
}
)
);
export default router;
@@ -1,218 +0,0 @@
import { Router } from 'express'
import {
closeAdminManualRedeemSession,
closeAdminManualRedeemTask,
confirmAdminManualRedeemRole,
createAdminManualRedeemSession,
createAdminManualRedeemTask,
getAdminManualRedeemDetail,
getAdminManualRedeemSessionSummary,
reloadAdminManualRedeemSession,
redeemAdminManualRedeemTask,
} from '../../services/admin/admin-manual-redeem-service.js'
import { getAdminInventorySkuSuggestions } from '../../services/admin/admin-read-service.js'
import { createJsonHandler, requireAdminRoles } from './shared.js'
import type {
AdminInventorySkuSuggestionRouteQuery,
AdminManualRedeemCreateRouteBody,
AdminManualRedeemRouteParams,
} from '../../types/admin-route-inputs.js'
type AdminManualRedeemSessionRouteBody = {
loginType?: string
forceRecreate?: boolean
}
type AdminManualRedeemMutationResult = {
task?: {
taskId?: number
taskNo?: string
status?: string
deliveryStatus?: string
}
manualRequest?: { proofValue?: string }
order?: { platformOrderId?: string }
orderItem?: { skuCode?: string }
}
const router = Router()
router.use('/manual-redeem', requireAdminRoles(['admin', 'operator', 'support']))
router.get('/manual-redeem/sku-suggestions', createJsonHandler(
(req) => getAdminInventorySkuSuggestions(
req.query as AdminInventorySkuSuggestionRouteQuery,
req.adminSession || null,
),
{
successMessage: 'ok',
errorMessage: '读取人工兑换 SKU 建议失败',
scope: '[admin/manual-redeem/sku-suggestions]',
},
))
router.post('/manual-redeem', createJsonHandler(
(req) => createAdminManualRedeemTask(
req.body as AdminManualRedeemCreateRouteBody,
req.adminSession || null,
),
{
successMessage: '人工兑换任务已创建',
errorMessage: '创建人工兑换任务失败',
scope: '[admin/manual-redeem]',
audit: (req, data) => {
const result = data as AdminManualRedeemMutationResult
return {
action: 'manual_redeem_created',
targetType: 'task',
targetId: String(result.task?.taskId || ''),
data: {
taskId: result.task?.taskId,
taskNo: result.task?.taskNo,
proofValue: result.manualRequest?.proofValue || result.order?.platformOrderId || '',
skuCode: result.orderItem?.skuCode || '',
},
}
},
},
))
router.get('/manual-redeem/:taskId', createJsonHandler(
(req) => getAdminManualRedeemDetail(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: 'ok',
errorMessage: '读取人工兑换详情失败',
scope: '[admin/manual-redeem/:taskId]',
},
))
router.post('/manual-redeem/:taskId/session', createJsonHandler(
(req) => createAdminManualRedeemSession(
(req.params as AdminManualRedeemRouteParams).taskId,
req.body as AdminManualRedeemSessionRouteBody,
req.adminSession || null,
),
{
successMessage: '人工兑换登录会话已创建',
errorMessage: '创建人工兑换登录会话失败',
scope: '[admin/manual-redeem/:taskId/session]',
},
))
router.get('/manual-redeem/:taskId/session/summary', createJsonHandler(
(req) => getAdminManualRedeemSessionSummary(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: 'ok',
errorMessage: '读取人工兑换会话摘要失败',
scope: '[admin/manual-redeem/:taskId/session/summary]',
},
))
router.post('/manual-redeem/:taskId/session/refresh', createJsonHandler(
(req) => reloadAdminManualRedeemSession(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: '人工兑换会话已刷新',
errorMessage: '刷新人工兑换会话失败',
scope: '[admin/manual-redeem/:taskId/session/refresh]',
},
))
router.delete('/manual-redeem/:taskId/session', createJsonHandler(
(req) => closeAdminManualRedeemSession(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: '人工兑换会话已关闭',
errorMessage: '关闭人工兑换会话失败',
scope: '[admin/manual-redeem/:taskId/session]',
},
))
router.post('/manual-redeem/:taskId/confirm-role', createJsonHandler(
(req) => confirmAdminManualRedeemRole(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: '角色已确认',
errorMessage: '确认人工兑换角色失败',
scope: '[admin/manual-redeem/:taskId/confirm-role]',
audit: (req, data) => {
const result = data as AdminManualRedeemMutationResult
return {
action: 'manual_redeem_role_confirmed',
targetType: 'task',
targetId: String(result.task?.taskId || ''),
data: {
taskId: result.task?.taskId,
taskNo: result.task?.taskNo,
status: result.task?.status,
},
}
},
},
))
router.post('/manual-redeem/:taskId/redeem', createJsonHandler(
(req) => redeemAdminManualRedeemTask(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: '人工兑换任务已启动',
errorMessage: '执行人工兑换失败',
scope: '[admin/manual-redeem/:taskId/redeem]',
audit: (req, data) => {
const result = data as AdminManualRedeemMutationResult
return {
action: 'manual_redeem_started',
targetType: 'task',
targetId: String(result.task?.taskId || ''),
data: {
taskId: result.task?.taskId,
taskNo: result.task?.taskNo,
status: result.task?.status,
deliveryStatus: result.task?.deliveryStatus,
},
}
},
},
))
router.post('/manual-redeem/:taskId/close', createJsonHandler(
(req) => closeAdminManualRedeemTask(
(req.params as AdminManualRedeemRouteParams).taskId,
req.adminSession || null,
),
{
successMessage: '人工兑换任务已关闭',
errorMessage: '关闭人工兑换任务失败',
scope: '[admin/manual-redeem/:taskId/close]',
audit: (req, data) => {
const result = data as AdminManualRedeemMutationResult
return {
action: 'manual_redeem_closed',
targetType: 'task',
targetId: String(result.task?.taskId || ''),
data: {
taskId: result.task?.taskId,
taskNo: result.task?.taskNo,
status: result.task?.status,
},
}
},
},
))
export default router
@@ -1,19 +0,0 @@
import { Router } from "express";
import { requireAdminRoles } from "./shared.js";
import cloudtentaclesRouter from "./platform-config/cloudtentacles.js";
import kuaishouCloudFulfillmentRouter from "./platform-config/kuaishou-cloud-fulfillment.js";
import kuaishouEticketRouter from "./platform-config/kuaishou-eticket.js";
import ninetyoneRouter from "./platform-config/ninetyone.js";
import notificationsRouter from "./platform-config/notifications.js";
const router = Router();
router.use("/platform-config", requireAdminRoles(["admin"]));
router.use("/platform-config", notificationsRouter);
router.use("/platform-config", kuaishouEticketRouter);
router.use("/platform-config", ninetyoneRouter);
router.use("/platform-config", cloudtentaclesRouter);
router.use("/platform-config", kuaishouCloudFulfillmentRouter);
export default router;
@@ -1,9 +1,7 @@
import { Router } from "express";
import { requireAdminRoles } from "./shared.js";
import agisoRouter from "./platform-config/agiso.js";
import cloudtentaclesRouter from "./platform-config/cloudtentacles.js";
import fulfillmentBindingsRouter from "./platform-config/fulfillment-bindings.js";
import kuaishouCloudFulfillmentRouter from "./platform-config/kuaishou-cloud-fulfillment.js";
import kuaishouEticketRouter from "./platform-config/kuaishou-eticket.js";
import ninetyoneRouter from "./platform-config/ninetyone.js";
@@ -12,12 +10,10 @@ import notificationsRouter from "./platform-config/notifications.js";
const router = Router();
router.use("/platform-config", requireAdminRoles(["admin"]));
router.use("/platform-config", agisoRouter);
router.use("/platform-config", notificationsRouter);
router.use("/platform-config", kuaishouEticketRouter);
router.use("/platform-config", ninetyoneRouter);
router.use("/platform-config", cloudtentaclesRouter);
router.use("/platform-config", fulfillmentBindingsRouter);
router.use("/platform-config", kuaishouCloudFulfillmentRouter);
export default router;
@@ -1,47 +0,0 @@
import { Router } from "express";
import {
getAdminAgisoShopConfigs,
updateAdminAgisoShopConfigs,
} from "../../../services/admin/platform-config/service.js";
import type { AdminAgisoShopConfigRouteBody } from "../../../types/admin-route-inputs.js";
import type { AdminAgisoShopConfigSaveResponse } from "../../../types/admin-write-models.js";
import { createJsonHandler } from "../shared.js";
const router = Router();
router.get(
"/agiso-shops",
createJsonHandler(() => getAdminAgisoShopConfigs(), {
successMessage: "ok",
errorMessage: "读取 Agiso 店铺配置失败",
scope: "[admin/platform-config/agiso-shops]",
})
);
router.post(
"/agiso-shops",
createJsonHandler(
(req) =>
updateAdminAgisoShopConfigs(req.body as AdminAgisoShopConfigRouteBody),
{
successMessage: "Agiso 店铺配置已保存",
errorMessage: "保存 Agiso 店铺配置失败",
scope: "[admin/platform-config/agiso-shops]",
audit: (_req, data) => {
const result = data as AdminAgisoShopConfigSaveResponse;
return {
action: "platform_shop_config_updated",
targetType: "platform_config",
targetId: "agiso_shops",
data: {
shopCount: result.shops.length,
filePath: result.filePath,
},
};
},
}
)
);
export default router;
@@ -1,98 +0,0 @@
import { Router } from "express";
import {
getAdminFulfillmentBindingConfigs,
lookupAdminFulfillmentBindingOrder,
updateAdminFulfillmentBindingConfigs,
} from "../../../services/admin/platform-config/service.js";
import type {
AdminFulfillmentBindingConfigRouteBody,
AdminFulfillmentBindingLookupRouteBody,
} from "../../../types/admin-route-inputs.js";
import { createJsonHandler } from "../shared.js";
import type { JsonRecord } from "./shared.js";
const router = Router();
router.get(
"/fulfillment-bindings",
createJsonHandler(() => getAdminFulfillmentBindingConfigs(), {
successMessage: "ok",
errorMessage: "读取履约配置失败",
scope: "[admin/platform-config/fulfillment-bindings]",
})
);
router.post(
"/fulfillment-bindings/lookup-order",
createJsonHandler(
(req) =>
lookupAdminFulfillmentBindingOrder(
req.body as AdminFulfillmentBindingLookupRouteBody
),
{
successMessage: "订单商品查询成功",
errorMessage: "手动查询订单商品失败",
scope: "[admin/platform-config/fulfillment-bindings/lookup-order]",
audit: (req, data) => {
const result = data as JsonRecord;
return {
action: "platform_fulfillment_order_lookup",
targetType: "platform_config",
targetId: [
result.order?.provider || "unknown",
result.order?.platform || "unknown",
result.order?.shopId || "unknown",
result.order?.platformOrderId || "unknown",
].join(":"),
data: {
itemCount: Array.isArray(result.items) ? result.items.length : 0,
shopId:
result.order?.shopId ||
String(
(req.body as AdminFulfillmentBindingLookupRouteBody)?.shopId ||
""
).trim(),
platformOrderId:
result.order?.platformOrderId ||
String(
(req.body as AdminFulfillmentBindingLookupRouteBody)
?.platformOrderId || ""
).trim(),
},
};
},
}
)
);
router.post(
"/fulfillment-bindings",
createJsonHandler(
(req) =>
updateAdminFulfillmentBindingConfigs(
req.body as AdminFulfillmentBindingConfigRouteBody
),
{
successMessage: "履约配置已保存",
errorMessage: "保存履约配置失败",
scope: "[admin/platform-config/fulfillment-bindings]",
audit: (_req, data) => {
const result = data as JsonRecord;
return {
action: "platform_fulfillment_config_updated",
targetType: "platform_config",
targetId: "fulfillment_bindings",
data: {
bindingCount: Array.isArray(result.bindings)
? result.bindings.length
: 0,
filePath: result.filePath || "",
},
};
},
}
)
);
export default router;
@@ -1,162 +0,0 @@
import type { Request } from "express";
import { Router } from "express";
import {
getAdminTaskDetail,
getAdminTasks,
} from "../../services/admin/admin-read-service.js";
import {
dispatchAdminTaskKuaishouCloudFulfillment,
prepareAdminTaskKuaishouCloudFulfillment,
refreshAdminTaskKuaishouCloudRoleInfo,
returnNumberAdminTaskKuaishouCloudFulfillment,
} from "../../services/admin/write/kuaishou-cloud-actions.js";
import {
createJsonHandler,
requireAdminRoles,
} from "./shared.js";
import type {
AdminTaskKuaishouCloudDispatchRouteBody,
AdminTaskRouteParams,
AdminTaskRouteQuery,
} from "../../types/admin-route-inputs.js";
import type { AdminTaskActionResponse } from "../../types/admin-write-models.js";
const router = Router();
function getTaskId(req: Request): string | undefined {
return (req.params as AdminTaskRouteParams).taskId;
}
router.get(
"/tasks",
createJsonHandler(
(req) =>
getAdminTasks(req.query as AdminTaskRouteQuery, req.adminSession || null),
{
successMessage: "ok",
errorMessage: "读取任务列表失败",
scope: "[admin-kuaishou/tasks]",
}
)
);
router.get(
"/tasks/:taskId",
createJsonHandler(
(req) => getAdminTaskDetail(getTaskId(req), req.adminSession || null),
{
successMessage: "ok",
errorMessage: "读取任务详情失败",
scope: "[admin-kuaishou/tasks/:taskId]",
}
)
);
router.post(
"/tasks/:taskId/kuaishou-cloud/prepare",
requireAdminRoles(["admin", "operator"]),
createJsonHandler(
(req) =>
prepareAdminTaskKuaishouCloudFulfillment(
getTaskId(req),
req.adminSession || null
),
{
successMessage: "绑定资源已准备完成",
errorMessage: "准备绑定资源失败",
scope: "[admin-kuaishou/tasks/:taskId/kuaishou-cloud/prepare]",
audit: (req, data) => buildTaskAudit("task_kuaishou_cloud_prepare", req, data),
}
)
);
router.post(
"/tasks/:taskId/kuaishou-cloud/refresh-role-info",
requireAdminRoles(["admin", "operator", "support"]),
createJsonHandler(
(req) =>
refreshAdminTaskKuaishouCloudRoleInfo(
getTaskId(req),
req.adminSession || null
),
{
successMessage: "角色信息已刷新",
errorMessage: "刷新角色信息失败",
scope: "[admin-kuaishou/tasks/:taskId/kuaishou-cloud/refresh-role-info]",
audit: (req, data) =>
buildTaskAudit("task_kuaishou_cloud_role_info_refreshed", req, data),
}
)
);
router.post(
"/tasks/:taskId/kuaishou-cloud/dispatch",
requireAdminRoles(["admin", "operator"]),
createJsonHandler(
(req) =>
dispatchAdminTaskKuaishouCloudFulfillment(
getTaskId(req),
req.body as AdminTaskKuaishouCloudDispatchRouteBody,
req.adminSession || null
),
{
successMessage: "已完成绑定确认并发货",
errorMessage: "执行发货失败",
scope: "[admin-kuaishou/tasks/:taskId/kuaishou-cloud/dispatch]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
const body = req.body as AdminTaskKuaishouCloudDispatchRouteBody;
return {
action: "task_kuaishou_cloud_dispatch",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
deliveryStatus: result.task.deliveryStatus,
ticketCodeProvided: Boolean(String(body.ticketCode || "").trim()),
},
};
},
}
)
);
router.post(
"/tasks/:taskId/kuaishou-cloud/return-number",
requireAdminRoles(["admin", "operator"]),
createJsonHandler(
(req) =>
returnNumberAdminTaskKuaishouCloudFulfillment(
getTaskId(req),
req.adminSession || null
),
{
successMessage: "号码已退还",
errorMessage: "退还号码失败",
scope: "[admin-kuaishou/tasks/:taskId/kuaishou-cloud/return-number]",
audit: (req, data) =>
buildTaskAudit("task_kuaishou_cloud_return_number", req, data),
}
)
);
function buildTaskAudit(action: string, req: Request, data: unknown) {
const result = data as AdminTaskActionResponse;
return {
action,
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
}
export default router;
+29 -300
View File
@@ -1,42 +1,26 @@
import type { Request } from "express";
import { Router } from "express";
import {
closeAdminTask,
completeAdminTaskManualDispatch,
confirmAdminTaskAssistedRole,
dispatchAdminTaskKuaishouCloudFulfillment,
markAdminTaskManualReview,
prepareAdminTaskKuaishouCloudFulfillment,
refreshAdminTaskKuaishouCloudRoleInfo,
regenerateAdminTaskClaimLink,
redeemAdminTaskAssisted,
releaseAdminTaskInventoryBinding,
releaseAdminTaskInventory,
returnNumberAdminTaskKuaishouCloudFulfillment,
retryAdminTask,
} from "../../services/admin/admin-write-service.js";
import {
getAdminTaskDetail,
getAdminTasks,
} from "../../services/admin/admin-read-service.js";
import { getAdminTaskScreenshotPathWithTencentFallback } from "../../services/admin/admin-task-screenshot-service.js";
import {
createFileHandler,
dispatchAdminTaskKuaishouCloudFulfillment,
prepareAdminTaskKuaishouCloudFulfillment,
refreshAdminTaskKuaishouCloudRoleInfo,
returnNumberAdminTaskKuaishouCloudFulfillment,
} from "../../services/admin/write/kuaishou-cloud-actions.js";
import {
createJsonHandler,
requireAdminRoles,
} from "./shared.js";
import type { Request } from "express";
import type {
AdminTaskKuaishouCloudDispatchRouteBody,
AdminTaskManualDispatchRouteBody,
AdminTaskRouteParams,
AdminTaskRouteQuery,
} from "../../types/admin-route-inputs.js";
import type {
AdminTaskActionResponse,
AdminTaskBindingReleaseResponse,
AdminTaskManualDispatchResponse,
} from "../../types/admin-write-models.js";
import type { AdminTaskActionResponse } from "../../types/admin-write-models.js";
const router = Router();
@@ -44,10 +28,6 @@ function getTaskId(req: Request): string | undefined {
return (req.params as AdminTaskRouteParams).taskId;
}
function getBindingId(req: Request): string | undefined {
return (req.params as AdminTaskRouteParams).bindingId;
}
router.get(
"/tasks",
createJsonHandler(
@@ -73,239 +53,6 @@ router.get(
)
);
router.get(
"/tasks/:taskId/screenshot",
createFileHandler(
(req) =>
getAdminTaskScreenshotPathWithTencentFallback(getTaskId(req), req.adminSession || null),
{
errorMessage: "读取任务截图失败",
scope: "[admin/tasks/:taskId/screenshot]",
}
)
);
router.post(
"/tasks/:taskId/retry",
requireAdminRoles(["admin", "operator"]),
createJsonHandler((req) => retryAdminTask(getTaskId(req)), {
successMessage: "任务已重试",
errorMessage: "重试任务失败",
scope: "[admin/tasks/:taskId/retry]",
})
);
router.post(
"/tasks/:taskId/release-inventory",
requireAdminRoles(["admin"]),
createJsonHandler((req) => releaseAdminTaskInventory(getTaskId(req)), {
successMessage: "库存凭据已释放",
errorMessage: "释放库存凭据失败",
scope: "[admin/tasks/:taskId/release-inventory]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_release_inventory",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
inventoryItemId: result.task.inventoryItemId,
},
};
},
})
);
router.post(
"/tasks/:taskId/inventory-bindings/:bindingId/release",
requireAdminRoles(["admin"]),
createJsonHandler(
(req) =>
releaseAdminTaskInventoryBinding(getTaskId(req), getBindingId(req)),
{
successMessage: "库存绑定已释放",
errorMessage: "释放库存绑定失败",
scope: "[admin/tasks/:taskId/inventory-bindings/:bindingId/release]",
audit: (req, data) => {
const result = data as AdminTaskBindingReleaseResponse;
return {
action: "task_release_inventory_binding",
targetType: "task_inventory_binding",
targetId: String(getBindingId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
bindingId: result.bindingId,
inventoryItemId: result.inventoryItemId,
},
};
},
}
)
);
router.post(
"/tasks/:taskId/regenerate-claim-link",
requireAdminRoles(["admin", "operator", "support"]),
createJsonHandler(
(req) =>
regenerateAdminTaskClaimLink(getTaskId(req), req.adminSession || null),
{
successMessage: "领取链接已重新生成",
errorMessage: "重新生成领取链接失败",
scope: "[admin/tasks/:taskId/regenerate-claim-link]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_regenerate_claim_link",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
primaryClaimTokenId: result.task.primaryClaimTokenId,
},
};
},
}
)
);
router.post(
"/tasks/:taskId/support-confirm-role",
requireAdminRoles(["admin", "operator", "support"]),
createJsonHandler(
(req) =>
confirmAdminTaskAssistedRole(getTaskId(req), req.adminSession || null),
{
successMessage: "角色已确认",
errorMessage: "客服确认角色失败",
scope: "[admin/tasks/:taskId/support-confirm-role]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_support_confirm_role",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
}
)
);
router.post(
"/tasks/:taskId/support-redeem",
requireAdminRoles(["admin", "operator", "support"]),
createJsonHandler(
(req) => redeemAdminTaskAssisted(getTaskId(req), req.adminSession || null),
{
successMessage: "兑换任务已启动",
errorMessage: "客服发起兑换失败",
scope: "[admin/tasks/:taskId/support-redeem]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_support_redeem",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
deliveryStatus: result.task.deliveryStatus,
},
};
},
}
)
);
router.post(
"/tasks/:taskId/close",
requireAdminRoles(["admin", "operator", "support"]),
createJsonHandler((req) => closeAdminTask(getTaskId(req)), {
successMessage: "任务已关闭",
errorMessage: "关闭任务失败",
scope: "[admin/tasks/:taskId/close]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_closed",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
})
);
router.post(
"/tasks/:taskId/mark-manual-review",
requireAdminRoles(["admin", "operator"]),
createJsonHandler((req) => markAdminTaskManualReview(getTaskId(req)), {
successMessage: "任务已转人工处理",
errorMessage: "标记人工处理失败",
scope: "[admin/tasks/:taskId/mark-manual-review]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_mark_manual_review",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
})
);
router.post(
"/tasks/:taskId/complete-manual-dispatch",
requireAdminRoles(["admin", "operator"]),
createJsonHandler(
(req) =>
completeAdminTaskManualDispatch(
getTaskId(req),
req.body as AdminTaskManualDispatchRouteBody,
req.adminSession || null
),
{
successMessage: "人工履约结果已回写",
errorMessage: "回写人工履约结果失败",
scope: "[admin/tasks/:taskId/complete-manual-dispatch]",
audit: (req, data) => {
const result = data as AdminTaskManualDispatchResponse;
return {
action: "task_complete_manual_dispatch",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
outcome: result.outcome,
deliveryStatus: result.task.deliveryStatus,
resultCode: result.task.resultCode,
},
};
},
}
)
);
router.post(
"/tasks/:taskId/kuaishou-cloud/prepare",
requireAdminRoles(["admin", "operator"]),
@@ -319,19 +66,7 @@ router.post(
successMessage: "绑定资源已准备完成",
errorMessage: "准备绑定资源失败",
scope: "[admin/tasks/:taskId/kuaishou-cloud/prepare]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_kuaishou_cloud_prepare",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
audit: (req, data) => buildTaskAudit("task_kuaishou_cloud_prepare", req, data),
}
)
);
@@ -349,19 +84,8 @@ router.post(
successMessage: "角色信息已刷新",
errorMessage: "刷新角色信息失败",
scope: "[admin/tasks/:taskId/kuaishou-cloud/refresh-role-info]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_kuaishou_cloud_role_info_refreshed",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
audit: (req, data) =>
buildTaskAudit("task_kuaishou_cloud_role_info_refreshed", req, data),
}
)
);
@@ -383,6 +107,7 @@ router.post(
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
const body = req.body as AdminTaskKuaishouCloudDispatchRouteBody;
return {
action: "task_kuaishou_cloud_dispatch",
targetType: "task",
@@ -413,21 +138,25 @@ router.post(
successMessage: "号码已退还",
errorMessage: "退还号码失败",
scope: "[admin/tasks/:taskId/kuaishou-cloud/return-number]",
audit: (req, data) => {
const result = data as AdminTaskActionResponse;
return {
action: "task_kuaishou_cloud_return_number",
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
},
audit: (req, data) =>
buildTaskAudit("task_kuaishou_cloud_return_number", req, data),
}
)
);
function buildTaskAudit(action: string, req: Request, data: unknown) {
const result = data as AdminTaskActionResponse;
return {
action,
targetType: "task",
targetId: String(getTaskId(req)),
data: {
taskId: result.task.taskId,
taskNo: result.task.taskNo,
status: result.task.status,
},
};
}
export default router;
@@ -1,76 +0,0 @@
import { Router } from "express";
import {
getAdminWebhookEventDetail,
getAdminWebhookEvents,
} from "../../services/admin/admin-read-service.js";
import { createHttpError } from "../../utils/http.js";
import { createJsonHandler, requireAdminRoles } from "./shared.js";
import type {
AdminWebhookEventRouteParams,
AdminWebhookEventRouteQuery,
} from "../../types/admin-route-inputs.js";
const router = Router();
router.use("/webhook-events", requireAdminRoles(["admin", "operator"]));
router.get(
"/webhook-events",
createJsonHandler(
(req) => getAdminWebhookEvents(req.query as AdminWebhookEventRouteQuery),
{
successMessage: "ok",
errorMessage: "读取 webhook 列表失败",
scope: "[admin-kuaishou/webhook-events]",
}
)
);
router.get(
"/webhook-events/:eventId",
createJsonHandler(
(req) =>
getAdminWebhookEventDetail(
(req.params as AdminWebhookEventRouteParams).eventId
),
{
successMessage: "ok",
errorMessage: "读取 webhook 详情失败",
scope: "[admin-kuaishou/webhook-events/:eventId]",
}
)
);
router.post(
"/webhook-events/:eventId/replay",
requireAdminRoles(["admin"]),
createJsonHandler(
() => {
throw createHttpError("快手轻量后端不支持重放旧 Webhook", {
statusCode: 409,
errorCode: "admin_webhook_replay_disabled",
});
},
{
successMessage: "Webhook 已重放",
errorMessage: "重放 webhook 失败",
scope: "[admin-kuaishou/webhook-events/:eventId/replay]",
audit: (req, data) => {
return {
action: "webhook_replayed",
targetType: "webhook_event",
targetId: String(
(req.params as AdminWebhookEventRouteParams).eventId
),
data: {
disabled: true,
result: data,
},
};
},
}
)
);
export default router;
+62 -46
View File
@@ -1,60 +1,76 @@
import { Router } from 'express'
import { Router } from "express";
import {
replayAdminWebhookEvent,
} from '../../services/admin/admin-write-service.js'
import {
getAdminWebhookEventDetail,
getAdminWebhookEvents,
} from '../../services/admin/admin-read-service.js'
import { createJsonHandler, requireAdminRoles } from './shared.js'
} from "../../services/admin/admin-read-service.js";
import { createHttpError } from "../../utils/http.js";
import { createJsonHandler, requireAdminRoles } from "./shared.js";
import type {
AdminWebhookEventRouteParams,
AdminWebhookEventRouteQuery,
} from '../../types/admin-route-inputs.js'
import type { AdminWebhookReplayResponse } from '../../types/admin-write-models.js'
} from "../../types/admin-route-inputs.js";
const router = Router()
const router = Router();
router.use('/webhook-events', requireAdminRoles(['admin', 'operator']))
router.use("/webhook-events", requireAdminRoles(["admin", "operator"]));
router.get('/webhook-events', createJsonHandler(
(req) => getAdminWebhookEvents(req.query as AdminWebhookEventRouteQuery),
{
successMessage: 'ok',
errorMessage: '读取 webhook 列表失败',
scope: '[admin/webhook-events]',
},
))
router.get(
"/webhook-events",
createJsonHandler(
(req) => getAdminWebhookEvents(req.query as AdminWebhookEventRouteQuery),
{
successMessage: "ok",
errorMessage: "读取 webhook 列表失败",
scope: "[admin/webhook-events]",
}
)
);
router.get('/webhook-events/:eventId', createJsonHandler(
(req) => getAdminWebhookEventDetail((req.params as AdminWebhookEventRouteParams).eventId),
{
successMessage: 'ok',
errorMessage: '读取 webhook 详情失败',
scope: '[admin/webhook-events/:eventId]',
},
))
router.get(
"/webhook-events/:eventId",
createJsonHandler(
(req) =>
getAdminWebhookEventDetail(
(req.params as AdminWebhookEventRouteParams).eventId
),
{
successMessage: "ok",
errorMessage: "读取 webhook 详情失败",
scope: "[admin/webhook-events/:eventId]",
}
)
);
router.post('/webhook-events/:eventId/replay', requireAdminRoles(['admin']), createJsonHandler(
(req) => replayAdminWebhookEvent((req.params as AdminWebhookEventRouteParams).eventId),
{
successMessage: 'Webhook 已重放',
errorMessage: '重放 webhook 失败',
scope: '[admin/webhook-events/:eventId/replay]',
audit: (req, data) => {
const result = data as AdminWebhookReplayResponse
return {
action: 'webhook_replayed',
targetType: 'webhook_event',
targetId: String((req.params as AdminWebhookEventRouteParams).eventId),
data: {
eventId: result.eventId,
replayed: result.replayed,
},
}
router.post(
"/webhook-events/:eventId/replay",
requireAdminRoles(["admin"]),
createJsonHandler(
() => {
throw createHttpError("快手轻量后端不支持重放旧 Webhook", {
statusCode: 409,
errorCode: "admin_webhook_replay_disabled",
});
},
},
))
{
successMessage: "Webhook 已重放",
errorMessage: "重放 webhook 失败",
scope: "[admin/webhook-events/:eventId/replay]",
audit: (req, data) => {
return {
action: "webhook_replayed",
targetType: "webhook_event",
targetId: String(
(req.params as AdminWebhookEventRouteParams).eventId
),
data: {
disabled: true,
result: data,
},
};
},
}
)
);
export default router
export default router;