【Vibe Coding 工程之 StockAnalyzerPro 记录】- EP3.Phase 2股票列表管理功能

前端效果

Cursor 执行过程

User

继续按计划进行 phase2 的开发，仔细进行程序设计，过程中通过review 代码和合理测试确保功能完整

Cursor

好的，现在开始Phase 2的开发。让我先制定详细的Phase 2开发计划，然后逐步实现股票列表管理功能。

# Phase 2 开发计划 - 股票列表管理功能

## 开发目标
实现完整的股票列表管理功能，包括股票代码CRUD操作、股票组合管理、股票代码验证、本地存储与云端同步等功能。

## 开发时间
第2-3周 (2025年4月5日 - 2025年4月19日)

## 功能模块

### 2.1 股票代码CRUD操作
- [ ] 股票代码添加功能
- [ ] 股票代码编辑功能
- [ ] 股票代码删除功能
- [ ] 股票代码批量导入/导出
- [ ] 股票代码验证机制

### 2.2 股票组合管理
- [ ] 创建股票组合
- [ ] 编辑组合信息
- [ ] 删除组合
- [ ] 组合内股票管理
- [ ] 组合性能分析

### 2.3 股票代码验证
- [ ] 实时股票代码验证
- [ ] 多数据源验证
- [ ] 股票信息自动补全
- [ ] 错误提示和处理

### 2.4 本地存储与云端同步
- [ ] 本地存储机制
- [ ] 云端数据同步
- [ ] 冲突解决策略
- [ ] 离线功能支持

### 2.5 股票列表UI界面
- [ ] 股票列表组件优化
- [ ] 股票详情页面
- [ ] 组合管理界面
- [ ] 搜索和筛选优化

## 技术实现方案

### 后端API设计

#### 股票管理API
```typescript
// 股票CRUD
POST   /api/v1/stocks                    // 添加股票
PUT    /api/v1/stocks/:symbol            // 更新股票信息
DELETE /api/v1/stocks/:symbol            // 删除股票
POST   /api/v1/stocks/batch              // 批量操作
GET    /api/v1/stocks/validate/:symbol   // 验证股票代码

// 组合管理
GET    /api/v1/portfolios                // 获取用户组合
POST   /api/v1/portfolios                // 创建组合
PUT    /api/v1/portfolios/:id            // 更新组合
DELETE /api/v1/portfolios/:id            // 删除组合
POST   /api/v1/portfolios/:id/stocks     // 添加股票到组合
DELETE /api/v1/portfolios/:id/stocks/:symbol // 从组合移除股票

数据验证服务

// 股票验证
interface StockValidation {
  symbol: string;
  isValid: boolean;
  name?: string;
  exchange?: string;
  sector?: string;
  error?: string;
}

// 组合数据
interface Portfolio {
  id: string;
  name: string;
  description?: string;
  stocks: PortfolioStock[];
  totalValue: number;
  totalReturn: number;
  totalReturnPercent: number;
}

前端组件设计

核心组件

// 股票管理组件
<StockManager />
<StockForm />
<StockList />
<StockDetail />

// 组合管理组件
<PortfolioManager />
<PortfolioForm />
<PortfolioList />
<PortfolioDetail />

// 通用组件
<SearchBar />
<FilterPanel />
<DataTable />
<Modal />

状态管理

// Zustand Store
interface StockStore {
  stocks: Stock[];
  portfolios: Portfolio[];
  watchlists: Watchlist[];
  loading: boolean;
  error: string | null;
  
  // Actions
  fetchStocks: () => Promise<void>;
  addStock: (stock: Stock) => Promise<void>;
  updateStock: (symbol: string, data: Partial<Stock>) => Promise<void>;
  deleteStock: (symbol: string) => Promise<void>;
  validateStock: (symbol: string) => Promise<StockValidation>;
  
  // Portfolio Actions
  fetchPortfolios: () => Promise<void>;
  createPortfolio: (portfolio: CreatePortfolio) => Promise<void>;
  updatePortfolio: (id: string, data: Partial<Portfolio>) => Promise<void>;
  deletePortfolio: (id: string) => Promise<void>;
}

开发步骤

第1周 (4月5日-4月11日)

1. 后端API开发

   • 实现股票CRUD控制器
   • 实现组合管理控制器
   • 实现股票验证服务
   • 编写API测试

2. 数据库优化

   • 优化数据库查询
   • 添加索引
   • 实现数据缓存

第2周 (4月12日-4月18日)

1. 前端组件开发

   • 实现股票管理组件
   • 实现组合管理组件
   • 实现搜索和筛选功能
   • 实现数据表格组件

2. 状态管理实现

   • 实现Zustand store
   • 实现数据同步逻辑
   • 实现错误处理

第3周 (4月19日-4月25日)

1. 功能集成测试

   • 端到端测试
   • 性能优化
   • 用户体验优化

2. 文档和部署

   • 更新API文档
   • 编写用户指南
   • 部署准备

测试策略

单元测试

• 控制器函数测试
• 服务层测试
• 组件测试
• 工具函数测试

集成测试

• API端点测试
• 数据库操作测试
• 前端组件集成测试

端到端测试

• 用户操作流程测试
• 数据同步测试
• 错误处理测试

质量保证

代码审查

• 代码规范检查
• 性能优化审查
• 安全性审查
• 可维护性审查

性能指标

• API响应时间 < 200ms
• 页面加载时间 < 2s
• 数据库查询优化
• 内存使用优化

风险评估

验收标准

功能验收

• 股票CRUD操作完整可用
• 组合管理功能完整可用
• 股票验证功能准确可靠
• 数据同步功能稳定

性能验收

• API响应时间达标
• 页面加载速度达标
• 内存使用合理
• 数据库性能优化

用户体验验收

• 界面友好易用
• 操作流程顺畅
• 错误提示清晰
• 响应式设计完善

下一步计划

Phase 2完成后，将进入Phase 3：

• 数据采集模块开发
• MCP工具集成
• 实时数据更新
• 数据清洗和存储

Phase 2 开始时间: 2025年4月5日
预计完成时间: 2025年4月25日
负责人: 开发团队
状态: 准备开始

现在开始Phase 2的开发。首先实现后端的股票CRUD操作和组合管理功能。

## 第一步：实现股票验证服务


```typescript
import axios from 'axios';

export interface StockValidation {
  symbol: string;
  isValid: boolean;
  name?: string;
  exchange?: string;
  sector?: string;
  industry?: string;
  error?: string;
}

export interface StockInfo {
  symbol: string;
  name: string;
  exchange: string;
  sector?: string;
  industry?: string;
  marketCap?: number;
  peRatio?: number;
  pbRatio?: number;
  dividendYield?: number;
}

