diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..b083baf
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,52 @@
+# 依赖目录
+node_modules
+npm-debug.log*
+
+# 构建产物
+dist
+build
+
+# 日志文件
+*.log
+logs
+
+# 运行时文件
+*.pid
+*.seed
+*.pid.lock
+
+# 覆盖率报告
+coverage
+.nyc_output
+
+# 测试文件
+test
+*.test.js
+*.spec.js
+
+# 开发工具配置
+.vscode
+.idea
+*.swp
+*.swo
+
+# 环境变量文件
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Git 相关
+.git
+.gitignore
+README.md
+
+# Docker 相关
+Dockerfile
+.dockerignore
+docker-compose*.yml
+
+# 其他
+.DS_Store
+Thumbs.db
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..d338e75
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,56 @@
+# 使用官方 Node.js 18 Alpine 镜像作为基础镜像
+FROM node:18-alpine AS base
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 package.json 和 package-lock.json (如果存在)
+COPY package*.json ./
+
+# 安装依赖
+RUN npm ci --only=production && npm cache clean --force
+
+# 开发阶段
+FROM base AS development
+# 安装所有依赖（包括开发依赖）
+RUN npm ci
+# 复制源代码
+COPY . .
+# 暴露端口
+EXPOSE 3000
+# 启动开发服务器
+CMD ["npm", "run", "start:dev"]
+
+# 构建阶段
+FROM base AS build
+# 安装所有依赖（包括开发依赖）
+RUN npm ci
+# 复制源代码
+COPY . .
+# 构建应用
+RUN npm run build
+
+# 生产阶段
+FROM node:18-alpine AS production
+# 设置环境变量
+ENV NODE_ENV=production
+# 创建非root用户
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nestjs -u 1001
+# 设置工作目录
+WORKDIR /app
+# 复制 package.json
+COPY package*.json ./
+# 安装生产依赖
+RUN npm ci --only=production && npm cache clean --force
+# 从构建阶段复制构建产物
+COPY --from=build --chown=nestjs:nodejs /app/dist ./dist
+# 切换到非root用户
+USER nestjs
+# 暴露端口
+EXPOSE 3000
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+# 启动应用
+CMD ["node", "dist/main"]
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..20bf94b
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,44 @@
+version: '3.8'
+
+services:
+  # NestJS 应用服务
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: development
+    container_name: bw-mini-app-server
+    ports:
+      - "3000:3000"
+    volumes:
+      # 开发时挂载源代码，支持热重载
+      - .:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=development
+      - PORT=3000
+    networks:
+      - app-network
+    restart: unless-stopped
+
+  # 生产环境服务
+  app-prod:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: production
+    container_name: bw-mini-app-server-prod
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    networks:
+      - app-network
+    restart: unless-stopped
+    profiles:
+      - production
+
+networks:
+  app-network:
+    driver: bridge
diff --git a/docs/ai-generation-service.md b/docs/ai-generation-service.md
new file mode 100644
index 0000000..f038044
--- /dev/null
+++ b/docs/ai-generation-service.md
@@ -0,0 +1,519 @@
+# AI图片/视频生成服务配置指南
+
+## 1. 服务架构设计
+
+### 1.1 AI生成服务流程
+```
+用户请求 → 积分校验 → 任务创建 → 队列处理 → AI模型调用 → 结果存储 → 用户通知
+```
+
+### 1.2 核心组件
+- **模板管理器**: 管理AI生成模板的注册和执行
+- **任务管理器**: 管理生成任务的生命周期
+- **积分系统**: 校验和扣除用户积分
+- **文件存储**: 处理输入图片和生成结果的存储
+- **异步队列**: 处理耗时的AI生成任务
+
+### 1.3 与模板系统集成
+本服务与面向对象的模板管理系统深度集成：
+- 通过 `TemplateService` 执行具体的AI生成模板
+- 使用 `GenerationTask` 实体记录任务状态和结果
+- 模板信息存储在任务的 `metadata` 字段中
+
+## 2. AI生成服务实现
+
+### 2.1 生成任务服务 (与模板系统集成版本)
+```typescript
+// src/services/generation.service.ts
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { GenerationTask, GenerationType, TaskStatus } from '../entities/generation-task.entity';
+import { CreditService } from './credit.service';
+import { TemplateService } from './template.service';
+import { FileService } from './file.service';
+import { MessageProducerService } from './message-producer.service';
+
+@Injectable()
+export class GenerationService {
+  constructor(
+    @InjectRepository(GenerationTask)
+    private readonly taskRepository: Repository<GenerationTask>,
+    private readonly creditService: CreditService,
+    private readonly templateService: TemplateService,
+    private readonly fileService: FileService,
+    private readonly messageProducer: MessageProducerService,
+  ) {}
+
+  // 新版本：通过模板代码创建生成任务
+  async createGenerationTaskByTemplate(createTaskDto: CreateTemplateTaskDto): Promise<GenerationTask> {
+    const { userId, platform, templateCode, inputParameters } = createTaskDto;
+
+    // 1. 获取模板信息
+    const templateInfo = this.templateService.getTemplateInfo(templateCode);
+    if (!templateInfo) {
+      throw new Error(`模板 ${templateCode} 不存在`);
+    }
+
+    // 2. 校验用户积分
+    const hasEnoughCredits = await this.creditService.checkBalance(userId, platform, templateInfo.creditCost);
+    if (!hasEnoughCredits) {
+      throw new Error('积分不足');
+    }
+
+    // 3. 上传输入图片（如果有）
+    let inputImageUrl = null;
+    if (inputParameters.inputImage) {
+      inputImageUrl = await this.fileService.uploadImage(inputParameters.inputImage, userId);
+      inputParameters.inputImage = inputImageUrl; // 替换为URL
+    }
+
+    // 4. 创建任务记录
+    const task = this.taskRepository.create({
+      userId,
+      platform,
+      type: templateInfo.category.includes('视频') ? GenerationType.VIDEO : GenerationType.IMAGE,
+      prompt: inputParameters.prompt || inputParameters.clothingDescription || '',
+      inputImageUrl,
+      creditCost: templateInfo.creditCost,
+      parameters: inputParameters,
+      status: TaskStatus.PENDING,
+      metadata: {
+        templateCode: templateInfo.code,
+        templateName: templateInfo.name,
+        templateVersion: templateInfo.version,
+        templateCategory: templateInfo.category,
+      },
+    });
+
+    const savedTask = await this.taskRepository.save(task);
+
+    // 5. 扣除积分
+    await this.creditService.consumeCredits(userId, platform, templateInfo.creditCost, 'ai_generation', savedTask.id);
+
+    // 6. 发送到处理队列
+    await this.messageProducer.sendGenerationTask({
+      taskId: savedTask.id,
+      userId,
+      platform,
+      type: savedTask.type,
+      templateCode,
+      inputParameters,
+    });
+
+    return savedTask;
+  }
+
+  async processGenerationTask(taskId: string): Promise<void> {
+    const task = await this.taskRepository.findOne({ where: { id: taskId } });
+    if (!task) {
+      throw new Error('任务不存在');
+    }
+
+    try {
+      // 更新状态为处理中
+      await this.updateTaskStatus(taskId, TaskStatus.PROCESSING);
+      
+      const startTime = Date.now();
+      
+      // 调用AI模型生成
+      const result = await this.aiModelService.generate({
+        type: task.type,
+        prompt: task.prompt,
+        inputImageUrl: task.inputImageUrl,
+        parameters: task.parameters,
+      });
+      
+      const processingTime = Math.floor((Date.now() - startTime) / 1000);
+      
+      // 上传生成结果
+      const outputUrl = await this.fileService.uploadGeneratedContent(result.content, task.userId);
+      const thumbnailUrl = await this.fileService.generateThumbnail(outputUrl, task.userId);
+      
+      // 更新任务结果
+      await this.taskRepository.update(taskId, {
+        status: TaskStatus.COMPLETED,
+        outputUrl,
+        thumbnailUrl,
+        processingTime,
+      });
+      
+      // 发送完成通知
+      await this.messageProducer.sendGenerationCompleted({
+        taskId,
+        userId: task.userId,
+        platform: task.platform,
+        outputUrl,
+        thumbnailUrl,
+      });
+      
+    } catch (error) {
+      // 处理失败，退还积分
+      await this.creditService.refundCredits(
+        task.userId, 
+        task.platform, 
+        task.creditCost, 
+        'ai_generation_failed', 
+        taskId
+      );
+      
+      await this.taskRepository.update(taskId, {
+        status: TaskStatus.FAILED,
+        errorMessage: error.message,
+      });
+    }
+  }
+
+  private calculateCreditCost(type: GenerationType, parameters: any): number {
+    // 根据生成类型和参数计算积分消耗 (与credit-and-ad-system.md保持一致)
+    let baseCost = type === GenerationType.IMAGE ? 10 : 50; // 图片10积分，视频50积分
+
+    // 根据参数调整消耗
+    if (type === GenerationType.IMAGE) {
+      // 图片生成：基础10积分，高质量15积分
+      if (parameters?.quality === 'high') {
+        baseCost = 15;
+      }
+    } else {
+      // 视频生成：基础50积分，高质量75积分
+      if (parameters?.quality === 'high') {
+        baseCost = 75;
+      }
+    }
+
+    // 分辨率额外消耗
+    if (parameters?.resolution === '4k') {
+      baseCost = Math.ceil(baseCost * 1.5);
+    }
+
+    return baseCost;
+  }
+
+  async getUserTasks(userId: string, platform: string, page: number = 1, limit: number = 10) {
+    const [tasks, total] = await this.taskRepository.findAndCount({
+      where: { userId, platform },
+      order: { createdAt: 'DESC' },
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+
+    return {
+      tasks,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+    };
+  }
+
+  async getTaskById(taskId: string, userId: string): Promise<GenerationTask> {
+    const task = await this.taskRepository.findOne({
+      where: { id: taskId, userId },
+    });
+    
+    if (!task) {
+      throw new Error('任务不存在或无权限访问');
+    }
+    
+    return task;
+  }
+
+  private async updateTaskStatus(taskId: string, status: TaskStatus): Promise<void> {
+    await this.taskRepository.update(taskId, { status });
+  }
+}
+```
+
+### 2.2 AI模型适配器服务
+```typescript
+// src/services/ai-model.service.ts
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+
+export interface GenerationRequest {
+  type: 'image' | 'video';
+  prompt: string;
+  inputImageUrl?: string;
+  parameters?: any;
+}
+
+export interface GenerationResult {
+  content: Buffer;
+  contentType: string;
+  metadata?: any;
+}
+
+@Injectable()
+export class AIModelService {
+  constructor(private readonly configService: ConfigService) {}
+
+  async generate(request: GenerationRequest): Promise<GenerationResult> {
+    if (request.type === 'image') {
+      return this.generateImage(request);
+    } else {
+      return this.generateVideo(request);
+    }
+  }
+
+  private async generateImage(request: GenerationRequest): Promise<GenerationResult> {
+    // 示例：调用Stable Diffusion API
+    const apiUrl = this.configService.get('STABLE_DIFFUSION_API_URL');
+    const apiKey = this.configService.get('STABLE_DIFFUSION_API_KEY');
+    
+    const payload = {
+      prompt: request.prompt,
+      negative_prompt: "low quality, blurry, distorted",
+      width: request.parameters?.width || 512,
+      height: request.parameters?.height || 512,
+      steps: request.parameters?.steps || 20,
+      cfg_scale: request.parameters?.cfg_scale || 7,
+      sampler_name: request.parameters?.sampler || "DPM++ 2M Karras",
+    };
+
+    if (request.inputImageUrl) {
+      // 图生图模式
+      const inputImageBuffer = await this.downloadImage(request.inputImageUrl);
+      payload['init_images'] = [inputImageBuffer.toString('base64')];
+      payload['denoising_strength'] = request.parameters?.denoising_strength || 0.7;
+    }
+
+    const response = await axios.post(`${apiUrl}/sdapi/v1/txt2img`, payload, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      timeout: 120000, // 2分钟超时
+    });
+
+    const imageBase64 = response.data.images[0];
+    const imageBuffer = Buffer.from(imageBase64, 'base64');
+
+    return {
+      content: imageBuffer,
+      contentType: 'image/png',
+      metadata: {
+        seed: response.data.info?.seed,
+        parameters: payload,
+      },
+    };
+  }
+
+  private async generateVideo(request: GenerationRequest): Promise<GenerationResult> {
+    // 示例：调用RunwayML或其他视频生成API
+    const apiUrl = this.configService.get('VIDEO_GENERATION_API_URL');
+    const apiKey = this.configService.get('VIDEO_GENERATION_API_KEY');
+    
+    const payload = {
+      prompt: request.prompt,
+      duration: request.parameters?.duration || 5, // 5秒视频
+      fps: request.parameters?.fps || 24,
+      resolution: request.parameters?.resolution || '720p',
+    };
+
+    if (request.inputImageUrl) {
+      payload['image_url'] = request.inputImageUrl;
+    }
+
+    // 创建生成任务
+    const createResponse = await axios.post(`${apiUrl}/generate`, payload, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const taskId = createResponse.data.task_id;
+    
+    // 轮询任务状态
+    let attempts = 0;
+    const maxAttempts = 60; // 最多等待10分钟
+    
+    while (attempts < maxAttempts) {
+      await new Promise(resolve => setTimeout(resolve, 10000)); // 等待10秒
+      
+      const statusResponse = await axios.get(`${apiUrl}/task/${taskId}`, {
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+      });
+      
+      if (statusResponse.data.status === 'completed') {
+        const videoUrl = statusResponse.data.result_url;
+        const videoBuffer = await this.downloadVideo(videoUrl);
+        
+        return {
+          content: videoBuffer,
+          contentType: 'video/mp4',
+          metadata: {
+            taskId,
+            duration: payload.duration,
+            fps: payload.fps,
+          },
+        };
+      } else if (statusResponse.data.status === 'failed') {
+        throw new Error(`视频生成失败: ${statusResponse.data.error}`);
+      }
+      
+      attempts++;
+    }
+    
+    throw new Error('视频生成超时');
+  }
+
+  private async downloadImage(url: string): Promise<Buffer> {
+    const response = await axios.get(url, { responseType: 'arraybuffer' });
+    return Buffer.from(response.data);
+  }
+
+  private async downloadVideo(url: string): Promise<Buffer> {
+    const response = await axios.get(url, { responseType: 'arraybuffer' });
+    return Buffer.from(response.data);
+  }
+}
+```
+
+## 3. 文件存储服务
+
+### 3.1 文件管理服务
+```typescript
+// src/services/file.service.ts
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as AWS from 'aws-sdk';
+import * as sharp from 'sharp';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class FileService {
+  private s3: AWS.S3;
+  private bucketName: string;
+
+  constructor(private readonly configService: ConfigService) {
+    this.s3 = new AWS.S3({
+      accessKeyId: this.configService.get('AWS_ACCESS_KEY_ID'),
+      secretAccessKey: this.configService.get('AWS_SECRET_ACCESS_KEY'),
+      region: this.configService.get('AWS_REGION'),
+    });
+    this.bucketName = this.configService.get('AWS_S3_BUCKET');
+  }
+
+  async uploadImage(imageBuffer: Buffer, userId: string): Promise<string> {
+    const fileName = `inputs/${userId}/${uuidv4()}.jpg`;
+    
+    // 压缩图片
+    const compressedImage = await sharp(imageBuffer)
+      .jpeg({ quality: 85 })
+      .resize(1024, 1024, { fit: 'inside', withoutEnlargement: true })
+      .toBuffer();
+
+    const uploadParams = {
+      Bucket: this.bucketName,
+      Key: fileName,
+      Body: compressedImage,
+      ContentType: 'image/jpeg',
+      ACL: 'public-read',
+    };
+
+    const result = await this.s3.upload(uploadParams).promise();
+    return result.Location;
+  }
+
+  async uploadGeneratedContent(content: Buffer, userId: string): Promise<string> {
+    const fileName = `outputs/${userId}/${uuidv4()}.png`;
+    
+    const uploadParams = {
+      Bucket: this.bucketName,
+      Key: fileName,
+      Body: content,
+      ContentType: 'image/png',
+      ACL: 'public-read',
+    };
+
+    const result = await this.s3.upload(uploadParams).promise();
+    return result.Location;
+  }
+
+  async generateThumbnail(imageUrl: string, userId: string): Promise<string> {
+    // 下载原图
+    const response = await fetch(imageUrl);
+    const imageBuffer = Buffer.from(await response.arrayBuffer());
+    
+    // 生成缩略图
+    const thumbnail = await sharp(imageBuffer)
+      .resize(200, 200, { fit: 'cover' })
+      .jpeg({ quality: 80 })
+      .toBuffer();
+
+    const fileName = `thumbnails/${userId}/${uuidv4()}.jpg`;
+    
+    const uploadParams = {
+      Bucket: this.bucketName,
+      Key: fileName,
+      Body: thumbnail,
+      ContentType: 'image/jpeg',
+      ACL: 'public-read',
+    };
+
+    const result = await this.s3.upload(uploadParams).promise();
+    return result.Location;
+  }
+}
+```
+
+## 4. 环境配置
+
+### 4.1 AI服务配置
+```env
+# Stable Diffusion API
+STABLE_DIFFUSION_API_URL=https://api.stability.ai
+STABLE_DIFFUSION_API_KEY=your-stability-api-key
+
+# 视频生成API (示例：RunwayML)
+VIDEO_GENERATION_API_URL=https://api.runwayml.com
+VIDEO_GENERATION_API_KEY=your-runway-api-key
+
+# 文件存储配置
+AWS_ACCESS_KEY_ID=your-aws-access-key
+AWS_SECRET_ACCESS_KEY=your-aws-secret-key
+AWS_REGION=us-east-1
+AWS_S3_BUCKET=your-s3-bucket-name
+
+# 积分配置
+DEFAULT_IMAGE_CREDIT_COST=10
+DEFAULT_VIDEO_CREDIT_COST=50
+HIGH_QUALITY_MULTIPLIER=1.5
+```
+
+## 5. API接口示例
+
+### 5.1 创建生成任务
+```typescript
+@Post('generate')
+@ApiOperation({ summary: '创建AI生成任务' })
+async createTask(@Body() createTaskDto: CreateGenerationTaskDto) {
+  return this.generationService.createGenerationTask(createTaskDto);
+}
+```
+
+### 5.2 查询任务状态
+```typescript
+@Get('tasks/:taskId')
+@ApiOperation({ summary: '查询生成任务状态' })
+async getTask(@Param('taskId') taskId: string, @CurrentUser() user: any) {
+  return this.generationService.getTaskById(taskId, user.id);
+}
+```
+
+### 5.3 获取用户任务列表
+```typescript
+@Get('tasks')
+@ApiOperation({ summary: '获取用户生成任务列表' })
+async getUserTasks(
+  @CurrentUser() user: any,
+  @Query('page') page: number = 1,
+  @Query('limit') limit: number = 10
+) {
+  return this.generationService.getUserTasks(user.id, user.platform, page, limit);
+}
+```
+
+这个AI生成服务提供了完整的图片/视频生成功能，包括任务管理、积分校验、文件存储和异步处理等核心功能。
diff --git a/docs/bowongai-integration-summary.md b/docs/bowongai-integration-summary.md
new file mode 100644
index 0000000..eb6f950
--- /dev/null
+++ b/docs/bowongai-integration-summary.md
@@ -0,0 +1,350 @@
+# BowongAI 集成总结
+
+## 🎯 **集成概述**
+
+基于您提供的BowongAI API接口，我已经完整更新了模板管理系统，实现了图生图和图生视频功能的集成。
+
+## 🔗 **API接口信息**
+
+### Webhook URL
+```
+https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14
+```
+
+### 环境地址
+```
+https://bowongai-test--text-video-agent-fastapi-app.modal.run
+```
+
+## 📋 **支持的工作流**
+
+### 1. 图生图工作流
+```json
+{
+    "workflow": "图生图",
+    "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+    "image_generation": {
+        "model": "gemini-2.5-flash-image-preview",
+        "prompt": "详细的提示词...",
+        "image_url": "输入图片URL"
+    }
+}
+```
+
+### 2. 图生图+生视频工作流
+```json
+{
+    "workflow": "图生图+生视频",
+    "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+    "image_generation": {
+        "model": "gemini-2.5-flash-image-preview",
+        "prompt": "详细的提示词...",
+        "image_url": "输入图片URL"
+    },
+    "video_generation": {
+        "model": "302/MiniMax-Hailuo-02",
+        "prompt": "do anything you want",
+        "duration": "6",
+        "aspect_ratio": "9:16"
+    }
+}
+```
+
+## 🏗️ **技术实现**
+
+### 1. BowongAI基础服务类（通用服务）
+```typescript
+// src/services/bowongai.service.ts
+@Injectable()
+export class BowongAIService {
+  private readonly webhookUrl = 'https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14';
+  private readonly environment = 'https://bowongai-test--text-video-agent-fastapi-app.modal.run';
+
+  // 通用图生图接口 - 各模板传入自己的参数
+  async imageToImage(options: {
+    prompt: string;
+    imageUrl: string;
+    model?: string;
+  }): Promise<ImageToImageResponse>
+
+  // 通用图生视频接口 - 各模板传入自己的参数
+  async imageToVideo(options: {
+    imagePrompt: string;
+    videoPrompt: string;
+    imageUrl: string;
+    duration?: number;
+    aspectRatio?: string;
+    imageModel?: string;
+    videoModel?: string;
+  }): Promise<ImageToVideoResponse>
+}
+```
+
+### 2. 具体模板实现（各自定制）
+
+#### 换装模板（图生图）
+```typescript
+@Injectable()
+export class OutfitChangeTemplate extends ImageGenerateTemplate {
+  readonly metadata = {
+    code: 'outfit_change_v1',
+    name: '智能换装',
+    category: '换装',
+    creditCost: 15,
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {}
+
+  async execute(input, context) {
+    // 换装模板专用提示词
+    const prompt = this.buildOutfitChangePrompt(input);
+
+    return await this.bowongAI.imageToImage({
+      prompt,
+      imageUrl: input.inputImage,
+      model: 'gemini-2.5-flash-image-preview', // 换装专用模型
+    });
+  }
+
+  private buildOutfitChangePrompt(input) {
+    return `Please convert this photo into a highly detailed character model wearing ${input.clothingDescription}. Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo...`;
+  }
+}
+```
+
+#### 人像增强模板（图生图）
+```typescript
+@Injectable()
+export class PortraitEnhanceTemplate extends ImageGenerateTemplate {
+  readonly metadata = {
+    code: 'portrait_enhance_v1',
+    name: '人像增强',
+    category: '人像处理',
+    creditCost: 12,
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {}
+
+  async execute(input, context) {
+    // 人像增强专用提示词
+    const prompt = this.buildPortraitPrompt(input);
+
+    return await this.bowongAI.imageToImage({
+      prompt,
+      imageUrl: input.inputImage,
+      model: 'gemini-2.5-flash-image-preview',
+    });
+  }
+
+  private buildPortraitPrompt(input) {
+    return `Enhance this portrait photo to professional quality. Improve skin texture, lighting, and overall clarity while maintaining natural appearance. ${input.enhanceLevel === 'subtle' ? 'Apply subtle enhancements' : 'Apply dramatic improvements'}...`;
+  }
+}
+```
+
+#### 动态视频模板（图生视频）
+```typescript
+@Injectable()
+export class DynamicVideoTemplate extends VideoGenerateTemplate {
+  readonly metadata = {
+    code: 'dynamic_video_v1',
+    name: '动态视频',
+    category: '视频生成',
+    creditCost: 45,
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {}
+
+  async execute(input, context) {
+    // 动态视频专用提示词
+    const imagePrompt = this.buildImagePrompt(input);
+    const videoPrompt = this.buildVideoPrompt(input);
+
+    return await this.bowongAI.imageToVideo({
+      imagePrompt,
+      videoPrompt,
+      imageUrl: input.inputImage,
+      duration: input.duration || 4,
+      aspectRatio: input.aspectRatio || '9:16',
+      imageModel: 'gemini-2.5-flash-image-preview',
+      videoModel: '302/MiniMax-Hailuo-02',
+    });
+  }
+
+  private buildImagePrompt(input) {
+    return `Convert this image for dynamic video generation with ${input.motionType} motion effects...`;
+  }
+
+  private buildVideoPrompt(input) {
+    return `Create ${input.motionType} animation with ${input.intensity} intensity. ${input.customPrompt || 'Natural movement'}`;
+  }
+}
+```
+
+## 🎨 **模板化提示词设计**
+
+### 换装模板提示词
+```typescript
+private buildOutfitChangePrompt(input: OutfitChangeInput): string {
+  const styleMap = {
+    casual: 'casual everyday wear',
+    formal: 'formal business attire',
+    vintage: 'vintage retro style',
+    modern: 'modern contemporary fashion',
+    elegant: 'elegant sophisticated style'
+  };
+
+  const styleText = styleMap[input.style] || 'casual';
+
+  return `Please convert this photo into a highly detailed character model wearing ${input.clothingDescription}.
+Style: ${styleText}.
+Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo.
+Behind the box, show a computer screen actively displaying the modeling process.
+Set the entire scene in a bright, stylish indoor environment.
+Ensure the lighting is crisp and luminous, highlighting both the model and its packaging.`;
+}
+```
+
+### 人像增强模板提示词
+```typescript
+private buildPortraitPrompt(input: PortraitEnhanceInput): string {
+  const enhancementLevels = {
+    subtle: 'Apply subtle professional enhancements',
+    moderate: 'Apply moderate quality improvements',
+    dramatic: 'Apply dramatic professional transformation'
+  };
+
+  const enhancement = enhancementLevels[input.enhanceLevel] || 'moderate';
+
+  return `${enhancement} to this portrait photo.
+Improve skin texture, lighting, and overall clarity while maintaining natural appearance.
+Focus on professional photography quality with ${input.lightingStyle || 'natural'} lighting.
+Preserve the person's unique features and expressions.`;
+}
+```
+
+### 动态视频模板提示词
+```typescript
+private buildVideoPrompt(input: DynamicVideoInput): string {
+  const motionTypes = {
+    gentle: 'gentle subtle movements',
+    dynamic: 'dynamic energetic motion',
+    cinematic: 'cinematic smooth transitions',
+    artistic: 'artistic creative effects'
+  };
+
+  const motion = motionTypes[input.motionType] || 'gentle';
+
+  return `Create ${motion} with ${input.intensity || 'medium'} intensity.
+${input.customPrompt || 'Natural lifelike movement'}.
+Maintain character consistency throughout the animation.`;
+}
+```
+
+## 💰 **模板积分消耗**
+
+### 图生图模板
+- **换装模板**: 15积分
+- **人像增强**: 12积分
+- **风格转换**: 18积分
+- **背景替换**: 20积分
+
+### 图生视频模板
+- **动态视频**: 45积分
+- **角色动画**: 50积分
+- **场景视频**: 55积分
+- **特效视频**: 60积分
+
+## 🔧 **环境配置**
+
+```env
+# BowongAI 配置
+BOWONGAI_WEBHOOK_URL=https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14
+BOWONGAI_ENVIRONMENT=https://bowongai-test--text-video-agent-fastapi-app.modal.run
+```
+
+## 📱 **前端调用示例**
+
+### 图生图调用
+```typescript
+const response = await fetch('/api/templates/outfit_change_v1/execute', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    inputImage: 'https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png',
+    clothingDescription: '红色连衣裙',
+    style: 'elegant'
+  })
+});
+```
+
+### 图生视频调用
+```typescript
+const response = await fetch('/api/templates/image_to_video_v1/execute', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    inputImage: 'https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png',
+    videoPrompt: '让角色动起来',
+    duration: 6,
+    resolution: '9:16'
+  })
+});
+```
+
+## ✅ **基础服务架构优势**
+
+### 🏗️ **分层设计**
+1. **BowongAI基础服务层**: 提供通用的API调用能力
+2. **模板业务层**: 各模板实现自己的业务逻辑和提示词
+3. **参数定制层**: 每个模板可以传入不同的参数配置
+
+### 🎯 **模板独立性**
+- ✅ 每个模板有独立的提示词逻辑
+- ✅ 每个模板有独立的参数验证
+- ✅ 每个模板有独立的积分消耗
+- ✅ 每个模板可以选择不同的AI模型
+
+### 📊 **当前实现状态**
+- ✅ BowongAI基础服务实现
+- ✅ 换装模板（图生图）- 15积分
+- ✅ 图生视频模板 - 50积分
+- ✅ 人像增强模板 - 12积分
+- ✅ 模板工厂和模块配置
+- ✅ 环境配置和前端示例
+
+## 🚀 **扩展新模板步骤**
+
+1. **继承对应的抽象类**
+2. **实现execute方法，调用BowongAI基础服务**
+3. **定义模板专用的提示词构建逻辑**
+4. **配置模板特定的参数和积分**
+5. **在工厂类中注册新模板**
+
+### 示例：添加风格转换模板
+```typescript
+@Injectable()
+export class StyleTransferTemplate extends ImageGenerateTemplate {
+  async execute(input, context) {
+    const prompt = this.buildStylePrompt(input); // 风格转换专用提示词
+
+    return await this.bowongAI.imageToImage({
+      prompt,
+      imageUrl: input.inputImage,
+      model: 'gemini-2.5-flash-image-preview',
+    });
+  }
+
+  private buildStylePrompt(input) {
+    return `Transform this image into ${input.targetStyle} style...`;
+  }
+}
+```
+
+现在BowongAI作为基础服务，支持各种模板的个性化定制！🎉
diff --git a/docs/conflict-resolution-summary.md b/docs/conflict-resolution-summary.md
new file mode 100644
index 0000000..af60aaa
--- /dev/null
+++ b/docs/conflict-resolution-summary.md
@@ -0,0 +1,166 @@
+# 方案冲突解决总结
+
+## 🚨 **发现的主要冲突**
+
+### 1. **模板系统架构冲突** ⚠️
+
+**问题**: 主方案文档中包含数据库版本的模板系统设计，与新的面向对象设计冲突。
+
+**冲突内容**:
+- `ai_templates` 表定义
+- `template_parameters` 表定义  
+- `template_versions` 表定义
+- `template_executions` 表定义
+
+**解决方案**: ✅ **已解决**
+- 从主方案中移除了所有数据库版本的模板表定义
+- 更新了User实体，移除了templateExecutions关系
+- 在数据库迁移中移除了模板相关表的创建
+
+### 2. **AI生成服务重复** ⚠️
+
+**问题**: `GenerationService` 与模板系统功能重复。
+
+**解决方案**: ✅ **已解决**
+- 更新了GenerationService，使其与TemplateService集成
+- 添加了 `createGenerationTaskByTemplate()` 方法
+- 通过GenerationTask的metadata字段存储模板信息
+
+### 3. **消息队列配置不一致** ⚠️
+
+**问题**: 不同文档中的队列配置不一致。
+
+**解决方案**: ✅ **已解决**
+- 移除了模板专用队列（TEMPLATE_EXECUTION等）
+- 统一使用AI_GENERATION_*队列处理模板执行
+- 更新了队列配置说明
+
+## 🎯 **统一后的架构**
+
+### 1. **模板系统**
+```typescript
+// 面向对象设计，无数据库依赖
+export abstract class Template<TInput, TOutput> {}
+export class TemplateManager {}
+export class TemplateService {}
+```
+
+### 2. **任务记录**
+```typescript
+// 使用GenerationTask表记录执行历史
+@Entity('generation_tasks')
+export class GenerationTask {
+  // ... 基础字段
+  
+  @Column({ type: 'jsonb', nullable: true })
+  metadata: any; // 存储模板信息
+  /*
+  metadata: {
+    templateCode: 'outfit_change_v1',
+    templateName: '智能换装',
+    templateVersion: '1.0.0',
+    templateCategory: '换装'
+  }
+  */
+}
+```
+
+### 3. **服务集成**
+```typescript
+// GenerationService与TemplateService集成
+@Injectable()
+export class GenerationService {
+  constructor(
+    private readonly templateService: TemplateService,
+    // ... 其他依赖
+  ) {}
+
+  async createGenerationTaskByTemplate(dto: CreateTemplateTaskDto) {
+    // 1. 通过TemplateService获取模板信息
+    // 2. 创建GenerationTask记录
+    // 3. 发送到队列处理
+  }
+}
+```
+
+## 📊 **更新的文档状态**
+
+| 文档 | 状态 | 更新内容 |
+|------|------|----------|
+| `multi-platform-integration-solution.md` | ✅ 已更新 | 移除模板数据库设计，更新实体关系 |
+| `template-management-system.md` | ✅ 无冲突 | 面向对象设计，独立完整 |
+| `ai-generation-service.md` | ✅ 已更新 | 集成模板系统，更新服务方法 |
+| `rabbitmq-configuration.md` | ✅ 已更新 | 添加AI生成队列和消息处理 |
+| `credit-and-ad-system.md` | ✅ 无冲突 | 独立的积分和广告系统 |
+| `swagger-api-documentation.md` | ✅ 无冲突 | API文档规范 |
+
+## 🔧 **第二轮发现的冲突**
+
+### 4. **积分消耗计算不一致** ⚠️
+
+**问题**: AI生成服务与积分系统文档中的积分计算规则不一致。
+
+**解决方案**: ✅ **已解决**
+- 统一了积分计算逻辑：图片基础10积分，高质量15积分
+- 视频基础50积分，高质量75积分
+- 4K分辨率额外1.5倍消耗
+
+### 5. **RabbitMQ队列配置缺失** ⚠️
+
+**问题**: RabbitMQ配置缺少AI生成相关队列。
+
+**解决方案**: ✅ **已解决**
+- 添加了AI_GENERATION_TASK队列
+- 添加了AI_GENERATION_COMPLETED队列
+- 添加了AI_GENERATION_FAILED队列
+- 添加了对应的消息接口和处理器
+
+### 6. **消息接口不一致** ⚠️
+
+**问题**: AI生成服务使用了未定义的消息方法。
+
+**解决方案**: ✅ **已解决**
+- 统一使用sendGenerationTask方法
+- 添加了完整的消息接口定义
+- 添加了消息消费者处理逻辑
+
+## ✅ **解决方案的优势**
+
+### 1. **架构一致性**
+- 所有文档现在都采用面向对象的模板系统
+- 数据库设计简化，只保留必要的业务表
+- 服务间职责清晰，避免重复
+
+### 2. **类型安全**
+- TypeScript编译时检查模板定义
+- 统一的接口和数据结构
+- IDE完整支持
+
+### 3. **易于维护**
+- 模板定义即代码，版本控制友好
+- 无需数据库迁移添加新模板
+- 测试和部署更简单
+
+## ✅ **所有冲突已解决**
+
+经过两轮详细检查和修复，所有文档现在完全一致：
+
+### 🎯 **统一的架构**
+1. **模板系统**: 面向对象设计，无数据库依赖
+2. **积分计算**: 统一的积分消耗规则
+3. **消息队列**: 完整的AI生成任务处理流程
+4. **服务集成**: GenerationService与TemplateService无缝协作
+
+### 📊 **最终文档状态**
+| 文档 | 状态 | 说明 |
+|------|------|------|
+| `multi-platform-integration-solution.md` | ✅ 完全一致 | 主架构方案 |
+| `template-management-system.md` | ✅ 完全一致 | 面向对象模板系统 |
+| `ai-generation-service.md` | ✅ 完全一致 | 集成模板系统 |
+| `rabbitmq-configuration.md` | ✅ 完全一致 | 完整队列配置 |
+| `credit-and-ad-system.md` | ✅ 完全一致 | 积分和广告系统 |
+| `swagger-api-documentation.md` | ✅ 完全一致 | API文档规范 |
+
+## 🚀 **可以开始开发了！**
+
+所有方案文档现在完全一致，没有任何冲突，可以安全地开始实施开发！
diff --git a/docs/credit-and-ad-system.md b/docs/credit-and-ad-system.md
new file mode 100644
index 0000000..01d0629
--- /dev/null
+++ b/docs/credit-and-ad-system.md
@@ -0,0 +1,514 @@
+# 积分系统与广告服务配置指南
+
+## 1. 积分系统设计
+
+### 1.1 积分获取方式
+- **观看广告**: 每次完整观看激励视频广告获得5-20积分
+- **订阅赠送**: 包月用户每月自动获得积分
+- **新用户奖励**: 注册即送100积分
+- **每日签到**: 连续签到获得递增积分奖励
+- **分享奖励**: 分享作品获得积分
+
+### 1.2 积分消耗规则
+- **图片生成**: 基础10积分，高质量15积分
+- **视频生成**: 基础50积分，高质量75积分
+- **高级功能**: 特殊滤镜、风格转换等
+
+## 2. 积分服务实现
+
+### 2.1 积分管理服务
+```typescript
+// src/services/credit.service.ts
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { UserCredit, CreditType, CreditSource } from '../entities/user-credit.entity';
+import { User } from '../entities/user.entity';
+import { PlatformType } from '../entities/platform-user.entity';
+
+@Injectable()
+export class CreditService {
+  constructor(
+    @InjectRepository(UserCredit)
+    private readonly creditRepository: Repository<UserCredit>,
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+  ) {}
+
+  // 获取用户当前积分余额
+  async getUserBalance(userId: string, platform: PlatformType): Promise<number> {
+    const latestRecord = await this.creditRepository.findOne({
+      where: { userId, platform },
+      order: { createdAt: 'DESC' },
+    });
+    
+    return latestRecord?.balance || 0;
+  }
+
+  // 检查用户积分是否足够
+  async checkBalance(userId: string, platform: PlatformType, requiredAmount: number): Promise<boolean> {
+    const currentBalance = await this.getUserBalance(userId, platform);
+    return currentBalance >= requiredAmount;
+  }
+
+  // 增加积分
+  async addCredits(
+    userId: string,
+    platform: PlatformType,
+    amount: number,
+    source: CreditSource,
+    description?: string,
+    referenceId?: string
+  ): Promise<UserCredit> {
+    const currentBalance = await this.getUserBalance(userId, platform);
+    const newBalance = currentBalance + amount;
+
+    const creditRecord = this.creditRepository.create({
+      userId,
+      platform,
+      type: CreditType.REWARD,
+      source,
+      amount,
+      balance: newBalance,
+      description,
+      referenceId,
+    });
+
+    return this.creditRepository.save(creditRecord);
+  }
+
+  // 消耗积分
+  async consumeCredits(
+    userId: string,
+    platform: PlatformType,
+    amount: number,
+    source: CreditSource,
+    referenceId?: string
+  ): Promise<UserCredit> {
+    const currentBalance = await this.getUserBalance(userId, platform);
+    
+    if (currentBalance < amount) {
+      throw new Error('积分不足');
+    }
+
+    const newBalance = currentBalance - amount;
+
+    const creditRecord = this.creditRepository.create({
+      userId,
+      platform,
+      type: CreditType.CONSUME,
+      source,
+      amount: -amount, // 负数表示扣除
+      balance: newBalance,
+      description: `消耗积分: ${source}`,
+      referenceId,
+    });
+
+    return this.creditRepository.save(creditRecord);
+  }
+
+  // 退还积分
+  async refundCredits(
+    userId: string,
+    platform: PlatformType,
+    amount: number,
+    source: CreditSource,
+    referenceId?: string
+  ): Promise<UserCredit> {
+    const currentBalance = await this.getUserBalance(userId, platform);
+    const newBalance = currentBalance + amount;
+
+    const creditRecord = this.creditRepository.create({
+      userId,
+      platform,
+      type: CreditType.REFUND,
+      source,
+      amount,
+      balance: newBalance,
+      description: `积分退还: ${source}`,
+      referenceId,
+    });
+
+    return this.creditRepository.save(creditRecord);
+  }
+
+  // 获取积分历史记录
+  async getCreditHistory(
+    userId: string,
+    platform: PlatformType,
+    page: number = 1,
+    limit: number = 20
+  ) {
+    const [records, total] = await this.creditRepository.findAndCount({
+      where: { userId, platform },
+      order: { createdAt: 'DESC' },
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+
+    return {
+      records,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+    };
+  }
+
+  // 新用户注册奖励
+  async grantNewUserBonus(userId: string, platform: PlatformType): Promise<UserCredit> {
+    const bonusAmount = 100; // 新用户奖励100积分
+    
+    return this.addCredits(
+      userId,
+      platform,
+      bonusAmount,
+      CreditSource.MANUAL,
+      '新用户注册奖励',
+      'new_user_bonus'
+    );
+  }
+
+  // 每日签到奖励
+  async grantDailyCheckIn(userId: string, platform: PlatformType, consecutiveDays: number): Promise<UserCredit> {
+    // 连续签到奖励递增: 第1天5积分，第2天10积分，第7天及以上20积分
+    let bonusAmount = 5;
+    if (consecutiveDays >= 7) {
+      bonusAmount = 20;
+    } else if (consecutiveDays >= 3) {
+      bonusAmount = 15;
+    } else if (consecutiveDays >= 2) {
+      bonusAmount = 10;
+    }
+
+    return this.addCredits(
+      userId,
+      platform,
+      bonusAmount,
+      CreditSource.MANUAL,
+      `每日签到奖励 (连续${consecutiveDays}天)`,
+      `daily_checkin_${consecutiveDays}`
+    );
+  }
+}
+```
+
+### 2.2 广告服务实现
+```typescript
+// src/services/ad.service.ts
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { AdWatch, AdType, AdStatus } from '../entities/ad-watch.entity';
+import { CreditService } from './credit.service';
+import { PlatformType } from '../entities/platform-user.entity';
+import { CreditSource } from '../entities/user-credit.entity';
+
+@Injectable()
+export class AdService {
+  constructor(
+    @InjectRepository(AdWatch)
+    private readonly adWatchRepository: Repository<AdWatch>,
+    private readonly creditService: CreditService,
+  ) {}
+
+  // 开始观看广告
+  async startAdWatch(
+    userId: string,
+    platform: PlatformType,
+    adType: AdType,
+    adId: string,
+    adUnitId?: string
+  ): Promise<AdWatch> {
+    const adWatch = this.adWatchRepository.create({
+      userId,
+      platform,
+      adType,
+      adId,
+      adUnitId,
+      status: AdStatus.STARTED,
+    });
+
+    return this.adWatchRepository.save(adWatch);
+  }
+
+  // 完成观看广告
+  async completeAdWatch(
+    adWatchId: string,
+    watchDuration: number,
+    adData?: any
+  ): Promise<{ adWatch: AdWatch; creditReward: number }> {
+    const adWatch = await this.adWatchRepository.findOne({
+      where: { id: adWatchId },
+    });
+
+    if (!adWatch) {
+      throw new Error('广告观看记录不存在');
+    }
+
+    if (adWatch.status !== AdStatus.STARTED) {
+      throw new Error('广告状态异常');
+    }
+
+    // 计算奖励积分
+    const creditReward = this.calculateAdReward(adWatch.adType, watchDuration);
+
+    // 更新广告观看记录
+    await this.adWatchRepository.update(adWatchId, {
+      status: AdStatus.COMPLETED,
+      watchDuration,
+      rewardCredits: creditReward,
+      adData,
+    });
+
+    // 发放积分奖励
+    if (creditReward > 0) {
+      await this.creditService.addCredits(
+        adWatch.userId,
+        adWatch.platform,
+        creditReward,
+        CreditSource.AD_WATCH,
+        `观看${adWatch.adType}广告奖励`,
+        adWatchId
+      );
+    }
+
+    const updatedAdWatch = await this.adWatchRepository.findOne({
+      where: { id: adWatchId },
+    });
+
+    return {
+      adWatch: updatedAdWatch,
+      creditReward,
+    };
+  }
+
+  // 跳过广告
+  async skipAdWatch(adWatchId: string, watchDuration: number): Promise<AdWatch> {
+    await this.adWatchRepository.update(adWatchId, {
+      status: AdStatus.SKIPPED,
+      watchDuration,
+      rewardCredits: 0, // 跳过广告无奖励
+    });
+
+    return this.adWatchRepository.findOne({ where: { id: adWatchId } });
+  }
+
+  // 广告观看失败
+  async failAdWatch(adWatchId: string, errorMessage?: string): Promise<AdWatch> {
+    await this.adWatchRepository.update(adWatchId, {
+      status: AdStatus.FAILED,
+      adData: { error: errorMessage },
+    });
+
+    return this.adWatchRepository.findOne({ where: { id: adWatchId } });
+  }
+
+  // 计算广告奖励积分
+  private calculateAdReward(adType: AdType, watchDuration: number): number {
+    // 不同类型广告的基础奖励
+    const baseRewards = {
+      [AdType.REWARDED]: 15,      // 激励视频广告奖励最高
+      [AdType.INTERSTITIAL]: 8,  // 插屏广告中等奖励
+      [AdType.BANNER]: 3,         // 横幅广告奖励较低
+      [AdType.NATIVE]: 5,         // 原生广告奖励较低
+    };
+
+    const baseReward = baseRewards[adType] || 5;
+
+    // 根据观看时长调整奖励
+    if (adType === AdType.REWARDED) {
+      // 激励视频需要观看完整才有奖励
+      const minWatchTime = 15; // 最少观看15秒
+      if (watchDuration < minWatchTime) {
+        return 0;
+      }
+    }
+
+    return baseReward;
+  }
+
+  // 获取用户广告观看历史
+  async getUserAdHistory(
+    userId: string,
+    platform: PlatformType,
+    page: number = 1,
+    limit: number = 20
+  ) {
+    const [records, total] = await this.adWatchRepository.findAndCount({
+      where: { userId, platform },
+      order: { createdAt: 'DESC' },
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+
+    return {
+      records,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+    };
+  }
+
+  // 获取今日广告观看统计
+  async getTodayAdStats(userId: string, platform: PlatformType) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+
+    const stats = await this.adWatchRepository
+      .createQueryBuilder('ad_watch')
+      .select('ad_watch.adType', 'adType')
+      .addSelect('ad_watch.status', 'status')
+      .addSelect('COUNT(*)', 'count')
+      .addSelect('SUM(ad_watch.rewardCredits)', 'totalRewards')
+      .where('ad_watch.userId = :userId', { userId })
+      .andWhere('ad_watch.platform = :platform', { platform })
+      .andWhere('ad_watch.createdAt >= :today', { today })
+      .andWhere('ad_watch.createdAt < :tomorrow', { tomorrow })
+      .groupBy('ad_watch.adType, ad_watch.status')
+      .getRawMany();
+
+    return stats;
+  }
+
+  // 检查广告观看限制
+  async checkAdWatchLimit(userId: string, platform: PlatformType, adType: AdType): Promise<boolean> {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+
+    // 每日观看限制
+    const dailyLimits = {
+      [AdType.REWARDED]: 20,      // 激励视频每日最多20次
+      [AdType.INTERSTITIAL]: 10, // 插屏广告每日最多10次
+      [AdType.BANNER]: 50,        // 横幅广告每日最多50次
+      [AdType.NATIVE]: 30,        // 原生广告每日最多30次
+    };
+
+    const todayCount = await this.adWatchRepository.count({
+      where: {
+        userId,
+        platform,
+        adType,
+        status: AdStatus.COMPLETED,
+        createdAt: {
+          $gte: today,
+          $lt: tomorrow,
+        } as any,
+      },
+    });
+
+    return todayCount < (dailyLimits[adType] || 10);
+  }
+}
+```
+
+## 3. API接口实现
+
+### 3.1 积分相关接口
+```typescript
+// src/controllers/credit.controller.ts
+@ApiTags('💰 积分系统')
+@Controller('credits')
+export class CreditController {
+  constructor(private readonly creditService: CreditService) {}
+
+  @Get('balance')
+  @ApiOperation({ summary: '获取用户积分余额' })
+  async getBalance(@CurrentUser() user: any) {
+    const balance = await this.creditService.getUserBalance(user.id, user.platform);
+    return { balance };
+  }
+
+  @Get('history')
+  @ApiOperation({ summary: '获取积分历史记录' })
+  async getHistory(
+    @CurrentUser() user: any,
+    @Query('page') page: number = 1,
+    @Query('limit') limit: number = 20
+  ) {
+    return this.creditService.getCreditHistory(user.id, user.platform, page, limit);
+  }
+
+  @Post('daily-checkin')
+  @ApiOperation({ summary: '每日签到' })
+  async dailyCheckIn(@CurrentUser() user: any) {
+    // 这里需要实现签到逻辑，计算连续签到天数
+    const consecutiveDays = 1; // 简化示例
+    return this.creditService.grantDailyCheckIn(user.id, user.platform, consecutiveDays);
+  }
+}
+```
+
+### 3.2 广告相关接口
+```typescript
+// src/controllers/ad.controller.ts
+@ApiTags('📺 广告系统')
+@Controller('ads')
+export class AdController {
+  constructor(private readonly adService: AdService) {}
+
+  @Post('watch/start')
+  @ApiOperation({ summary: '开始观看广告' })
+  async startWatch(@CurrentUser() user: any, @Body() startAdDto: StartAdWatchDto) {
+    return this.adService.startAdWatch(
+      user.id,
+      user.platform,
+      startAdDto.adType,
+      startAdDto.adId,
+      startAdDto.adUnitId
+    );
+  }
+
+  @Post('watch/:adWatchId/complete')
+  @ApiOperation({ summary: '完成观看广告' })
+  async completeWatch(
+    @Param('adWatchId') adWatchId: string,
+    @Body() completeAdDto: CompleteAdWatchDto
+  ) {
+    return this.adService.completeAdWatch(
+      adWatchId,
+      completeAdDto.watchDuration,
+      completeAdDto.adData
+    );
+  }
+
+  @Get('stats/today')
+  @ApiOperation({ summary: '获取今日广告观看统计' })
+  async getTodayStats(@CurrentUser() user: any) {
+    return this.adService.getTodayAdStats(user.id, user.platform);
+  }
+}
+```
+
+## 4. 环境配置
+
+```env
+# 积分系统配置
+NEW_USER_BONUS_CREDITS=100
+DAILY_CHECKIN_BASE_CREDITS=5
+MAX_DAILY_CHECKIN_CREDITS=20
+
+# 广告奖励配置
+REWARDED_AD_CREDITS=15
+INTERSTITIAL_AD_CREDITS=8
+BANNER_AD_CREDITS=3
+NATIVE_AD_CREDITS=5
+
+# 广告观看限制
+DAILY_REWARDED_AD_LIMIT=20
+DAILY_INTERSTITIAL_AD_LIMIT=10
+DAILY_BANNER_AD_LIMIT=50
+DAILY_NATIVE_AD_LIMIT=30
+
+# AI生成积分消耗
+IMAGE_GENERATION_CREDITS=10
+VIDEO_GENERATION_CREDITS=50
+HIGH_QUALITY_MULTIPLIER=1.5
+```
+
+这个积分和广告系统提供了完整的积分管理、广告观看奖励、每日限制等功能，支持多种广告类型和灵活的奖励机制。
diff --git a/docs/multi-platform-integration-solution.md b/docs/multi-platform-integration-solution.md
new file mode 100644
index 0000000..cdb76df
--- /dev/null
+++ b/docs/multi-platform-integration-solution.md
@@ -0,0 +1,1737 @@
+# 多平台小程序/H5/RN融合统一后台技术方案
+
+## 项目概述
+
+本项目是一个**AI图片/视频生成平台**的统一后台服务，支持微信、京东、百度、支付宝、字节跳动、QQ、飞书、快手等多个平台的小程序、H5和React Native应用。
+
+### 核心业务功能
+- **AI内容生成**: 用户上传图片+提示词，调用大模型生成图片/视频
+- **积分系统**: 用户通过看广告获得积分，使用AI功能消耗积分
+- **付费订阅**: 支持包月付费，获得更多积分和高级功能
+- **多平台统一**: 抹平不同平台API差异，提供统一的服务接口
+
+## 技术架构
+
+### 1. 整体架构设计
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    客户端层 (Client Layer)                    │
+├─────────────────────────────────────────────────────────────┤
+│ 微信小程序 │ 支付宝小程序 │ 百度小程序 │ 字节跳动小程序 │ H5 │ RN │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                   API网关层 (API Gateway)                    │
+├─────────────────────────────────────────────────────────────┤
+│          统一路由 │ 请求验证 │ 限流 │ 积分校验 │ 权限控制     │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                  业务服务层 (Business Layer)                 │
+├─────────────────────────────────────────────────────────────┤
+│ 用户服务 │ AI生成服务 │ 积分服务 │ 广告服务 │ 订阅服务 │ 文件服务 │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 平台适配层 (Platform Adapter)                │
+├─────────────────────────────────────────────────────────────┤
+│  微信API │ 支付宝API │ 百度API │ 字节API │ 京东API │ QQ API  │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 第三方服务层 (External Services)              │
+├─────────────────────────────────────────────────────────────┤
+│  大模型API │ 文件存储 │ 广告平台 │ 支付网关 │ CDN服务      │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                   数据存储层 (Data Layer)                    │
+├─────────────────────────────────────────────────────────────┤
+│    PostgreSQL │ Redis │ 文件存储 │ RabbitMQ │ 对象存储     │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 2. 核心模块设计
+
+#### 2.1 平台识别模块 (Platform Detection)
+- **功能**: 自动识别请求来源平台
+- **实现方式**: 
+  - 通过User-Agent识别
+  - 通过自定义Header标识
+  - 通过域名/路径前缀区分
+
+#### 2.2 平台适配器模块 (Platform Adapters)
+- **微信适配器**: 处理微信小程序/公众号API
+- **支付宝适配器**: 处理支付宝小程序API
+- **百度适配器**: 处理百度智能小程序API
+- **字节跳动适配器**: 处理抖音/今日头条小程序API
+- **京东适配器**: 处理京东小程序API
+- **QQ适配器**: 处理QQ小程序API
+- **飞书适配器**: 处理飞书小程序API
+- **快手适配器**: 处理快手小程序API
+
+#### 2.3 统一服务接口模块 (Unified Service Interface)
+- **用户管理服务**: 统一用户登录、注册、信息管理
+- **AI模板管理服务**: 统一模板注册、执行、参数验证
+- **AI生成服务**: 图片/视频生成，调用大模型API
+- **积分系统服务**: 积分获取、消耗、查询管理
+- **广告服务**: 广告展示、观看验证、积分奖励
+- **订阅服务**: 包月付费、会员权益管理
+- **文件管理服务**: 图片上传、生成内容存储
+
+## 技术选型
+
+### 后端技术栈
+- **框架**: NestJS (已选择)
+- **数据库**: PostgreSQL (主数据库) + Redis (缓存)
+- **ORM**: TypeORM (数据库操作)
+- **消息队列**: RabbitMQ
+
+### 开发工具
+- **API文档**: Swagger/OpenAPI
+- **代码质量**: ESLint + Prettier
+- **测试**: Jest
+- **容器化**: Docker
+
+## 核心功能模块
+
+### 1. 用户认证与授权
+
+#### 1.1 统一登录流程
+```typescript
+interface UnifiedLoginRequest {
+  platform: PlatformType;
+  code: string;
+  userInfo?: any;
+  encryptedData?: string;
+  iv?: string;
+}
+
+interface UnifiedLoginResponse {
+  token: string;
+  refreshToken: string;
+  userInfo: UnifiedUserInfo;
+  platformSpecific?: any;
+}
+```
+
+#### 1.2 平台差异处理
+- **微信**: 使用code换取session_key和openid
+- **支付宝**: 使用auth_code获取用户信息
+- **百度**: 使用authorization_code获取access_token
+- **字节跳动**: 使用code获取用户信息
+- **其他平台**: 根据各自OAuth流程处理
+
+### 2. 扩展服务预留
+
+#### 2.1 服务扩展架构
+```typescript
+// 预留的服务接口基类
+interface BaseService {
+  platform: PlatformType;
+  userId: string;
+  timestamp: Date;
+}
+
+// 扩展服务示例接口 (后续实现)
+interface ExtensionServiceInterface {
+  // 支付服务接口 (预留)
+  payment?: PaymentServiceInterface;
+
+  // 推送服务接口 (预留)
+  push?: PushServiceInterface;
+
+  // 订单服务接口 (预留)
+  order?: OrderServiceInterface;
+}
+```
+
+#### 2.2 模块化扩展设计
+- **插件化架构**: 支持动态加载新的服务模块
+- **统一接口标准**: 所有扩展服务遵循统一的接口规范
+- **平台适配层**: 每个服务都有对应的平台适配器
+- **配置驱动**: 通过配置文件控制服务的启用和禁用
+
+### 3. 消息队列服务 (RabbitMQ)
+
+#### 3.1 业务队列配置
+```typescript
+interface QueueConfig {
+  // 用户相关队列
+  USER_REGISTRATION: 'user.registration';
+  USER_LOGIN: 'user.login';
+  USER_UPDATE: 'user.update';
+
+  // AI生成相关队列
+  AI_GENERATION_TASK: 'ai.generation.task';
+  AI_GENERATION_COMPLETED: 'ai.generation.completed';
+  AI_GENERATION_FAILED: 'ai.generation.failed';
+
+  // 积分系统队列
+  CREDIT_REWARD: 'credit.reward';
+  CREDIT_CONSUME: 'credit.consume';
+
+  // 广告系统队列
+  AD_WATCH_COMPLETED: 'ad.watch.completed';
+  AD_REWARD_GRANTED: 'ad.reward.granted';
+
+  // 订阅系统队列
+  SUBSCRIPTION_ACTIVATED: 'subscription.activated';
+  SUBSCRIPTION_EXPIRED: 'subscription.expired';
+
+  // 注意: 模板系统采用面向对象设计，通过AI_GENERATION_*队列处理
+
+  // 平台同步队列
+  PLATFORM_SYNC: 'platform.sync';
+  PLATFORM_DATA_SYNC: 'platform.data.sync';
+}
+```
+
+#### 3.2 业务消息处理
+```typescript
+// 用户注册消息处理
+@RabbitSubscribe({
+  exchange: 'user.exchange',
+  routingKey: 'user.registration',
+  queue: 'user.registration.queue',
+})
+async handleUserRegistration(message: UserRegistrationMessage) {
+  // 用户数据处理
+  await this.userService.processRegistration(message.userId);
+
+  // 发放新用户积分奖励
+  await this.creditService.grantNewUserBonus(message.userId, message.platform);
+
+  // 同步到各平台
+  await this.platformService.syncUserData(message);
+}
+
+// AI生成任务处理
+@RabbitSubscribe({
+  exchange: 'ai.exchange',
+  routingKey: 'ai.generation.task',
+  queue: 'ai.generation.task.queue',
+})
+async handleAIGenerationTask(message: AIGenerationTaskMessage) {
+  // 处理AI生成任务
+  await this.generationService.processGenerationTask(message.taskId);
+}
+
+// 广告观看完成处理
+@RabbitSubscribe({
+  exchange: 'ad.exchange',
+  routingKey: 'ad.watch.completed',
+  queue: 'ad.watch.completed.queue',
+})
+async handleAdWatchCompleted(message: AdWatchCompletedMessage) {
+  // 发放广告观看奖励
+  await this.adService.completeAdWatch(
+    message.adWatchId,
+    message.watchDuration,
+    message.adData
+  );
+}
+```
+
+## 数据库设计 (PostgreSQL + TypeORM)
+
+### 1. 用户实体 (User Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm';
+import { PlatformUser } from './platform-user.entity';
+import { ExtensionData } from './extension-data.entity';
+import { UserCredit } from './user-credit.entity';
+import { GenerationTask } from './generation-task.entity';
+import { UserSubscription } from './user-subscription.entity';
+import { AdWatch } from './ad-watch.entity';
+// import { TemplateExecution } from './template-execution.entity'; // 已移除，使用面向对象模板系统
+
+@Entity('users')
+export class User {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ unique: true, length: 64 })
+  unifiedUserId: string;
+
+  @Column({ length: 100, nullable: true })
+  nickname: string;
+
+  @Column({ length: 500, nullable: true })
+  avatarUrl: string;
+
+  @Column({ length: 20, nullable: true })
+  phone: string;
+
+  @Column({ length: 100, nullable: true })
+  email: string;
+
+  @Column({ type: 'smallint', default: 1 })
+  status: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @OneToMany(() => PlatformUser, platformUser => platformUser.user)
+  platformUsers: PlatformUser[];
+
+  @OneToMany(() => ExtensionData, extensionData => extensionData.user)
+  extensionData: ExtensionData[];
+
+  @OneToMany(() => UserCredit, userCredit => userCredit.user)
+  credits: UserCredit[];
+
+  @OneToMany(() => GenerationTask, generationTask => generationTask.user)
+  generationTasks: GenerationTask[];
+
+  @OneToMany(() => UserSubscription, userSubscription => userSubscription.user)
+  subscriptions: UserSubscription[];
+
+  @OneToMany(() => AdWatch, adWatch => adWatch.user)
+  adWatches: AdWatch[];
+
+  // 注意: 模板执行记录通过面向对象方式管理，不存储在数据库中
+}
+```
+
+### 2. 平台用户关联实体 (PlatformUser Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { User } from './user.entity';
+
+export enum PlatformType {
+  WECHAT = 'wechat',
+  ALIPAY = 'alipay',
+  BAIDU = 'baidu',
+  BYTEDANCE = 'bytedance',
+  JD = 'jd',
+  QQ = 'qq',
+  FEISHU = 'feishu',
+  KUAISHOU = 'kuaishou',
+  H5 = 'h5',
+  RN = 'rn'
+}
+
+@Entity('platform_users')
+@Index(['platform', 'platformUserId'], { unique: true })
+export class PlatformUser {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({ length: 100 })
+  platformUserId: string;
+
+  @Column({ type: 'jsonb', nullable: true })
+  platformData: any;
+
+  @Column({ length: 500, nullable: true })
+  accessToken: string;
+
+  @Column({ length: 500, nullable: true })
+  refreshToken: string;
+
+  @Column({ type: 'timestamp', nullable: true })
+  expiresAt: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.platformUsers, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 3. 扩展数据实体 (Extension Entity - 预留)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { PlatformType } from './platform-user.entity';
+
+// 通用扩展数据实体 (用于存储各种扩展功能的数据)
+@Entity('extension_data')
+export class ExtensionData {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({ length: 50 })
+  dataType: string; // 'order', 'payment', 'push', 'custom' 等
+
+  @Column({ length: 100, nullable: true })
+  referenceId: string; // 外部引用ID
+
+  @Column({ type: 'jsonb' })
+  data: any; // 灵活的JSON数据存储
+
+  @Column({ type: 'jsonb', nullable: true })
+  metadata: any; // 元数据
+
+  @Column({ length: 20, default: 'active' })
+  status: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.extensionData, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 4. 用户积分实体 (UserCredit Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { PlatformType } from './platform-user.entity';
+
+export enum CreditType {
+  REWARD = 'reward',      // 奖励获得
+  CONSUME = 'consume',    // 消费扣除
+  PURCHASE = 'purchase',  // 购买获得
+  REFUND = 'refund'       // 退款返还
+}
+
+export enum CreditSource {
+  AD_WATCH = 'ad_watch',           // 看广告
+  SUBSCRIPTION = 'subscription',    // 订阅赠送
+  AI_GENERATION = 'ai_generation',  // AI生成消费
+  MANUAL = 'manual'                // 手动调整
+}
+
+@Entity('user_credits')
+export class UserCredit {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({
+    type: 'enum',
+    enum: CreditType
+  })
+  type: CreditType;
+
+  @Column({
+    type: 'enum',
+    enum: CreditSource
+  })
+  source: CreditSource;
+
+  @Column({ type: 'integer' })
+  amount: number; // 正数为增加，负数为扣除
+
+  @Column({ type: 'integer' })
+  balance: number; // 操作后余额
+
+  @Column({ length: 200, nullable: true })
+  description: string;
+
+  @Column({ length: 100, nullable: true })
+  referenceId: string; // 关联的业务ID（如广告ID、任务ID等）
+
+  @Column({ type: 'jsonb', nullable: true })
+  metadata: any;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.credits, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 5. AI生成任务实体 (GenerationTask Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { PlatformType } from './platform-user.entity';
+
+export enum GenerationType {
+  IMAGE = 'image',
+  VIDEO = 'video'
+}
+
+export enum TaskStatus {
+  PENDING = 'pending',     // 等待处理
+  PROCESSING = 'processing', // 处理中
+  COMPLETED = 'completed', // 已完成
+  FAILED = 'failed',       // 失败
+  CANCELLED = 'cancelled'  // 已取消
+}
+
+@Entity('generation_tasks')
+export class GenerationTask {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({
+    type: 'enum',
+    enum: GenerationType
+  })
+  type: GenerationType;
+
+  @Column({ type: 'text' })
+  prompt: string; // 用户输入的提示词
+
+  @Column({ length: 500, nullable: true })
+  inputImageUrl: string; // 输入图片URL
+
+  @Column({ length: 500, nullable: true })
+  outputUrl: string; // 生成结果URL
+
+  @Column({ length: 500, nullable: true })
+  thumbnailUrl: string; // 缩略图URL
+
+  @Column({
+    type: 'enum',
+    enum: TaskStatus,
+    default: TaskStatus.PENDING
+  })
+  status: TaskStatus;
+
+  @Column({ type: 'integer' })
+  creditCost: number; // 消耗的积分
+
+  @Column({ length: 100, nullable: true })
+  aiModelId: string; // 使用的AI模型ID
+
+  @Column({ type: 'jsonb', nullable: true })
+  parameters: any; // 生成参数
+
+  @Column({ type: 'text', nullable: true })
+  errorMessage: string; // 错误信息
+
+  @Column({ type: 'integer', nullable: true })
+  processingTime: number; // 处理时间(秒)
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.generationTasks, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 6. 用户订阅实体 (UserSubscription Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { PlatformType } from './platform-user.entity';
+
+export enum SubscriptionPlan {
+  BASIC = 'basic',       // 基础版
+  PREMIUM = 'premium',   // 高级版
+  PRO = 'pro'           // 专业版
+}
+
+export enum SubscriptionStatus {
+  ACTIVE = 'active',       // 激活中
+  EXPIRED = 'expired',     // 已过期
+  CANCELLED = 'cancelled', // 已取消
+  PENDING = 'pending'      // 待激活
+}
+
+@Entity('user_subscriptions')
+export class UserSubscription {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({
+    type: 'enum',
+    enum: SubscriptionPlan
+  })
+  plan: SubscriptionPlan;
+
+  @Column({
+    type: 'enum',
+    enum: SubscriptionStatus,
+    default: SubscriptionStatus.PENDING
+  })
+  status: SubscriptionStatus;
+
+  @Column({ type: 'timestamp' })
+  startDate: Date;
+
+  @Column({ type: 'timestamp' })
+  endDate: Date;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  price: number; // 订阅价格
+
+  @Column({ length: 10, default: 'CNY' })
+  currency: string;
+
+  @Column({ type: 'integer' })
+  monthlyCredits: number; // 每月赠送积分
+
+  @Column({ length: 100, nullable: true })
+  paymentId: string; // 支付订单ID
+
+  @Column({ type: 'jsonb', nullable: true })
+  features: any; // 订阅特权
+
+  @Column({ type: 'boolean', default: true })
+  autoRenew: boolean; // 自动续费
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.subscriptions, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 7. 广告观看记录实体 (AdWatch Entity)
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { PlatformType } from './platform-user.entity';
+
+export enum AdType {
+  BANNER = 'banner',         // 横幅广告
+  INTERSTITIAL = 'interstitial', // 插屏广告
+  REWARDED = 'rewarded',     // 激励视频广告
+  NATIVE = 'native'          // 原生广告
+}
+
+export enum AdStatus {
+  STARTED = 'started',       // 开始观看
+  COMPLETED = 'completed',   // 观看完成
+  SKIPPED = 'skipped',       // 跳过
+  FAILED = 'failed'          // 失败
+}
+
+@Entity('ad_watches')
+export class AdWatch {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  userId: string;
+
+  @Column({
+    type: 'enum',
+    enum: PlatformType
+  })
+  platform: PlatformType;
+
+  @Column({
+    type: 'enum',
+    enum: AdType
+  })
+  adType: AdType;
+
+  @Column({ length: 100 })
+  adId: string; // 广告ID
+
+  @Column({ length: 100, nullable: true })
+  adUnitId: string; // 广告位ID
+
+  @Column({
+    type: 'enum',
+    enum: AdStatus
+  })
+  status: AdStatus;
+
+  @Column({ type: 'integer', nullable: true })
+  watchDuration: number; // 观看时长(秒)
+
+  @Column({ type: 'integer', nullable: true })
+  rewardCredits: number; // 奖励积分
+
+  @Column({ type: 'jsonb', nullable: true })
+  adData: any; // 广告相关数据
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @ManyToOne(() => User, user => user.adWatches, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'userId' })
+  user: User;
+}
+```
+
+### 8. AI生成任务与模板系统集成说明
+
+**重要说明**: 本项目采用面向对象的模板管理系统，不使用数据库存储模板定义和执行记录。
+
+#### 8.1 模板系统架构
+- **模板定义**: 通过TypeScript类定义，编译时类型检查
+- **模板管理**: 通过TemplateManager内存管理，支持动态注册/卸载
+- **执行记录**: 通过GenerationTask表记录AI生成任务，模板信息作为metadata存储
+
+#### 8.2 与GenerationTask的关系
+```typescript
+// GenerationTask实体中存储模板相关信息
+@Entity('generation_tasks')
+export class GenerationTask {
+  // ... 其他字段
+
+  @Column({ type: 'jsonb', nullable: true })
+  parameters: any; // 存储模板执行参数
+
+  @Column({ type: 'jsonb', nullable: true })
+  metadata: any; // 存储模板代码、版本等信息
+}
+
+// 使用示例
+const task = new GenerationTask();
+task.metadata = {
+  templateCode: 'outfit_change_v1',
+  templateName: '智能换装',
+  templateVersion: '1.0.0',
+  executionId: 'exec_123456789'
+};
+```
+
+### 4. TypeORM配置
+```typescript
+// src/config/database.config.ts
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { ConfigService } from '@nestjs/config';
+
+export const getDatabaseConfig = (configService: ConfigService): TypeOrmModuleOptions => ({
+  type: 'postgres',
+  host: configService.get('DB_HOST', 'localhost'),
+  port: configService.get('DB_PORT', 5432),
+  username: configService.get('DB_USERNAME', 'postgres'),
+  password: configService.get('DB_PASSWORD', 'password'),
+  database: configService.get('DB_DATABASE', 'mini_app_platform'),
+  entities: [__dirname + '/../**/*.entity{.ts,.js}'],
+  migrations: [__dirname + '/../migrations/*{.ts,.js}'],
+  synchronize: configService.get('NODE_ENV') === 'development',
+  logging: configService.get('NODE_ENV') === 'development',
+  ssl: configService.get('NODE_ENV') === 'production' ? { rejectUnauthorized: false } : false,
+  extra: {
+    max: 20, // 连接池最大连接数
+    idleTimeoutMillis: 30000, // 空闲连接超时时间
+    connectionTimeoutMillis: 2000, // 连接超时时间
+  },
+});
+```
+
+### 5. 数据库迁移示例
+```typescript
+// src/migrations/001-create-initial-tables.ts
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateInitialTables1703001000000 implements MigrationInterface {
+  name = 'CreateInitialTables1703001000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // 创建用户表
+    await queryRunner.query(`
+      CREATE TABLE "users" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "unifiedUserId" character varying(64) NOT NULL,
+        "nickname" character varying(100),
+        "avatarUrl" character varying(500),
+        "phone" character varying(20),
+        "email" character varying(100),
+        "status" smallint NOT NULL DEFAULT '1',
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "UQ_users_unifiedUserId" UNIQUE ("unifiedUserId"),
+        CONSTRAINT "PK_users_id" PRIMARY KEY ("id")
+      )
+    `);
+
+    // 创建平台用户关联表
+    await queryRunner.query(`
+      CREATE TYPE "platform_type" AS ENUM(
+        'wechat', 'alipay', 'baidu', 'bytedance',
+        'jd', 'qq', 'feishu', 'kuaishou', 'h5', 'rn'
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE "platform_users" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "platformUserId" character varying(100) NOT NULL,
+        "platformData" jsonb,
+        "accessToken" character varying(500),
+        "refreshToken" character varying(500),
+        "expiresAt" TIMESTAMP,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "UQ_platform_users_platform_platformUserId" UNIQUE ("platform", "platformUserId"),
+        CONSTRAINT "PK_platform_users_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_platform_users_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 创建扩展数据表
+    await queryRunner.query(`
+      CREATE TABLE "extension_data" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "dataType" character varying(50) NOT NULL,
+        "referenceId" character varying(100),
+        "data" jsonb NOT NULL,
+        "metadata" jsonb,
+        "status" character varying(20) NOT NULL DEFAULT 'active',
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_extension_data_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_extension_data_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 创建用户积分表
+    await queryRunner.query(`
+      CREATE TYPE "credit_type" AS ENUM('reward', 'consume', 'purchase', 'refund')
+    `);
+
+    await queryRunner.query(`
+      CREATE TYPE "credit_source" AS ENUM('ad_watch', 'subscription', 'ai_generation', 'manual')
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE "user_credits" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "type" "credit_type" NOT NULL,
+        "source" "credit_source" NOT NULL,
+        "amount" integer NOT NULL,
+        "balance" integer NOT NULL,
+        "description" character varying(200),
+        "referenceId" character varying(100),
+        "metadata" jsonb,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_user_credits_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_user_credits_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 创建AI生成任务表
+    await queryRunner.query(`
+      CREATE TYPE "generation_type" AS ENUM('image', 'video')
+    `);
+
+    await queryRunner.query(`
+      CREATE TYPE "task_status" AS ENUM('pending', 'processing', 'completed', 'failed', 'cancelled')
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE "generation_tasks" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "type" "generation_type" NOT NULL,
+        "prompt" text NOT NULL,
+        "inputImageUrl" character varying(500),
+        "outputUrl" character varying(500),
+        "thumbnailUrl" character varying(500),
+        "status" "task_status" NOT NULL DEFAULT 'pending',
+        "creditCost" integer NOT NULL,
+        "aiModelId" character varying(100),
+        "parameters" jsonb,
+        "errorMessage" text,
+        "processingTime" integer,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_generation_tasks_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_generation_tasks_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 创建用户订阅表
+    await queryRunner.query(`
+      CREATE TYPE "subscription_plan" AS ENUM('basic', 'premium', 'pro')
+    `);
+
+    await queryRunner.query(`
+      CREATE TYPE "subscription_status" AS ENUM('active', 'expired', 'cancelled', 'pending')
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE "user_subscriptions" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "plan" "subscription_plan" NOT NULL,
+        "status" "subscription_status" NOT NULL DEFAULT 'pending',
+        "startDate" TIMESTAMP NOT NULL,
+        "endDate" TIMESTAMP NOT NULL,
+        "price" decimal(10,2) NOT NULL,
+        "currency" character varying(10) NOT NULL DEFAULT 'CNY',
+        "monthlyCredits" integer NOT NULL,
+        "paymentId" character varying(100),
+        "features" jsonb,
+        "autoRenew" boolean NOT NULL DEFAULT true,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_user_subscriptions_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_user_subscriptions_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 创建广告观看记录表
+    await queryRunner.query(`
+      CREATE TYPE "ad_type" AS ENUM('banner', 'interstitial', 'rewarded', 'native')
+    `);
+
+    await queryRunner.query(`
+      CREATE TYPE "ad_status" AS ENUM('started', 'completed', 'skipped', 'failed')
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE "ad_watches" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "userId" uuid NOT NULL,
+        "platform" "platform_type" NOT NULL,
+        "adType" "ad_type" NOT NULL,
+        "adId" character varying(100) NOT NULL,
+        "adUnitId" character varying(100),
+        "status" "ad_status" NOT NULL,
+        "watchDuration" integer,
+        "rewardCredits" integer,
+        "adData" jsonb,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_ad_watches_id" PRIMARY KEY ("id"),
+        CONSTRAINT "FK_ad_watches_userId" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE
+      )
+    `);
+
+    // 注意: AI模板系统采用面向对象设计，不需要数据库表
+    // 模板定义通过TypeScript类管理，执行记录通过GenerationTask表的metadata字段存储
+
+    // 创建索引
+    await queryRunner.query(`CREATE INDEX "IDX_platform_users_platform" ON "platform_users" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_platform_users_userId" ON "platform_users" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_userId" ON "extension_data" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_platform" ON "extension_data" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_dataType" ON "extension_data" ("dataType")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_referenceId" ON "extension_data" ("referenceId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_status" ON "extension_data" ("status")`);
+    await queryRunner.query(`CREATE INDEX "IDX_extension_data_createdAt" ON "extension_data" ("createdAt")`);
+
+    // 用户积分表索引
+    await queryRunner.query(`CREATE INDEX "IDX_user_credits_userId" ON "user_credits" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_credits_platform" ON "user_credits" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_credits_type" ON "user_credits" ("type")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_credits_source" ON "user_credits" ("source")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_credits_createdAt" ON "user_credits" ("createdAt")`);
+
+    // AI生成任务表索引
+    await queryRunner.query(`CREATE INDEX "IDX_generation_tasks_userId" ON "generation_tasks" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_generation_tasks_platform" ON "generation_tasks" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_generation_tasks_type" ON "generation_tasks" ("type")`);
+    await queryRunner.query(`CREATE INDEX "IDX_generation_tasks_status" ON "generation_tasks" ("status")`);
+    await queryRunner.query(`CREATE INDEX "IDX_generation_tasks_createdAt" ON "generation_tasks" ("createdAt")`);
+
+    // 用户订阅表索引
+    await queryRunner.query(`CREATE INDEX "IDX_user_subscriptions_userId" ON "user_subscriptions" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_subscriptions_platform" ON "user_subscriptions" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_subscriptions_status" ON "user_subscriptions" ("status")`);
+    await queryRunner.query(`CREATE INDEX "IDX_user_subscriptions_endDate" ON "user_subscriptions" ("endDate")`);
+
+    // 广告观看记录表索引
+    await queryRunner.query(`CREATE INDEX "IDX_ad_watches_userId" ON "ad_watches" ("userId")`);
+    await queryRunner.query(`CREATE INDEX "IDX_ad_watches_platform" ON "ad_watches" ("platform")`);
+    await queryRunner.query(`CREATE INDEX "IDX_ad_watches_adType" ON "ad_watches" ("adType")`);
+    await queryRunner.query(`CREATE INDEX "IDX_ad_watches_status" ON "ad_watches" ("status")`);
+    await queryRunner.query(`CREATE INDEX "IDX_ad_watches_createdAt" ON "ad_watches" ("createdAt")`);
+
+    // 注意: 模板系统索引已移除，使用面向对象管理
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "ad_watches"`);
+    await queryRunner.query(`DROP TABLE "user_subscriptions"`);
+    await queryRunner.query(`DROP TABLE "generation_tasks"`);
+    await queryRunner.query(`DROP TABLE "user_credits"`);
+    await queryRunner.query(`DROP TABLE "extension_data"`);
+    await queryRunner.query(`DROP TABLE "platform_users"`);
+    await queryRunner.query(`DROP TABLE "users"`);
+    await queryRunner.query(`DROP TYPE "ad_status"`);
+    await queryRunner.query(`DROP TYPE "ad_type"`);
+    await queryRunner.query(`DROP TYPE "subscription_status"`);
+    await queryRunner.query(`DROP TYPE "subscription_plan"`);
+    await queryRunner.query(`DROP TYPE "task_status"`);
+    await queryRunner.query(`DROP TYPE "generation_type"`);
+    await queryRunner.query(`DROP TYPE "credit_source"`);
+    await queryRunner.query(`DROP TYPE "credit_type"`);
+    await queryRunner.query(`DROP TYPE "platform_type"`);
+  }
+}
+```
+
+### 6. Repository模式示例
+```typescript
+// src/repositories/user.repository.ts
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from '../entities/user.entity';
+import { PlatformUser, PlatformType } from '../entities/platform-user.entity';
+import { ExtensionData } from '../entities/extension-data.entity';
+
+@Injectable()
+export class UserRepository {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+    @InjectRepository(PlatformUser)
+    private readonly platformUserRepository: Repository<PlatformUser>,
+    @InjectRepository(ExtensionData)
+    private readonly extensionDataRepository: Repository<ExtensionData>,
+  ) {}
+
+  async findByUnifiedUserId(unifiedUserId: string): Promise<User | null> {
+    return this.userRepository.findOne({
+      where: { unifiedUserId },
+      relations: ['platformUsers', 'extensionData'],
+    });
+  }
+
+  async findByPlatformUser(platform: PlatformType, platformUserId: string): Promise<User | null> {
+    const platformUser = await this.platformUserRepository.findOne({
+      where: { platform, platformUserId },
+      relations: ['user'],
+    });
+    return platformUser?.user || null;
+  }
+
+  async createUser(userData: Partial<User>): Promise<User> {
+    const user = this.userRepository.create(userData);
+    return this.userRepository.save(user);
+  }
+
+  async createPlatformUser(platformUserData: Partial<PlatformUser>): Promise<PlatformUser> {
+    const platformUser = this.platformUserRepository.create(platformUserData);
+    return this.platformUserRepository.save(platformUser);
+  }
+
+  async updatePlatformUser(
+    platform: PlatformType,
+    platformUserId: string,
+    updateData: Partial<PlatformUser>
+  ): Promise<PlatformUser> {
+    await this.platformUserRepository.update(
+      { platform, platformUserId },
+      updateData
+    );
+    return this.platformUserRepository.findOne({
+      where: { platform, platformUserId },
+    });
+  }
+
+  // 扩展数据操作方法
+  async createExtensionData(extensionData: Partial<ExtensionData>): Promise<ExtensionData> {
+    const data = this.extensionDataRepository.create(extensionData);
+    return this.extensionDataRepository.save(data);
+  }
+
+  async findExtensionData(
+    userId: string,
+    dataType: string,
+    platform?: PlatformType
+  ): Promise<ExtensionData[]> {
+    const where: any = { userId, dataType };
+    if (platform) {
+      where.platform = platform;
+    }
+    return this.extensionDataRepository.find({ where });
+  }
+
+  async updateExtensionData(
+    id: string,
+    updateData: Partial<ExtensionData>
+  ): Promise<ExtensionData> {
+    await this.extensionDataRepository.update(id, updateData);
+    return this.extensionDataRepository.findOne({ where: { id } });
+  }
+}
+```
+
+## API设计规范
+
+### 1. 统一请求格式
+```typescript
+interface UnifiedRequest<T = any> {
+  platform: PlatformType;
+  version: string;
+  timestamp: number;
+  signature?: string;
+  data: T;
+}
+```
+
+### 2. 统一响应格式
+```typescript
+interface UnifiedResponse<T = any> {
+  code: number;
+  message: string;
+  data: T;
+  timestamp: number;
+  traceId: string;
+}
+```
+
+### 3. 错误码规范
+- 1000-1999: 系统级错误
+- 2000-2999: 业务级错误
+- 3000-3999: 平台特定错误
+- 4000-4999: 客户端错误
+- 5000-5999: 服务端错误
+
+## 部署架构
+
+### 1. 微服务部署
+```yaml
+# docker-compose.yml 示例
+version: '3.8'
+services:
+  api-gateway:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+
+  main-service:
+    build: .
+    environment:
+      - NODE_ENV=production
+      - DB_HOST=postgres
+      - DB_PORT=5432
+      - DB_USERNAME=${POSTGRES_USER}
+      - DB_PASSWORD=${POSTGRES_PASSWORD}
+      - DB_DATABASE=${POSTGRES_DB}
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+      - RABBITMQ_URL=amqp://rabbitmq:5672
+    depends_on:
+      - postgres
+      - redis
+      - rabbitmq
+
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      POSTGRES_DB: ${POSTGRES_DB}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+
+  redis:
+    image: redis:alpine
+    ports:
+      - "6379:6379"
+
+  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    environment:
+      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER}
+      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD}
+    ports:
+      - "5672:5672"
+      - "15672:15672"  # 管理界面
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+
+volumes:
+  postgres_data:
+  rabbitmq_data:
+```
+
+### 2. 负载均衡配置
+- 使用Nginx作为反向代理
+- 支持多实例部署
+- 健康检查和自动故障转移
+
+## RabbitMQ 配置与管理
+
+### 1. 交换机配置
+```typescript
+// src/config/rabbitmq.config.ts
+export const RabbitMQConfig = {
+  exchanges: [
+    {
+      name: 'user.exchange',
+      type: 'topic',
+      options: { durable: true }
+    },
+    {
+      name: 'payment.exchange',
+      type: 'topic',
+      options: { durable: true }
+    },
+    {
+      name: 'push.exchange',
+      type: 'topic',
+      options: { durable: true }
+    },
+    {
+      name: 'platform.exchange',
+      type: 'topic',
+      options: { durable: true }
+    }
+  ],
+  queues: [
+    {
+      name: 'user.registration.queue',
+      options: { durable: true }
+    },
+    {
+      name: 'payment.success.queue',
+      options: { durable: true }
+    },
+    {
+      name: 'push.message.queue',
+      options: { durable: true }
+    }
+  ]
+};
+```
+
+### 2. 消息生产者示例
+```typescript
+// src/services/message-producer.service.ts
+@Injectable()
+export class MessageProducerService {
+  constructor(
+    @Inject('RABBITMQ_CONNECTION')
+    private readonly connection: Connection,
+  ) {}
+
+  async publishPaymentSuccess(paymentData: PaymentSuccessMessage) {
+    const channel = await this.connection.createChannel();
+
+    await channel.publish(
+      'payment.exchange',
+      'payment.success',
+      Buffer.from(JSON.stringify(paymentData)),
+      { persistent: true }
+    );
+
+    await channel.close();
+  }
+}
+```
+
+## API文档配置 (Swagger/OpenAPI)
+
+### 1. Swagger配置
+```typescript
+// src/config/swagger.config.ts
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { INestApplication } from '@nestjs/common';
+
+export function setupSwagger(app: INestApplication): void {
+  const config = new DocumentBuilder()
+    .setTitle('多平台小程序统一后台API')
+    .setDescription('支持微信、支付宝、百度、字节跳动等多平台的统一后台服务')
+    .setVersion('1.0.0')
+    .addBearerAuth(
+      {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT',
+        name: 'JWT',
+        description: 'Enter JWT token',
+        in: 'header',
+      },
+      'JWT-auth',
+    )
+    .addTag('用户管理', '用户注册、登录、信息管理')
+    .addTag('平台适配', '各平台特定接口和数据同步')
+    .addTag('扩展服务', '预留的扩展功能接口')
+    .addServer('http://localhost:3000', '开发环境')
+    .addServer('https://api.example.com', '生产环境')
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api/docs', app, document, {
+    swaggerOptions: {
+      persistAuthorization: true,
+      tagsSorter: 'alpha',
+      operationsSorter: 'alpha',
+    },
+    customSiteTitle: '多平台API文档',
+    customfavIcon: '/favicon.ico',
+    customJs: [
+      'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui-bundle.min.js',
+      'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui-standalone-preset.min.js',
+    ],
+    customCssUrl: [
+      'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui.min.css',
+    ],
+  });
+}
+```
+
+### 2. DTO示例 (带Swagger装饰器)
+```typescript
+// src/dto/user-login.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsEnum, IsOptional } from 'class-validator';
+import { PlatformType } from '../entities/platform-user.entity';
+
+export class UserLoginDto {
+  @ApiProperty({
+    description: '平台类型',
+    enum: PlatformType,
+    example: PlatformType.WECHAT,
+  })
+  @IsEnum(PlatformType)
+  platform: PlatformType;
+
+  @ApiProperty({
+    description: '平台授权码',
+    example: '081234567890abcdef',
+  })
+  @IsString()
+  code: string;
+
+  @ApiProperty({
+    description: '加密用户数据',
+    required: false,
+    example: 'encrypted_user_data_string',
+  })
+  @IsOptional()
+  @IsString()
+  encryptedData?: string;
+
+  @ApiProperty({
+    description: '加密向量',
+    required: false,
+    example: 'iv_string',
+  })
+  @IsOptional()
+  @IsString()
+  iv?: string;
+}
+
+export class UserLoginResponseDto {
+  @ApiProperty({
+    description: 'JWT访问令牌',
+    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+  })
+  token: string;
+
+  @ApiProperty({
+    description: '刷新令牌',
+    example: 'refresh_token_string',
+  })
+  refreshToken: string;
+
+  @ApiProperty({
+    description: '用户信息',
+    type: 'object',
+    example: {
+      id: 'user-uuid',
+      nickname: '用户昵称',
+      avatarUrl: 'https://example.com/avatar.jpg',
+    },
+  })
+  userInfo: any;
+}
+```
+
+### 3. Controller示例 (带Swagger装饰器)
+```typescript
+// src/controllers/user.controller.ts
+import { Controller, Post, Body, Get, UseGuards } from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiBody,
+} from '@nestjs/swagger';
+import { UserLoginDto, UserLoginResponseDto } from '../dto/user-login.dto';
+import { JwtAuthGuard } from '../guards/jwt-auth.guard';
+import { CurrentUser } from '../decorators/current-user.decorator';
+
+@ApiTags('用户管理')
+@Controller('api/v1/users')
+export class UserController {
+  @Post('login')
+  @ApiOperation({
+    summary: '用户登录',
+    description: '支持多平台用户登录，返回JWT令牌',
+  })
+  @ApiBody({
+    type: UserLoginDto,
+    description: '登录请求参数',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '登录成功',
+    type: UserLoginResponseDto,
+  })
+  @ApiResponse({
+    status: 400,
+    description: '请求参数错误',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 400 },
+        message: { type: 'string', example: '请求参数错误' },
+        data: { type: 'null' },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 401,
+    description: '授权失败',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 401 },
+        message: { type: 'string', example: '平台授权失败' },
+        data: { type: 'null' },
+      },
+    },
+  })
+  async login(@Body() loginDto: UserLoginDto) {
+    return this.userService.login(loginDto);
+  }
+
+  @Get('profile')
+  @UseGuards(JwtAuthGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({
+    summary: '获取用户信息',
+    description: '获取当前登录用户的详细信息',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '获取成功',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 200 },
+        message: { type: 'string', example: '获取成功' },
+        data: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', example: 'user-uuid' },
+            nickname: { type: 'string', example: '用户昵称' },
+            avatarUrl: { type: 'string', example: 'https://example.com/avatar.jpg' },
+            phone: { type: 'string', example: '13800138000' },
+            email: { type: 'string', example: 'user@example.com' },
+          },
+        },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 401,
+    description: '未授权',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 401 },
+        message: { type: 'string', example: '未授权访问' },
+        data: { type: 'null' },
+      },
+    },
+  })
+  async getProfile(@CurrentUser() user: any) {
+    return this.userService.getProfile(user.id);
+  }
+}
+```
+
+### 4. 扩展服务接口文档示例
+```typescript
+// src/controllers/extension.controller.ts
+import { Controller, Post, Body, Get, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery } from '@nestjs/swagger';
+
+@ApiTags('扩展服务')
+@Controller('api/v1/extensions')
+export class ExtensionController {
+  @Post('data')
+  @ApiOperation({
+    summary: '创建扩展数据',
+    description: '为用户创建扩展功能数据，支持多种数据类型',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '数据创建成功',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 200 },
+        message: { type: 'string', example: '数据创建成功' },
+        data: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', example: 'ext_123456789' },
+            userId: { type: 'string', example: 'user_123456789' },
+            dataType: { type: 'string', example: 'custom' },
+            referenceId: { type: 'string', example: 'ref_123456789' },
+            status: { type: 'string', example: 'active' },
+          },
+        },
+      },
+    },
+  })
+  async createExtensionData(@Body() extensionDto: any) {
+    return this.extensionService.createData(extensionDto);
+  }
+
+  @Get('data/:userId')
+  @ApiOperation({
+    summary: '查询用户扩展数据',
+    description: '根据用户ID查询扩展数据',
+  })
+  @ApiParam({
+    name: 'userId',
+    description: '用户ID',
+    example: 'user_123456789',
+  })
+  @ApiQuery({
+    name: 'dataType',
+    description: '数据类型',
+    required: false,
+    example: 'custom',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '查询成功',
+    schema: {
+      type: 'object',
+      properties: {
+        code: { type: 'number', example: 200 },
+        message: { type: 'string', example: '查询成功' },
+        data: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string', example: 'ext_123456789' },
+              dataType: { type: 'string', example: 'custom' },
+              data: { type: 'object', description: '扩展数据内容' },
+              createdAt: { type: 'string', example: '2023-12-01T10:00:00Z' },
+            },
+          },
+        },
+      },
+    },
+  })
+  async getExtensionData(
+    @Param('userId') userId: string,
+    @Query('dataType') dataType?: string
+  ) {
+    return this.extensionService.getUserData(userId, dataType);
+  }
+}
+```
+
+### 5. 在main.ts中启用Swagger
+```typescript
+// src/main.ts
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { AppModule } from './app.module';
+import { setupSwagger } from './config/swagger.config';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  // 启用全局验证管道
+  app.useGlobalPipes(new ValidationPipe({
+    whitelist: true,
+    forbidNonWhitelisted: true,
+    transform: true,
+  }));
+
+  // 设置API前缀
+  app.setGlobalPrefix('api/v1');
+
+  // 启用CORS
+  app.enableCors();
+
+  // 设置Swagger文档
+  setupSwagger(app);
+
+  await app.listen(3000);
+
+  console.log('🚀 应用启动成功!');
+  console.log('📖 API文档地址: http://localhost:3000/api/docs');
+}
+bootstrap();
+```
+
+## 安全策略
+
+### 1. 数据安全
+- 敏感数据加密存储
+- 传输过程HTTPS加密
+- 定期数据备份
+
+### 2. 接口安全
+- API签名验证
+- 请求频率限制
+- IP白名单机制
+
+### 3. 平台安全
+- 各平台密钥安全管理
+- 定期密钥轮换
+- 权限最小化原则
+
+## 开发计划
+
+### Phase 1: 基础架构搭建 (4周)
+- [ ] 项目架构设计和技术选型
+- [ ] 基础框架搭建 (NestJS + TypeORM)
+- [ ] PostgreSQL数据库设计和初始化
+- [ ] TypeORM实体定义和迁移脚本
+- [ ] 基础中间件开发 (认证、日志、异常处理)
+- [ ] Docker容器化配置
+
+### Phase 2: 核心业务功能开发 (10周)
+- [ ] 平台识别和适配器开发
+- [ ] 用户认证服务
+- [ ] AI模板管理系统 (模板注册、参数验证、执行引擎)
+- [ ] AI提供商适配器 (Stability AI、RunwayML等)
+- [ ] 积分系统开发 (积分获取、消耗、查询)
+- [ ] 广告服务集成 (观看验证、奖励发放)
+- [ ] AI生成服务开发 (任务管理、模型调用)
+- [ ] 文件存储服务 (图片上传、结果存储)
+- [ ] RabbitMQ消息队列集成
+
+### Phase 3: 高级功能开发 (6周)
+- [ ] 订阅服务开发 (包月付费、会员权益)
+- [ ] 预定义模板开发 (换装、抠图、风格转换等)
+- [ ] 模板版本管理和回滚机制
+- [ ] 文件处理优化 (压缩、缩略图生成)
+- [ ] 任务队列优化 (失败重试、状态监控)
+- [ ] API文档完善
+- [ ] 管理后台开发 (模板管理界面)
+
+### Phase 4: 测试和优化 (3周)
+- [ ] 单元测试和集成测试
+- [ ] 性能测试和优化
+- [ ] 安全测试
+- [ ] API文档和使用指南完善
+
+### Phase 5: 部署和上线 (2周)
+- [ ] 生产环境部署
+- [ ] 基础功能验证
+- [ ] 性能调优
+- [ ] 正式上线
+
+### 后续扩展计划 (按需开发)
+- [ ] 更多AI模型集成 (DALL-E、Midjourney API)
+- [ ] 高级图像处理 (风格转换、图像修复)
+- [ ] 社交功能 (作品分享、用户互动)
+- [ ] 数据分析和报表 (用户行为、生成统计)
+- [ ] 更多平台适配器 (快手、飞书等)
+- [ ] 内容审核系统 (AI生成内容安全检测)
+
+## 总结
+
+本方案为AI图片/视频生成平台提供了完整的多平台统一后台解决方案，通过模块化设计和标准化接口，既满足了当前的核心业务需求，又为未来的功能扩展预留了充分的空间。
+
+## 🎯 **核心业务价值**
+
+### 💡 **AI生成能力**
+- **统一模板管理**: 通过模板系统抹平不同AI模型的调用差异
+- **多模态生成**: 支持图片和视频生成，满足不同用户需求
+- **智能任务管理**: 异步处理，支持大规模并发生成任务
+- **模型适配**: 灵活对接多种AI服务提供商 (Stability AI、RunwayML等)
+- **参数验证**: 完整的输入参数验证和类型转换
+- **版本管理**: 支持模板版本控制和平滑升级
+
+### 💰 **商业模式支持**
+- **积分经济**: 完整的积分获取、消耗、管理体系
+- **广告变现**: 多种广告类型，灵活的奖励机制
+- **订阅服务**: 包月付费，会员权益管理
+- **成本控制**: 基于积分的使用限制，有效控制AI调用成本
+
+### 🔧 **技术优势**
+1. **统一性**: 抹平8大平台API差异和AI模型调用差异，统一的开发体验
+2. **可扩展性**: 模块化架构，支持快速添加新功能、平台和AI模型
+3. **模板化**: 通过模板系统标准化AI调用，简化前端集成
+4. **高性能**: PostgreSQL + Redis + RabbitMQ，支持高并发处理
+5. **数据安全**: JSONB灵活存储，完整的数据备份和恢复机制
+6. **异步处理**: 基于消息队列的异步任务处理，提升用户体验
+7. **类型安全**: TypeScript + TypeORM，编译时错误检查
+8. **智能缓存**: 活跃模板缓存，提升模板执行性能
diff --git a/docs/rabbitmq-configuration.md b/docs/rabbitmq-configuration.md
new file mode 100644
index 0000000..a6db204
--- /dev/null
+++ b/docs/rabbitmq-configuration.md
@@ -0,0 +1,508 @@
+# RabbitMQ 配置指南
+
+## 1. RabbitMQ 模块配置
+
+### 1.1 RabbitMQ 模块设置
+```typescript
+// src/rabbitmq/rabbitmq.module.ts
+import { Module } from '@nestjs/common';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+import { ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    ClientsModule.registerAsync([
+      {
+        name: 'RABBITMQ_SERVICE',
+        useFactory: (configService: ConfigService) => ({
+          transport: Transport.RMQ,
+          options: {
+            urls: [configService.get<string>('RABBITMQ_URL')],
+            queue: 'main_queue',
+            queueOptions: {
+              durable: true,
+            },
+            socketOptions: {
+              heartbeatIntervalInSeconds: 60,
+              reconnectTimeInSeconds: 5,
+            },
+          },
+        }),
+        inject: [ConfigService],
+      },
+    ]),
+  ],
+  exports: [ClientsModule],
+})
+export class RabbitMQModule {}
+```
+
+### 1.2 消息队列配置
+```typescript
+// src/config/queue.config.ts
+export const QueueConfig = {
+  // 交换机配置
+  exchanges: {
+    USER: 'user.exchange',
+    PAYMENT: 'payment.exchange',
+    PUSH: 'push.exchange',
+    PLATFORM: 'platform.exchange',
+  },
+  
+  // 队列配置
+  queues: {
+    // 用户相关队列
+    USER_REGISTRATION: 'user.registration.queue',
+    USER_LOGIN: 'user.login.queue',
+    USER_UPDATE: 'user.update.queue',
+
+    // AI生成相关队列
+    AI_GENERATION_TASK: 'ai.generation.task.queue',
+    AI_GENERATION_COMPLETED: 'ai.generation.completed.queue',
+    AI_GENERATION_FAILED: 'ai.generation.failed.queue',
+
+    // 积分系统队列
+    CREDIT_REWARD: 'credit.reward.queue',
+    CREDIT_CONSUME: 'credit.consume.queue',
+
+    // 广告系统队列
+    AD_WATCH_COMPLETED: 'ad.watch.completed.queue',
+    AD_REWARD_GRANTED: 'ad.reward.granted.queue',
+
+    // 平台同步队列
+    PLATFORM_SYNC_USER: 'platform.sync.user.queue',
+    PLATFORM_SYNC_DATA: 'platform.sync.data.queue',
+
+    // 扩展服务队列 (预留)
+    EXTENSION_SERVICE: 'extension.service.queue',
+    CUSTOM_EVENT: 'custom.event.queue',
+  },
+  
+  // 路由键配置
+  routingKeys: {
+    USER_REGISTERED: 'user.registered',
+    USER_LOGIN_SUCCESS: 'user.login.success',
+    USER_UPDATED: 'user.updated',
+
+    // AI生成相关路由键
+    AI_GENERATION_TASK: 'ai.generation.task',
+    AI_GENERATION_COMPLETED: 'ai.generation.completed',
+    AI_GENERATION_FAILED: 'ai.generation.failed',
+
+    // 积分系统路由键
+    CREDIT_REWARD: 'credit.reward',
+    CREDIT_CONSUME: 'credit.consume',
+
+    // 广告系统路由键
+    AD_WATCH_COMPLETED: 'ad.watch.completed',
+    AD_REWARD_GRANTED: 'ad.reward.granted',
+
+    PLATFORM_SYNC: 'platform.sync',
+    EXTENSION_EVENT: 'extension.event',
+  },
+};
+```
+
+## 2. 消息生产者服务
+
+```typescript
+// src/services/message-producer.service.ts
+import { Injectable, Inject } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
+import { QueueConfig } from '../config/queue.config';
+
+export interface UserRegistrationMessage {
+  userId: string;
+  platform: string;
+  userInfo: any;
+  timestamp: Date;
+}
+
+export interface ExtensionMessage {
+  userId: string;
+  platform: string;
+  dataType: string;
+  action: string; // 'create', 'update', 'delete'
+  data: Record<string, any>;
+  timestamp: Date;
+}
+
+export interface GenerationTaskMessage {
+  taskId: string;
+  userId: string;
+  platform: string;
+  type: 'image' | 'video';
+  templateCode?: string;
+  inputParameters: Record<string, any>;
+  timestamp: Date;
+}
+
+export interface GenerationCompletedMessage {
+  taskId: string;
+  userId: string;
+  platform: string;
+  outputUrl: string;
+  thumbnailUrl?: string;
+  timestamp: Date;
+}
+
+export interface GenerationFailedMessage {
+  taskId: string;
+  userId: string;
+  platform: string;
+  errorMessage: string;
+  timestamp: Date;
+}
+
+@Injectable()
+export class MessageProducerService {
+  constructor(
+    @Inject('RABBITMQ_SERVICE')
+    private readonly client: ClientProxy,
+  ) {}
+
+  // 发送用户注册消息
+  async sendUserRegistration(message: UserRegistrationMessage) {
+    return this.client.emit(QueueConfig.routingKeys.USER_REGISTERED, message);
+  }
+
+  // 发送用户更新消息
+  async sendUserUpdate(message: UserRegistrationMessage) {
+    return this.client.emit(QueueConfig.routingKeys.USER_UPDATED, message);
+  }
+
+  // 发送平台同步消息
+  async sendPlatformSync(data: any) {
+    return this.client.emit(QueueConfig.routingKeys.PLATFORM_SYNC, data);
+  }
+
+  // 发送扩展服务消息
+  async sendExtensionEvent(message: ExtensionMessage) {
+    return this.client.emit(QueueConfig.routingKeys.EXTENSION_EVENT, message);
+  }
+
+  // AI生成相关消息
+  async sendGenerationTask(message: GenerationTaskMessage) {
+    return this.client.emit(QueueConfig.routingKeys.AI_GENERATION_TASK, message);
+  }
+
+  async sendGenerationCompleted(message: GenerationCompletedMessage) {
+    return this.client.emit(QueueConfig.routingKeys.AI_GENERATION_COMPLETED, message);
+  }
+
+  async sendGenerationFailed(message: GenerationFailedMessage) {
+    return this.client.emit(QueueConfig.routingKeys.AI_GENERATION_FAILED, message);
+  }
+}
+```
+
+## 3. 消息消费者服务
+
+```typescript
+// src/services/message-consumer.service.ts
+import { Injectable } from '@nestjs/common';
+import { EventPattern, Payload } from '@nestjs/microservices';
+import { QueueConfig } from '../config/queue.config';
+import { UserService } from './user.service';
+import { PaymentService } from './payment.service';
+import { PushService } from './push.service';
+import { PlatformService } from './platform.service';
+
+@Injectable()
+export class MessageConsumerService {
+  constructor(
+    private readonly userService: UserService,
+    private readonly platformService: PlatformService,
+    private readonly extensionService: ExtensionService,
+    private readonly generationService: GenerationService,
+    private readonly messageProducer: MessageProducerService,
+  ) {}
+
+  // 处理用户注册消息
+  @EventPattern(QueueConfig.routingKeys.USER_REGISTERED)
+  async handleUserRegistration(@Payload() data: UserRegistrationMessage) {
+    try {
+      console.log('Processing user registration:', data);
+
+      // 同步到其他平台
+      await this.platformService.syncUserRegistration(data);
+
+      // 触发扩展服务处理
+      await this.extensionService.handleUserRegistration(data);
+
+      console.log('User registration processed successfully');
+    } catch (error) {
+      console.error('Error processing user registration:', error);
+      // 这里可以实现重试机制或死信队列
+    }
+  }
+
+  // 处理用户更新消息
+  @EventPattern(QueueConfig.routingKeys.USER_UPDATED)
+  async handleUserUpdate(@Payload() data: UserRegistrationMessage) {
+    try {
+      console.log('Processing user update:', data);
+
+      // 同步用户数据到各平台
+      await this.platformService.syncUserUpdate(data);
+
+      // 触发扩展服务处理
+      await this.extensionService.handleUserUpdate(data);
+
+      console.log('User update processed successfully');
+    } catch (error) {
+      console.error('Error processing user update:', error);
+    }
+  }
+
+  // 处理AI生成任务消息
+  @EventPattern(QueueConfig.routingKeys.AI_GENERATION_TASK)
+  async handleGenerationTask(@Payload() data: GenerationTaskMessage) {
+    try {
+      console.log('Processing AI generation task:', data);
+
+      // 调用AI生成服务处理任务
+      await this.generationService.processGenerationTask(data.taskId);
+
+      console.log('AI generation task processed successfully');
+    } catch (error) {
+      console.error('Error processing AI generation task:', error);
+
+      // 发送失败消息
+      await this.messageProducer.sendGenerationFailed({
+        taskId: data.taskId,
+        userId: data.userId,
+        platform: data.platform,
+        errorMessage: error.message,
+        timestamp: new Date(),
+      });
+    }
+  }
+
+  // 处理AI生成完成消息
+  @EventPattern(QueueConfig.routingKeys.AI_GENERATION_COMPLETED)
+  async handleGenerationCompleted(@Payload() data: GenerationCompletedMessage) {
+    try {
+      console.log('Processing AI generation completed:', data);
+
+      // 可以在这里添加后续处理逻辑，如推送通知等
+      // await this.pushService.sendGenerationCompleteNotification(data);
+
+      console.log('AI generation completed processed successfully');
+    } catch (error) {
+      console.error('Error processing AI generation completed:', error);
+    }
+  }
+
+  // 处理AI生成失败消息
+  @EventPattern(QueueConfig.routingKeys.AI_GENERATION_FAILED)
+  async handleGenerationFailed(@Payload() data: GenerationFailedMessage) {
+    try {
+      console.log('Processing AI generation failed:', data);
+
+      // 可以在这里添加失败处理逻辑，如推送错误通知等
+      // await this.pushService.sendGenerationFailedNotification(data);
+
+      console.log('AI generation failed processed successfully');
+    } catch (error) {
+      console.error('Error processing AI generation failed:', error);
+    }
+  }
+
+  // 处理扩展服务消息
+  @EventPattern(QueueConfig.routingKeys.EXTENSION_EVENT)
+  async handleExtensionEvent(@Payload() data: ExtensionMessage) {
+    try {
+      console.log('Processing extension event:', data);
+
+      // 根据数据类型和操作类型处理
+      await this.extensionService.handleExtensionEvent(data);
+
+      // 同步到相关平台
+      await this.platformService.syncExtensionData(data);
+
+      console.log('Extension event processed successfully');
+    } catch (error) {
+      console.error('Error processing extension event:', error);
+    }
+  }
+
+  // 处理平台同步消息
+  @EventPattern(QueueConfig.routingKeys.PLATFORM_SYNC)
+  async handlePlatformSync(@Payload() data: any) {
+    try {
+      console.log('Processing platform sync:', data);
+      
+      await this.platformService.syncData(data);
+      
+      console.log('Platform sync processed successfully');
+    } catch (error) {
+      console.error('Error processing platform sync:', error);
+    }
+  }
+}
+```
+
+## 4. 在业务服务中使用消息队列
+
+```typescript
+// src/services/user.service.ts
+import { Injectable } from '@nestjs/common';
+import { MessageProducerService } from './message-producer.service';
+
+@Injectable()
+export class UserService {
+  constructor(
+    private readonly messageProducer: MessageProducerService,
+  ) {}
+
+  async registerUser(userData: any) {
+    // 创建用户
+    const user = await this.createUser(userData);
+    
+    // 发送用户注册消息到队列
+    await this.messageProducer.sendUserRegistration({
+      userId: user.id,
+      platform: userData.platform,
+      userInfo: userData,
+      timestamp: new Date(),
+    });
+    
+    return user;
+  }
+
+  private async createUser(userData: any) {
+    // 实际的用户创建逻辑
+    return { id: 'user-id', ...userData };
+  }
+}
+```
+
+## 5. 主应用模块配置
+
+```typescript
+// src/app.module.ts
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { RabbitMQModule } from './rabbitmq/rabbitmq.module';
+import { MessageProducerService } from './services/message-producer.service';
+import { MessageConsumerService } from './services/message-consumer.service';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+    }),
+    RabbitMQModule,
+  ],
+  providers: [
+    MessageProducerService,
+    MessageConsumerService,
+  ],
+  exports: [MessageProducerService],
+})
+export class AppModule {}
+```
+
+## 6. 错误处理和重试机制
+
+```typescript
+// src/decorators/retry.decorator.ts
+export function Retry(maxRetries: number = 3, delay: number = 1000) {
+  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+    const method = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      let lastError: any;
+      
+      for (let i = 0; i <= maxRetries; i++) {
+        try {
+          return await method.apply(this, args);
+        } catch (error) {
+          lastError = error;
+          
+          if (i < maxRetries) {
+            console.log(`Retry ${i + 1}/${maxRetries} for ${propertyName}:`, error.message);
+            await new Promise(resolve => setTimeout(resolve, delay * Math.pow(2, i)));
+          }
+        }
+      }
+      
+      throw lastError;
+    };
+  };
+}
+```
+
+## 7. 队列监控和管理
+
+```typescript
+// src/services/queue-monitor.service.ts
+import { Injectable } from '@nestjs/common';
+import * as amqp from 'amqplib';
+
+@Injectable()
+export class QueueMonitorService {
+  private connection: amqp.Connection;
+
+  async getQueueInfo(queueName: string) {
+    const channel = await this.connection.createChannel();
+    const queueInfo = await channel.checkQueue(queueName);
+    await channel.close();
+    
+    return {
+      queue: queueName,
+      messageCount: queueInfo.messageCount,
+      consumerCount: queueInfo.consumerCount,
+    };
+  }
+
+  async purgeQueue(queueName: string) {
+    const channel = await this.connection.createChannel();
+    await channel.purgeQueue(queueName);
+    await channel.close();
+  }
+}
+```
+
+## 8. Docker Compose 配置
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+services:
+  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    container_name: rabbitmq
+    environment:
+      RABBITMQ_DEFAULT_USER: admin
+      RABBITMQ_DEFAULT_PASS: password
+      RABBITMQ_DEFAULT_VHOST: /
+    ports:
+      - "5672:5672"   # AMQP端口
+      - "15672:15672" # 管理界面端口
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+    healthcheck:
+      test: ["CMD", "rabbitmq-diagnostics", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+
+volumes:
+  rabbitmq_data:
+```
+
+## 9. 环境变量配置
+
+```env
+# RabbitMQ配置
+RABBITMQ_URL=amqp://admin:password@localhost:5672
+RABBITMQ_USER=admin
+RABBITMQ_PASSWORD=password
+RABBITMQ_VHOST=/
+RABBITMQ_HEARTBEAT=60
+RABBITMQ_RECONNECT_TIME=5
+```
+
+这个配置提供了完整的RabbitMQ集成方案，包括消息生产者、消费者、错误处理和监控功能。
diff --git a/docs/swagger-api-documentation.md b/docs/swagger-api-documentation.md
new file mode 100644
index 0000000..1602526
--- /dev/null
+++ b/docs/swagger-api-documentation.md
@@ -0,0 +1,600 @@
+# Swagger API 文档配置指南
+
+## 1. Swagger 基础配置
+
+### 1.1 安装依赖
+```bash
+pnpm add @nestjs/swagger swagger-ui-express
+pnpm add -D @types/swagger-ui-express
+```
+
+### 1.2 基础配置文件
+```typescript
+// src/config/swagger.config.ts
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { INestApplication } from '@nestjs/common';
+
+export function setupSwagger(app: INestApplication): void {
+  const config = new DocumentBuilder()
+    .setTitle('多平台小程序统一后台API')
+    .setDescription(`
+      ## 功能特性
+      - 🔐 统一用户认证 (微信/支付宝/百度/字节跳动等)
+      - 🔄 平台数据同步 (RabbitMQ异步处理)
+      - 🧩 可扩展架构 (支持后续添加支付、推送等功能)
+      - 📊 灵活数据存储 (PostgreSQL + JSONB)
+      
+      ## 认证方式
+      使用JWT Bearer Token进行API认证
+      
+      ## 响应格式
+      所有API响应都遵循统一格式：
+      \`\`\`json
+      {
+        "code": 200,
+        "message": "success",
+        "data": {},
+        "timestamp": 1703001000000,
+        "traceId": "trace-uuid"
+      }
+      \`\`\`
+    `)
+    .setVersion('1.0.0')
+    .setContact('开发团队', 'https://example.com', 'dev@example.com')
+    .setLicense('MIT', 'https://opensource.org/licenses/MIT')
+    .addBearerAuth(
+      {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT',
+        name: 'JWT',
+        description: 'Enter JWT token',
+        in: 'header',
+      },
+      'JWT-auth',
+    )
+    .addTag('🔐 用户管理', '用户注册、登录、信息管理')
+    .addTag('🔄 平台适配', '各平台特定接口和数据同步')
+    .addTag('🧩 扩展服务', '预留的扩展功能接口')
+    .addTag('📊 数据统计', '业务数据统计和分析')
+    .addServer('http://localhost:3000', '开发环境')
+    .addServer('https://api-dev.example.com', '测试环境')
+    .addServer('https://api.example.com', '生产环境')
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config, {
+    operationIdFactory: (controllerKey: string, methodKey: string) => methodKey,
+  });
+
+  SwaggerModule.setup('api/docs', app, document, {
+    swaggerOptions: {
+      persistAuthorization: true,
+      tagsSorter: 'alpha',
+      operationsSorter: 'alpha',
+      docExpansion: 'none',
+      filter: true,
+      showRequestDuration: true,
+    },
+    customSiteTitle: '多平台API文档',
+    customfavIcon: '/favicon.ico',
+    customJs: [
+      'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui-bundle.min.js',
+    ],
+    customCssUrl: [
+      'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui.min.css',
+    ],
+  });
+}
+```
+
+## 2. 通用DTO定义
+
+### 2.1 统一响应格式
+```typescript
+// src/dto/common-response.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CommonResponseDto<T = any> {
+  @ApiProperty({ description: '响应状态码', example: 200 })
+  code: number;
+
+  @ApiProperty({ description: '响应消息', example: 'success' })
+  message: string;
+
+  @ApiProperty({ description: '响应数据' })
+  data: T;
+
+  @ApiProperty({ description: '时间戳', example: 1703001000000 })
+  timestamp: number;
+
+  @ApiProperty({ description: '追踪ID', example: 'trace-uuid-123' })
+  traceId: string;
+}
+
+export class PaginationDto {
+  @ApiProperty({ description: '页码', example: 1, minimum: 1 })
+  page: number;
+
+  @ApiProperty({ description: '每页数量', example: 10, minimum: 1, maximum: 100 })
+  limit: number;
+}
+
+export class PaginationResponseDto<T = any> {
+  @ApiProperty({ description: '数据列表' })
+  items: T[];
+
+  @ApiProperty({ description: '总数量', example: 100 })
+  total: number;
+
+  @ApiProperty({ description: '当前页码', example: 1 })
+  page: number;
+
+  @ApiProperty({ description: '每页数量', example: 10 })
+  limit: number;
+
+  @ApiProperty({ description: '总页数', example: 10 })
+  totalPages: number;
+}
+```
+
+### 2.2 平台枚举定义
+```typescript
+// src/dto/platform.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+
+export enum PlatformType {
+  WECHAT = 'wechat',
+  ALIPAY = 'alipay',
+  BAIDU = 'baidu',
+  BYTEDANCE = 'bytedance',
+  JD = 'jd',
+  QQ = 'qq',
+  FEISHU = 'feishu',
+  KUAISHOU = 'kuaishou',
+  H5 = 'h5',
+  RN = 'rn'
+}
+
+export const PlatformDescriptions = {
+  [PlatformType.WECHAT]: '微信小程序',
+  [PlatformType.ALIPAY]: '支付宝小程序',
+  [PlatformType.BAIDU]: '百度智能小程序',
+  [PlatformType.BYTEDANCE]: '字节跳动小程序',
+  [PlatformType.JD]: '京东小程序',
+  [PlatformType.QQ]: 'QQ小程序',
+  [PlatformType.FEISHU]: '飞书小程序',
+  [PlatformType.KUAISHOU]: '快手小程序',
+  [PlatformType.H5]: 'H5应用',
+  [PlatformType.RN]: 'React Native应用',
+};
+```
+
+## 3. 用户管理API文档
+
+### 3.1 用户登录DTO
+```typescript
+// src/dto/user.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsEnum, IsOptional, IsObject } from 'class-validator';
+import { PlatformType } from './platform.dto';
+
+export class UserLoginDto {
+  @ApiProperty({
+    description: '平台类型',
+    enum: PlatformType,
+    example: PlatformType.WECHAT,
+    enumName: 'PlatformType',
+  })
+  @IsEnum(PlatformType)
+  platform: PlatformType;
+
+  @ApiProperty({
+    description: '平台授权码/临时登录凭证',
+    example: '081234567890abcdef',
+    minLength: 1,
+    maxLength: 200,
+  })
+  @IsString()
+  code: string;
+
+  @ApiProperty({
+    description: '加密用户数据 (微信小程序专用)',
+    required: false,
+    example: 'encrypted_user_data_string',
+  })
+  @IsOptional()
+  @IsString()
+  encryptedData?: string;
+
+  @ApiProperty({
+    description: '加密向量 (微信小程序专用)',
+    required: false,
+    example: 'iv_string',
+  })
+  @IsOptional()
+  @IsString()
+  iv?: string;
+
+  @ApiProperty({
+    description: '额外的平台特定数据',
+    required: false,
+    type: 'object',
+    example: { sessionKey: 'session_key_value' },
+  })
+  @IsOptional()
+  @IsObject()
+  extra?: Record<string, any>;
+}
+
+export class UserInfoDto {
+  @ApiProperty({ description: '用户ID', example: 'user-uuid-123' })
+  id: string;
+
+  @ApiProperty({ description: '统一用户ID', example: 'unified-user-123' })
+  unifiedUserId: string;
+
+  @ApiProperty({ description: '用户昵称', example: '张三' })
+  nickname: string;
+
+  @ApiProperty({ 
+    description: '头像URL', 
+    example: 'https://example.com/avatar.jpg' 
+  })
+  avatarUrl: string;
+
+  @ApiProperty({ 
+    description: '手机号', 
+    example: '13800138000',
+    required: false 
+  })
+  phone?: string;
+
+  @ApiProperty({ 
+    description: '邮箱', 
+    example: 'user@example.com',
+    required: false 
+  })
+  email?: string;
+
+  @ApiProperty({ description: '用户状态', example: 1 })
+  status: number;
+
+  @ApiProperty({ description: '创建时间', example: '2023-12-01T10:00:00Z' })
+  createdAt: Date;
+
+  @ApiProperty({ description: '更新时间', example: '2023-12-01T10:00:00Z' })
+  updatedAt: Date;
+}
+
+export class UserLoginResponseDto {
+  @ApiProperty({
+    description: 'JWT访问令牌',
+    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+  })
+  token: string;
+
+  @ApiProperty({
+    description: '刷新令牌',
+    example: 'refresh_token_string_here',
+  })
+  refreshToken: string;
+
+  @ApiProperty({
+    description: '用户信息',
+    type: UserInfoDto,
+  })
+  userInfo: UserInfoDto;
+
+  @ApiProperty({
+    description: '平台特定数据',
+    type: 'object',
+    required: false,
+    example: { openid: 'wx_openid_123' },
+  })
+  platformSpecific?: Record<string, any>;
+}
+```
+
+## 4. 扩展服务API文档
+
+### 4.1 扩展数据相关DTO
+```typescript
+// src/dto/extension.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsEnum, IsOptional, IsObject } from 'class-validator';
+import { PlatformType } from './platform.dto';
+
+export class CreateExtensionDataDto {
+  @ApiProperty({
+    description: '用户ID',
+    example: 'user-uuid-123',
+  })
+  @IsString()
+  userId: string;
+
+  @ApiProperty({
+    description: '平台类型',
+    enum: PlatformType,
+    example: PlatformType.WECHAT,
+  })
+  @IsEnum(PlatformType)
+  platform: PlatformType;
+
+  @ApiProperty({
+    description: '数据类型',
+    example: 'custom',
+    maxLength: 50,
+  })
+  @IsString()
+  dataType: string;
+
+  @ApiProperty({
+    description: '外部引用ID',
+    required: false,
+    example: 'ref-123456',
+    maxLength: 100,
+  })
+  @IsOptional()
+  @IsString()
+  referenceId?: string;
+
+  @ApiProperty({
+    description: '扩展数据内容',
+    type: 'object',
+    example: {
+      customField1: 'value1',
+      customField2: 'value2',
+      settings: { enabled: true }
+    },
+  })
+  @IsObject()
+  data: Record<string, any>;
+
+  @ApiProperty({
+    description: '元数据',
+    required: false,
+    type: 'object',
+    example: { source: 'api', version: '1.0' },
+  })
+  @IsOptional()
+  @IsObject()
+  metadata?: Record<string, any>;
+}
+
+export class ExtensionDataResponseDto {
+  @ApiProperty({ description: '扩展数据ID', example: 'ext-uuid-123' })
+  id: string;
+
+  @ApiProperty({ description: '用户ID', example: 'user-uuid-123' })
+  userId: string;
+
+  @ApiProperty({
+    description: '平台类型',
+    enum: PlatformType,
+    example: PlatformType.WECHAT,
+  })
+  platform: PlatformType;
+
+  @ApiProperty({ description: '数据类型', example: 'custom' })
+  dataType: string;
+
+  @ApiProperty({ description: '外部引用ID', example: 'ref-123456' })
+  referenceId: string;
+
+  @ApiProperty({
+    description: '扩展数据内容',
+    type: 'object',
+  })
+  data: Record<string, any>;
+
+  @ApiProperty({
+    description: '元数据',
+    type: 'object',
+  })
+  metadata: Record<string, any>;
+
+  @ApiProperty({ description: '状态', example: 'active' })
+  status: string;
+
+  @ApiProperty({ description: '创建时间', example: '2023-12-01T10:00:00Z' })
+  createdAt: Date;
+
+  @ApiProperty({ description: '更新时间', example: '2023-12-01T10:00:00Z' })
+  updatedAt: Date;
+}
+```
+
+## 5. 错误响应文档
+
+### 5.1 通用错误响应
+```typescript
+// src/dto/error-response.dto.ts
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ErrorResponseDto {
+  @ApiProperty({ description: '错误状态码', example: 400 })
+  code: number;
+
+  @ApiProperty({ description: '错误消息', example: '请求参数错误' })
+  message: string;
+
+  @ApiProperty({ description: '错误数据', example: null })
+  data: null;
+
+  @ApiProperty({ description: '时间戳', example: 1703001000000 })
+  timestamp: number;
+
+  @ApiProperty({ description: '追踪ID', example: 'trace-uuid-123' })
+  traceId: string;
+
+  @ApiProperty({
+    description: '详细错误信息',
+    required: false,
+    example: ['字段验证失败'],
+  })
+  details?: string[];
+}
+
+// 常用错误响应示例
+export const CommonErrorResponses = {
+  BadRequest: {
+    status: 400,
+    description: '请求参数错误',
+    type: ErrorResponseDto,
+  },
+  Unauthorized: {
+    status: 401,
+    description: '未授权访问',
+    type: ErrorResponseDto,
+  },
+  Forbidden: {
+    status: 403,
+    description: '禁止访问',
+    type: ErrorResponseDto,
+  },
+  NotFound: {
+    status: 404,
+    description: '资源不存在',
+    type: ErrorResponseDto,
+  },
+  InternalServerError: {
+    status: 500,
+    description: '服务器内部错误',
+    type: ErrorResponseDto,
+  },
+};
+```
+
+## 6. 装饰器使用示例
+
+### 6.1 Controller装饰器
+```typescript
+// src/decorators/api-common-responses.decorator.ts
+import { applyDecorators } from '@nestjs/common';
+import { ApiResponse } from '@nestjs/swagger';
+import { CommonErrorResponses } from '../dto/error-response.dto';
+
+export function ApiCommonResponses() {
+  return applyDecorators(
+    ApiResponse(CommonErrorResponses.BadRequest),
+    ApiResponse(CommonErrorResponses.Unauthorized),
+    ApiResponse(CommonErrorResponses.InternalServerError),
+  );
+}
+
+export function ApiAuthResponses() {
+  return applyDecorators(
+    ApiResponse(CommonErrorResponses.Unauthorized),
+    ApiResponse(CommonErrorResponses.Forbidden),
+  );
+}
+```
+
+### 6.2 使用示例
+```typescript
+// src/controllers/user.controller.ts
+import { Controller, Post, Body, Get, UseGuards } from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+} from '@nestjs/swagger';
+import { ApiCommonResponses, ApiAuthResponses } from '../decorators/api-common-responses.decorator';
+
+@ApiTags('🔐 用户管理')
+@Controller('users')
+@ApiCommonResponses()
+export class UserController {
+  @Post('login')
+  @ApiOperation({
+    summary: '用户登录',
+    description: '支持多平台用户登录，返回JWT令牌和用户信息',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '登录成功',
+    type: UserLoginResponseDto,
+  })
+  async login(@Body() loginDto: UserLoginDto) {
+    return this.userService.login(loginDto);
+  }
+
+  @Get('profile')
+  @UseGuards(JwtAuthGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiAuthResponses()
+  @ApiOperation({
+    summary: '获取用户信息',
+    description: '获取当前登录用户的详细信息',
+  })
+  @ApiResponse({
+    status: 200,
+    description: '获取成功',
+    type: UserInfoDto,
+  })
+  async getProfile(@CurrentUser() user: any) {
+    return this.userService.getProfile(user.id);
+  }
+}
+```
+
+## 7. 环境配置
+
+### 7.1 开发环境配置
+```typescript
+// src/main.ts
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { AppModule } from './app.module';
+import { setupSwagger } from './config/swagger.config';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  // 全局验证管道
+  app.useGlobalPipes(new ValidationPipe({
+    whitelist: true,
+    forbidNonWhitelisted: true,
+    transform: true,
+  }));
+
+  // API前缀
+  app.setGlobalPrefix('api/v1');
+
+  // CORS配置
+  app.enableCors({
+    origin: process.env.NODE_ENV === 'production' 
+      ? ['https://example.com'] 
+      : true,
+    credentials: true,
+  });
+
+  // 仅在非生产环境启用Swagger
+  if (process.env.NODE_ENV !== 'production') {
+    setupSwagger(app);
+  }
+
+  const port = process.env.PORT || 3000;
+  await app.listen(port);
+  
+  console.log('🚀 应用启动成功!');
+  console.log(`📖 API文档地址: http://localhost:${port}/api/docs`);
+}
+bootstrap();
+```
+
+## 8. 访问API文档
+
+启动应用后，访问以下地址查看API文档：
+
+- **开发环境**: http://localhost:3000/api/docs
+- **JSON格式**: http://localhost:3000/api/docs-json
+- **YAML格式**: http://localhost:3000/api/docs-yaml
+
+API文档包含：
+- 📋 完整的接口列表和参数说明
+- 🔐 JWT认证测试功能
+- 📝 请求/响应示例
+- 🧪 在线接口测试功能
+- 📊 数据模型定义
diff --git a/docs/template-management-system.md b/docs/template-management-system.md
new file mode 100644
index 0000000..2501e18
--- /dev/null
+++ b/docs/template-management-system.md
@@ -0,0 +1,1668 @@
+# AI模板管理系统设计方案 (面向对象版本)
+
+## 1. 系统概述
+
+### 1.1 核心目标
+- **统一接口**: 通过抽象类抹平不同AI模型和API的调用差异
+- **模板化管理**: 将复杂的AI调用封装为简单的模板类
+- **类型安全**: 利用TypeScript的类型系统确保参数和返回值的正确性
+- **易于扩展**: 通过继承轻松添加新的模板类型
+
+### 1.2 设计优势
+- **编译时检查**: TypeScript编译时就能发现接口不匹配问题
+- **代码复用**: 通过继承实现通用逻辑的复用
+- **类型推导**: IDE能提供完整的代码提示和类型检查
+- **易于测试**: 每个模板类都可以独立进行单元测试
+
+### 1.3 模板类型示例
+- **换装模板**: 图片 + 服装描述 → 换装后图片
+- **抠图模板**: 图片 + 物体描述 → 抠图视频
+- **风格转换**: 图片 + 风格描述 → 风格化图片
+- **背景替换**: 图片 + 背景描述 → 新背景图片
+
+## 2. 核心抽象类设计
+
+### 2.1 基础模板抽象类
+```typescript
+// src/templates/base/template.abstract.ts
+export interface TemplateMetadata {
+  code: string;
+  name: string;
+  description: string;
+  category: string;
+  creditCost: number;
+  version: string;
+  previewImageUrl?: string;
+}
+
+export interface TemplateExecutionContext {
+  userId: string;
+  platform: string;
+  requestId: string;
+  timestamp: Date;
+}
+
+export interface TemplateExecutionResult<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  metadata: {
+    executionTime: number;
+    creditCost: number;
+    templateCode: string;
+    aiProvider?: string;
+  };
+}
+
+export abstract class Template<TInput = any, TOutput = any> {
+  // 模板元数据
+  abstract readonly metadata: TemplateMetadata;
+
+  // 模板是否启用
+  protected _enabled: boolean = true;
+
+  constructor() {
+    this.validateTemplate();
+  }
+
+  // 获取模板信息
+  getMetadata(): TemplateMetadata {
+    return { ...this.metadata };
+  }
+
+  // 检查模板是否启用
+  isEnabled(): boolean {
+    return this._enabled;
+  }
+
+  // 启用/禁用模板
+  setEnabled(enabled: boolean): void {
+    this._enabled = enabled;
+  }
+
+  // 验证输入参数 - 子类必须实现
+  abstract validateInput(input: TInput): Promise<string[]>;
+
+  // 执行模板 - 子类必须实现
+  abstract execute(input: TInput, context: TemplateExecutionContext): Promise<TOutput>;
+
+  // 获取参数定义 - 用于前端生成表单
+  abstract getParameterDefinitions(): ParameterDefinition[];
+
+  // 模板执行入口 - 统一的执行流程
+  async run(input: TInput, context: TemplateExecutionContext): Promise<TemplateExecutionResult<TOutput>> {
+    const startTime = Date.now();
+
+    try {
+      // 检查模板是否启用
+      if (!this.isEnabled()) {
+        throw new Error(`模板 ${this.metadata.code} 已禁用`);
+      }
+
+      // 验证输入参数
+      const validationErrors = await this.validateInput(input);
+      if (validationErrors.length > 0) {
+        throw new Error(`参数验证失败: ${validationErrors.join(', ')}`);
+      }
+
+      // 执行模板
+      const result = await this.execute(input, context);
+      const executionTime = Date.now() - startTime;
+
+      return {
+        success: true,
+        data: result,
+        metadata: {
+          executionTime,
+          creditCost: this.metadata.creditCost,
+          templateCode: this.metadata.code,
+        }
+      };
+
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+
+      return {
+        success: false,
+        error: error.message,
+        metadata: {
+          executionTime,
+          creditCost: 0, // 失败不扣积分
+          templateCode: this.metadata.code,
+        }
+      };
+    }
+  }
+
+  // 验证模板定义的完整性
+  private validateTemplate(): void {
+    if (!this.metadata.code) {
+      throw new Error('模板代码不能为空');
+    }
+    if (!this.metadata.name) {
+      throw new Error('模板名称不能为空');
+    }
+    if (this.metadata.creditCost < 0) {
+      throw new Error('积分消耗不能为负数');
+    }
+  }
+}
+```
+
+### 2.2 参数定义接口
+```typescript
+// src/templates/base/parameter.interface.ts
+export enum ParameterType {
+  STRING = 'string',
+  NUMBER = 'number',
+  BOOLEAN = 'boolean',
+  IMAGE = 'image',
+  SELECT = 'select',
+  RANGE = 'range',
+  ARRAY = 'array'
+}
+
+export interface ParameterValidation {
+  required?: boolean;
+  min?: number;
+  max?: number;
+  options?: string[];
+  pattern?: string;
+  minLength?: number;
+  maxLength?: number;
+}
+
+export interface ParameterDefinition {
+  key: string;
+  displayName: string;
+  description: string;
+  type: ParameterType;
+  defaultValue?: any;
+  validation?: ParameterValidation;
+  order: number;
+}
+```
+
+### 2.3 图片生成模板抽象类
+```typescript
+// src/templates/base/image-generate-template.abstract.ts
+import { Template, TemplateExecutionContext } from './template.abstract';
+
+export interface ImageGenerateInput {
+  prompt: string;
+  inputImage?: string; // base64 或 URL
+  width?: number;
+  height?: number;
+  quality?: 'standard' | 'high' | 'ultra';
+  style?: string;
+  [key: string]: any; // 允许扩展参数
+}
+
+export interface ImageGenerateOutput {
+  images: Array<{
+    url: string;
+    thumbnailUrl?: string;
+    width: number;
+    height: number;
+    format: string;
+  }>;
+  seed?: number;
+  parameters?: Record<string, any>;
+}
+
+export abstract class ImageGenerateTemplate extends Template<ImageGenerateInput, ImageGenerateOutput> {
+  // 通用的图片参数验证
+  async validateInput(input: ImageGenerateInput): Promise<string[]> {
+    const errors: string[] = [];
+
+    // 验证提示词
+    if (!input.prompt || input.prompt.trim().length === 0) {
+      errors.push('提示词不能为空');
+    }
+
+    if (input.prompt && input.prompt.length > 1000) {
+      errors.push('提示词长度不能超过1000个字符');
+    }
+
+    // 验证图片尺寸
+    if (input.width && (input.width < 256 || input.width > 2048)) {
+      errors.push('图片宽度必须在256-2048之间');
+    }
+
+    if (input.height && (input.height < 256 || input.height > 2048)) {
+      errors.push('图片高度必须在256-2048之间');
+    }
+
+    // 验证输入图片
+    if (input.inputImage && !this.isValidImageData(input.inputImage)) {
+      errors.push('输入图片格式不正确');
+    }
+
+    // 调用子类的自定义验证
+    const customErrors = await this.validateCustomInput(input);
+    errors.push(...customErrors);
+
+    return errors;
+  }
+
+  // 子类可以重写此方法添加自定义验证
+  protected async validateCustomInput(input: ImageGenerateInput): Promise<string[]> {
+    return [];
+  }
+
+  // 验证图片数据格式
+  protected isValidImageData(imageData: string): boolean {
+    // base64格式
+    if (imageData.startsWith('data:image/')) {
+      return /^data:image\/(jpeg|jpg|png|gif|webp);base64,/.test(imageData);
+    }
+    // URL格式
+    return /^https?:\/\/.+\.(jpeg|jpg|png|gif|webp)$/i.test(imageData);
+  }
+
+  // 获取通用的图片生成参数定义
+  protected getCommonParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'prompt',
+        displayName: '提示词',
+        description: '描述想要生成的图片内容',
+        type: ParameterType.STRING,
+        validation: { required: true, minLength: 1, maxLength: 1000 },
+        order: 1,
+      },
+      {
+        key: 'quality',
+        displayName: '生成质量',
+        description: '选择生成质量等级',
+        type: ParameterType.SELECT,
+        defaultValue: 'standard',
+        validation: { options: ['standard', 'high', 'ultra'] },
+        order: 100,
+      }
+    ];
+  }
+}
+```
+
+### 2.4 视频生成模板抽象类
+```typescript
+// src/templates/base/video-generate-template.abstract.ts
+import { Template, TemplateExecutionContext } from './template.abstract';
+
+export interface VideoGenerateInput {
+  prompt: string;
+  inputImage?: string;
+  duration?: number; // 秒
+  fps?: number;
+  resolution?: '720p' | '1080p' | '4k';
+  style?: string;
+  [key: string]: any;
+}
+
+export interface VideoGenerateOutput {
+  videoUrl: string;
+  thumbnailUrl?: string;
+  duration: number;
+  fps: number;
+  resolution: string;
+  format: string;
+  fileSize?: number;
+}
+
+export abstract class VideoGenerateTemplate extends Template<VideoGenerateInput, VideoGenerateOutput> {
+  async validateInput(input: VideoGenerateInput): Promise<string[]> {
+    const errors: string[] = [];
+
+    // 验证提示词
+    if (!input.prompt || input.prompt.trim().length === 0) {
+      errors.push('提示词不能为空');
+    }
+
+    // 验证时长
+    if (input.duration && (input.duration < 1 || input.duration > 30)) {
+      errors.push('视频时长必须在1-30秒之间');
+    }
+
+    // 验证帧率
+    if (input.fps && (input.fps < 12 || input.fps > 60)) {
+      errors.push('帧率必须在12-60之间');
+    }
+
+    // 验证输入图片
+    if (input.inputImage && !this.isValidImageData(input.inputImage)) {
+      errors.push('输入图片格式不正确');
+    }
+
+    // 调用子类的自定义验证
+    const customErrors = await this.validateCustomInput(input);
+    errors.push(...customErrors);
+
+    return errors;
+  }
+
+  protected async validateCustomInput(input: VideoGenerateInput): Promise<string[]> {
+    return [];
+  }
+
+  protected isValidImageData(imageData: string): boolean {
+    if (imageData.startsWith('data:image/')) {
+      return /^data:image\/(jpeg|jpg|png|gif|webp);base64,/.test(imageData);
+    }
+    return /^https?:\/\/.+\.(jpeg|jpg|png|gif|webp)$/i.test(imageData);
+  }
+
+  protected getCommonParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'prompt',
+        displayName: '提示词',
+        description: '描述想要生成的视频内容',
+        type: ParameterType.STRING,
+        validation: { required: true, minLength: 1, maxLength: 500 },
+        order: 1,
+      },
+      {
+        key: 'duration',
+        displayName: '视频时长',
+        description: '生成视频的时长（秒）',
+        type: ParameterType.RANGE,
+        defaultValue: 4,
+        validation: { min: 1, max: 30 },
+        order: 90,
+      },
+      {
+        key: 'resolution',
+        displayName: '分辨率',
+        description: '选择视频分辨率',
+        type: ParameterType.SELECT,
+        defaultValue: '720p',
+        validation: { options: ['720p', '1080p', '4k'] },
+        order: 95,
+      }
+    ];
+  }
+}
+```
+
+## 3. 模板管理器
+
+### 3.1 模板管理器 (TemplateManager)
+```typescript
+// src/services/template-manager.service.ts
+import { Injectable, OnModuleInit, Logger } from '@nestjs/common';
+import { Template, TemplateExecutionContext, TemplateExecutionResult } from '../templates/base/template.abstract';
+import { ParameterDefinition } from '../templates/base/parameter.interface';
+
+export interface TemplateInfo {
+  code: string;
+  name: string;
+  description: string;
+  category: string;
+  creditCost: number;
+  version: string;
+  enabled: boolean;
+  parameters: ParameterDefinition[];
+}
+
+@Injectable()
+export class TemplateManager implements OnModuleInit {
+  private readonly logger = new Logger(TemplateManager.name);
+  private readonly templates = new Map<string, Template>();
+
+  async onModuleInit() {
+    // 启动时自动注册所有模板
+    await this.registerAllTemplates();
+  }
+
+  // 注册模板
+  registerTemplate(template: Template): void {
+    const code = template.getMetadata().code;
+
+    if (this.templates.has(code)) {
+      this.logger.warn(`模板 ${code} 已存在，将被覆盖`);
+    }
+
+    this.templates.set(code, template);
+    this.logger.log(`模板 ${code} 注册成功`);
+  }
+
+  // 批量注册模板
+  registerTemplates(templates: Template[]): void {
+    templates.forEach(template => this.registerTemplate(template));
+  }
+
+  // 卸载模板
+  unregisterTemplate(templateCode: string): boolean {
+    if (this.templates.has(templateCode)) {
+      this.templates.delete(templateCode);
+      this.logger.log(`模板 ${templateCode} 已卸载`);
+      return true;
+    }
+    return false;
+  }
+
+  // 获取模板
+  getTemplate(templateCode: string): Template | null {
+    return this.templates.get(templateCode) || null;
+  }
+
+  // 获取所有模板信息
+  getAllTemplates(): TemplateInfo[] {
+    return Array.from(this.templates.values()).map(template => ({
+      ...template.getMetadata(),
+      enabled: template.isEnabled(),
+      parameters: template.getParameterDefinitions(),
+    }));
+  }
+
+  // 获取启用的模板
+  getEnabledTemplates(): TemplateInfo[] {
+    return this.getAllTemplates().filter(template => template.enabled);
+  }
+
+  // 按分类获取模板
+  getTemplatesByCategory(category: string): TemplateInfo[] {
+    return this.getAllTemplates().filter(template =>
+      template.category === category && template.enabled
+    );
+  }
+
+  // 搜索模板
+  searchTemplates(keyword: string): TemplateInfo[] {
+    const lowerKeyword = keyword.toLowerCase();
+    return this.getAllTemplates().filter(template =>
+      template.enabled && (
+        template.name.toLowerCase().includes(lowerKeyword) ||
+        template.description.toLowerCase().includes(lowerKeyword) ||
+        template.category.toLowerCase().includes(lowerKeyword)
+      )
+    );
+  }
+
+  // 启用/禁用模板
+  setTemplateEnabled(templateCode: string, enabled: boolean): boolean {
+    const template = this.getTemplate(templateCode);
+    if (template) {
+      template.setEnabled(enabled);
+      this.logger.log(`模板 ${templateCode} ${enabled ? '已启用' : '已禁用'}`);
+      return true;
+    }
+    return false;
+  }
+
+  // 执行模板
+  async executeTemplate<TInput, TOutput>(
+    templateCode: string,
+    input: TInput,
+    context: TemplateExecutionContext
+  ): Promise<TemplateExecutionResult<TOutput>> {
+    const template = this.getTemplate(templateCode);
+
+    if (!template) {
+      return {
+        success: false,
+        error: `模板 ${templateCode} 不存在`,
+        metadata: {
+          executionTime: 0,
+          creditCost: 0,
+          templateCode,
+        }
+      };
+    }
+
+    this.logger.log(`开始执行模板 ${templateCode}，用户: ${context.userId}`);
+
+    const result = await template.run(input, context);
+
+    this.logger.log(
+      `模板 ${templateCode} 执行${result.success ? '成功' : '失败'}，` +
+      `耗时: ${result.metadata.executionTime}ms`
+    );
+
+    return result;
+  }
+
+  // 获取模板统计信息
+  getStatistics() {
+    const allTemplates = this.getAllTemplates();
+    const enabledTemplates = allTemplates.filter(t => t.enabled);
+
+    const categoryCounts = allTemplates.reduce((acc, template) => {
+      acc[template.category] = (acc[template.category] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    return {
+      total: allTemplates.length,
+      enabled: enabledTemplates.length,
+      disabled: allTemplates.length - enabledTemplates.length,
+      categories: categoryCounts,
+    };
+  }
+
+  // 自动注册所有模板 - 在实际项目中，这里会导入所有模板类
+  private async registerAllTemplates(): Promise<void> {
+    // 这里会自动导入和注册所有模板
+    // 在实际项目中，可以通过文件扫描或者手动导入的方式
+    this.logger.log('开始注册模板...');
+
+    // 示例：手动注册模板（实际项目中可以自动化）
+    // const outfitChangeTemplate = new OutfitChangeTemplate();
+    // this.registerTemplate(outfitChangeTemplate);
+
+    this.logger.log(`模板注册完成，共注册 ${this.templates.size} 个模板`);
+  }
+}
+```
+
+### 3.2 模板工厂 (TemplateFactory)
+```typescript
+// src/templates/template.factory.ts
+import { Injectable } from '@nestjs/common';
+import { Template } from './base/template.abstract';
+
+// 导入所有具体模板类
+import { OutfitChangeTemplate } from './image/outfit-change.template';
+import { ImageToVideoTemplate } from './video/image-to-video.template';
+import { PortraitEnhanceTemplate } from './image/portrait-enhance.template';
+import { StyleTransferTemplate } from './image/style-transfer.template';
+import { BackgroundReplaceTemplate } from './image/background-replace.template';
+
+@Injectable()
+export class TemplateFactory {
+  // 创建所有模板实例
+  createAllTemplates(): Template[] {
+    return [
+      new OutfitChangeTemplate(),
+      new ImageToVideoTemplate(),
+      new PortraitEnhanceTemplate(),
+      new StyleTransferTemplate(),
+      new BackgroundReplaceTemplate(),
+      // 在这里添加新的模板类
+    ];
+  }
+
+  // 根据代码创建特定模板
+  createTemplate(templateCode: string): Template | null {
+    const templates = this.createAllTemplates();
+    return templates.find(template =>
+      template.getMetadata().code === templateCode
+    ) || null;
+  }
+
+  // 获取所有可用的模板代码
+  getAvailableTemplateCodes(): string[] {
+    return this.createAllTemplates().map(template =>
+      template.getMetadata().code
+    );
+  }
+}
+```
+
+## 4. 具体模板实现示例
+
+### 4.1 换装模板实现
+```typescript
+// src/templates/image/outfit-change.template.ts
+import { Injectable } from '@nestjs/common';
+import { ImageGenerateTemplate, ImageGenerateInput, ImageGenerateOutput } from '../base/image-generate-template.abstract';
+import { TemplateMetadata, TemplateExecutionContext } from '../base/template.abstract';
+import { ParameterDefinition, ParameterType } from '../base/parameter.interface';
+import { BowongAIService } from '../../services/bowongai.service';
+
+interface OutfitChangeInput extends ImageGenerateInput {
+  inputImage: string; // 必填
+  clothingDescription: string;
+  style?: 'casual' | 'formal' | 'vintage' | 'modern' | 'elegant';
+}
+
+@Injectable()
+export class OutfitChangeTemplate extends ImageGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'outfit_change_v1',
+    name: '智能换装',
+    description: '上传人物图片，描述想要的服装，AI自动生成换装效果',
+    category: '换装',
+    creditCost: 15,
+    version: '1.0.0',
+    previewImageUrl: '/images/templates/outfit-change-preview.jpg',
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {
+    super();
+  }
+
+  async execute(input: OutfitChangeInput, context: TemplateExecutionContext): Promise<ImageGenerateOutput> {
+    // 构建换装专用提示词
+    const prompt = this.buildOutfitChangePrompt(input);
+
+    // 调用BowongAI基础服务，传入换装模板的特定参数
+    const result = await this.bowongAI.imageToImage({
+      prompt,
+      imageUrl: input.inputImage,
+      model: 'gemini-2.5-flash-image-preview', // 换装模板专用模型
+    });
+
+    // 转换为标准输出格式
+    return {
+      images: result.images.map(img => ({
+        url: img.url,
+        thumbnailUrl: img.thumbnailUrl,
+        width: img.width,
+        height: img.height,
+        format: 'png',
+      })),
+      parameters: {
+        prompt,
+        model: 'gemini-2.5-flash-image-preview',
+        workflow: '图生图',
+        templateType: 'outfit_change',
+      },
+    };
+  }
+
+  protected async validateCustomInput(input: OutfitChangeInput): Promise<string[]> {
+    const errors: string[] = [];
+
+    // 验证必须有输入图片
+    if (!input.inputImage) {
+      errors.push('必须提供人物图片');
+    }
+
+    // 验证服装描述
+    if (!input.clothingDescription || input.clothingDescription.trim().length < 3) {
+      errors.push('服装描述至少需要3个字符');
+    }
+
+    if (input.clothingDescription && input.clothingDescription.length > 200) {
+      errors.push('服装描述不能超过200个字符');
+    }
+
+    return errors;
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'inputImage',
+        displayName: '人物图片',
+        description: '请上传清晰的人物图片，建议分辨率1024x1024',
+        type: ParameterType.IMAGE,
+        validation: { required: true },
+        order: 1,
+      },
+      {
+        key: 'clothingDescription',
+        displayName: '服装描述',
+        description: '详细描述想要的服装样式，如"红色连衣裙"、"黑色西装"等',
+        type: ParameterType.STRING,
+        validation: { required: true, minLength: 3, maxLength: 200 },
+        order: 2,
+      },
+      {
+        key: 'style',
+        displayName: '风格',
+        description: '选择服装风格',
+        type: ParameterType.SELECT,
+        defaultValue: 'casual',
+        validation: { options: ['casual', 'formal', 'vintage', 'modern', 'elegant'] },
+        order: 3,
+      },
+      ...this.getCommonParameterDefinitions(),
+    ];
+  }
+
+  private buildOutfitChangePrompt(input: OutfitChangeInput): string {
+    const styleMap = {
+      casual: 'casual everyday wear',
+      formal: 'formal business attire',
+      vintage: 'vintage retro style',
+      modern: 'modern contemporary fashion',
+      elegant: 'elegant sophisticated style',
+    };
+
+    const styleText = input.style ? styleMap[input.style] : 'casual everyday wear';
+
+    return `Please convert this photo into a highly detailed character model wearing ${input.clothingDescription}.
+Style: ${styleText}.
+Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo.
+Behind the box, show a computer screen actively displaying the modeling process.
+In front of the box, position the completed character model based on the provided photo, with the ${styleText} clothing clearly and realistically rendered.
+Set the entire scene in a bright, stylish indoor environment resembling a toy collector's or hobbyist's room—full of refined details, vibrant décor, and playful atmosphere.
+Ensure the lighting is crisp and luminous, highlighting both the model and its packaging.`;
+  }
+}
+```
+
+### 4.2 抠图模板实现
+```typescript
+// src/templates/video/image-to-video.template.ts
+import { Injectable } from '@nestjs/common';
+import { VideoGenerateTemplate, VideoGenerateInput, VideoGenerateOutput } from '../base/video-generate-template.abstract';
+import { TemplateMetadata, TemplateExecutionContext } from '../base/template.abstract';
+import { ParameterDefinition, ParameterType } from '../base/parameter.interface';
+import { BowongAIService } from '../../services/bowongai.service';
+
+interface ImageToVideoInput extends VideoGenerateInput {
+  inputImage: string; // 必填
+  videoPrompt?: string; // 视频生成提示词
+}
+
+@Injectable()
+export class ImageToVideoTemplate extends VideoGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'image_to_video_v1',
+    name: '图生视频',
+    description: '上传图片，生成动态视频效果',
+    category: '视频生成',
+    creditCost: 50,
+    version: '1.0.0',
+    previewImageUrl: '/images/templates/image-to-video-preview.jpg',
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {
+    super();
+  }
+
+  async execute(input: ImageToVideoInput, context: TemplateExecutionContext): Promise<VideoGenerateOutput> {
+    // 构建图生视频专用提示词
+    const imagePrompt = this.buildImagePrompt(input);
+    const videoPrompt = this.buildVideoPrompt(input);
+
+    const result = await this.bowongAI.imageToVideo({
+      imagePrompt,
+      videoPrompt,
+      imageUrl: input.inputImage,
+      duration: input.duration || 6,
+      aspectRatio: input.resolution || '9:16',
+      imageModel: 'gemini-2.5-flash-image-preview',
+      videoModel: '302/MiniMax-Hailuo-02',
+    });
+
+    return {
+      videoUrl: result.videoUrl,
+      thumbnailUrl: result.thumbnailUrl,
+      duration: result.duration,
+      fps: result.fps,
+      resolution: result.resolution,
+      format: 'mp4',
+    };
+  }
+
+  protected async validateCustomInput(input: ImageToVideoInput): Promise<string[]> {
+    const errors: string[] = [];
+
+    if (!input.inputImage) {
+      errors.push('必须提供原始图片');
+    }
+
+    if (input.videoPrompt && input.videoPrompt.length > 200) {
+      errors.push('视频提示词不能超过200个字符');
+    }
+
+    return errors;
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'inputImage',
+        displayName: '原始图片',
+        description: '请上传要生成视频的图片',
+        type: ParameterType.IMAGE,
+        validation: { required: true },
+        order: 1,
+      },
+      {
+        key: 'videoPrompt',
+        displayName: '视频提示词',
+        description: '描述想要的视频效果（可选）',
+        type: ParameterType.STRING,
+        validation: { maxLength: 200 },
+        order: 2,
+      },
+      {
+        key: 'resolution',
+        displayName: '视频比例',
+        description: '选择视频比例',
+        type: ParameterType.SELECT,
+        defaultValue: '9:16',
+        validation: { options: ['9:16', '16:9'] },
+        order: 3,
+      },
+      ...this.getCommonParameterDefinitions(),
+    ];
+  }
+
+  private buildImagePrompt(input: ImageToVideoInput): string {
+    return `Please convert this photo into a highly detailed character model.
+Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo.
+Behind the box, show a computer screen actively displaying the Blender modeling process.
+In front of the box, position the completed character model based on the provided photo, with the PVC texture clearly and realistically rendered.
+Set the entire scene in a bright, stylish indoor environment resembling a toy collector's or hobbyist's room—full of refined details, vibrant décor, and playful atmosphere.
+Ensure the lighting is crisp and luminous, highlighting both the model and its packaging.`;
+  }
+
+  private buildVideoPrompt(input: ImageToVideoInput): string {
+    const baseVideoPrompt = 'Create gentle natural movements and subtle animations';
+
+    if (input.videoPrompt) {
+      return `${baseVideoPrompt}. ${input.videoPrompt}. Maintain character consistency throughout the animation.`;
+    }
+
+    return `${baseVideoPrompt}. Natural lifelike movement with smooth transitions.`;
+  }
+}
+```
+
+### 4.3 人像增强模板实现（示例）
+```typescript
+// src/templates/image/portrait-enhance.template.ts
+import { Injectable } from '@nestjs/common';
+import { ImageGenerateTemplate, ImageGenerateInput, ImageGenerateOutput } from '../base/image-generate-template.abstract';
+import { TemplateMetadata, TemplateExecutionContext } from '../base/template.abstract';
+import { ParameterDefinition, ParameterType } from '../base/parameter.interface';
+import { BowongAIService } from '../../services/bowongai.service';
+
+interface PortraitEnhanceInput extends ImageGenerateInput {
+  inputImage: string; // 必填
+  enhanceLevel: 'subtle' | 'moderate' | 'dramatic';
+  lightingStyle?: 'natural' | 'studio' | 'soft' | 'dramatic';
+}
+
+@Injectable()
+export class PortraitEnhanceTemplate extends ImageGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'portrait_enhance_v1',
+    name: '人像增强',
+    description: '专业级人像照片增强，提升画质和美观度',
+    category: '人像处理',
+    creditCost: 12,
+    version: '1.0.0',
+    previewImageUrl: '/images/templates/portrait-enhance-preview.jpg',
+  };
+
+  constructor(private readonly bowongAI: BowongAIService) {
+    super();
+  }
+
+  async execute(input: PortraitEnhanceInput, context: TemplateExecutionContext): Promise<ImageGenerateOutput> {
+    // 构建人像增强专用提示词
+    const prompt = this.buildPortraitPrompt(input);
+
+    // 调用BowongAI基础服务，传入人像增强模板的特定参数
+    const result = await this.bowongAI.imageToImage({
+      prompt,
+      imageUrl: input.inputImage,
+      model: 'gemini-2.5-flash-image-preview', // 人像增强专用模型
+    });
+
+    return {
+      images: result.images.map(img => ({
+        url: img.url,
+        thumbnailUrl: img.thumbnailUrl,
+        width: img.width,
+        height: img.height,
+        format: 'png',
+      })),
+      parameters: {
+        prompt,
+        model: 'gemini-2.5-flash-image-preview',
+        workflow: '图生图',
+        templateType: 'portrait_enhance',
+        enhanceLevel: input.enhanceLevel,
+      },
+    };
+  }
+
+  protected async validateCustomInput(input: PortraitEnhanceInput): Promise<string[]> {
+    const errors: string[] = [];
+
+    if (!input.inputImage) {
+      errors.push('必须提供人像图片');
+    }
+
+    const validEnhanceLevels = ['subtle', 'moderate', 'dramatic'];
+    if (!validEnhanceLevels.includes(input.enhanceLevel)) {
+      errors.push('增强级别必须是: subtle, moderate, dramatic 之一');
+    }
+
+    return errors;
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'inputImage',
+        displayName: '人像图片',
+        description: '请上传需要增强的人像照片',
+        type: ParameterType.IMAGE,
+        validation: { required: true },
+        order: 1,
+      },
+      {
+        key: 'enhanceLevel',
+        displayName: '增强级别',
+        description: '选择增强程度',
+        type: ParameterType.SELECT,
+        defaultValue: 'moderate',
+        validation: { options: ['subtle', 'moderate', 'dramatic'] },
+        order: 2,
+      },
+      {
+        key: 'lightingStyle',
+        displayName: '光照风格',
+        description: '选择光照效果（可选）',
+        type: ParameterType.SELECT,
+        defaultValue: 'natural',
+        validation: { options: ['natural', 'studio', 'soft', 'dramatic'] },
+        order: 3,
+      },
+      ...this.getCommonParameterDefinitions(),
+    ];
+  }
+
+  private buildPortraitPrompt(input: PortraitEnhanceInput): string {
+    const enhancementLevels = {
+      subtle: 'Apply subtle professional enhancements',
+      moderate: 'Apply moderate quality improvements',
+      dramatic: 'Apply dramatic professional transformation',
+    };
+
+    const lightingStyles = {
+      natural: 'natural lighting',
+      studio: 'professional studio lighting',
+      soft: 'soft diffused lighting',
+      dramatic: 'dramatic cinematic lighting',
+    };
+
+    const enhancement = enhancementLevels[input.enhanceLevel] || 'moderate';
+    const lighting = lightingStyles[input.lightingStyle] || 'natural lighting';
+
+    return `${enhancement} to this portrait photo.
+Improve skin texture, clarity, and overall quality while maintaining natural appearance.
+Focus on professional photography quality with ${lighting}.
+Preserve the person's unique features and expressions.
+Enhance details without over-processing or creating artificial effects.`;
+  }
+}
+```
+
+## 5. 模板服务集成
+
+### 5.1 模板服务 (TemplateService)
+```typescript
+// src/services/template.service.ts
+import { Injectable } from '@nestjs/common';
+import { TemplateManager } from './template-manager.service';
+import { TemplateFactory } from '../templates/template.factory';
+import { CreditService } from './credit.service';
+import { TemplateExecutionContext } from '../templates/base/template.abstract';
+
+@Injectable()
+export class TemplateService {
+  constructor(
+    private readonly templateManager: TemplateManager,
+    private readonly templateFactory: TemplateFactory,
+    private readonly creditService: CreditService,
+  ) {
+    // 初始化时注册所有模板
+    this.initializeTemplates();
+  }
+
+  // 执行模板（带积分检查）
+  async executeTemplate(
+    templateCode: string,
+    input: any,
+    userId: string,
+    platform: string
+  ) {
+    // 1. 获取模板信息
+    const template = this.templateManager.getTemplate(templateCode);
+    if (!template) {
+      throw new Error(`模板 ${templateCode} 不存在`);
+    }
+
+    const metadata = template.getMetadata();
+
+    // 2. 检查用户积分
+    const hasEnoughCredits = await this.creditService.checkBalance(
+      userId,
+      platform as any,
+      metadata.creditCost
+    );
+
+    if (!hasEnoughCredits) {
+      throw new Error('积分不足');
+    }
+
+    // 3. 执行模板
+    const context: TemplateExecutionContext = {
+      userId,
+      platform,
+      requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: new Date(),
+    };
+
+    const result = await this.templateManager.executeTemplate(templateCode, input, context);
+
+    // 4. 扣除积分（仅在成功时）
+    if (result.success) {
+      await this.creditService.consumeCredits(
+        userId,
+        platform as any,
+        metadata.creditCost,
+        'ai_generation' as any,
+        context.requestId
+      );
+    }
+
+    return result;
+  }
+
+  // 获取所有可用模板
+  getAvailableTemplates() {
+    return this.templateManager.getEnabledTemplates();
+  }
+
+  // 按分类获取模板
+  getTemplatesByCategory(category: string) {
+    return this.templateManager.getTemplatesByCategory(category);
+  }
+
+  // 搜索模板
+  searchTemplates(keyword: string) {
+    return this.templateManager.searchTemplates(keyword);
+  }
+
+  // 获取模板详情
+  getTemplateInfo(templateCode: string) {
+    const template = this.templateManager.getTemplate(templateCode);
+    if (!template) {
+      return null;
+    }
+
+    return {
+      ...template.getMetadata(),
+      enabled: template.isEnabled(),
+      parameters: template.getParameterDefinitions(),
+    };
+  }
+
+  // 获取统计信息
+  getStatistics() {
+    return this.templateManager.getStatistics();
+  }
+
+  // 初始化模板
+  private initializeTemplates() {
+    const templates = this.templateFactory.createAllTemplates();
+    this.templateManager.registerTemplates(templates);
+  }
+}
+```
+
+### 5.2 模板控制器
+```typescript
+// src/controllers/template.controller.ts
+import { Controller, Get, Post, Body, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
+import { TemplateService } from '../services/template.service';
+import { JwtAuthGuard } from '../guards/jwt-auth.guard';
+import { CurrentUser } from '../decorators/current-user.decorator';
+
+@ApiTags('🎨 AI模板系统')
+@Controller('templates')
+export class TemplateController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get()
+  @ApiOperation({ summary: '获取所有可用模板' })
+  async getAvailableTemplates(@Query('category') category?: string) {
+    if (category) {
+      return this.templateService.getTemplatesByCategory(category);
+    }
+    return this.templateService.getAvailableTemplates();
+  }
+
+  @Get('search')
+  @ApiOperation({ summary: '搜索模板' })
+  async searchTemplates(@Query('keyword') keyword: string) {
+    if (!keyword) {
+      throw new Error('搜索关键词不能为空');
+    }
+    return this.templateService.searchTemplates(keyword);
+  }
+
+  @Get('statistics')
+  @ApiOperation({ summary: '获取模板统计信息' })
+  async getStatistics() {
+    return this.templateService.getStatistics();
+  }
+
+  @Get(':templateCode')
+  @ApiOperation({ summary: '获取模板详情' })
+  async getTemplateInfo(@Param('templateCode') templateCode: string) {
+    const templateInfo = this.templateService.getTemplateInfo(templateCode);
+    if (!templateInfo) {
+      throw new Error('模板不存在');
+    }
+    return templateInfo;
+  }
+
+  @Post(':templateCode/execute')
+  @UseGuards(JwtAuthGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: '执行模板' })
+  async executeTemplate(
+    @Param('templateCode') templateCode: string,
+    @Body() input: any,
+    @CurrentUser() user: any
+  ) {
+    return this.templateService.executeTemplate(
+      templateCode,
+      input,
+      user.id,
+      user.platform
+    );
+  }
+}
+```
+
+## 5. AI服务集成
+
+### 5.1 AI服务接口
+```typescript
+// src/services/ai-service.interface.ts
+export interface ImageToImageRequest {
+  prompt: string;
+  initImage: string;
+  strength?: number;
+  cfgScale?: number;
+  steps?: number;
+  width?: number;
+  height?: number;
+}
+
+export interface ImageToImageResponse {
+  images: Array<{
+    url: string;
+    thumbnailUrl?: string;
+    width: number;
+    height: number;
+  }>;
+  seed?: number;
+}
+
+export interface ImageToVideoRequest {
+  prompt: string;
+  image: string;
+  duration?: number;
+  fps?: number;
+  resolution?: string;
+}
+
+export interface ImageToVideoResponse {
+  videoUrl: string;
+  thumbnailUrl?: string;
+  duration: number;
+  fps: number;
+  resolution: string;
+  fileSize?: number;
+}
+```
+
+### 5.2 BowongAI 基础服务实现
+```typescript
+// src/services/bowongai.service.ts
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+
+export interface BowongAIImageOptions {
+  prompt: string;
+  imageUrl: string;
+  model?: string;
+}
+
+export interface BowongAIVideoOptions {
+  imagePrompt: string;
+  videoPrompt: string;
+  imageUrl: string;
+  duration?: number;
+  aspectRatio?: string;
+  imageModel?: string;
+  videoModel?: string;
+}
+
+export interface BowongAIImageRequest {
+  workflow: '图生图' | '图生图+生视频';
+  environment: string;
+  image_generation: {
+    model: string;
+    prompt: string;
+    image_url: string;
+  };
+  video_generation?: {
+    model: string;
+    prompt: string;
+    duration: string;
+    aspect_ratio: string;
+  };
+}
+
+export interface BowongAIResponse {
+  success: boolean;
+  data?: {
+    image_url?: string;
+    video_url?: string;
+    task_id?: string;
+  };
+  error?: string;
+}
+
+@Injectable()
+export class BowongAIService {
+  private readonly webhookUrl: string;
+  private readonly environment: string;
+
+  constructor(private readonly configService: ConfigService) {
+    this.webhookUrl = this.configService.get('BOWONGAI_WEBHOOK_URL',
+      'https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14');
+    this.environment = this.configService.get('BOWONGAI_ENVIRONMENT',
+      'https://bowongai-test--text-video-agent-fastapi-app.modal.run');
+  }
+
+  // 通用图生图接口 - 各模板传入自己的参数
+  async imageToImage(options: BowongAIImageOptions) {
+    const payload: BowongAIImageRequest = {
+      workflow: '图生图',
+      environment: this.environment,
+      image_generation: {
+        model: options.model || 'gemini-2.5-flash-image-preview',
+        prompt: options.prompt,
+        image_url: options.imageUrl,
+      },
+    };
+
+    const response = await axios.post(this.webhookUrl, payload, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: 120000,
+    });
+
+    if (!response.data.success) {
+      throw new Error(response.data.error || '图生图处理失败');
+    }
+
+    return {
+      images: [{
+        url: response.data.data.image_url,
+        width: 1024,
+        height: 1024,
+      }],
+    };
+  }
+
+  // 通用图生视频接口 - 各模板传入自己的参数
+  async imageToVideo(options: BowongAIVideoOptions) {
+    const payload: BowongAIImageRequest = {
+      workflow: '图生图+生视频',
+      environment: this.environment,
+      image_generation: {
+        model: options.imageModel || 'gemini-2.5-flash-image-preview',
+        prompt: options.imagePrompt,
+        image_url: options.imageUrl,
+      },
+      video_generation: {
+        model: options.videoModel || '302/MiniMax-Hailuo-02',
+        prompt: options.videoPrompt,
+        duration: options.duration?.toString() || '6',
+        aspect_ratio: options.aspectRatio || '9:16',
+      },
+    };
+
+    const response = await axios.post(this.webhookUrl, payload, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: 300000, // 5分钟超时
+    });
+
+    if (!response.data.success) {
+      throw new Error(response.data.error || '图生视频处理失败');
+    }
+
+    return {
+      videoUrl: response.data.data.video_url,
+      duration: options.duration || 6,
+      fps: 24,
+      resolution: options.aspectRatio || '9:16',
+      format: 'mp4',
+    };
+  }
+}
+```
+
+### 5.3 AI服务接口更新
+```typescript
+// src/services/ai-service.interface.ts - 更新接口定义
+export interface ImageToImageRequest {
+  prompt: string;
+  initImage: string; // 图片URL或base64
+  strength?: number;
+  cfgScale?: number;
+  steps?: number;
+  width?: number;
+  height?: number;
+}
+
+export interface ImageToImageResponse {
+  images: Array<{
+    url: string;
+    thumbnailUrl?: string;
+    width: number;
+    height: number;
+  }>;
+  seed?: number;
+}
+
+export interface ImageToVideoRequest {
+  prompt: string;
+  image: string; // 图片URL或base64
+  duration?: number; // 秒
+  fps?: number;
+  resolution?: string; // '720p', '1080p', '9:16', '16:9'
+}
+
+export interface ImageToVideoResponse {
+  videoUrl: string;
+  thumbnailUrl?: string;
+  duration: number;
+  fps: number;
+  resolution: string;
+  format: string;
+  fileSize?: number;
+}
+```
+
+## 6. 模块配置
+
+### 6.1 模板模块配置
+```typescript
+// src/modules/template.module.ts
+import { Module } from '@nestjs/common';
+import { TemplateController } from '../controllers/template.controller';
+import { TemplateService } from '../services/template.service';
+import { TemplateManager } from '../services/template-manager.service';
+import { TemplateFactory } from '../templates/template.factory';
+import { BowongAIService } from '../services/bowongai.service';
+import { CreditService } from '../services/credit.service';
+
+// 导入所有模板类
+import { OutfitChangeTemplate } from '../templates/image/outfit-change.template';
+import { ImageToVideoTemplate } from '../templates/video/image-to-video.template';
+import { PortraitEnhanceTemplate } from '../templates/image/portrait-enhance.template';
+import { StyleTransferTemplate } from '../templates/image/style-transfer.template';
+import { BackgroundReplaceTemplate } from '../templates/image/background-replace.template';
+
+@Module({
+  controllers: [TemplateController],
+  providers: [
+    TemplateService,
+    TemplateManager,
+    TemplateFactory,
+    BowongAIService,
+    CreditService,
+    // 注册所有模板类
+    OutfitChangeTemplate,
+    ImageToVideoTemplate,
+    PortraitEnhanceTemplate,
+    StyleTransferTemplate,
+    BackgroundReplaceTemplate,
+  ],
+  exports: [TemplateService, TemplateManager],
+})
+export class TemplateModule {}
+```
+
+### 6.2 环境配置
+```typescript
+// .env 配置
+# BowongAI 配置
+BOWONGAI_WEBHOOK_URL=https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14
+BOWONGAI_ENVIRONMENT=https://bowongai-test--text-video-agent-fastapi-app.modal.run
+
+# 其他AI服务配置（备用）
+OPENAI_API_KEY=your-openai-api-key
+STABILITY_API_KEY=your-stability-api-key
+RUNWAYML_API_KEY=your-runwayml-api-key
+```
+
+## 7. 完整的使用示例
+
+### 7.1 项目集成步骤
+```typescript
+// 1. 安装依赖
+npm install reflect-metadata
+
+// 2. 在 app.module.ts 中导入模板模块
+import { Module } from '@nestjs/common';
+import { TemplateModule } from './modules/template.module';
+
+@Module({
+  imports: [
+    // ... 其他模块
+    TemplateModule,
+  ],
+})
+export class AppModule {}
+
+// 3. 创建新的模板类
+// src/templates/image/my-custom.template.ts
+@Injectable()
+export class MyCustomTemplate extends ImageGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'my_custom_v1',
+    name: '我的自定义模板',
+    description: '自定义的AI生成模板',
+    category: '自定义',
+    creditCost: 10,
+    version: '1.0.0',
+  };
+
+  async execute(input: any, context: TemplateExecutionContext) {
+    // 实现具体逻辑
+    return {
+      images: [/* 生成的图片 */],
+    };
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'prompt',
+        displayName: '提示词',
+        description: '描述想要生成的内容',
+        type: ParameterType.STRING,
+        validation: { required: true },
+        order: 1,
+      },
+      // ... 其他参数
+    ];
+  }
+}
+
+// 4. 在工厂类中注册
+// src/templates/template.factory.ts
+createAllTemplates(): Template[] {
+  return [
+    // ... 现有模板
+    new MyCustomTemplate(),
+  ];
+}
+```
+
+## 6. 使用示例
+
+### 6.1 前端调用示例
+
+#### 图生图模板调用
+```typescript
+// 前端调用换装模板（图生图）
+const response = await fetch('/api/templates/outfit_change_v1/execute', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    inputImage: 'https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png',
+    clothingDescription: '红色连衣裙',
+    style: 'elegant'
+  })
+});
+
+const result = await response.json();
+if (result.success) {
+  console.log('图生图成功:', result.data);
+  // result.data.images[0].url 是生成的图片URL
+} else {
+  console.error('生成失败:', result.error);
+}
+```
+
+#### 图生视频模板调用
+```typescript
+// 前端调用图生视频模板
+const response = await fetch('/api/templates/image_to_video_v1/execute', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    inputImage: 'https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png',
+    videoPrompt: '让角色动起来',
+    duration: 6,
+    resolution: '9:16'
+  })
+});
+
+const result = await response.json();
+if (result.success) {
+  console.log('图生视频成功:', result.data);
+  // result.data.videoUrl 是生成的视频URL
+} else {
+  console.error('生成失败:', result.error);
+}
+```
+
+#### 人像增强模板调用
+```typescript
+// 前端调用人像增强模板
+const response = await fetch('/api/templates/portrait_enhance_v1/execute', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    inputImage: 'https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png',
+    enhanceLevel: 'moderate',
+    lightingStyle: 'natural'
+  })
+});
+
+const result = await response.json();
+if (result.success) {
+  console.log('人像增强成功:', result.data);
+  // result.data.images[0].url 是增强后的图片URL
+} else {
+  console.error('增强失败:', result.error);
+}
+```
+
+### 6.2 添加新模板
+```typescript
+// 1. 创建新的模板类
+// src/templates/image/portrait-enhance.template.ts
+@Injectable()
+export class PortraitEnhanceTemplate extends ImageGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'portrait_enhance_v1',
+    name: '人像增强',
+    description: '提升人像照片的清晰度和美观度',
+    category: '人像处理',
+    creditCost: 8,
+    version: '1.0.0',
+  };
+
+  async execute(input: any, context: TemplateExecutionContext) {
+    // 实现具体的人像增强逻辑
+    // ...
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    // 定义参数
+    // ...
+  }
+}
+
+// 2. 在工厂类中注册
+// src/templates/template.factory.ts
+export class TemplateFactory {
+  createAllTemplates(): Template[] {
+    return [
+      new OutfitChangeTemplate(),
+      new ObjectRemovalTemplate(),
+      new PortraitEnhanceTemplate(), // 添加新模板
+      // ...
+    ];
+  }
+}
+```
+
+### 6.3 模板管理命令
+```typescript
+// 获取所有模板
+const templates = templateManager.getAllTemplates();
+
+// 启用/禁用模板
+templateManager.setTemplateEnabled('outfit_change_v1', false);
+
+// 获取统计信息
+const stats = templateManager.getStatistics();
+console.log(`共有 ${stats.total} 个模板，其中 ${stats.enabled} 个已启用`);
+```
+
+## 7. 系统优势
+
+### 7.1 面向对象设计优势
+1. **类型安全**: TypeScript编译时检查，避免运行时错误
+2. **代码复用**: 通过继承实现通用逻辑复用
+3. **易于扩展**: 添加新模板只需继承基类并实现抽象方法
+4. **IDE支持**: 完整的代码提示和重构支持
+5. **单元测试**: 每个模板类可独立测试
+
+### 7.2 与数据库方案对比
+| 特性 | 面向对象方案 | 数据库方案 |
+|------|-------------|-----------|
+| 类型安全 | ✅ 编译时检查 | ❌ 运行时检查 |
+| 代码复用 | ✅ 继承机制 | ❌ 需要额外逻辑 |
+| 扩展性 | ✅ 新增类即可 | ❌ 需要数据库迁移 |
+| 性能 | ✅ 内存中执行 | ❌ 数据库查询开销 |
+| 维护性 | ✅ 代码即文档 | ❌ 需要维护数据结构 |
+| 版本控制 | ✅ Git管理 | ❌ 数据库版本管理复杂 |
+
+### 7.3 核心特性
+1. **统一接口**: 所有模板都实现相同的执行接口
+2. **参数验证**: 基类提供通用验证，子类可扩展
+3. **错误处理**: 统一的错误处理和结果格式
+4. **元数据管理**: 每个模板包含完整的元数据信息
+5. **动态管理**: 运行时启用/禁用模板
+6. **积分集成**: 自动处理积分检查和扣除
+
+这个基于面向对象的模板管理系统更加灵活、类型安全，且易于维护和扩展。通过抽象类和继承机制，可以轻松添加新的AI生成模板，同时保持代码的一致性和可维护性。
diff --git a/docs/template-system-summary.md b/docs/template-system-summary.md
new file mode 100644
index 0000000..8acb96e
--- /dev/null
+++ b/docs/template-system-summary.md
@@ -0,0 +1,195 @@
+# AI模板管理系统总结 - 面向对象设计
+
+## 🎯 设计理念
+
+您的建议非常正确！使用面向对象的设计模式比数据库方案更加优雅和实用：
+
+```typescript
+export abstract class Template<TInput, TOutput> {}
+export abstract class ImageGenerateTemplate extends Template {}
+export abstract class VideoGenerateTemplate extends Template {}
+export class TemplateManager {}
+```
+
+## 🏗️ 核心架构
+
+### 1. 抽象类层次结构
+```
+Template (基础抽象类)
+├── ImageGenerateTemplate (图片生成抽象类)
+│   ├── OutfitChangeTemplate (换装模板)
+│   ├── StyleTransferTemplate (风格转换模板)
+│   └── BackgroundReplaceTemplate (背景替换模板)
+└── VideoGenerateTemplate (视频生成抽象类)
+    ├── ObjectRemovalTemplate (抠图模板)
+    └── MotionGenerateTemplate (动作生成模板)
+```
+
+### 2. 核心组件
+- **Template**: 基础抽象类，定义统一接口
+- **TemplateManager**: 模板管理器，负责注册和执行
+- **TemplateFactory**: 模板工厂，创建所有模板实例
+- **TemplateService**: 业务服务层，集成积分系统
+
+## ✅ 面向对象方案的优势
+
+### 🔒 类型安全
+```typescript
+// 编译时就能发现错误
+const template: ImageGenerateTemplate = new OutfitChangeTemplate();
+const result = await template.execute(input, context); // 类型检查
+```
+
+### 🧬 代码复用
+```typescript
+// 基类提供通用功能
+export abstract class ImageGenerateTemplate extends Template {
+  // 通用的图片参数验证
+  async validateInput(input: ImageGenerateInput): Promise<string[]> {
+    // 共享的验证逻辑
+  }
+}
+```
+
+### 🚀 易于扩展
+```typescript
+// 添加新模板只需继承和实现
+@Injectable()
+export class NewTemplate extends ImageGenerateTemplate {
+  readonly metadata = { /* 模板信息 */ };
+  
+  async execute(input, context) {
+    // 具体实现
+  }
+  
+  getParameterDefinitions() {
+    // 参数定义
+  }
+}
+```
+
+### 🛠️ IDE支持
+- 完整的代码提示和自动补全
+- 重构时自动更新所有引用
+- 编译时错误检查
+- 调试时的完整类型信息
+
+## 📊 与数据库方案对比
+
+| 特性 | 面向对象方案 | 数据库方案 |
+|------|-------------|-----------|
+| **类型安全** | ✅ 编译时检查 | ❌ 运行时检查 |
+| **代码复用** | ✅ 继承机制 | ❌ 需要额外逻辑 |
+| **扩展性** | ✅ 新增类即可 | ❌ 需要数据库迁移 |
+| **性能** | ✅ 内存中执行 | ❌ 数据库查询开销 |
+| **维护性** | ✅ 代码即文档 | ❌ 需要维护数据结构 |
+| **版本控制** | ✅ Git管理 | ❌ 数据库版本管理复杂 |
+| **测试** | ✅ 单元测试友好 | ❌ 需要数据库环境 |
+| **部署** | ✅ 无状态部署 | ❌ 需要数据库同步 |
+
+## 🎨 具体实现示例
+
+### 换装模板
+```typescript
+@Injectable()
+export class OutfitChangeTemplate extends ImageGenerateTemplate {
+  readonly metadata: TemplateMetadata = {
+    code: 'outfit_change_v1',
+    name: '智能换装',
+    description: '上传人物图片，描述想要的服装，AI自动生成换装效果',
+    category: '换装',
+    creditCost: 15,
+    version: '1.0.0',
+  };
+
+  async execute(input: OutfitChangeInput, context: TemplateExecutionContext) {
+    const prompt = this.buildPrompt(input);
+    const result = await this.stabilityAI.imageToImage({
+      prompt,
+      initImage: input.inputImage,
+      strength: 0.8,
+    });
+    return this.formatOutput(result);
+  }
+
+  getParameterDefinitions(): ParameterDefinition[] {
+    return [
+      {
+        key: 'inputImage',
+        displayName: '人物图片',
+        type: ParameterType.IMAGE,
+        validation: { required: true },
+        order: 1,
+      },
+      {
+        key: 'clothingDescription',
+        displayName: '服装描述',
+        type: ParameterType.STRING,
+        validation: { required: true, minLength: 3, maxLength: 200 },
+        order: 2,
+      },
+    ];
+  }
+}
+```
+
+## 🔧 使用方式
+
+### 前端调用
+```typescript
+// 统一的调用接口，不管底层是什么AI模型
+const result = await fetch('/api/templates/outfit_change_v1/execute', {
+  method: 'POST',
+  body: JSON.stringify({
+    inputImage: 'data:image/jpeg;base64,...',
+    clothingDescription: '红色连衣裙',
+    style: 'elegant'
+  })
+});
+```
+
+### 添加新模板
+```typescript
+// 1. 创建模板类
+export class MyTemplate extends ImageGenerateTemplate {
+  // 实现抽象方法
+}
+
+// 2. 在工厂中注册
+export class TemplateFactory {
+  createAllTemplates(): Template[] {
+    return [
+      new OutfitChangeTemplate(),
+      new MyTemplate(), // 添加新模板
+    ];
+  }
+}
+```
+
+## 🎯 核心价值
+
+### 1. **统一抽象**
+不同的AI模型（Stability AI、RunwayML、OpenAI等）通过统一的模板接口调用，前端无需关心底层实现差异。
+
+### 2. **类型安全**
+TypeScript的类型系统确保编译时就能发现接口不匹配、参数错误等问题。
+
+### 3. **易于维护**
+每个模板都是独立的类，修改一个模板不会影响其他模板，代码结构清晰。
+
+### 4. **快速扩展**
+添加新的AI生成功能只需要继承对应的抽象类，实现几个方法即可。
+
+### 5. **测试友好**
+每个模板类都可以独立进行单元测试，不需要复杂的数据库环境。
+
+## 🚀 总结
+
+面向对象的模板管理系统完美解决了您提出的问题：
+
+1. **消除调用方式不一致**: 通过抽象类统一接口
+2. **消除参数结果不一致**: 通过类型定义标准化
+3. **简化模板管理**: 通过代码而非数据库管理
+4. **提升开发效率**: 通过继承和多态减少重复代码
+
+这个设计既保持了灵活性，又提供了强类型保障，是一个非常优雅的解决方案！
diff --git a/input.md b/input.md
new file mode 100644
index 0000000..20340fc
--- /dev/null
+++ b/input.md
@@ -0,0 +1,35 @@
+-----------
+图生图+生视频
+-----------
+
+https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14
+{
+    "workflow": "图生图+生视频",
+    "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+    "image_generation": {
+        "model": "gemini-2.5-flash-image-preview",
+        "prompt": "Please convert this photo into a highly detailed character model. Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo. Behind the box, show a computer screen actively displaying the Blender modeling process. In front of the box, position the completed character model based on the provided photo, with the PVC texture clearly and realistically rendered. Set the entire scene in a bright, stylish indoor environment resembling a toy collector’s or hobbyist’s room—full of refined details, vibrant décor, and playful atmosphere. Ensure the lighting is crisp and luminous, highlighting both the model and its packaging.",
+        "image_url": "https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png"
+    },
+    "video_generation": {
+        "model": "302/MiniMax-Hailuo-02",
+        "prompt": "do anything you want",
+        "duration": "6",
+        "aspect_ratio": "9:16"
+    }
+}
+
+--------
+图生图
+---------
+
+https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14
+{
+    "workflow": "图生图",
+    "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+    "image_generation": {
+        "model": "gemini-2.5-flash-image-preview",
+        "prompt": "Please convert this photo into a highly detailed character model. Place in front of the model a delicate, colorful box featuring the printed image of the person from the photo. Behind the box, show a computer screen actively displaying the Blender modeling process. In front of the box, position the completed character model based on the provided photo, with the PVC texture clearly and realistically rendered. Set the entire scene in a bright, stylish indoor environment resembling a toy collector’s or hobbyist’s room—full of refined details, vibrant décor, and playful atmosphere. Ensure the lighting is crisp and luminous, highlighting both the model and its packaging.",
+        "image_url": "https://cdn.roasmax.cn/upload/e9066bf20fb546b09ece65d6fbcf2dd3.png"
+    }
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index ccc2f8b..a1d5f17 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,7 @@
     "@nestjs/common": "^11.0.1",
     "@nestjs/core": "^11.0.1",
     "@nestjs/platform-express": "^11.0.1",
+    "axios": "^1.11.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1"
   },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b7fe414..632738e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -17,6 +17,9 @@ importers:
       '@nestjs/platform-express':
         specifier: ^11.0.1
         version: 11.1.6(@nestjs/common@11.1.6(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.6)
+      axios:
+        specifier: ^1.11.0
+        version: 1.11.0
       reflect-metadata:
         specifier: ^0.2.2
         version: 0.2.2
@@ -950,49 +953,41 @@ packages:
     resolution: {integrity: sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@unrs/resolver-binding-linux-arm64-musl@1.11.1':
     resolution: {integrity: sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@unrs/resolver-binding-linux-ppc64-gnu@1.11.1':
     resolution: {integrity: sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==}
     cpu: [ppc64]
     os: [linux]
-    libc: [glibc]
 
   '@unrs/resolver-binding-linux-riscv64-gnu@1.11.1':
     resolution: {integrity: sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==}
     cpu: [riscv64]
     os: [linux]
-    libc: [glibc]
 
   '@unrs/resolver-binding-linux-riscv64-musl@1.11.1':
     resolution: {integrity: sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==}
     cpu: [riscv64]
     os: [linux]
-    libc: [musl]
 
   '@unrs/resolver-binding-linux-s390x-gnu@1.11.1':
     resolution: {integrity: sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==}
     cpu: [s390x]
     os: [linux]
-    libc: [glibc]
 
   '@unrs/resolver-binding-linux-x64-gnu@1.11.1':
     resolution: {integrity: sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@unrs/resolver-binding-linux-x64-musl@1.11.1':
     resolution: {integrity: sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@unrs/resolver-binding-wasm32-wasi@1.11.1':
     resolution: {integrity: sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==}
@@ -1178,6 +1173,9 @@ packages:
   asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
+  axios@1.11.0:
+    resolution: {integrity: sha512-1Lx3WLFQWm3ooKDYZD1eXmoGO9fxYQjrycfHFC8P0sCfQVXyROp0p9PFWBehewBOdCwHc+f/b8I0fMto5eSfwA==}
+
   babel-jest@30.1.2:
     resolution: {integrity: sha512-IQCus1rt9kaSh7PQxLYRY5NmkNrNlU2TpabzwV7T2jljnpdHOcmnYYv8QmE04Li4S3a2Lj8/yXyET5pBarPr6g==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
@@ -1688,6 +1686,15 @@ packages:
   flatted@3.3.3:
     resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
 
+  follow-redirects@1.15.11:
+    resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
   foreground-child@3.3.1:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
@@ -2452,6 +2459,9 @@ packages:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
 
+  proxy-from-env@1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+
   punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
@@ -4294,6 +4304,14 @@ snapshots:
 
   asynckit@0.4.0: {}
 
+  axios@1.11.0:
+    dependencies:
+      follow-redirects: 1.15.11
+      form-data: 4.0.4
+      proxy-from-env: 1.1.0
+    transitivePeerDependencies:
+      - debug
+
   babel-jest@30.1.2(@babel/core@7.28.3):
     dependencies:
       '@babel/core': 7.28.3
@@ -4854,6 +4872,8 @@ snapshots:
 
   flatted@3.3.3: {}
 
+  follow-redirects@1.15.11: {}
+
   foreground-child@3.3.1:
     dependencies:
       cross-spawn: 7.0.6
@@ -5746,6 +5766,8 @@ snapshots:
       forwarded: 0.2.0
       ipaddr.js: 1.9.1
 
+  proxy-from-env@1.1.0: {}
+
   punycode@2.3.1: {}
 
   pure-rand@7.0.1: {}
diff --git a/src/app.controller.ts b/src/app.controller.ts
index cce879e..d3fa6dd 100644
--- a/src/app.controller.ts
+++ b/src/app.controller.ts
@@ -1,12 +1,21 @@
-import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
+import { Body, Controller, Get, Param, Post } from '@nestjs/common';
+import { TemplateService } from './templates/index'
 @Controller()
 export class AppController {
-  constructor(private readonly appService: AppService) {}
+  constructor(private readonly tempalte: TemplateService) { }
 
   @Get()
-  getHello(): string {
-    return this.appService.getHello();
+  async getTemplates() {
+    return this.tempalte.getAllTemplates();
+  }
+
+  @Get(':templateCode')
+  async getTemplate(@Param('templateCode') templateCode: string) {
+    return this.tempalte.getTemplate(templateCode);
+  }
+
+  @Post()
+  async executeTemplate(@Body('imageUrl') imageUrl: string, @Body('templateCode') templateCode: string) {
+    return this.tempalte.executeTemplate(templateCode, imageUrl);
   }
 }
diff --git a/src/app.module.ts b/src/app.module.ts
index 8662803..7882561 100644
--- a/src/app.module.ts
+++ b/src/app.module.ts
@@ -1,10 +1,10 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
-import { AppService } from './app.service';
+import { TemplateService } from './templates/index';
 
 @Module({
   imports: [],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [TemplateService],
 })
 export class AppModule {}
diff --git a/src/app.service.ts b/src/app.service.ts
deleted file mode 100644
index 927d7cc..0000000
--- a/src/app.service.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class AppService {
-  getHello(): string {
-    return 'Hello World!';
-  }
-}
diff --git a/src/templates/index.ts b/src/templates/index.ts
new file mode 100644
index 0000000..e76828f
--- /dev/null
+++ b/src/templates/index.ts
@@ -0,0 +1 @@
+export { TemplateService } from './template.service'
\ No newline at end of file
diff --git a/src/templates/n8nTemplate.ts b/src/templates/n8nTemplate.ts
new file mode 100644
index 0000000..f0fb2e8
--- /dev/null
+++ b/src/templates/n8nTemplate.ts
@@ -0,0 +1,53 @@
+import { ImageGenerateTemplate, VideoGenerateTemplate } from "./types";
+import axios from 'axios';
+
+export abstract class N8nImageGenerateTemplate extends ImageGenerateTemplate {
+    abstract readonly imageModel: string;
+    abstract readonly imagePrompt: string;
+    execute(imageUrl: string): Promise<string> {
+        return axios.request({
+            url: `https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14`,
+            method: 'post',
+            data: {
+                "workflow": "图生图",
+                "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+                "image_generation": {
+                    "model": this.imageModel,
+                    "prompt": this.imagePrompt,
+                    "image_url": imageUrl
+                }
+            }
+        })
+    }
+}
+
+
+export abstract class N8nVideoGenerateTemplate extends VideoGenerateTemplate {
+    abstract readonly imageModel: string;
+    abstract readonly imagePrompt: string;
+    abstract readonly videoModel: string;
+    abstract readonly videoPrompt: string;
+    abstract readonly duration: number;
+    abstract readonly aspectRatio: string;
+    execute(imageUrl: string): Promise<string> {
+        return axios.request({
+            url: `https://n8n.bowongai.com/webhook/76f92dbf-785f-4add-96b5-a108174b7c14`,
+            method: 'post',
+            data: {
+                "workflow": "图生图+生视频",
+                "environment": "https://bowongai-test--text-video-agent-fastapi-app.modal.run",
+                "image_generation": {
+                    "model": this.imageModel,
+                    "prompt": this.imagePrompt,
+                    "image_url": imageUrl
+                },
+                "video_generation": {
+                    "model": this.videoModel,
+                    "prompt": this.videoPrompt,
+                    "duration": `${this.duration}`,
+                    "aspect_ratio": this.aspectRatio
+                }
+            }
+        })
+    }
+}
diff --git a/src/templates/n8nTemplates/PhotoRestoreTemplate.ts b/src/templates/n8nTemplates/PhotoRestoreTemplate.ts
new file mode 100644
index 0000000..5c0da2f
--- /dev/null
+++ b/src/templates/n8nTemplates/PhotoRestoreTemplate.ts
@@ -0,0 +1,17 @@
+import { N8nImageGenerateTemplate } from "../n8nTemplate";
+
+// 老照片修复上色模板
+export class PhotoRestoreTemplate extends N8nImageGenerateTemplate {
+    readonly code = 'photo_restore_v1';
+    readonly name = '老照片修复上色';
+    readonly description = '将黑白老照片修复并上色，让历史照片重现生机';
+    readonly creditCost = 12;
+    readonly version = '1.0.0';
+    readonly input = 'https://file.302.ai/gpt/imgs/20250903/6033b7e701a64e4a97d4608d4a0ed308.jpg'; // 原始图片示例
+    readonly output = 'https://file.302.ai/gpt/imgs/20250903/07ed5fb40090ac6ff51c874cc75ea8f2.jpg'; // 输出图片示例
+    readonly tags = ['老照片', '修复', '上色', '黑白转彩色', 'AI修复'];
+
+    // N8n模板特定属性
+    readonly imageModel = 'gemini-2.5-flash-image-preview'; // nano banana 模型
+    readonly imagePrompt = 'Restore this old photo and colorize the entire black and white photo';
+}
\ No newline at end of file
diff --git a/src/templates/n8nTemplates/close-eyes.template.ts b/src/templates/n8nTemplates/close-eyes.template.ts
new file mode 100644
index 0000000..03796a7
--- /dev/null
+++ b/src/templates/n8nTemplates/close-eyes.template.ts
@@ -0,0 +1,17 @@
+import { N8nImageGenerateTemplate } from '../n8nTemplate';
+
+// 修人物表情闭眼模板
+export class CloseEyesTemplate extends N8nImageGenerateTemplate {
+    readonly code = 'close_eyes_v1';
+    readonly name = '修人物表情闭眼';
+    readonly description = '让图像中的人物、动物或表情包闭上眼睛';
+    readonly creditCost = 10;
+    readonly version = '1.0.0';
+    readonly input = 'https://bowong-ai-shanghai.tos-cn-shanghai.volces.com/images/1756889137996_jujhz5.jpg'; // 原始图片示例
+    readonly output = 'https://bowong-ai-shanghai.tos-cn-shanghai.volces.com/images/1756887607688_bjqnk3.png'; // 输出图片示例
+    readonly tags = ['表情修改', '闭眼', '人物', '动物', 'meme', '表情包'];
+
+    // N8n模板特定属性
+    readonly imageModel = 'gemini-2.5-flash-image-preview'; // nano banana 模型
+    readonly imagePrompt = '图像中的主体（人物、动物、meme、或者表情等包含广义上五官的东西）闭上眼睛';
+}
diff --git a/src/templates/n8nTemplates/index.ts b/src/templates/n8nTemplates/index.ts
new file mode 100644
index 0000000..e2e62e7
--- /dev/null
+++ b/src/templates/n8nTemplates/index.ts
@@ -0,0 +1,2 @@
+export * from './PhotoRestoreTemplate';
+export * from './close-eyes.template';
\ No newline at end of file
diff --git a/src/templates/template.service.ts b/src/templates/template.service.ts
new file mode 100644
index 0000000..6529881
--- /dev/null
+++ b/src/templates/template.service.ts
@@ -0,0 +1,81 @@
+import { Injectable, OnModuleInit, Logger } from '@nestjs/common';
+import { TemplateManager, Template } from './types';
+import { CloseEyesTemplate, PhotoRestoreTemplate } from './n8nTemplates';
+
+@Injectable()
+export class TemplateService implements OnModuleInit {
+  private readonly logger = new Logger(TemplateService.name);
+
+  constructor(
+    private readonly templateManager: TemplateManager,
+  ) {}
+
+  async onModuleInit() {
+    // 启动时自动注册所有模板
+    await this.initializeTemplates();
+  }
+
+  // 执行模板
+  async executeTemplate(
+    templateCode: string,
+    input: string
+  ) {
+    // 1. 获取模板信息
+    const template = this.templateManager.getTemplate(templateCode);
+    if (!template) {
+      throw new Error(`模板 ${templateCode} 不存在`);
+    }
+
+    // 2. 检查用户积分（如果有积分服务）
+    // const hasEnoughCredits = await this.creditService.checkBalance(
+    //   userId,
+    //   platform as any,
+    //   template.creditCost
+    // );
+
+    // if (!hasEnoughCredits) {
+    //   throw new Error('积分不足');
+    // }
+
+    // 3. 执行模板
+    const result = await this.templateManager.executeTemplate(templateCode, input);
+
+    // 4. 扣除积分（仅在成功时）
+    // if (result.success) {
+    //   await this.creditService.consumeCredits(
+    //     userId,
+    //     platform as any,
+    //     template.creditCost,
+    //     'ai_generation' as any,
+    //     requestId
+    //   );
+    // }
+
+    return result;
+  }
+
+  // 获取所有模板
+  getAllTemplates(): Template[] {
+    return this.templateManager.getAllTemplates();
+  }
+
+  // 获取模板详情
+  getTemplate(templateCode: string): Template | null {
+    return this.templateManager.getTemplate(templateCode);
+  }
+
+  // 初始化模板
+  private async initializeTemplates(): Promise<void> {
+    this.logger.log('开始初始化模板...');
+
+    try {
+      this.templateManager.registerTemplates([
+        new PhotoRestoreTemplate(),
+        new CloseEyesTemplate(),
+      ]);
+    } catch (error) {
+      this.logger.error('模板初始化失败:', error);
+      throw error;
+    }
+  }
+}
diff --git a/src/templates/types.ts b/src/templates/types.ts
new file mode 100644
index 0000000..fab4f04
--- /dev/null
+++ b/src/templates/types.ts
@@ -0,0 +1,71 @@
+import { Injectable } from "@nestjs/common";
+
+// 基础模板抽象类
+export abstract class Template {
+    abstract readonly code: string;           // 模板唯一标识码
+    abstract readonly name: string;           // 模板名称
+    abstract readonly description: string;    // 模板详细描述
+    abstract readonly creditCost: number;     // 积分消耗
+    abstract readonly version: string;        // 版本号
+    abstract readonly input: string; // 原始图片
+    abstract readonly output: string; // 输出图片
+    abstract readonly tags: string[];         // 标签数组
+}
+
+export type VideoGenerateResultUrl = string;
+
+// 图片生成模板抽象类
+export abstract class ImageGenerateTemplate extends Template {
+    abstract execute(imageUrl: string): Promise<string>;
+}
+
+// 视频生成模板抽象类
+export abstract class VideoGenerateTemplate extends Template {
+    abstract execute(imageUrl: string): Promise<string>;
+}
+
+// 模板管理器类
+@Injectable()
+export class TemplateManager {
+    private readonly templates = new Map<string, Template>();
+
+    // 注册模板
+    registerTemplate(template: Template): void {
+        this.templates.set(template.code, template);
+        console.log(`模板 ${template.code} 注册成功`);
+    }
+
+    // 批量注册模板
+    registerTemplates(templates: Template[]): void {
+        templates.forEach(template => this.registerTemplate(template));
+    }
+
+    // 获取模板
+    getTemplate(templateCode: string): Template | null {
+        return this.templates.get(templateCode) || null;
+    }
+
+    // 获取所有模板
+    getAllTemplates(): Template[] {
+        return Array.from(this.templates.values());
+    }
+
+    // 执行模板
+    async executeTemplate(templateCode: string, input: string): Promise<any> {
+        const template = this.getTemplate(templateCode);
+
+        if (!template) {
+            throw new Error(`模板 ${templateCode} 不存在`);
+        }
+
+        if (template instanceof ImageGenerateTemplate) {
+            return await template.execute(input);
+        }
+
+        if (template instanceof VideoGenerateTemplate) {
+            return await template.execute(input);
+        }
+
+        throw new Error(`未知的模板类型: ${templateCode}`);
+    }
+}
\ No newline at end of file