feat: 添加前端页面和业务说明书

refactor(server): 重构服务层代码结构
feat(server): 添加基础设施、跨境电商、AI决策等核心服务
docs: 完善前端业务说明书和开发进度文档
style: 格式化代码和文档
This commit is contained in:
2026-03-18 19:12:38 +08:00
parent c932a67be2
commit 6d0d2b6157
140 changed files with 23859 additions and 5833 deletions

View File

@@ -0,0 +1,325 @@
import { MessageConfig, MessageStatus, MessageQueue, Message } from '../types/message';
import { logger } from '../utils/logger';
import { v4 as uuidv4 } from 'uuid';
/**
* 消息处理服务
* 负责管理系统中的消息,包括消息的发送、接收、处理等
*/
export class MessageProcessingService {
private static messageQueues: Map<string, MessageQueue> = new Map();
private static messages: Map<string, Message> = new Map();
private static messageStatus: Map<string, MessageStatus> = new Map();
/**
* 创建消息队列
* @param config 消息队列配置
* @returns 创建结果
*/
static async createMessageQueue(config: MessageConfig): Promise<{ success: boolean; queueId: string; message: string }> {
try {
if (this.messageQueues.has(config.id)) {
return { success: false, queueId: '', message: 'Message queue already exists' };
}
const queue: MessageQueue = {
id: config.id,
name: config.name,
type: config.type,
maxSize: config.maxSize || 10000,
retentionPeriod: config.retentionPeriod || 86400000, // 24 hours
created: new Date(),
messages: []
};
this.messageQueues.set(config.id, queue);
logger.info(`Message queue ${config.id} created successfully`);
return { success: true, queueId: config.id, message: 'Message queue created successfully' };
} catch (error) {
logger.error(`Error creating message queue: ${error}`);
return { success: false, queueId: '', message: `Error creating message queue: ${error}` };
}
}
/**
* 发送消息
* @param queueId 队列ID
* @param payload 消息内容
* @returns 发送结果
*/
static async sendMessage(queueId: string, payload: any): Promise<{ success: boolean; messageId: string; message: string }> {
try {
const queue = this.messageQueues.get(queueId);
if (!queue) {
return { success: false, messageId: '', message: 'Message queue not found' };
}
// 检查队列大小
if (queue.messages.length >= queue.maxSize) {
return { success: false, messageId: '', message: 'Message queue is full' };
}
const messageId = uuidv4();
const message: Message = {
id: messageId,
queueId,
payload,
status: 'PENDING',
created: new Date(),
updated: new Date()
};
// 添加到队列
queue.messages.push(messageId);
this.messages.set(messageId, message);
this.messageStatus.set(messageId, {
status: 'PENDING',
lastUpdated: new Date()
});
logger.info(`Message ${messageId} sent to queue ${queueId}`);
return { success: true, messageId, message: 'Message sent successfully' };
} catch (error) {
logger.error(`Error sending message: ${error}`);
return { success: false, messageId: '', message: `Error sending message: ${error}` };
}
}
/**
* 接收消息
* @param queueId 队列ID
* @returns 消息
*/
static async receiveMessage(queueId: string): Promise<Message | null> {
try {
const queue = this.messageQueues.get(queueId);
if (!queue) {
return null;
}
if (queue.messages.length === 0) {
return null;
}
// 取出第一个消息
const messageId = queue.messages.shift();
if (!messageId) {
return null;
}
const message = this.messages.get(messageId);
if (!message) {
return null;
}
// 更新消息状态
message.status = 'PROCESSING';
message.updated = new Date();
this.messages.set(messageId, message);
this.messageStatus.set(messageId, {
status: 'PROCESSING',
lastUpdated: new Date()
});
logger.info(`Message ${messageId} received from queue ${queueId}`);
return message;
} catch (error) {
logger.error(`Error receiving message: ${error}`);
return null;
}
}
/**
* 确认消息处理完成
* @param messageId 消息ID
* @returns 确认结果
*/
static async acknowledgeMessage(messageId: string): Promise<{ success: boolean; message: string }> {
try {
const message = this.messages.get(messageId);
if (!message) {
return { success: false, message: 'Message not found' };
}
// 更新消息状态
message.status = 'COMPLETED';
message.updated = new Date();
this.messages.set(messageId, message);
this.messageStatus.set(messageId, {
status: 'COMPLETED',
lastUpdated: new Date()
});
logger.info(`Message ${messageId} acknowledged`);
return { success: true, message: 'Message acknowledged successfully' };
} catch (error) {
logger.error(`Error acknowledging message: ${error}`);
return { success: false, message: `Error acknowledging message: ${error}` };
}
}
/**
* 拒绝消息
* @param messageId 消息ID
* @param requeue 是否重新入队
* @returns 拒绝结果
*/
static async rejectMessage(messageId: string, requeue: boolean = false): Promise<{ success: boolean; message: string }> {
try {
const message = this.messages.get(messageId);
if (!message) {
return { success: false, message: 'Message not found' };
}
// 更新消息状态
message.status = 'REJECTED';
message.updated = new Date();
this.messages.set(messageId, message);
this.messageStatus.set(messageId, {
status: 'REJECTED',
lastUpdated: new Date()
});
// 如果需要重新入队
if (requeue) {
const queue = this.messageQueues.get(message.queueId);
if (queue) {
queue.messages.push(messageId);
}
}
logger.info(`Message ${messageId} rejected${requeue ? ' and requeued' : ''}`);
return { success: true, message: 'Message rejected successfully' };
} catch (error) {
logger.error(`Error rejecting message: ${error}`);
return { success: false, message: `Error rejecting message: ${error}` };
}
}
/**
* 获取消息状态
* @param messageId 消息ID
* @returns 消息状态
*/
static async getMessageStatus(messageId: string): Promise<MessageStatus | null> {
try {
const status = this.messageStatus.get(messageId);
if (!status) {
return null;
}
return status;
} catch (error) {
logger.error(`Error getting message status: ${error}`);
return null;
}
}
/**
* 获取队列状态
* @param queueId 队列ID
* @returns 队列状态
*/
static async getQueueStatus(queueId: string): Promise<{ queueId: string; size: number; maxSize: number; messages: Message[] } | null> {
try {
const queue = this.messageQueues.get(queueId);
if (!queue) {
return null;
}
// 获取队列中的消息
const queueMessages: Message[] = [];
for (const messageId of queue.messages) {
const message = this.messages.get(messageId);
if (message) {
queueMessages.push(message);
}
}
return {
queueId,
size: queue.messages.length,
maxSize: queue.maxSize,
messages: queueMessages
};
} catch (error) {
logger.error(`Error getting queue status: ${error}`);
return null;
}
}
/**
* 列出所有队列
* @returns 队列列表
*/
static async listQueues(): Promise<MessageQueue[]> {
try {
return Array.from(this.messageQueues.values());
} catch (error) {
logger.error(`Error listing queues: ${error}`);
return [];
}
}
/**
* 删除队列
* @param queueId 队列ID
* @returns 删除结果
*/
static async deleteQueue(queueId: string): Promise<{ success: boolean; message: string }> {
try {
const queue = this.messageQueues.get(queueId);
if (!queue) {
return { success: false, message: 'Message queue not found' };
}
// 删除队列中的消息
for (const messageId of queue.messages) {
this.messages.delete(messageId);
this.messageStatus.delete(messageId);
}
// 删除队列
this.messageQueues.delete(queueId);
logger.info(`Message queue ${queueId} deleted successfully`);
return { success: true, message: 'Message queue deleted successfully' };
} catch (error) {
logger.error(`Error deleting queue: ${error}`);
return { success: false, message: `Error deleting queue: ${error}` };
}
}
/**
* 清空队列
* @param queueId 队列ID
* @returns 清空结果
*/
static async clearQueue(queueId: string): Promise<{ success: boolean; clearedCount: number; message: string }> {
try {
const queue = this.messageQueues.get(queueId);
if (!queue) {
return { success: false, clearedCount: 0, message: 'Message queue not found' };
}
const clearedCount = queue.messages.length;
// 删除队列中的消息
for (const messageId of queue.messages) {
this.messages.delete(messageId);
this.messageStatus.delete(messageId);
}
// 清空队列
queue.messages = [];
this.messageQueues.set(queueId, queue);
logger.info(`Message queue ${queueId} cleared, removed ${clearedCount} messages`);
return { success: true, clearedCount, message: 'Message queue cleared successfully' };
} catch (error) {
logger.error(`Error clearing queue: ${error}`);
return { success: false, clearedCount: 0, message: `Error clearing queue: ${error}` };
}
}
}