export class StockValidationService {
  private static instance: StockValidationService;
  private cache = new Map<string, { data: StockValidation; timestamp: number }>();
  private readonly CACHE_DURATION = 24 * 60 * 60 * 1000; // 24小时

  public static getInstance(): StockValidationService {
    if (!StockValidationService.instance) {
      StockValidationService.instance = new StockValidationService();
    }
    return StockValidationService.instance;
  }

  /**
   * 验证股票代码
   */
  async validateStock(symbol: string): Promise<StockValidation> {
    const normalizedSymbol = symbol.toUpperCase().trim();
    
    // 检查缓存
    const cached = this.cache.get(normalizedSymbol);
    if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
      return cached.data;
    }

    try {
      // 尝试多个数据源验证
      const validation = await this.validateFromMultipleSources(normalizedSymbol);
      
      // 缓存结果
      this.cache.set(normalizedSymbol, {
        data: validation,
        timestamp: Date.now()
      });

      return validation;
    } catch (error) {
      console.error(`Error validating stock ${symbol}:`, error);
      return {
        symbol: normalizedSymbol,
        isValid: false,
        error: '验证服务暂时不可用'
      };
    }
  }

  /**
   * 从多个数据源验证股票
   */
  private async validateFromMultipleSources(symbol: string): Promise<StockValidation> {
    const sources = [
      this.validateFromYahooFinance.bind(this),
      this.validateFromAlphaVantage.bind(this),
      this.validateFromMockData.bind(this) // 备用数据源
    ];

    for (const source of sources) {
      try {
        const result = await source(symbol);
        if (result.isValid) {
          return result;
        }
      } catch (error) {
        console.warn(`Validation source failed for ${symbol}:`, error);
        continue;
      }
    }

    return {
      symbol,
      isValid: false,
      error: '无法验证股票代码'
    };
  }

  /**
   * 从Yahoo Finance验证股票
   */
  private async validateFromYahooFinance(symbol: string): Promise<StockValidation> {
    try {
      const response = await axios.get(
        `https://query1.finance.yahoo.com/v8/finance/chart/${symbol}`,
        {
          timeout: 5000,
          headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
          }
        }
      );

      const data = response.data;
      if (data.chart?.result?.[0]?.meta) {
        const meta = data.chart.result[0].meta;
        return {
          symbol,
          isValid: true,
          name: meta.shortName || meta.longName || symbol,
          exchange: meta.exchangeName || 'Unknown',
          sector: meta.sector || undefined,
          industry: meta.industry || undefined
        };
      }

      return {
        symbol,
        isValid: false,
        error: '股票信息不完整'
      };
    } catch (error) {
      throw new Error('Yahoo Finance验证失败');
    }
  }

  /**
   * 从Alpha Vantage验证股票
   */
  private async validateFromAlphaVantage(symbol: string): Promise<StockValidation> {
    const apiKey = process.env.ALPHA_VANTAGE_API_KEY;
    if (!apiKey) {
      throw new Error('Alpha Vantage API key not configured');
    }

    try {
      const response = await axios.get(
        `https://www.alphavantage.co/query?function=OVERVIEW&symbol=${symbol}&apikey=${apiKey}`,
        { timeout: 5000 }
      );

      const data = response.data;
      if (data.Symbol && data.Name) {
        return {
          symbol,
          isValid: true,
          name: data.Name,
          exchange: data.Exchange || 'Unknown',
          sector: data.Sector || undefined,
          industry: data.Industry || undefined
        };
      }

      return {
        symbol,
        isValid: false,
        error: '股票信息不完整'
      };
    } catch (error) {
      throw new Error('Alpha Vantage验证失败');
    }
  }

  /**
   * 模拟数据验证（备用方案）
   */
  private async validateFromMockData(symbol: string): Promise<StockValidation> {
    // 模拟一些常见股票数据
    const mockStocks: Record<string, StockInfo> = {
      'AAPL': {
        symbol: 'AAPL',
        name: 'Apple Inc.',
        exchange: 'NASDAQ',
        sector: 'Technology',
        industry: 'Consumer Electronics'
      },
      'GOOGL': {
        symbol: 'GOOGL',
        name: 'Alphabet Inc.',
        exchange: 'NASDAQ',
        sector: 'Technology',
        industry: 'Internet Content & Information'
      },
      'MSFT': {
        symbol: 'MSFT',
        name: 'Microsoft Corporation',
        exchange: 'NASDAQ',
        sector: 'Technology',
        industry: 'Software'
      },
      'TSLA': {
        symbol: 'TSLA',
        name: 'Tesla, Inc.',
        exchange: 'NASDAQ',
        sector: 'Consumer Cyclical',
        industry: 'Auto Manufacturers'
      },
      'AMZN': {
        symbol: 'AMZN',
        name: 'Amazon.com, Inc.',
        exchange: 'NASDAQ',
        sector: 'Consumer Cyclical',
        industry: 'Internet Retail'
      },
      'META': {
        symbol: 'META',
        name: 'Meta Platforms, Inc.',
        exchange: 'NASDAQ',
        sector: 'Technology',
        industry: 'Internet Content & Information'
      },
      'NVDA': {
        symbol: 'NVDA',
        name: 'NVIDIA Corporation',
        exchange: 'NASDAQ',
        sector: 'Technology',
        industry: 'Semiconductors'
      },
      'NFLX': {
        symbol: 'NFLX',
        name: 'Netflix, Inc.',
        exchange: 'NASDAQ',
        sector: 'Communication Services',
        industry: 'Entertainment'
      }
    };

    const stockInfo = mockStocks[symbol];
    if (stockInfo) {
      return {
        symbol,
        isValid: true,
        name: stockInfo.name,
        exchange: stockInfo.exchange,
        sector: stockInfo.sector,
        industry: stockInfo.industry
      };
    }

    return {
      symbol,
      isValid: false,
      error: '股票代码不存在'
    };
  }

  /**
   * 批量验证股票代码
   */
  async validateStocks(symbols: string[]): Promise<StockValidation[]> {
    const validations = await Promise.allSettled(
      symbols.map(symbol => this.validateStock(symbol))
    );

    return validations.map((result, index) => {
      if (result.status === 'fulfilled') {
        return result.value;
      } else {
        return {
          symbol: symbols[index],
          isValid: false,
          error: '验证失败'
        };
      }
    });
  }

  /**
   * 清除缓存
   */
  clearCache(): void {
    this.cache.clear();
  }

  /**
   * 获取缓存统计
   */
  getCacheStats(): { size: number; entries: string[] } {
    return {
      size: this.cache.size,
      entries: Array.from(this.cache.keys())
    };
  }
}

export const stockValidationService = StockValidationService.getInstance();

现在安装axios依赖：

第二步：扩展股票控制器，添加CRUD操作

import { Request, Response } from 'express';
import { prisma } from '../index';
import { stockValidationService, StockValidation } from '../services/stockValidationService';

