删除咸鱼旧链路

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
-34
View File
@@ -1,34 +0,0 @@
import { Router } from "express";
import authRouter from "./admin/auth.js";
import auditLogsRouter from "./admin/audit-logs.js";
import dashboardRouter from "./admin/dashboard.js";
import inventoryRouter from "./admin/inventory-kuaishou.js";
import messageDeliveriesRouter from "./admin/message-deliveries.js";
import ordersRouter from "./admin/orders.js";
import platformConfigRouter from "./admin/platform-config-kuaishou.js";
import { requireAdminSession } from "./admin/shared.js";
import tasksRouter from "./admin/tasks-kuaishou.js";
import usersRouter from "./admin/users.js";
import webhookEventsRouter from "./admin/webhook-events-kuaishou.js";
import { buildNotFoundPayload } from "../utils/http.js";
const router = Router();
router.use(authRouter);
router.use(requireAdminSession);
router.use(dashboardRouter);
router.use(usersRouter);
router.use(auditLogsRouter);
router.use(platformConfigRouter);
router.use(ordersRouter);
router.use(tasksRouter);
router.use(inventoryRouter);
router.use(messageDeliveriesRouter);
router.use(webhookEventsRouter);
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req));
});
export default router;
+28 -30
View File
@@ -1,36 +1,34 @@
import { Router } from 'express'
import { Router } from "express";
import authRouter from './admin/auth.js'
import auditLogsRouter from './admin/audit-logs.js'
import dashboardRouter from './admin/dashboard.js'
import inventoryRouter from './admin/inventory.js'
import manualRedeemRouter from './admin/manual-redeem.js'
import messageDeliveriesRouter from './admin/message-deliveries.js'
import ordersRouter from './admin/orders.js'
import platformConfigRouter from './admin/platform-config.js'
import { requireAdminSession } from './admin/shared.js'
import tasksRouter from './admin/tasks.js'
import usersRouter from './admin/users.js'
import webhookEventsRouter from './admin/webhook-events.js'
import { buildNotFoundPayload } from '../utils/http.js'
import authRouter from "./admin/auth.js";
import auditLogsRouter from "./admin/audit-logs.js";
import dashboardRouter from "./admin/dashboard.js";
import inventoryRouter from "./admin/inventory.js";
import messageDeliveriesRouter from "./admin/message-deliveries.js";
import ordersRouter from "./admin/orders.js";
import platformConfigRouter from "./admin/platform-config.js";
import { requireAdminSession } from "./admin/shared.js";
import tasksRouter from "./admin/tasks.js";
import usersRouter from "./admin/users.js";
import webhookEventsRouter from "./admin/webhook-events.js";
import { buildNotFoundPayload } from "../utils/http.js";
const router = Router()
const router = Router();
router.use(authRouter)
router.use(requireAdminSession)
router.use(dashboardRouter)
router.use(usersRouter)
router.use(auditLogsRouter)
router.use(platformConfigRouter)
router.use(ordersRouter)
router.use(tasksRouter)
router.use(manualRedeemRouter)
router.use(inventoryRouter)
router.use(messageDeliveriesRouter)
router.use(webhookEventsRouter)
router.use(authRouter);
router.use(requireAdminSession);
router.use(dashboardRouter);
router.use(usersRouter);
router.use(auditLogsRouter);
router.use(platformConfigRouter);
router.use(ordersRouter);
router.use(tasksRouter);
router.use(inventoryRouter);
router.use(messageDeliveriesRouter);
router.use(webhookEventsRouter);
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req))
})
res.status(404).json(buildNotFoundPayload(req));
});
export default router
export default router;
@@ -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;
@@ -1,71 +0,0 @@
import { Router } from "express";
import {
confirmKuaishouCloudClaimRole,
getKuaishouCloudClaimDetail,
getKuaishouCloudClaimGuideAssetPath,
redeemKuaishouCloudClaim,
verifyKuaishouCloudClaimTicket,
} from "../services/claim/kuaishou-cloud-claim-service.js";
import {
buildNotFoundPayload,
createRouteFileHandler,
createRouteHandler,
} from "../utils/http.js";
const router = Router();
router.get(
"/:token",
createRouteHandler((req) => getKuaishouCloudClaimDetail(req.params.token), {
errorMessage: "查询快手领取详情失败",
scope: "[claims-kuaishou/:token]",
})
);
router.post(
"/:token/kuaishou-cloud/verify-ticket",
createRouteHandler(
(req) => verifyKuaishouCloudClaimTicket(req.params.token, req.body),
{
successMessage: "核销码校验成功",
errorMessage: "校验核销码失败",
scope: "[claims-kuaishou/:token/kuaishou-cloud/verify-ticket]",
}
)
);
router.post(
"/:token/kuaishou-cloud/confirm-role",
createRouteHandler((req) => confirmKuaishouCloudClaimRole(req.params.token), {
successMessage: "角色已确认",
errorMessage: "确认角色失败",
scope: "[claims-kuaishou/:token/kuaishou-cloud/confirm-role]",
})
);
router.post(
"/:token/kuaishou-cloud/redeem",
createRouteHandler((req) => redeemKuaishouCloudClaim(req.params.token), {
successMessage: "兑换请求已提交",
errorMessage: "兑换失败",
scope: "[claims-kuaishou/:token/kuaishou-cloud/redeem]",
})
);
router.get(
"/assets/kuaishou-cloud/:filename",
createRouteFileHandler(
(req) => getKuaishouCloudClaimGuideAssetPath(req.params.filename),
{
errorMessage: "读取指引图片失败",
scope: "[claims-kuaishou/assets/kuaishou-cloud/:filename]",
}
)
);
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req));
});
export default router;
+52 -78
View File
@@ -1,97 +1,71 @@
import { Router } from 'express'
import { Router } from "express";
import {
closeClaimSession,
confirmClaimRole,
createClaimSession,
getClaimDetail,
getClaimScreenshotPath,
getClaimSessionSummary,
reloadClaimSession,
redeemClaimTask,
} from '../services/claim/claim-session-service.js'
import {
confirmKuaishouCloudClaimRole,
getKuaishouCloudClaimDetail,
getKuaishouCloudClaimGuideAssetPath,
redeemKuaishouCloudClaim,
verifyKuaishouCloudClaimTicket,
} from '../services/claim/kuaishou-cloud-claim-service.js'
} from "../services/claim/kuaishou-cloud-claim-service.js";
import {
buildNotFoundPayload,
buildSuccessPayload,
createRouteFileHandler,
createRouteHandler,
sendRouteError,
} from '../utils/http.js'
} from "../utils/http.js";
const router = Router()
const router = Router();
router.get('/:token', createRouteHandler(
(req) => getClaimDetail(req.params.token),
{ errorMessage: '查询领取详情失败', scope: '[claims/:token]' },
))
router.get(
"/:token",
createRouteHandler((req) => getKuaishouCloudClaimDetail(req.params.token), {
errorMessage: "查询快手领取详情失败",
scope: "[claims/:token]",
})
);
router.post('/:token/session', createRouteHandler(
(req) => createClaimSession(req.params.token, req.body),
{ successMessage: '浏览器会话已创建', errorMessage: '创建领取会话失败', scope: '[claims/:token/session]' },
))
router.post(
"/:token/kuaishou-cloud/verify-ticket",
createRouteHandler(
(req) => verifyKuaishouCloudClaimTicket(req.params.token, req.body),
{
successMessage: "核销码校验成功",
errorMessage: "校验核销码失败",
scope: "[claims/:token/kuaishou-cloud/verify-ticket]",
}
)
);
router.get('/:token/session/summary', createRouteHandler(
(req) => getClaimSessionSummary(req.params.token),
{ errorMessage: '查询领取会话摘要失败', scope: '[claims/:token/session/summary]' },
))
router.post(
"/:token/kuaishou-cloud/confirm-role",
createRouteHandler((req) => confirmKuaishouCloudClaimRole(req.params.token), {
successMessage: "角色已确认",
errorMessage: "确认角色失败",
scope: "[claims/:token/kuaishou-cloud/confirm-role]",
})
);
router.post('/:token/session/refresh', async (req, res) => {
try {
const data = await reloadClaimSession(req.params.token)
res.json(buildSuccessPayload(data, data.session ? (data.session.notice || '后端页面已刷新') : '领取会话已重置'))
} catch (error) {
sendRouteError(res, error, '刷新领取会话失败', '[claims/:token/session/refresh]')
}
})
router.post(
"/:token/kuaishou-cloud/redeem",
createRouteHandler((req) => redeemKuaishouCloudClaim(req.params.token), {
successMessage: "兑换请求已提交",
errorMessage: "兑换失败",
scope: "[claims/:token/kuaishou-cloud/redeem]",
})
);
router.delete('/:token/session', createRouteHandler(
(req) => closeClaimSession(req.params.token),
{ successMessage: '领取会话已关闭', errorMessage: '关闭领取会话失败', scope: '[claims/:token/session]' },
))
router.post('/:token/confirm-role', createRouteHandler(
(req) => confirmClaimRole(req.params.token),
{ successMessage: '角色已确认', errorMessage: '确认角色失败', scope: '[claims/:token/confirm-role]' },
))
router.post('/:token/redeem', createRouteHandler(
(req) => redeemClaimTask(req.params.token),
{ successMessage: '兑换完成', errorMessage: '执行领取兑换失败', scope: '[claims/:token/redeem]' },
))
router.post('/:token/kuaishou-cloud/verify-ticket', createRouteHandler(
(req) => verifyKuaishouCloudClaimTicket(req.params.token, req.body),
{ successMessage: '核销码校验成功', errorMessage: '校验核销码失败', scope: '[claims/:token/kuaishou-cloud/verify-ticket]' },
))
router.post('/:token/kuaishou-cloud/confirm-role', createRouteHandler(
(req) => confirmKuaishouCloudClaimRole(req.params.token),
{ successMessage: '角色已确认', errorMessage: '确认角色失败', scope: '[claims/:token/kuaishou-cloud/confirm-role]' },
))
router.post('/:token/kuaishou-cloud/redeem', createRouteHandler(
(req) => redeemKuaishouCloudClaim(req.params.token),
{ successMessage: '兑换请求已提交', errorMessage: '兑换失败', scope: '[claims/:token/kuaishou-cloud/redeem]' },
))
router.get('/:token/screenshot', createRouteFileHandler(
(req) => getClaimScreenshotPath(req.params.token),
{ errorMessage: '读取领取截图失败', scope: '[claims/:token/screenshot]' },
))
router.get('/assets/kuaishou-cloud/:filename', createRouteFileHandler(
(req) => getKuaishouCloudClaimGuideAssetPath(req.params.filename),
{ errorMessage: '读取指引图片失败', scope: '[claims/assets/kuaishou-cloud/:filename]' },
))
router.get(
"/assets/kuaishou-cloud/:filename",
createRouteFileHandler(
(req) => getKuaishouCloudClaimGuideAssetPath(req.params.filename),
{
errorMessage: "读取指引图片失败",
scope: "[claims/assets/kuaishou-cloud/:filename]",
}
)
);
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req))
})
res.status(404).json(buildNotFoundPayload(req));
});
export default router
export default router;
-77
View File
@@ -1,77 +0,0 @@
import { Router } from 'express'
import {
closeTencentBrowserSession,
createTencentBrowserSession,
getTencentBrowserSession,
getTencentBrowserSessionSummary,
getTencentBrowserSessionScreenshotPath,
reloadTencentBrowserSession,
redeemTencentBrowserSession,
} from '../services/session/session.js'
import {
buildNotFoundPayload,
buildSuccessPayload,
createRouteFileHandler,
createRouteHandler,
sendRouteError,
} from '../utils/http.js'
const router = Router()
router.post('/browser/session', createRouteHandler(
(req) => createTencentBrowserSession(req.body),
{ successMessage: '浏览器会话已创建', errorMessage: '创建浏览器会话失败', scope: '[browser/session]' },
))
router.get('/browser/session/:sessionId', async (req, res) => {
try {
const data = await getTencentBrowserSession(req.params.sessionId)
res.json(buildSuccessPayload(data, data.notice || 'ok'))
} catch (error) {
sendRouteError(res, error, '查询浏览器会话失败', '[browser/session/:sessionId]')
}
})
router.get('/browser/session/:sessionId/summary', async (req, res) => {
try {
const data = await getTencentBrowserSessionSummary(req.params.sessionId)
res.json(buildSuccessPayload(data, data.notice || 'ok'))
} catch (error) {
sendRouteError(res, error, '查询浏览器会话摘要失败', '[browser/session/:sessionId/summary]')
}
})
router.post('/browser/session/:sessionId/refresh', async (req, res) => {
try {
const data = await reloadTencentBrowserSession(req.params.sessionId)
res.json(buildSuccessPayload(data, data.notice || '后端页面已刷新'))
} catch (error) {
sendRouteError(res, error, '刷新后端页面失败', '[browser/session/:sessionId/refresh]')
}
})
router.post('/browser/session/:sessionId/redeem', async (req, res) => {
try {
const data = await redeemTencentBrowserSession(req.params.sessionId, req.body)
res.json(buildSuccessPayload(data, data.notice || '兑换完成'))
} catch (error) {
sendRouteError(res, error, '浏览器会话兑换失败', '[browser/session/:sessionId/redeem]')
}
})
router.get('/browser/session/:sessionId/screenshot', createRouteFileHandler(
(req) => getTencentBrowserSessionScreenshotPath(req.params.sessionId),
{ errorMessage: '读取兑换截图失败', scope: '[browser/session/:sessionId/screenshot]' },
))
router.delete('/browser/session/:sessionId', createRouteHandler(
(req) => closeTencentBrowserSession(req.params.sessionId),
{ successMessage: '浏览器会话已关闭', errorMessage: '关闭浏览器会话失败', scope: '[browser/session/:sessionId]' },
))
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req))
})
export default router
-57
View File
@@ -1,57 +0,0 @@
import { Router } from 'express'
import { processAgisoTradeWebhook } from '../services/order/webhook-service.js'
import { createRequestId, logWebhook } from '../utils/logger.js'
import { buildNotFoundPayload, buildSuccessPayload, sendRouteError } from '../utils/http.js'
const router = Router()
router.post('/agiso/trade', async (req, res) => {
const requestId = createRequestId('wh')
const startedAt = Date.now()
logWebhook('[webhooks/agiso/trade]', '收到 Agiso webhook 请求', {
requestId,
method: req.method,
originalUrl: req.originalUrl,
ip: req.ip,
headers: req.headers,
query: req.query,
body: req.body,
})
try {
const data = await processAgisoTradeWebhook({
requestId,
headers: req.headers,
query: req.query,
body: req.body,
})
logWebhook('[webhooks/agiso/trade]', 'Agiso webhook 处理完成', {
requestId,
durationMs: Date.now() - startedAt,
result: data,
})
res.json(buildSuccessPayload(data, 'success'))
} catch (error) {
logWebhook(
'[webhooks/agiso/trade]',
'Agiso webhook 处理失败',
{
requestId,
durationMs: Date.now() - startedAt,
error,
},
{ level: 'error' },
)
sendRouteError(res, error, '处理 Agiso 订单通知失败', '[webhooks/agiso/trade]')
}
})
router.use((req, res) => {
res.status(404).json(buildNotFoundPayload(req))
})
export default router