// 获取股票列表
export const getStocks = async (req: Request, res: Response): Promise<void> => {
  try {
    const { page = 1, limit = 20, search, sector, exchange } = req.query;
    const skip = (Number(page) - 1) * Number(limit);

    // 构建查询条件
    const where: any = {};
    
    if (search) {
      where.OR = [
        { symbol: { contains: String(search), mode: 'insensitive' } },
        { name: { contains: String(search), mode: 'insensitive' } }
      ];
    }
    
    if (sector) {
      where.sector = { contains: String(sector), mode: 'insensitive' };
    }
    
    if (exchange) {
      where.exchange = { contains: String(exchange), mode: 'insensitive' };
    }

    // 查询股票数据
    const [stocks, total] = await Promise.all([
      prisma.stock.findMany({
        where,
        skip,
        take: Number(limit),
        orderBy: { symbol: 'asc' },
        include: {
          stockData: {
            orderBy: { date: 'desc' },
            take: 1
          }
        }
      }),
      prisma.stock.count({ where })
    ]);

    // 格式化响应数据
    const formattedStocks = stocks.map(stock => {
      const latestData = stock.stockData[0];
      return {
        id: stock.id,
        symbol: stock.symbol,
        name: stock.name,
        exchange: stock.exchange,
        sector: stock.sector,
        industry: stock.industry,
        marketCap: stock.marketCap,
        peRatio: stock.peRatio,
        pbRatio: stock.pbRatio,
        dividendYield: stock.dividendYield,
        currentPrice: latestData?.close || null,
        change: latestData ? latestData.close - latestData.open : null,
        changePercent: latestData ? ((latestData.close - latestData.open) / latestData.open) * 100 : null,
        volume: latestData?.volume || null
      };
    });

    res.json({
      success: true,
      data: {
        stocks: formattedStocks,
        pagination: {
          page: Number(page),
          limit: Number(limit),
          total,
          totalPages: Math.ceil(total / Number(limit))
        }
      }
    });
  } catch (error) {
    console.error('Error fetching stocks:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取股票列表失败'
    });
  }
};

// 验证股票代码
export const validateStock = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    
    if (!symbol) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '股票代码不能为空'
      });
      return;
    }

    const validation = await stockValidationService.validateStock(symbol);
    
    res.json({
      success: true,
      data: { validation }
    });
  } catch (error) {
    console.error('Error validating stock:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '股票验证失败'
    });
  }
};

// 添加股票
export const addStock = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol, name, exchange, sector, industry } = req.body;
    
    if (!symbol) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '股票代码不能为空'
      });
      return;
    }

    // 验证股票代码
    const validation = await stockValidationService.validateStock(symbol);
    if (!validation.isValid) {
      res.status(400).json({
        success: false,
        error: 'VALIDATION_ERROR',
        message: validation.error || '股票代码无效'
      });
      return;
    }

    // 检查股票是否已存在
    const existingStock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (existingStock) {
      res.status(409).json({
        success: false,
        error: 'CONFLICT',
        message: '股票已存在'
      });
      return;
    }

    // 创建股票记录
    const stock = await prisma.stock.create({
      data: {
        symbol: symbol.toUpperCase(),
        name: name || validation.name || symbol,
        exchange: exchange || validation.exchange || 'Unknown',
        sector: sector || validation.sector,
        industry: industry || validation.industry
      }
    });

    res.status(201).json({
      success: true,
      data: { stock },
      message: '股票添加成功'
    });
  } catch (error) {
    console.error('Error adding stock:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '添加股票失败'
    });
  }
};

// 更新股票信息
export const updateStock = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    const { name, exchange, sector, industry, marketCap, peRatio, pbRatio, dividendYield } = req.body;

    // 查找股票
    const existingStock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!existingStock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 更新股票信息
    const updatedStock = await prisma.stock.update({
      where: { symbol: symbol.toUpperCase() },
      data: {
        name,
        exchange,
        sector,
        industry,
        marketCap: marketCap ? Number(marketCap) : undefined,
        peRatio: peRatio ? Number(peRatio) : undefined,
        pbRatio: pbRatio ? Number(pbRatio) : undefined,
        dividendYield: dividendYield ? Number(dividendYield) : undefined
      }
    });

    res.json({
      success: true,
      data: { stock: updatedStock },
      message: '股票信息更新成功'
    });
  } catch (error) {
    console.error('Error updating stock:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '更新股票信息失败'
    });
  }
};

// 删除股票
export const deleteStock = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;

    // 查找股票
    const existingStock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!existingStock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 删除股票（级联删除相关数据）
    await prisma.stock.delete({
      where: { symbol: symbol.toUpperCase() }
    });

    res.json({
      success: true,
      message: '股票删除成功'
    });
  } catch (error) {
    console.error('Error deleting stock:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '删除股票失败'
    });
  }
};

// 批量操作股票
export const batchStockOperation = async (req: Request, res: Response): Promise<void> => {
  try {
    const { operation, symbols } = req.body;

    if (!operation || !symbols || !Array.isArray(symbols)) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '操作类型和股票代码列表不能为空'
      });
      return;
    }

    switch (operation) {
      case 'validate':
        const validations = await stockValidationService.validateStocks(symbols);
        res.json({
          success: true,
          data: { validations }
        });
        break;

      case 'add':
        const addResults = await Promise.allSettled(
          symbols.map(async (symbol: string) => {
            const validation = await stockValidationService.validateStock(symbol);
            if (validation.isValid) {
              return await prisma.stock.upsert({
                where: { symbol: symbol.toUpperCase() },
                update: {},
                create: {
                  symbol: symbol.toUpperCase(),
                  name: validation.name || symbol,
                  exchange: validation.exchange || 'Unknown',
                  sector: validation.sector,
                  industry: validation.industry
                }
              });
            }
            throw new Error(validation.error || '股票验证失败');
          })
        );

        const addedStocks = addResults
          .filter((result): result is PromiseFulfilledResult<any> => result.status === 'fulfilled')
          .map(result => result.value);

        const failedStocks = addResults
          .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
          .map((result, index) => ({ symbol: symbols[index], error: result.reason.message }));

        res.json({
          success: true,
          data: {
            added: addedStocks,
            failed: failedStocks
          },
          message: `成功添加 ${addedStocks.length} 支股票，失败 ${failedStocks.length} 支`
        });
        break;

      case 'delete':
        const deleteResults = await Promise.allSettled(
          symbols.map((symbol: string) =>
            prisma.stock.delete({
              where: { symbol: symbol.toUpperCase() }
            })
          )
        );

        const deletedStocks = deleteResults
          .filter((result): result is PromiseFulfilledResult<any> => result.status === 'fulfilled')
          .map(result => result.value);

        const deleteFailed = deleteResults
          .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
          .map((result, index) => ({ symbol: symbols[index], error: result.reason.message }));

        res.json({
          success: true,
          data: {
            deleted: deletedStocks,
            failed: deleteFailed
          },
          message: `成功删除 ${deletedStocks.length} 支股票，失败 ${deleteFailed.length} 支`
        });
        break;

      default:
        res.status(400).json({
          success: false,
          error: 'BAD_REQUEST',
          message: '不支持的操作类型'
        });
    }
  } catch (error) {
    console.error('Error in batch operation:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '批量操作失败'
    });
  }
};

// 获取股票详情
export const getStockBySymbol = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;

    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() },
      include: {
        stockData: {
          orderBy: { date: 'desc' },
          take: 1
        },
        analysisReports: {
          orderBy: { reportDate: 'desc' },
          take: 1
        }
      }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    const latestData = stock.stockData[0];
    const latestAnalysis = stock.analysisReports[0];

    // 获取历史数据用于计算涨跌幅
    const previousData = await prisma.stockData.findFirst({
      where: { 
        stockId: stock.id,
        date: { lt: latestData?.date }
      },
      orderBy: { date: 'desc' }
    });

    const response = {
      id: stock.id,
      symbol: stock.symbol,
      name: stock.name,
      exchange: stock.exchange,
      sector: stock.sector,
      industry: stock.industry,
      marketCap: stock.marketCap,
      peRatio: stock.peRatio,
      pbRatio: stock.pbRatio,
      dividendYield: stock.dividendYield,
      currentPrice: latestData?.close || null,
      change: latestData && previousData ? latestData.close - previousData.close : null,
      changePercent: latestData && previousData ? 
        ((latestData.close - previousData.close) / previousData.close) * 100 : null,
      volume: latestData?.volume || null,
      dayHigh: latestData?.high || null,
      dayLow: latestData?.low || null,
      open: latestData?.open || null,
      analysis: latestAnalysis ? {
        overallScore: latestAnalysis.overallScore,
        recommendation: latestAnalysis.recommendation,
        targetPrice: latestAnalysis.targetPrice,
        confidence: latestAnalysis.confidence
      } : null
    };

    res.json({
      success: true,
      data: { stock: response }
    });
  } catch (error) {
    console.error('Error fetching stock:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取股票详情失败'
    });
  }
};

// 添加股票到观察列表
export const addToWatchlist = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    const userId = (req as any).user?.id; // 从JWT中获取用户ID

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    // 查找股票
    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 获取或创建默认观察列表
    let watchlist = await prisma.watchlist.findFirst({
      where: { userId, name: '默认观察列表' }
    });

    if (!watchlist) {
      watchlist = await prisma.watchlist.create({
        data: {
          name: '默认观察列表',
          description: '默认观察列表',
          userId
        }
      });
    }

    // 检查是否已在观察列表中
    const existingItem = await prisma.watchlistStock.findUnique({
      where: {
        watchlistId_stockId: {
          watchlistId: watchlist.id,
          stockId: stock.id
        }
      }
    });

    if (existingItem) {
      res.status(409).json({
        success: false,
        error: 'CONFLICT',
        message: '股票已在观察列表中'
      });
      return;
    }

    // 添加到观察列表
    const watchlistItem = await prisma.watchlistStock.create({
      data: {
        watchlistId: watchlist.id,
        stockId: stock.id
      }
    });

    res.json({
      success: true,
      data: { watchlistItem },
      message: '股票已添加到观察列表'
    });
  } catch (error) {
    console.error('Error adding to watchlist:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '添加到观察列表失败'
    });
  }
};

// 从观察列表移除股票
export const removeFromWatchlist = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    // 查找股票
    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 查找观察列表项
    const watchlistItem = await prisma.watchlistStock.findFirst({
      where: {
        stockId: stock.id,
        watchlist: { userId }
      }
    });

    if (!watchlistItem) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不在观察列表中'
      });
      return;
    }

    // 从观察列表移除
    await prisma.watchlistStock.delete({
      where: { id: watchlistItem.id }
    });

    res.json({
      success: true,
      message: '股票已从观察列表移除'
    });
  } catch (error) {
    console.error('Error removing from watchlist:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '从观察列表移除失败'
    });
  }
};

// 获取股票历史数据
export const getStockHistory = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    const { period = '1y', interval = '1d' } = req.query;

    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 计算日期范围
    const endDate = new Date();
    let startDate = new Date();
    
    switch (period) {
      case '1d':
        startDate.setDate(endDate.getDate() - 1);
        break;
      case '5d':
        startDate.setDate(endDate.getDate() - 5);
        break;
      case '1mo':
        startDate.setMonth(endDate.getMonth() - 1);
        break;
      case '3mo':
        startDate.setMonth(endDate.getMonth() - 3);
        break;
      case '6mo':
        startDate.setMonth(endDate.getMonth() - 6);
        break;
      case '1y':
        startDate.setFullYear(endDate.getFullYear() - 1);
        break;
      case '2y':
        startDate.setFullYear(endDate.getFullYear() - 2);
        break;
      case '5y':
        startDate.setFullYear(endDate.getFullYear() - 5);
        break;
      case '10y':
        startDate.setFullYear(endDate.getFullYear() - 10);
        break;
      default:
        startDate.setFullYear(endDate.getFullYear() - 1);
    }

    const history = await prisma.stockData.findMany({
      where: {
        stockId: stock.id,
        date: {
          gte: startDate,
          lte: endDate
        }
      },
      orderBy: { date: 'asc' },
      select: {
        date: true,
        open: true,
        high: true,
        low: true,
        close: true,
        volume: true,
        adjClose: true
      }
    });

    res.json({
      success: true,
      data: { history }
    });
  } catch (error) {
    console.error('Error fetching stock history:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取股票历史数据失败'
    });
  }
};

// 获取股票新闻
export const getStockNews = async (req: Request, res: Response): Promise<void> => {
  try {
    const { symbol } = req.params;
    const { page = 1, limit = 10, days = 7 } = req.query;

    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    const startDate = new Date();
    startDate.setDate(startDate.getDate() - Number(days));

    const [news, total] = await Promise.all([
      prisma.news.findMany({
        where: {
          stockId: stock.id,
          publishedAt: {
            gte: startDate
          }
        },
        orderBy: { publishedAt: 'desc' },
        skip: (Number(page) - 1) * Number(limit),
        take: Number(limit)
      }),
      prisma.news.count({
        where: {
          stockId: stock.id,
          publishedAt: {
            gte: startDate
          }
        }
      })
    ]);

    res.json({
      success: true,
      data: {
        news,
        pagination: {
          page: Number(page),
          limit: Number(limit),
          total,
          totalPages: Math.ceil(total / Number(limit))
        }
      }
    });
  } catch (error) {
    console.error('Error fetching stock news:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取股票新闻失败'
    });
  }
};

第三步：创建组合管理控制器

import { Request, Response } from 'express';
import { prisma } from '../index';

// 获取用户投资组合列表
export const getPortfolios = async (req: Request, res: Response): Promise<void> => {
  try {
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    const portfolios = await prisma.portfolio.findMany({
      where: { userId },
      include: {
        portfolioStocks: {
          include: {
            stock: {
              include: {
                stockData: {
                  orderBy: { date: 'desc' },
                  take: 1
                }
              }
            }
          }
        }
      },
      orderBy: { createdAt: 'desc' }
    });

    // 计算组合总价值和收益
    const portfoliosWithStats = portfolios.map(portfolio => {
      let totalValue = 0;
      let totalCost = 0;
      const stocks = portfolio.portfolioStocks.map(ps => {
        const currentPrice = ps.stock.stockData[0]?.close || 0;
        const marketValue = currentPrice * ps.quantity;
        const costValue = ps.avgPrice * ps.quantity;
        const unrealizedGain = marketValue - costValue;
        const unrealizedGainPercent = costValue > 0 ? (unrealizedGain / costValue) * 100 : 0;

        totalValue += marketValue;
        totalCost += costValue;

        return {
          id: ps.id,
          symbol: ps.stock.symbol,
          name: ps.stock.name,
          quantity: ps.quantity,
          avgPrice: ps.avgPrice,
          currentPrice,
          marketValue,
          costValue,
          unrealizedGain,
          unrealizedGainPercent
        };
      });

      const totalReturn = totalValue - totalCost;
      const totalReturnPercent = totalCost > 0 ? (totalReturn / totalCost) * 100 : 0;

      return {
        id: portfolio.id,
        name: portfolio.name,
        description: portfolio.description,
        totalValue,
        totalCost,
        totalReturn,
        totalReturnPercent,
        stocks,
        createdAt: portfolio.createdAt,
        updatedAt: portfolio.updatedAt
      };
    });

    res.json({
      success: true,
      data: { portfolios: portfoliosWithStats }
    });
  } catch (error) {
    console.error('Error fetching portfolios:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取投资组合失败'
    });
  }
};

// 获取单个投资组合详情
export const getPortfolioById = async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    const portfolio = await prisma.portfolio.findFirst({
      where: { id, userId },
      include: {
        portfolioStocks: {
          include: {
            stock: {
              include: {
                stockData: {
                  orderBy: { date: 'desc' },
                  take: 1
                }
              }
            }
          }
        }
      }
    });

    if (!portfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 计算组合统计信息
    let totalValue = 0;
    let totalCost = 0;
    const stocks = portfolio.portfolioStocks.map(ps => {
      const currentPrice = ps.stock.stockData[0]?.close || 0;
      const marketValue = currentPrice * ps.quantity;
      const costValue = ps.avgPrice * ps.quantity;
      const unrealizedGain = marketValue - costValue;
      const unrealizedGainPercent = costValue > 0 ? (unrealizedGain / costValue) * 100 : 0;

      totalValue += marketValue;
      totalCost += costValue;

      return {
        id: ps.id,
        symbol: ps.stock.symbol,
        name: ps.stock.name,
        quantity: ps.quantity,
        avgPrice: ps.avgPrice,
        currentPrice,
        marketValue,
        costValue,
        unrealizedGain,
        unrealizedGainPercent
      };
    });

    const totalReturn = totalValue - totalCost;
    const totalReturnPercent = totalCost > 0 ? (totalReturn / totalCost) * 100 : 0;

    const portfolioWithStats = {
      id: portfolio.id,
      name: portfolio.name,
      description: portfolio.description,
      totalValue,
      totalCost,
      totalReturn,
      totalReturnPercent,
      stocks,
      createdAt: portfolio.createdAt,
      updatedAt: portfolio.updatedAt
    };

    res.json({
      success: true,
      data: { portfolio: portfolioWithStats }
    });
  } catch (error) {
    console.error('Error fetching portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '获取投资组合详情失败'
    });
  }
};

// 创建投资组合
export const createPortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { name, description } = req.body;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    if (!name || name.trim().length === 0) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '组合名称不能为空'
      });
      return;
    }

    // 检查组合名称是否已存在
    const existingPortfolio = await prisma.portfolio.findFirst({
      where: { userId, name: name.trim() }
    });

    if (existingPortfolio) {
      res.status(409).json({
        success: false,
        error: 'CONFLICT',
        message: '组合名称已存在'
      });
      return;
    }

    const portfolio = await prisma.portfolio.create({
      data: {
        name: name.trim(),
        description: description?.trim(),
        userId
      }
    });

    res.status(201).json({
      success: true,
      data: { portfolio },
      message: '投资组合创建成功'
    });
  } catch (error) {
    console.error('Error creating portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '创建投资组合失败'
    });
  }
};

// 更新投资组合
export const updatePortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { name, description } = req.body;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    // 查找投资组合
    const existingPortfolio = await prisma.portfolio.findFirst({
      where: { id, userId }
    });

    if (!existingPortfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 如果更新名称，检查是否与其他组合重名
    if (name && name.trim() !== existingPortfolio.name) {
      const duplicatePortfolio = await prisma.portfolio.findFirst({
        where: { userId, name: name.trim(), id: { not: id } }
      });

      if (duplicatePortfolio) {
        res.status(409).json({
          success: false,
          error: 'CONFLICT',
          message: '组合名称已存在'
        });
        return;
      }
    }

    const updatedPortfolio = await prisma.portfolio.update({
      where: { id },
      data: {
        name: name?.trim(),
        description: description?.trim()
      }
    });

    res.json({
      success: true,
      data: { portfolio: updatedPortfolio },
      message: '投资组合更新成功'
    });
  } catch (error) {
    console.error('Error updating portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '更新投资组合失败'
    });
  }
};

// 删除投资组合
export const deletePortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    // 查找投资组合
    const existingPortfolio = await prisma.portfolio.findFirst({
      where: { id, userId }
    });

    if (!existingPortfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 删除投资组合（级联删除组合内的股票）
    await prisma.portfolio.delete({
      where: { id }
    });

    res.json({
      success: true,
      message: '投资组合删除成功'
    });
  } catch (error) {
    console.error('Error deleting portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '删除投资组合失败'
    });
  }
};

// 添加股票到投资组合
export const addStockToPortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { portfolioId } = req.params;
    const { symbol, quantity, avgPrice } = req.body;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    if (!symbol || !quantity || !avgPrice) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '股票代码、数量和平均价格不能为空'
      });
      return;
    }

    if (quantity <= 0 || avgPrice <= 0) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '数量和价格必须大于0'
      });
      return;
    }

    // 验证投资组合所有权
    const portfolio = await prisma.portfolio.findFirst({
      where: { id: portfolioId, userId }
    });

    if (!portfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 查找股票
    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 检查股票是否已在组合中
    const existingStock = await prisma.portfolioStock.findUnique({
      where: {
        portfolioId_stockId: {
          portfolioId,
          stockId: stock.id
        }
      }
    });

    if (existingStock) {
      res.status(409).json({
        success: false,
        error: 'CONFLICT',
        message: '股票已在投资组合中'
      });
      return;
    }

    // 添加股票到组合
    const portfolioStock = await prisma.portfolioStock.create({
      data: {
        portfolioId,
        stockId: stock.id,
        quantity: Number(quantity),
        avgPrice: Number(avgPrice)
      },
      include: {
        stock: true
      }
    });

    res.status(201).json({
      success: true,
      data: { portfolioStock },
      message: '股票已添加到投资组合'
    });
  } catch (error) {
    console.error('Error adding stock to portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '添加股票到投资组合失败'
    });
  }
};

// 从投资组合移除股票
export const removeStockFromPortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { portfolioId, symbol } = req.params;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    // 验证投资组合所有权
    const portfolio = await prisma.portfolio.findFirst({
      where: { id: portfolioId, userId }
    });

    if (!portfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 查找股票
    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 查找组合中的股票
    const portfolioStock = await prisma.portfolioStock.findUnique({
      where: {
        portfolioId_stockId: {
          portfolioId,
          stockId: stock.id
        }
      }
    });

    if (!portfolioStock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不在投资组合中'
      });
      return;
    }

    // 从组合中移除股票
    await prisma.portfolioStock.delete({
      where: { id: portfolioStock.id }
    });

    res.json({
      success: true,
      message: '股票已从投资组合移除'
    });
  } catch (error) {
    console.error('Error removing stock from portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '从投资组合移除股票失败'
    });
  }
};

// 更新投资组合中的股票
export const updateStockInPortfolio = async (req: Request, res: Response): Promise<void> => {
  try {
    const { portfolioId, symbol } = req.params;
    const { quantity, avgPrice } = req.body;
    const userId = (req as any).user?.id;

    if (!userId) {
      res.status(401).json({
        success: false,
        error: 'UNAUTHORIZED',
        message: '用户未认证'
      });
      return;
    }

    if (quantity !== undefined && quantity <= 0) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '数量必须大于0'
      });
      return;
    }

    if (avgPrice !== undefined && avgPrice <= 0) {
      res.status(400).json({
        success: false,
        error: 'BAD_REQUEST',
        message: '价格必须大于0'
      });
      return;
    }

    // 验证投资组合所有权
    const portfolio = await prisma.portfolio.findFirst({
      where: { id: portfolioId, userId }
    });

    if (!portfolio) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '投资组合不存在'
      });
      return;
    }

    // 查找股票
    const stock = await prisma.stock.findUnique({
      where: { symbol: symbol.toUpperCase() }
    });

    if (!stock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不存在'
      });
      return;
    }

    // 查找组合中的股票
    const portfolioStock = await prisma.portfolioStock.findUnique({
      where: {
        portfolioId_stockId: {
          portfolioId,
          stockId: stock.id
        }
      }
    });

    if (!portfolioStock) {
      res.status(404).json({
        success: false,
        error: 'NOT_FOUND',
        message: '股票不在投资组合中'
      });
      return;
    }

    // 更新股票信息
    const updatedPortfolioStock = await prisma.portfolioStock.update({
      where: { id: portfolioStock.id },
      data: {
        quantity: quantity !== undefined ? Number(quantity) : undefined,
        avgPrice: avgPrice !== undefined ? Number(avgPrice) : undefined
      },
      include: {
        stock: true
      }
    });

    res.json({
      success: true,
      data: { portfolioStock: updatedPortfolioStock },
      message: '投资组合中的股票信息已更新'
    });
  } catch (error) {
    console.error('Error updating stock in portfolio:', error);
    res.status(500).json({
      success: false,
      error: 'INTERNAL_SERVER_ERROR',
      message: '更新投资组合中的股票失败'
    });
  }
};

第四步：更新路由配置

import { Router } from 'express';
import {
  getStocks,
  getStockBySymbol,
  addStock,
  updateStock,
  deleteStock,
  validateStock,
  batchStockOperation,
  addToWatchlist,
  removeFromWatchlist,
  getStockHistory,
  getStockNews
} from '../controllers/stockController';
import { authenticateToken } from '../middleware/auth';

const router = Router();

// 公开路由 - 不需要认证
router.get('/', getStocks); // 获取股票列表
router.get('/validate/:symbol', validateStock); // 验证股票代码
router.get('/:symbol/history', getStockHistory); // 获取股票历史数据
router.get('/:symbol/news', getStockNews); // 获取股票新闻
router.get('/:symbol', getStockBySymbol); // 获取股票详情

// 需要认证的路由
router.post('/', authenticateToken, addStock); // 添加股票
router.put('/:symbol', authenticateToken, updateStock); // 更新股票信息
router.delete('/:symbol', authenticateToken, deleteStock); // 删除股票
router.post('/batch', authenticateToken, batchStockOperation); // 批量操作
router.post('/:symbol/watchlist', authenticateToken, addToWatchlist); // 添加到观察列表
router.delete('/:symbol/watchlist', authenticateToken, removeFromWatchlist); // 从观察列表移除

export default router;

User

contineu

Cursor

继续Phase 2的开发。现在更新路由配置，添加新的API端点。

第四步：更新股票路由配置

import { Router } from 'express';
import {
  getStocks,
  getStockBySymbol,
  addStock,
  updateStock,
  deleteStock,
  validateStock,
  batchStockOperation,
  addToWatchlist,
  removeFromWatchlist,
  getStockHistory,
  getStockNews
} from '../controllers/stockController';
import { authenticateToken } from '../middleware/auth';

const router = Router();

// 公开路由 - 不需要认证
router.get('/', getStocks); // 获取股票列表
router.get('/validate/:symbol', validateStock); // 验证股票代码
router.get('/:symbol/history', getStockHistory); // 获取股票历史数据
router.get('/:symbol/news', getStockNews); // 获取股票新闻
router.get('/:symbol', getStockBySymbol); // 获取股票详情

// 需要认证的路由
router.post('/', authenticateToken, addStock); // 添加股票
router.put('/:symbol', authenticateToken, updateStock); // 更新股票信息
router.delete('/:symbol', authenticateToken, deleteStock); // 删除股票
router.post('/batch', authenticateToken, batchStockOperation); // 批量操作
router.post('/:symbol/watchlist', authenticateToken, addToWatchlist); // 添加到观察列表
router.delete('/:symbol/watchlist', authenticateToken, removeFromWatchlist); // 从观察列表移除

export default router;

第五步：创建组合管理路由

import { Router } from 'express';
import {
  getPortfolios,
  getPortfolioById,
  createPortfolio,
  updatePortfolio,
  deletePortfolio,
  addStockToPortfolio,
  removeStockFromPortfolio,
  updateStockInPortfolio
} from '../controllers/portfolioController';
import { authenticateToken } from '../middleware/auth';

const router = Router();

// 所有组合管理路由都需要认证
router.use(authenticateToken);

// 组合管理
router.get('/', getPortfolios); // 获取用户投资组合列表
router.get('/:id', getPortfolioById); // 获取单个投资组合详情
router.post('/', createPortfolio); // 创建投资组合
router.put('/:id', updatePortfolio); // 更新投资组合
router.delete('/:id', deletePortfolio); // 删除投资组合

// 组合内股票管理
router.post('/:portfolioId/stocks', addStockToPortfolio); // 添加股票到投资组合
router.delete('/:portfolioId/stocks/:symbol', removeStockFromPortfolio); // 从投资组合移除股票
router.put('/:portfolioId/stocks/:symbol', updateStockInPortfolio); // 更新投资组合中的股票

export default router;

第六步：更新主入口文件，添加组合路由

import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import morgan from 'morgan';
import dotenv from 'dotenv';
import { PrismaClient } from '@prisma/client';

// Import routes
import stockRoutes from './routes/stockRoutes';
import portfolioRoutes from './routes/portfolioRoutes';

// Load environment variables
dotenv.config();

// Initialize Prisma client
export const prisma = new PrismaClient();

// Create Express app
const app = express();
const PORT = process.env.PORT || 3001;

// Middleware
app.use(helmet());
app.use(cors({
  origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
  credentials: true
}));
app.use(morgan('combined'));
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true }));

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

// API routes
app.use('/api/v1/stocks', stockRoutes);
app.use('/api/v1/portfolios', portfolioRoutes);

// API info endpoint
app.get('/api/v1', (req, res) => {
  res.json({
    message: 'Stock Analyzer Pro API v1',
    version: '1.0.0',
    endpoints: {
      health: '/health',
      stocks: '/api/v1/stocks',
      portfolios: '/api/v1/portfolios',
      analysis: '/api/v1/analysis',
      auth: '/api/v1/auth'
    },
    documentation: '/docs'
  });
});

// Error handling middleware
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  console.error(err.stack);
  res.status(500).json({
    error: 'Something went wrong!',
    message: process.env.NODE_ENV === 'development' ? err.message : 'Internal server error'
  });
});

// 404 handler
app.use('*', (req, res) => {
  res.status(404).json({
    error: 'Route not found',
    path: req.originalUrl
  });
});

// Start server
async function startServer() {
  try {
    // Test database connection
    await prisma.$connect();
    console.log('✅ Database connected successfully');

    app.listen(PORT, () => {
      console.log(`🚀 Server running on port ${PORT}`);
      console.log(`📊 Environment: ${process.env.NODE_ENV}`);
      console.log(`🔗 Health check: http://localhost:${PORT}/health`);
      console.log(`📚 API docs: http://localhost:${PORT}/api/v1`);
    });
  } catch (error) {
    console.error('❌ Failed to start server:', error);
    process.exit(1);
  }
}

// Graceful shutdown
process.on('SIGTERM', async () => {
  console.log('🛑 SIGTERM received, shutting down gracefully');
  await prisma.$disconnect();
  process.exit(0);
});

process.on('SIGINT', async () => {
  console.log('🛑 SIGINT received, shutting down gracefully');
  await prisma.$disconnect();
  process.exit(0);
});

// Start the server
startServer();

第七步：创建前端状态管理

现在开始前端开发。首先创建Zustand状态管理store：

import { create } from 'zustand';
import { devtools } from 'zustand/middleware';

export interface Stock {
  id: string;
  symbol: string;
  name: string;
  exchange: string;
  sector?: string;
  industry?: string;
  marketCap?: number;
  peRatio?: number;
  pbRatio?: number;
  dividendYield?: number;
  currentPrice?: number;
  change?: number;
  changePercent?: number;
  volume?: number;
}

export interface StockValidation {
  symbol: string;
  isValid: boolean;
  name?: string;
  exchange?: string;
  sector?: string;
  industry?: string;
  error?: string;
}

export interface PortfolioStock {
  id: string;
  symbol: string;
  name: string;
  quantity: number;
  avgPrice: number;
  currentPrice: number;
  marketValue: number;
  costValue: number;
  unrealizedGain: number;
  unrealizedGainPercent: number;
}

export interface Portfolio {
  id: string;
  name: string;
  description?: string;
  totalValue: number;
  totalCost: number;
  totalReturn: number;
  totalReturnPercent: number;
  stocks: PortfolioStock[];
  createdAt: string;
  updatedAt: string;
}

export interface Watchlist {
  id: string;
  name: string;
  description?: string;
  stocks: Stock[];
  createdAt: string;
  updatedAt: string;
}

interface StockState {
  // State
  stocks: Stock[];
  portfolios: Portfolio[];
  watchlists: Watchlist[];
  loading: boolean;
  error: string | null;
  selectedStock: Stock | null;
  selectedPortfolio: Portfolio | null;

  // Actions
  setLoading: (loading: boolean) => void;
  setError: (error: string | null) => void;
  setSelectedStock: (stock: Stock | null) => void;
  setSelectedPortfolio: (portfolio: Portfolio | null) => void;

  // Stock Actions
  fetchStocks: (params?: { search?: string; sector?: string; exchange?: string; page?: number; limit?: number }) => Promise<void>;
  addStock: (stock: Partial<Stock>) => Promise<void>;
  updateStock: (symbol: string, data: Partial<Stock>) => Promise<void>;
  deleteStock: (symbol: string) => Promise<void>;
  validateStock: (symbol: string) => Promise<StockValidation>;
  batchValidateStocks: (symbols: string[]) => Promise<StockValidation[]>;
  batchAddStocks: (symbols: string[]) => Promise<{ added: Stock[]; failed: { symbol: string; error: string }[] }>;
  batchDeleteStocks: (symbols: string[]) => Promise<{ deleted: Stock[]; failed: { symbol: string; error: string }[] }>;

  // Portfolio Actions
  fetchPortfolios: () => Promise<void>;
  createPortfolio: (portfolio: { name: string; description?: string }) => Promise<void>;
  updatePortfolio: (id: string, data: Partial<Portfolio>) => Promise<void>;
  deletePortfolio: (id: string) => Promise<void>;
  addStockToPortfolio: (portfolioId: string, stock: { symbol: string; quantity: number; avgPrice: number }) => Promise<void>;
  removeStockFromPortfolio: (portfolioId: string, symbol: string) => Promise<void>;
  updateStockInPortfolio: (portfolioId: string, symbol: string, data: { quantity?: number; avgPrice?: number }) => Promise<void>;

  // Watchlist Actions
  fetchWatchlists: () => Promise<void>;
  addToWatchlist: (symbol: string) => Promise<void>;
  removeFromWatchlist: (symbol: string) => Promise<void>;
}

const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3001/api/v1';

export const useStockStore = create<StockState>()(
  devtools(
    (set, get) => ({
      // Initial state
      stocks: [],
      portfolios: [],
      watchlists: [],
      loading: false,
      error: null,
      selectedStock: null,
      selectedPortfolio: null,

      // Basic setters
      setLoading: (loading) => set({ loading }),
      setError: (error) => set({ error }),
      setSelectedStock: (stock) => set({ selectedStock: stock }),
      setSelectedPortfolio: (portfolio) => set({ selectedPortfolio: portfolio }),

      // Stock Actions
      fetchStocks: async (params = {}) => {
        try {
          set({ loading: true, error: null });
          
          const searchParams = new URLSearchParams();
          Object.entries(params).forEach(([key, value]) => {
            if (value !== undefined) searchParams.append(key, String(value));
          });

          const response = await fetch(`${API_BASE_URL}/stocks?${searchParams}`);
          const data = await response.json();

          if (data.success) {
            set({ stocks: data.data.stocks });
          } else {
            set({ error: data.message || '获取股票列表失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      addStock: async (stockData) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(stockData)
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取股票列表
            await get().fetchStocks();
          } else {
            set({ error: data.message || '添加股票失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      updateStock: async (symbol, data) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/${symbol}`, {
            method: 'PUT',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(data)
          });

          const result = await response.json();

          if (result.success) {
            // 更新本地状态
            set((state) => ({
              stocks: state.stocks.map(stock => 
                stock.symbol === symbol ? { ...stock, ...data } : stock
              )
            }));
          } else {
            set({ error: result.message || '更新股票失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      deleteStock: async (symbol) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/${symbol}`, {
            method: 'DELETE',
            headers: {
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            // 从本地状态中移除
            set((state) => ({
              stocks: state.stocks.filter(stock => stock.symbol !== symbol)
            }));
          } else {
            set({ error: data.message || '删除股票失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      validateStock: async (symbol) => {
        try {
          const response = await fetch(`${API_BASE_URL}/stocks/validate/${symbol}`);
          const data = await response.json();

          if (data.success) {
            return data.data.validation;
          } else {
            throw new Error(data.message || '验证失败');
          }
        } catch (error) {
          throw new Error('网络错误，请稍后重试');
        }
      },

      batchValidateStocks: async (symbols) => {
        try {
          const response = await fetch(`${API_BASE_URL}/stocks/batch`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify({
              operation: 'validate',
              symbols
            })
          });

          const data = await response.json();

          if (data.success) {
            return data.data.validations;
          } else {
            throw new Error(data.message || '批量验证失败');
          }
        } catch (error) {
          throw new Error('网络错误，请稍后重试');
        }
      },

      batchAddStocks: async (symbols) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/batch`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify({
              operation: 'add',
              symbols
            })
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取股票列表
            await get().fetchStocks();
            return data.data;
          } else {
            throw new Error(data.message || '批量添加失败');
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
          throw error;
        } finally {
          set({ loading: false });
        }
      },

      batchDeleteStocks: async (symbols) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/batch`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify({
              operation: 'delete',
              symbols
            })
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取股票列表
            await get().fetchStocks();
            return data.data;
          } else {
            throw new Error(data.message || '批量删除失败');
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
          throw error;
        } finally {
          set({ loading: false });
        }
      },

      // Portfolio Actions
      fetchPortfolios: async () => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios`, {
            headers: {
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            set({ portfolios: data.data.portfolios });
          } else {
            set({ error: data.message || '获取投资组合失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      createPortfolio: async (portfolioData) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(portfolioData)
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取投资组合列表
            await get().fetchPortfolios();
          } else {
            set({ error: data.message || '创建投资组合失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      updatePortfolio: async (id, data) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios/${id}`, {
            method: 'PUT',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(data)
          });

          const result = await response.json();

          if (result.success) {
            // 更新本地状态
            set((state) => ({
              portfolios: state.portfolios.map(portfolio => 
                portfolio.id === id ? { ...portfolio, ...data } : portfolio
              )
            }));
          } else {
            set({ error: result.message || '更新投资组合失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      deletePortfolio: async (id) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios/${id}`, {
            method: 'DELETE',
            headers: {
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            // 从本地状态中移除
            set((state) => ({
              portfolios: state.portfolios.filter(portfolio => portfolio.id !== id)
            }));
          } else {
            set({ error: data.message || '删除投资组合失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      addStockToPortfolio: async (portfolioId, stockData) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios/${portfolioId}/stocks`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(stockData)
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取投资组合列表
            await get().fetchPortfolios();
          } else {
            set({ error: data.message || '添加股票到投资组合失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      removeStockFromPortfolio: async (portfolioId, symbol) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios/${portfolioId}/stocks/${symbol}`, {
            method: 'DELETE',
            headers: {
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            // 重新获取投资组合列表
            await get().fetchPortfolios();
          } else {
            set({ error: data.message || '从投资组合移除股票失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      updateStockInPortfolio: async (portfolioId, symbol, data) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/portfolios/${portfolioId}/stocks/${symbol}`, {
            method: 'PUT',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            },
            body: JSON.stringify(data)
          });

          const result = await response.json();

          if (result.success) {
            // 重新获取投资组合列表
            await get().fetchPortfolios();
          } else {
            set({ error: result.message || '更新投资组合中的股票失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      // Watchlist Actions
      fetchWatchlists: async () => {
        // TODO: 实现观察列表获取
        console.log('fetchWatchlists not implemented yet');
      },

      addToWatchlist: async (symbol) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/${symbol}/watchlist`, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            // 可以显示成功消息
            console.log('已添加到观察列表');
          } else {
            set({ error: data.message || '添加到观察列表失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      },

      removeFromWatchlist: async (symbol) => {
        try {
          set({ loading: true, error: null });
          
          const response = await fetch(`${API_BASE_URL}/stocks/${symbol}/watchlist`, {
            method: 'DELETE',
            headers: {
              'Authorization': `Bearer ${localStorage.getItem('token')}`
            }
          });

          const data = await response.json();

          if (data.success) {
            // 可以显示成功消息
            console.log('已从观察列表移除');
          } else {
            set({ error: data.message || '从观察列表移除失败' });
          }
        } catch (error) {
          set({ error: '网络错误，请稍后重试' });
        } finally {
          set({ loading: false });
        }
      }
    }),
    {
      name: 'stock-store'
    }
  )
);