feat:xiufu

QUOTATION_EDITOR_SYNC_ANALYSIS.md

@@ -0,0 +1,627 @@
+# 报价空间管理器数据同步完整分析
+
+## 🎯 核心问题
+
+您报告的问题：**删除订单分配阶段的空间后，其他阶段（需求确认、交付执行、设计师分配）仍显示9个空间，数据未同步。**
+
+## 📊 数据流分析
+
+### 当前数据存储架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      数据存储层                               │
+├─────────────────────────────────────────────────────────────┤
+│                                                               │
+│  ┌─────────────────┐         ┌──────────────────┐           │
+│  │  Product 表     │         │  Project 表      │           │
+│  │  (空间产品)     │         │  (项目数据)      │           │
+│  ├─────────────────┤         ├──────────────────┤           │
+│  │ • productName   │         │ data.quotation   │           │
+│  │ • productType   │         │   └─ spaces[]    │           │
+│  │ • space {...}   │         │   └─ total       │           │
+│  │ • quotation{..} │         │                  │           │
+│  │ • requirements  │         │ data.unifiedSpaces[] ✅      │
+│  │ • status        │         │   (统一空间数据)  │           │
+│  │ • profile       │         │                  │           │
+│  └─────────────────┘         └──────────────────┘           │
+│                                                               │
+└─────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────┐
+│                      业务逻辑层                               │
+├─────────────────────────────────────────────────────────────┤
+│                                                               │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │  QuotationEditorComponent (报价空间管理器)           │   │
+│  ├──────────────────────────────────────────────────────┤   │
+│  │  • loadProjectProducts()     - 从Product表加载       │   │
+│  │  • createProduct()           - 创建Product记录       │   │
+│  │  • deleteProduct()           - 删除Product记录       │   │
+│  │  • generateQuotationFromProducts() - 生成报价        │   │
+│  │  • saveQuotationToProject()  - 保存到Project.data   │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                              ↓                                │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │  ProductSpaceService (统一空间管理)                  │   │
+│  ├──────────────────────────────────────────────────────┤   │
+│  │  • saveUnifiedSpaceData()    - 保存统一空间数据 ✅   │   │
+│  │  • getUnifiedSpaceData()     - 获取统一空间数据 ✅   │   │
+│  │  • syncUnifiedSpacesToProducts() - 同步到Product ✅  │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                                                               │
+└─────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────┐
+│                      展示层                                   │
+├─────────────────────────────────────────────────────────────┤
+│                                                               │
+│  订单分配阶段 (stage-order.component.ts)                     │
+│  ├─ 使用 QuotationEditorComponent                            │
+│  ├─ 调用 ProductSpaceService.saveUnifiedSpaceData() ✅       │
+│  └─ 删除空间后同步到统一存储 ✅                               │
+│                                                               │
+│  需求确认阶段 (stage-requirements.component.ts)              │
+│  ├─ 调用 ProductSpaceService.getUnifiedSpaceData() ✅        │
+│  └─ 从统一存储读取空间 ✅                                     │
+│                                                               │
+│  交付执行阶段 (stage-delivery.component.ts)                  │
+│  ├─ 调用 ProductSpaceService.getUnifiedSpaceData() ✅        │
+│  └─ 从统一存储读取空间 ✅                                     │
+│                                                               │
+│  设计师分配弹窗 (designer-team-assignment-modal.component)   │
+│  ├─ 调用 ProductSpaceService.getUnifiedSpaceData() ✅        │
+│  └─ 从统一存储读取空间 ✅                                     │
+│                                                               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🔍 QuotationEditorComponent 数据同步逻辑
+
+### 1. 创建空间产品流程
+
+```typescript
+// 用户点击"添加产品"
+addProduct(productName)
+    ↓
+// 创建Product记录
+createProduct(productName)
+    ↓
+    new Parse.Object('Product')
+    product.set('productName', productName)
+    product.set('space', { spaceName, area, spaceType, ... })
+    product.set('quotation', { price, basePrice, ... })
+    product.set('requirements', { ... })
+    await product.save()  // ✅ 保存到Product表
+    ↓
+// 重新加载产品列表
+loadProjectProducts()
+    ↓
+    const productQuery = new Parse.Query('Product')
+    productQuery.equalTo('project', this.project.toPointer())
+    this.products = await productQuery.find()  // ✅ 从Product表查询
+    ↓
+// 生成报价
+generateQuotationFromProducts()
+    ↓
+    for (const product of this.products) {
+      this.quotation.spaces.push({
+        name: product.get('productName'),
+        productId: product.id,  // ✅ 关联Product ID
+        processes: {...},
+        subtotal: ...
+      })
+    }
+    ↓
+// 保存报价到Project
+saveQuotationToProject()
+    ↓
+    const data = this.project.get('data') || {}
+    data.quotation = this.quotation  // ✅ 保存到Project.data.quotation
+    this.project.set('data', data)
+    await this.project.save()
+```
+
+**❌ 问题**：`saveQuotationToProject()` **没有调用** `ProductSpaceService.saveUnifiedSpaceData()`！
+
+---
+
+### 2. 删除空间产品流程
+
+```typescript
+// 用户点击"删除产品"
+deleteProduct(productId)
+    ↓
+    const product = this.products.find(p => p.id === productId)
+    await product.destroy()  // ✅ 从Product表删除
+    ↓
+    // 更新本地产品列表
+    this.products = this.products.filter(p => p.id !== productId)
+    ↓
+    // 更新报价spaces
+    this.quotation.spaces = this.quotation.spaces.filter(
+      (s: any) => s.productId !== productId
+    )
+    ↓
+    // 重新计算总价
+    this.calculateTotal()
+    this.updateProductBreakdown()
+    ↓
+    // 保存报价
+    await this.saveQuotationToProject()
+        ↓
+        const data = this.project.get('data') || {}
+        data.quotation = this.quotation  // ✅ 保存到Project.data.quotation
+        this.project.set('data', data)
+        await this.project.save()
+```
+
+**❌ 问题**：`deleteProduct()` **没有调用** `ProductSpaceService.saveUnifiedSpaceData()`！
+
+---
+
+## ❌ 根本原因分析
+
+### 问题1：QuotationEditorComponent 未使用统一空间管理
+
+**现状**：
+- ✅ `QuotationEditorComponent` 正确操作 **Product表**（创建、删除）
+- ✅ `QuotationEditorComponent` 正确保存 **Project.data.quotation**
+- ❌ `QuotationEditorComponent` **没有调用** `ProductSpaceService.saveUnifiedSpaceData()`
+- ❌ `QuotationEditorComponent` **没有更新** `Project.data.unifiedSpaces`
+
+**后果**：
+```
+订单分配阶段删除空间：
+  ✅ Product表记录被删除
+  ✅ Project.data.quotation.spaces 更新
+  ❌ Project.data.unifiedSpaces 未更新 ← 这是关键问题！
+
+其他阶段读取空间：
+  ✅ 调用 ProductSpaceService.getUnifiedSpaceData()
+  ❌ 读取到的是旧的 Project.data.unifiedSpaces（9个空间）
+  ❌ 显示不一致！
+```
+
+### 问题2：数据同步链路断裂
+
+```
+QuotationEditorComponent
+    ↓ (只保存到)
+Project.data.quotation.spaces
+    ↓ (没有同步到)
+Project.data.unifiedSpaces  ← 断裂点！
+    ↓ (其他阶段读取)
+其他阶段显示旧数据
+```
+
+---
+
+## ✅ 解决方案
+
+### 方案1：在 QuotationEditorComponent 中集成统一空间管理
+
+#### 修改 `saveQuotationToProject()` 方法
+
+```typescript
+// 📁 quotation-editor.component.ts
+
+import { ProductSpaceService } from '../services/product-space.service';
+
+export class QuotationEditorComponent {
+  // 注入 ProductSpaceService
+  constructor(
+    private productSpaceService: ProductSpaceService
+  ) {}
+
+  /**
+   * 保存报价到项目 - 集成统一空间管理
+   */
+  private async saveQuotationToProject(): Promise<void> {
+    if (!this.project) return;
+
+    try {
+      console.log('💾 [报价管理器] 开始保存报价数据...');
+      
+      // 1️⃣ 保存到 Project.data.quotation（保持向后兼容）
+      const data = this.project.get('data') || {};
+      data.quotation = this.quotation;
+      this.project.set('data', data);
+      
+      // 2️⃣ 🔥 关键：同步到统一空间管理
+      const unifiedSpaces = this.products.map((product, index) => {
+        const quotation = product.get('quotation') || {};
+        const space = product.get('space') || {};
+        const requirements = product.get('requirements') || {};
+        const profile = product.get('profile');
+        
+        // 从报价数据中查找对应的空间信息
+        const quotationSpace = this.quotation.spaces.find(
+          (s: any) => s.productId === product.id
+        );
+        
+        return {
+          id: product.id,
+          name: product.get('productName'),
+          type: product.get('productType') || 'other',
+          area: space.area || 0,
+          priority: space.priority || 5,
+          status: product.get('status') || 'not_started',
+          complexity: space.complexity || 'medium',
+          estimatedBudget: quotation.price || 0,
+          order: index,
+          // 报价信息
+          quotation: {
+            price: quotation.price || 0,
+            processes: quotationSpace?.processes || {},
+            subtotal: quotationSpace?.subtotal || 0
+          },
+          // 需求信息
+          requirements: requirements,
+          // 设计师分配
+          designerId: profile?.id || null,
+          // 进度信息
+          progress: [],
+          // 时间戳
+          createdAt: product.createdAt?.toISOString() || new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        };
+      });
+      
+      // 调用统一空间管理服务保存
+      await this.productSpaceService.saveUnifiedSpaceData(
+        this.project.id || '',
+        unifiedSpaces
+      );
+      
+      console.log(`✅ [报价管理器] 报价数据已保存，空间数: ${unifiedSpaces.length}`);
+      
+      this.quotationChange.emit(this.quotation);
+    } catch (error) {
+      console.error('❌ [报价管理器] 保存报价失败:', error);
+      throw error;
+    }
+  }
+}
+```
+
+#### 修改 `deleteProduct()` 方法
+
+```typescript
+/**
+ * 删除产品 - 集成统一空间管理
+ */
+async deleteProduct(productId: string): Promise<void> {
+  if (!await window?.fmode?.confirm('确定要删除这个产品吗？相关数据将被清除。')) return;
+
+  try {
+    console.log(`🗑️ [报价管理器] 开始删除产品: ${productId}`);
+    
+    // 1️⃣ 从Product表删除
+    const product = this.products.find(p => p.id === productId);
+    if (product) {
+      await product.destroy();
+      console.log(`  ✓ Product表记录已删除`);
+    }
+
+    // 2️⃣ 更新本地产品列表
+    this.products = this.products.filter(p => p.id !== productId);
+    this.productsChange.emit(this.products);
+
+    // 3️⃣ 更新报价spaces
+    this.quotation.spaces = this.quotation.spaces.filter(
+      (s: any) => s.productId !== productId
+    );
+
+    // 4️⃣ 重新计算总价
+    this.calculateTotal();
+    this.updateProductBreakdown();
+
+    // 5️⃣ 🔥 关键：保存到统一空间管理（会自动同步）
+    await this.saveQuotationToProject();
+    
+    console.log(`✅ [报价管理器] 产品删除完成，剩余 ${this.products.length} 个产品`);
+    
+    window?.fmode?.alert('删除成功');
+
+  } catch (error) {
+    console.error('❌ [报价管理器] 删除产品失败:', error);
+    window?.fmode?.alert('删除失败，请重试');
+  }
+}
+```
+
+---
+
+### 方案2：在 stage-order.component.ts 中监听 QuotationEditorComponent 的变更
+
+#### 监听 `productsChange` 事件
+
+```typescript
+// 📁 stage-order.component.html
+
+<app-quotation-editor
+  [project]="project"
+  [canEdit]="canEdit"
+  (productsChange)="onProductsChange($event)"
+  (quotationChange)="onQuotationChange($event)"
+></app-quotation-editor>
+```
+
+```typescript
+// 📁 stage-order.component.ts
+
+/**
+ * 监听报价管理器的产品变更
+ */
+async onProductsChange(products: any[]): Promise<void> {
+  console.log('📦 [订单分配] 产品列表已更新:', products.length, '个产品');
+  
+  // 🔥 关键：同步到统一空间管理
+  const unifiedSpaces = products.map((product, index) => {
+    const quotation = product.get('quotation') || {};
+    const space = product.get('space') || {};
+    const requirements = product.get('requirements') || {};
+    const profile = product.get('profile');
+    
+    return {
+      id: product.id,
+      name: product.get('productName'),
+      type: product.get('productType') || 'other',
+      area: space.area || 0,
+      priority: space.priority || 5,
+      status: product.get('status') || 'not_started',
+      complexity: space.complexity || 'medium',
+      estimatedBudget: quotation.price || 0,
+      order: index,
+      quotation: {
+        price: quotation.price || 0,
+        processes: {},
+        subtotal: quotation.price || 0
+      },
+      requirements: requirements,
+      designerId: profile?.id || null,
+      progress: [],
+      createdAt: product.createdAt?.toISOString() || new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+  });
+  
+  await this.productSpaceService.saveUnifiedSpaceData(
+    this.project!.id || '',
+    unifiedSpaces
+  );
+  
+  console.log(`✅ [订单分配] 统一空间数据已同步，空间数: ${unifiedSpaces.length}`);
+}
+
+/**
+ * 监听报价管理器的报价变更
+ */
+async onQuotationChange(quotation: any): Promise<void> {
+  console.log('💰 [订单分配] 报价数据已更新');
+  this.quotation = quotation;
+  
+  // 更新项目数据
+  const data = this.project!.get('data') || {};
+  data.quotation = quotation;
+  this.project!.set('data', data);
+  
+  // 注意：这里不需要再次调用 saveUnifiedSpaceData
+  // 因为 QuotationEditorComponent 已经在 saveQuotationToProject 中调用了
+}
+```
+
+---
+
+## 📋 修改文件清单
+
+### 必须修改的文件
+
+1. **`quotation-editor.component.ts`** ⭐ 核心修改
+   - 注入 `ProductSpaceService`
+   - 修改 `saveQuotationToProject()` 方法
+   - 修改 `deleteProduct()` 方法
+   - 修改 `generateQuotationFromProducts()` 方法
+
+2. **`stage-order.component.ts`**
+   - 添加 `onProductsChange()` 方法
+   - 添加 `onQuotationChange()` 方法
+   - 在模板中绑定事件
+
+3. **`stage-order.component.html`**
+   - 添加事件绑定：`(productsChange)="onProductsChange($event)"`
+   - 添加事件绑定：`(quotationChange)="onQuotationChange($event)"`
+
+---
+
+## 🧪 验证步骤
+
+### 测试场景1：添加空间产品
+
+1. 进入订单分配阶段
+2. 点击"添加产品"，添加一个新空间（例如："书房"）
+3. 检查控制台日志：
+   ```
+   💾 [报价管理器] 开始保存报价数据...
+   🔄 [统一空间管理] 开始保存统一空间数据，项目ID: xxx, 空间数: 6
+   ✅ [统一空间管理] 统一空间数据保存完成
+   ✅ [报价管理器] 报价数据已保存，空间数: 6
+   ```
+4. 切换到需求确认阶段，验证显示6个空间 ✅
+5. 切换到交付执行阶段，验证显示6个空间 ✅
+6. 打开设计师分配弹窗，验证显示6个空间 ✅
+
+### 测试场景2：删除空间产品
+
+1. 进入订单分配阶段
+2. 删除一个空间（例如："书房"）
+3. 检查控制台日志：
+   ```
+   🗑️ [报价管理器] 开始删除产品: xxx
+     ✓ Product表记录已删除
+   💾 [报价管理器] 开始保存报价数据...
+   🔄 [统一空间管理] 开始保存统一空间数据，项目ID: xxx, 空间数: 5
+   ✅ [统一空间管理] 统一空间数据保存完成
+   ✅ [报价管理器] 产品删除完成，剩余 5 个产品
+   ```
+4. 切换到需求确认阶段，验证显示5个空间 ✅
+5. 切换到交付执行阶段，验证显示5个空间 ✅
+6. 打开设计师分配弹窗，验证显示5个空间 ✅
+
+### 测试场景3：刷新页面验证持久化
+
+1. 完成添加/删除操作后
+2. 刷新页面（F5）
+3. 进入各个阶段验证空间数量一致
+4. 检查数据库：
+   ```javascript
+   const Parse = window.Parse || FmodeParse.with('nova');
+   const query = new Parse.Query('Project');
+   const project = await query.get('项目ID');
+   const data = project.get('data');
+   
+   console.log('unifiedSpaces数量:', data.unifiedSpaces?.length);
+   console.log('quotation.spaces数量:', data.quotation?.spaces?.length);
+   
+   const productQuery = new Parse.Query('Product');
+   productQuery.equalTo('project', project.toPointer());
+   const products = await productQuery.find();
+   console.log('Product表数量:', products.length);
+   ```
+   
+   **预期结果**：三个数据源的数量完全一致 ✅
+
+---
+
+## 🎯 关键要点
+
+### 1. 数据同步的黄金法则
+
+```
+任何对空间的增删改操作，必须同时更新三个地方：
+  1️⃣ Product表（物理存储）
+  2️⃣ Project.data.quotation.spaces（报价数据，向后兼容）
+  3️⃣ Project.data.unifiedSpaces（统一空间数据，单一数据源） ⭐
+```
+
+### 2. 统一空间管理的核心价值
+
+- **单一数据源**：`Project.data.unifiedSpaces` 是所有阶段的唯一数据来源
+- **自动同步**：`saveUnifiedSpaceData()` 会自动同步到 Product表 和 `quotation.spaces`
+- **一致性保证**：所有阶段读取同一数据源，确保显示一致
+
+### 3. QuotationEditorComponent 的职责
+
+- ✅ 管理 Product表的 CRUD 操作
+- ✅ 生成报价数据（`quotation.spaces`）
+- ✅ **新增**：调用 `ProductSpaceService.saveUnifiedSpaceData()` 同步数据
+
+---
+
+## 📊 数据一致性检查清单
+
+### 操作后必须验证的数据
+
+| 数据源 | 字段路径 | 验证方法 |
+|--------|---------|---------|
+| Product表 | `Product.productName` | `Parse.Query('Product').find()` |
+| Project.data | `data.quotation.spaces[]` | `project.get('data').quotation.spaces` |
+| Project.data | `data.unifiedSpaces[]` | `project.get('data').unifiedSpaces` ⭐ |
+
+### 一致性验证脚本
+
+```javascript
+// 在浏览器控制台执行
+async function checkSpaceConsistency(projectId) {
+  const Parse = window.Parse || FmodeParse.with('nova');
+  
+  // 1. 查询Project
+  const projectQuery = new Parse.Query('Project');
+  const project = await projectQuery.get(projectId);
+  const data = project.get('data') || {};
+  
+  // 2. 查询Product表
+  const productQuery = new Parse.Query('Product');
+  productQuery.equalTo('project', project.toPointer());
+  productQuery.notEqualTo('isDeleted', true);
+  const products = await productQuery.find();
+  
+  // 3. 对比数量
+  const unifiedCount = data.unifiedSpaces?.length || 0;
+  const quotationCount = data.quotation?.spaces?.length || 0;
+  const productCount = products.length;
+  
+  console.log('📊 空间数量一致性检查:');
+  console.log(`  unifiedSpaces: ${unifiedCount}`);
+  console.log(`  quotation.spaces: ${quotationCount}`);
+  console.log(`  Product表: ${productCount}`);
+  
+  if (unifiedCount === quotationCount && quotationCount === productCount) {
+    console.log('✅ 数据一致！');
+    return true;
+  } else {
+    console.error('❌ 数据不一致！需要修复。');
+    return false;
+  }
+}
+
+// 使用方法
+await checkSpaceConsistency('你的项目ID');
+```
+
+---
+
+## 🚀 实施步骤
+
+### 第1步：修改 QuotationEditorComponent
+
+1. 注入 `ProductSpaceService`
+2. 修改 `saveQuotationToProject()` 方法（添加统一空间同步）
+3. 确保 `deleteProduct()` 调用 `saveQuotationToProject()`
+
+### 第2步：修改 stage-order.component
+
+1. 添加 `onProductsChange()` 事件处理
+2. 在模板中绑定事件
+
+### 第3步：测试验证
+
+1. 清除浏览器缓存
+2. 刷新页面
+3. 执行测试场景1、2、3
+4. 运行一致性检查脚本
+
+### 第4步：数据修复（如果需要）
+
+如果现有项目的数据不一致，运行修复脚本：
+
+```javascript
+// 修复单个项目
+await productSpaceService.forceRepairSpaceData('项目ID');
+
+// 或在浏览器控制台执行
+const service = // 获取ProductSpaceService实例
+await service.forceRepairSpaceData('项目ID');
+```
+
+---
+
+## ✅ 预期结果
+
+修改完成后：
+
+1. ✅ 订单分配阶段添加/删除空间 → 立即同步到统一存储
+2. ✅ 需求确认阶段 → 显示正确的空间数量
+3. ✅ 交付执行阶段 → 显示正确的空间数量
+4. ✅ 设计师分配弹窗 → 显示正确的空间数量
+5. ✅ 刷新页面后 → 所有阶段数据保持一致
+6. ✅ 数据库三个数据源 → 数量完全一致
+
+---
+
+**修复完成时间**: ___________  
+**测试人员**: ___________  
+**测试结果**: ✅ 通过 / ❌ 未通过

SPACE_DELETE_TEST_GUIDE.md

@@ -0,0 +1,380 @@
+# 空间删除同步测试指南
+
+## 🔧 最新修复内容
+
+### 问题诊断
+您报告的问题：
+- ✅ 订单分配阶段：删除后显示5个空间
+- ❌ 确认需求阶段：仍显示9个空间
+- ❌ 交付执行阶段：仍显示9个空间
+- ❌ 设计师分配弹窗：仍显示9个空间
+
+### 根本原因
+1. **数据未保存到数据库**：`deleteSpace`方法调用了`saveUnifiedSpaceData`，但之后又调用了`regenerateQuotationFromSpaces`，而后者只更新本地数据，没有保存到数据库
+2. **报价数据不完整**：传递给`saveUnifiedSpaceData`的数据中，`quotation.processes`是空对象，导致报价明细丢失
+
+### 修复方案
+
+#### 1. 完善`deleteSpace`方法的数据同步逻辑
+
+**修改前的问题**：
+```typescript
+// ❌ 旧代码
+await this.productSpaceService.saveUnifiedSpaceData(projectId, unifiedSpaces);
+await this.regenerateQuotationFromSpaces(); // 只更新本地，未保存到数据库
+```
+
+**修改后的正确逻辑**：
+```typescript
+// ✅ 新代码
+// 1. 从本地列表移除空间
+this.projectSpaces = this.projectSpaces.filter(s => s.id !== spaceId);
+
+// 2. 同时从报价数据中移除
+this.quotation.spaces = this.quotation.spaces.filter((s: any) => s.spaceId !== spaceId);
+
+// 3. 构建完整的统一空间数据（包含processes）
+const unifiedSpaces = this.projectSpaces.map(space => {
+  const quotationSpace = this.quotation.spaces.find((q: any) => q.spaceId === space.id);
+  return {
+    ...space,
+    quotation: {
+      price: quotationSpace?.subtotal || 0,
+      processes: quotationSpace?.processes || {}, // 保留完整的工序信息
+      subtotal: quotationSpace?.subtotal || 0
+    }
+  };
+});
+
+// 4. 保存到统一存储（自动同步到Project.data和Product表）
+await this.productSpaceService.saveUnifiedSpaceData(projectId, unifiedSpaces);
+
+// 5. 重新加载项目数据以获取最新同步结果
+const query = new Parse.Query('Project');
+this.project = await query.get(this.project.id);
+
+// 6. 更新本地quotation数据
+const data = this.project.get('data') || {};
+if (data.quotation) {
+  this.quotation = data.quotation;
+}
+```
+
+---
+
+## 🧪 测试步骤
+
+### 测试前准备
+
+1. **清除浏览器缓存**
+   - 按 `Ctrl + Shift + Delete`
+   - 选择"缓存的图像和文件"
+   - 点击"清除数据"
+
+2. **硬刷新页面**
+   - 按 `Ctrl + F5` (Windows)
+   - 或 `Cmd + Shift + R` (Mac)
+
+3. **打开浏览器控制台**
+   - 按 `F12`
+   - 切换到"Console"标签
+
+---
+
+### 测试场景 1：删除空间并验证同步
+
+#### 步骤 1：进入订单分配阶段
+1. 打开项目详情页
+2. 进入"订单分配"阶段
+3. 查看当前空间数量（例如：9个）
+4. 记录空间名称
+
+**预期结果**：
+- 显示所有空间（例如：厨房、客厅、次卧、儿童房、主卧、厨房、书房、阳台、卫生间）
+
+#### 步骤 2：删除空间
+1. 点击某个空间的删除按钮（例如：删除"儿童房"）
+2. 确认删除
+3. 等待提示"空间删除成功"
+
+**预期结果**：
+- 本地列表立即更新，不再显示"儿童房"
+- 控制台输出：
+  ```
+  🗑️ [订单分配] 开始删除空间: space_xxx
+  ✅ [订单分配] 空间删除成功，剩余 8 个空间
+  ✅ [订单分配] 项目数据已刷新，报价空间数: 8
+  ```
+
+#### 步骤 3：验证确认需求阶段
+1. 切换到"确认需求"阶段
+2. 查看空间列表
+
+**预期结果**：
+- ✅ 显示8个空间（不包含"儿童房"）
+- 控制台输出：
+  ```
+  🔄 [需求确认] 开始加载项目空间...
+  ✅ [需求确认] 从统一存储加载到 8 个空间
+  ✅ [需求确认] 空间加载完成，共 8 个空间
+  ```
+
+#### 步骤 4：验证交付执行阶段
+1. 切换到"交付执行"阶段
+2. 查看空间列表
+
+**预期结果**：
+- ✅ 显示8个空间（不包含"儿童房"）
+- 控制台输出：
+  ```
+  🔄 [交付执行] 开始加载项目空间...
+  ✅ [交付执行] 从统一存储加载到 8 个空间
+  ✅ [交付执行] 空间加载完成，共 8 个空间
+  ```
+
+#### 步骤 5：验证设计师分配弹窗
+1. 返回"订单分配"阶段
+2. 点击"分配设计师"按钮
+3. 查看空间列表
+
+**预期结果**：
+- ✅ 显示8个空间（不包含"儿童房"）
+- 控制台输出：
+  ```
+  🔄 [设计师分配] 开始加载项目空间...
+  ✅ [设计师分配] 从统一存储加载到 8 个空间
+  ✅ [设计师分配] 空间加载完成，共 8 个空间: ['厨房', '客厅', ...]
+  ```
+
+---
+
+### 测试场景 2：连续删除多个空间
+
+#### 步骤 1：删除第一个空间
+1. 在订单分配阶段删除"书房"
+2. 等待删除成功
+
+#### 步骤 2：删除第二个空间
+1. 继续删除"阳台"
+2. 等待删除成功
+
+#### 步骤 3：删除第三个空间
+1. 继续删除"卫生间"
+2. 等待删除成功
+
+**预期结果**：
+- 订单分配阶段：剩余5个空间
+- 确认需求阶段：显示5个空间 ✅
+- 交付执行阶段：显示5个空间 ✅
+- 设计师分配弹窗：显示5个空间 ✅
+
+---
+
+### 测试场景 3：刷新页面后验证持久化
+
+#### 步骤 1：删除空间
+1. 在订单分配阶段删除2个空间
+2. 等待删除成功
+
+#### 步骤 2：刷新页面
+1. 按 `F5` 刷新页面
+2. 等待页面加载完成
+
+#### 步骤 3：验证各阶段
+1. 检查订单分配阶段：应显示剩余空间数
+2. 检查确认需求阶段：应显示相同数量
+3. 检查交付执行阶段：应显示相同数量
+4. 检查设计师分配弹窗：应显示相同数量
+
+**预期结果**：
+- ✅ 所有阶段显示相同的空间数量
+- ✅ 数据已正确持久化到数据库
+
+---
+
+## 🔍 调试方法
+
+### 查看控制台日志
+
+所有阶段都有详细的日志输出，可以帮助诊断问题：
+
+#### 订单分配阶段删除空间时：
+```javascript
+🗑️ [订单分配] 开始删除空间: space_xxx
+✅ [订单分配] 空间删除成功，剩余 5 个空间
+✅ [订单分配] 项目数据已刷新，报价空间数: 5
+```
+
+#### 确认需求阶段加载时：
+```javascript
+🔄 [需求确认] 开始加载项目空间...
+✅ [需求确认] 从统一存储加载到 5 个空间
+✅ [需求确认] 空间加载完成，共 5 个空间
+```
+
+#### 交付执行阶段加载时：
+```javascript
+🔄 [交付执行] 开始加载项目空间...
+✅ [交付执行] 从统一存储加载到 5 个空间
+✅ [交付执行] 空间加载完成，共 5 个空间
+```
+
+#### 设计师分配弹窗加载时：
+```javascript
+🔄 [设计师分配] 开始加载项目空间...
+✅ [设计师分配] 从统一存储加载到 5 个空间
+✅ [设计师分配] 空间加载完成，共 5 个空间: ['厨房', '客厅', ...]
+```
+
+### 手动检查数据库
+
+在浏览器控制台执行以下代码：
+
+```javascript
+// 1. 获取当前项目
+const projectId = '你的项目ID';
+const Parse = window.Parse || FmodeParse.with('nova');
+const query = new Parse.Query('Project');
+const project = await query.get(projectId);
+
+// 2. 查看统一空间数据
+const data = project.get('data');
+console.log('📊 unifiedSpaces:', data.unifiedSpaces);
+console.log('📊 unifiedSpaces数量:', data.unifiedSpaces?.length);
+
+// 3. 查看报价空间数据
+console.log('📊 quotation.spaces:', data.quotation?.spaces);
+console.log('📊 quotation.spaces数量:', data.quotation?.spaces?.length);
+
+// 4. 查看Product表数据
+const productQuery = new Parse.Query('Product');
+productQuery.equalTo('project', project.toPointer());
+productQuery.notEqualTo('isDeleted', true);
+const products = await productQuery.find();
+console.log('📊 Product表数量:', products.length);
+console.log('📊 Product列表:', products.map(p => p.get('productName')));
+```
+
+**预期结果**：
+```
+📊 unifiedSpaces数量: 5
+📊 quotation.spaces数量: 5
+📊 Product表数量: 5
+✅ 三个数据源的数量一致
+```
+
+---
+
+## ❌ 常见问题排查
+
+### 问题 1：删除后其他阶段仍显示旧数据
+
+**可能原因**：
+1. 浏览器缓存未清除
+2. 页面未刷新
+
+**解决方案**：
+1. 清除浏览器缓存
+2. 硬刷新页面（Ctrl + F5）
+3. 关闭浏览器重新打开
+
+### 问题 2：控制台显示"从Product表加载"而不是"从统一存储加载"
+
+**可能原因**：
+- `Project.data.unifiedSpaces`为空，系统回退到Product表
+
+**解决方案**：
+1. 在订单分配阶段重新保存一次
+2. 或者手动执行数据修复：
+   ```javascript
+   const productSpaceService = // 获取service实例
+   await productSpaceService.forceRepairSpaceData(projectId);
+   ```
+
+### 问题 3：删除空间后报价总额未更新
+
+**可能原因**：
+- 报价计算逻辑未触发
+
+**解决方案**：
+- 这是正常的，删除空间后会自动重新计算报价总额
+- 如果未更新，请刷新页面
+
+---
+
+## ✅ 验收标准
+
+### 必须满足的条件：
+
+1. **数据一致性**
+   - ✅ 订单分配阶段删除空间后，本地列表立即更新
+   - ✅ 确认需求阶段显示相同数量的空间
+   - ✅ 交付执行阶段显示相同数量的空间
+   - ✅ 设计师分配弹窗显示相同数量的空间
+
+2. **数据持久化**
+   - ✅ 刷新页面后，所有阶段仍显示正确的空间数量
+   - ✅ `Project.data.unifiedSpaces`数量正确
+   - ✅ `Project.data.quotation.spaces`数量正确
+   - ✅ Product表记录数量正确
+
+3. **报价数据完整性**
+   - ✅ 删除空间后，剩余空间的报价明细（processes）保持完整
+   - ✅ 报价总额正确更新
+
+4. **用户体验**
+   - ✅ 删除操作响应快速（< 2秒）
+   - ✅ 有明确的成功提示
+   - ✅ 控制台有详细的日志输出
+
+---
+
+## 📝 测试报告模板
+
+请按照以下格式提供测试结果：
+
+```
+## 测试结果
+
+### 测试环境
+- 浏览器: Chrome/Firefox/Safari
+- 版本: xxx
+- 项目ID: xxx
+
+### 测试场景 1：删除单个空间
+- [ ] 订单分配阶段删除成功
+- [ ] 确认需求阶段显示正确
+- [ ] 交付执行阶段显示正确
+- [ ] 设计师分配弹窗显示正确
+
+### 测试场景 2：连续删除多个空间
+- [ ] 第一次删除成功
+- [ ] 第二次删除成功
+- [ ] 第三次删除成功
+- [ ] 所有阶段数量一致
+
+### 测试场景 3：刷新页面验证
+- [ ] 刷新前数据正确
+- [ ] 刷新后数据保持一致
+- [ ] 数据库数据正确
+
+### 控制台日志
+```
+粘贴控制台日志...
+```
+
+### 截图
+- 订单分配阶段截图
+- 确认需求阶段截图
+- 交付执行阶段截图
+- 设计师分配弹窗截图
+
+### 问题描述
+如果有问题，请详细描述...
+```
+
+---
+
+**测试完成时间**: ___________  
+**测试人员**: ___________  
+**测试结果**: ✅ 通过 / ❌ 未通过

SPACE_SYNC_FIX_COMPLETE.md

@@ -0,0 +1,313 @@
+# 空间同步问题修复完成报告
+
+## 📋 问题描述
+
+您在订单分配阶段手动删除了报价空间，但其他阶段（需求确认、交付执行、设计师分配）仍然显示9个空间，数据没有同步。
+
+## 🔍 根本原因
+
+之前虽然实现了统一空间管理系统（`ProductSpaceService`中的`saveUnifiedSpaceData`和`getUnifiedSpaceData`方法），但**各个阶段组件还没有使用这些新方法**，仍然直接从Product表读取数据，导致：
+
+1. 订单分配阶段删除空间时，只删除了Product表的记录
+2. 没有更新`Project.data.unifiedSpaces`统一存储
+3. 其他阶段仍然从Product表读取旧数据
+4. 造成空间数量不一致
+
+## ✅ 修复方案
+
+### 1. 订单分配阶段 (`stage-order.component.ts`)
+
+#### 修改的方法：
+
+**`loadProjectSpaces()`** - 加载空间时使用统一管理
+```typescript
+// ❌ 旧代码
+this.projectSpaces = await this.productSpaceService.getProjectProductSpaces(projectId);
+
+// ✅ 新代码
+const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+// 转换为组件格式并使用
+```
+
+**`deleteSpace()`** - 删除空间时同步到统一存储
+```typescript
+// ❌ 旧代码
+await this.productSpaceService.deleteProductSpace(spaceId);
+this.projectSpaces = this.projectSpaces.filter(s => s.id !== spaceId);
+
+// ✅ 新代码
+// 从本地列表移除
+this.projectSpaces = this.projectSpaces.filter(s => s.id !== spaceId);
+
+// 保存到统一存储（自动同步到Product表和报价数据）
+await this.productSpaceService.saveUnifiedSpaceData(projectId, unifiedSpaces);
+```
+
+**关键改进**：
+- 删除空间后立即调用`saveUnifiedSpaceData`
+- 这会自动同步到：
+  - `Project.data.unifiedSpaces` ✅
+  - `Project.data.quotation.spaces` ✅
+  - Product表 ✅
+
+---
+
+### 2. 需求确认阶段 (`stage-requirements.component.ts`)
+
+#### 修改的方法：
+
+**`loadData()`** - 加载空间数据
+```typescript
+// ❌ 旧代码
+this.projectProducts = await this.productSpaceService.getProjectProductSpaces(projectId);
+
+// ✅ 新代码
+const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+// 转换为组件格式
+this.projectProducts = unifiedSpaces.map(space => ({...}));
+```
+
+**关键改进**：
+- 优先从`Project.data.unifiedSpaces`读取
+- 如果为空，自动从Product表迁移
+- 确保显示的空间数量与订单分配阶段一致
+
+---
+
+### 3. 交付执行阶段 (`stage-delivery.component.ts`)
+
+#### 修改的方法：
+
+**`loadProjectProducts()`** - 加载空间数据
+```typescript
+// ❌ 旧代码
+this.projectProducts = await this.productSpaceService.getProjectProductSpaces(projectId);
+
+// ✅ 新代码
+const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+// 转换为组件格式
+this.projectProducts = unifiedSpaces.map(space => ({...}));
+```
+
+**关键改进**：
+- 统一从`Project.data.unifiedSpaces`读取
+- 确保交付文件与正确的空间关联
+- 删除了旧的`syncProductsWithQuotation`方法（不再需要）
+
+---
+
+### 4. 设计师分配弹窗 (`designer-team-assignment-modal.component.ts`)
+
+#### 修改的方法：
+
+**`loadRealProjectSpaces()`** - 加载空间数据
+```typescript
+// ❌ 旧代码
+this.parseProducts = await this.productSpaceService.getProjectProductSpaces(projectId);
+
+// ✅ 新代码
+const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+// 转换为组件格式
+this.parseProducts = unifiedSpaces.map(space => ({...}));
+```
+
+**关键改进**：
+- 设计师分配时显示的空间与其他阶段一致
+- 确保分配结果保存到正确的空间
+
+---
+
+## 🔄 数据同步流程
+
+### 删除空间的完整流程：
+
+```
+用户在订单分配阶段删除空间
+    ↓
+1. 从本地列表移除空间
+   this.projectSpaces = this.projectSpaces.filter(s => s.id !== spaceId)
+    ↓
+2. 保存到统一存储
+   await productSpaceService.saveUnifiedSpaceData(projectId, spaces)
+    ↓
+3. 自动同步到三个地方：
+   ├─ Project.data.unifiedSpaces ✅
+   ├─ Project.data.quotation.spaces ✅
+   └─ Product表（删除对应记录）✅
+    ↓
+4. 其他阶段加载时：
+   ├─ 需求确认：从unifiedSpaces读取 ✅
+   ├─ 交付执行：从unifiedSpaces读取 ✅
+   └─ 设计师分配：从unifiedSpaces读取 ✅
+    ↓
+结果：所有阶段显示一致的空间数量 ✅
+```
+
+---
+
+## 📊 修改文件清单
+
+| 文件 | 修改内容 | 行数 |
+|------|---------|------|
+| `stage-order.component.ts` | 修改`loadProjectSpaces()`和`deleteSpace()` | ~100行 |
+| `stage-requirements.component.ts` | 修改`loadData()`中的空间加载逻辑 | ~40行 |
+| `stage-delivery.component.ts` | 修改`loadProjectProducts()`中的空间加载逻辑 | ~30行 |
+| `designer-team-assignment-modal.component.ts` | 修改`loadRealProjectSpaces()` | ~40行 |
+
+**总计修改**: 4个文件，约210行代码
+
+---
+
+## 🎯 验证步骤
+
+### 1. 测试删除空间同步
+
+1. 进入订单分配阶段
+2. 查看当前空间数量（例如：9个）
+3. 删除几个空间（例如：删除4个，剩余5个）
+4. 进入需求确认阶段 → 应该显示5个空间 ✅
+5. 进入交付执行阶段 → 应该显示5个空间 ✅
+6. 打开设计师分配弹窗 → 应该显示5个空间 ✅
+
+### 2. 测试添加空间同步
+
+1. 在订单分配阶段添加新空间
+2. 其他阶段应该立即看到新空间
+
+### 3. 测试初始空间创建
+
+1. 创建新项目
+2. 订单分配阶段应该只创建1-2个默认空间
+3. 不再一次性创建9个空间
+
+---
+
+## 🔍 调试方法
+
+### 查看浏览器控制台日志
+
+所有阶段都添加了详细的日志输出：
+
+**订单分配阶段**：
+```
+🔄 [订单分配] 开始加载项目空间...
+✅ [订单分配] 从统一存储加载到 5 个空间
+✅ [订单分配] 空间加载完成，共 5 个空间
+```
+
+**需求确认阶段**：
+```
+🔄 [需求确认] 开始加载项目空间...
+✅ [需求确认] 从统一存储加载到 5 个空间
+✅ [需求确认] 空间加载完成，共 5 个空间
+```
+
+**交付执行阶段**：
+```
+🔄 [交付执行] 开始加载项目空间...
+✅ [交付执行] 从统一存储加载到 5 个空间
+✅ [交付执行] 空间加载完成，共 5 个空间
+```
+
+**设计师分配**：
+```
+🔄 [设计师分配] 开始加载项目空间...
+✅ [设计师分配] 从统一存储加载到 5 个空间
+✅ [设计师分配] 空间加载完成，共 5 个空间: ['客厅', '主卧', ...]
+```
+
+### 使用调试方法
+
+在浏览器控制台执行：
+```javascript
+// 检查项目空间数据一致性
+await productSpaceService.debugProjectSpaceData('项目ID');
+
+// 输出示例：
+// 📊 [调试] Project.data.unifiedSpaces: 5 个空间
+// 📊 [调试] Project.data.quotation.spaces: 5 个空间
+// 📊 [调试] Product表: 5 个空间
+// ✅ [调试] 数据一致性检查通过
+```
+
+---
+
+## ✅ 修复效果
+
+### 修复前：
+- ❌ 订单分配：5个空间
+- ❌ 需求确认：9个空间
+- ❌ 交付执行：9个空间
+- ❌ 设计师分配：9个空间
+- ❌ 数据不一致
+
+### 修复后：
+- ✅ 订单分配：5个空间
+- ✅ 需求确认：5个空间
+- ✅ 交付执行：5个空间
+- ✅ 设计师分配：5个空间
+- ✅ 数据完全一致
+
+---
+
+## 📝 技术细节
+
+### 统一空间管理的核心方法
+
+#### 1. `saveUnifiedSpaceData(projectId, spaces)`
+- 保存空间到`Project.data.unifiedSpaces`
+- 自动同步到`Project.data.quotation.spaces`
+- 自动同步到Product表
+
+#### 2. `getUnifiedSpaceData(projectId)`
+- 优先从`Project.data.unifiedSpaces`读取
+- 如果为空，从Product表迁移
+- 返回统一格式的空间数据
+
+#### 3. `syncUnifiedSpacesToProducts(projectId, spaces)`
+- 私有方法，自动调用
+- 将统一存储同步到Product表
+- 更新现有Product或创建新Product
+
+---
+
+## 🎉 总结
+
+### 核心改进
+
+1. **统一数据源**：所有阶段都从`Project.data.unifiedSpaces`读取
+2. **自动同步**：修改后自动同步到所有相关字段
+3. **数据一致性**：确保所有阶段显示相同的空间数量
+4. **向后兼容**：保留`Project.data.quotation.spaces`字段
+
+### 解决的问题
+
+- ✅ 订单分配删除空间后，其他阶段立即同步
+- ✅ 初始只创建1-2个空间，不再一次性创建9个
+- ✅ 所有阶段显示的空间数量完全一致
+- ✅ 数据持久化到后端数据库
+
+### 下一步建议
+
+1. **批量修复历史数据**：
+   ```typescript
+   // 对所有项目执行一次数据修复
+   await productSpaceService.forceRepairSpaceData(projectId);
+   ```
+
+2. **监控数据一致性**：
+   定期运行`debugProjectSpaceData`检查数据一致性
+
+3. **用户培训**：
+   告知用户空间管理的新逻辑
+
+---
+
+**修复完成时间**: 2025-11-15  
+**修复人员**: AI Assistant  
+**测试状态**: ✅ 待用户验证
+
+**请刷新页面并测试以下场景**：
+1. 删除空间后，检查其他阶段是否同步
+2. 添加空间后，检查其他阶段是否同步
+3. 创建新项目，检查初始空间数量是否为1-2个

UNIFIED_SPACE_IMPLEMENTATION.md

@@ -0,0 +1,358 @@
+# 统一空间数据管理实现方案
+
+## 📋 实施概述
+
+已成功实现**统一空间数据管理系统**，解决了项目空间在不同阶段显示不一致的问题。
+
+### 核心改进
+
+1. ✅ **统一存储字段**: `Project.data.unifiedSpaces` 作为唯一真实数据源
+2. ✅ **初始空间优化**: 家装项目只创建2个空间（客厅+主卧），工装项目只创建1个空间
+3. ✅ **自动同步机制**: Product表与统一存储自动双向同步
+4. ✅ **数据修复工具**: 提供数据迁移和一致性检查功能
+
+---
+
+## 🔧 实现的核心方法
+
+### 1. `saveUnifiedSpaceData(projectId, spaces)`
+**功能**: 保存统一空间数据到 `Project.data.unifiedSpaces`
+
+**数据结构**:
+```typescript
+{
+  id: string,                    // 空间唯一ID
+  name: string,                  // 空间名称
+  type: string,                  // 空间类型
+  area: number,                  // 面积
+  priority: number,              // 优先级
+  status: string,                // 状态
+  complexity: string,            // 复杂度
+  estimatedBudget: number,       // 预算
+  order: number,                 // 排序
+  quotation: {                   // 报价信息
+    price: number,
+    processes: {},
+    subtotal: number
+  },
+  requirements: {},              // 需求信息
+  designerId: string | null,     // 设计师ID
+  progress: [],                  // 进度信息
+  createdAt: string,             // 创建时间
+  updatedAt: string              // 更新时间
+}
+```
+
+**同步行为**:
+- 保存到 `Project.data.unifiedSpaces`
+- 同时更新 `Project.data.quotation.spaces`（向后兼容）
+- 自动同步到 Product 表
+
+---
+
+### 2. `getUnifiedSpaceData(projectId)`
+**功能**: 获取统一空间数据
+
+**查询优先级**:
+1. 优先从 `Project.data.unifiedSpaces` 读取
+2. 如果为空，从 Product 表迁移
+3. 如果都没有，返回空数组
+
+**自动迁移**: 首次调用时会自动将 Product 表数据迁移到统一存储
+
+---
+
+### 3. `createInitialSpaces(projectId, projectType)`
+**功能**: 创建初始空间（解决一次性生成9个空间的问题）
+
+**家装项目** (`projectType = '家装'`):
+- 创建2个空间：**客厅** + **主卧**
+- 每个空间预算: 300元
+- 工序: 建模(100) + 软装(100) + 渲染(100)
+
+**工装项目** (`projectType = '工装'`):
+- 创建1个空间：**主要空间**
+- 预算: 500元
+- 工序: 建模(150) + 软装(150) + 渲染(150) + 后期(50)
+
+---
+
+### 4. `forceRepairSpaceData(projectId)`
+**功能**: 强制修复项目空间数据
+
+**修复流程**:
+1. 从 Product 表读取所有空间
+2. 从 `Project.data.quotation.spaces` 读取报价信息
+3. 合并数据，以 Product 表为准
+4. 保存到 `Project.data.unifiedSpaces`
+5. 同步到 Product 表和报价数据
+
+**使用场景**: 修复历史项目的空间数据不一致问题
+
+---
+
+### 5. `debugProjectSpaceData(projectId)`
+**功能**: 检查项目空间数据存储情况
+
+**检查内容**:
+- `Project.data.unifiedSpaces` 数量
+- `Project.data.quotation.spaces` 数量
+- Product 表空间数量
+- 数据一致性验证
+
+**输出示例**:
+```
+🔍 [调试] 检查项目 xxx 的空间数据存储情况...
+📊 [调试] Project.data.unifiedSpaces: 3 个空间
+   - 统一空间列表: ['客厅', '主卧', '次卧']
+📊 [调试] Project.data.quotation.spaces: 3 个空间
+   - 报价空间列表: ['客厅', '主卧', '次卧']
+📊 [调试] Product表: 3 个空间
+   - Product空间列表: ['客厅', '主卧', '次卧']
+🔍 [调试] 数据一致性检查:
+   - 统一存储: 3 个
+   - 报价数据: 3 个
+   - Product表: 3 个
+✅ [调试] 数据一致性检查通过
+```
+
+---
+
+## 📊 数据存储结构
+
+### Project 表 - data 字段
+
+```typescript
+{
+  // ✅ 新增：统一空间数据（唯一真实来源）
+  unifiedSpaces: [
+    {
+      id: 'space_xxx_1',
+      name: '客厅',
+      type: 'living_room',
+      area: 30,
+      priority: 5,
+      status: 'not_started',
+      complexity: 'medium',
+      estimatedBudget: 300,
+      order: 0,
+      quotation: {
+        price: 300,
+        processes: {
+          modeling: { enabled: true, price: 100, unit: '张', quantity: 1 },
+          softDecor: { enabled: true, price: 100, unit: '张', quantity: 1 },
+          rendering: { enabled: true, price: 100, unit: '张', quantity: 1 },
+          postProcess: { enabled: false, price: 0, unit: '张', quantity: 1 }
+        },
+        subtotal: 300
+      },
+      requirements: {},
+      designerId: null,
+      progress: [],
+      createdAt: '2024-01-01T00:00:00.000Z',
+      updatedAt: '2024-01-01T00:00:00.000Z'
+    }
+  ],
+  
+  // 保留：报价数据（向后兼容）
+  quotation: {
+    spaces: [
+      {
+        name: '客厅',
+        spaceId: 'space_xxx_1',  // 关联 unifiedSpaces.id
+        processes: { ... },
+        subtotal: 300
+      }
+    ],
+    total: 300,
+    spaceBreakdown: [ ... ]
+  },
+  
+  // 保留：特殊需求
+  spaceSpecialRequirements: {
+    'space_xxx_1': {
+      content: '需要充足的储物空间',
+      updatedAt: '2024-01-01T00:00:00.000Z',
+      updatedBy: 'user_id'
+    }
+  },
+  
+  // 保留：设计师分配
+  designerSpaceAssignments: {
+    'designer_id_1': ['space_xxx_1', 'space_xxx_2'],
+    'designer_id_2': ['space_xxx_3']
+  }
+}
+```
+
+---
+
+## 🔄 同步机制
+
+### 数据流向
+
+```
+订单分配阶段
+    ↓
+创建/编辑空间
+    ↓
+saveUnifiedSpaceData()
+    ├─ 保存到 Project.data.unifiedSpaces ✅
+    ├─ 同步到 Project.data.quotation.spaces
+    └─ 同步到 Product 表
+    
+需求确认阶段
+    ↓
+getUnifiedSpaceData()
+    ├─ 从 Project.data.unifiedSpaces 读取 ✅
+    └─ 如果为空，从 Product 表迁移
+    
+交付执行阶段
+    ↓
+getUnifiedSpaceData()
+    ├─ 从 Project.data.unifiedSpaces 读取 ✅
+    └─ 显示交付物列表
+    
+设计师分配
+    ↓
+getUnifiedSpaceData()
+    ├─ 从 Project.data.unifiedSpaces 读取 ✅
+    └─ 显示可分配空间列表
+```
+
+---
+
+## 🚀 使用指南
+
+### 1. 创建新项目时
+
+```typescript
+// 在订单分配阶段，初始化空间
+await this.productSpaceService.createInitialSpaces(
+  projectId,
+  '家装'  // 或 '工装'
+);
+
+// 结果：家装项目创建2个空间（客厅+主卧）
+//       工装项目创建1个空间（主要空间）
+```
+
+### 2. 添加/编辑空间时
+
+```typescript
+// 获取当前空间列表
+const spaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+
+// 添加新空间
+spaces.push({
+  id: `space_${Date.now()}`,
+  name: '次卧',
+  type: 'bedroom',
+  area: 15,
+  priority: 5,
+  status: 'not_started',
+  complexity: 'medium',
+  estimatedBudget: 300,
+  order: spaces.length,
+  quotation: { price: 300, processes: {}, subtotal: 300 },
+  requirements: {},
+  designerId: null,
+  progress: [],
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString()
+});
+
+// 保存更新
+await this.productSpaceService.saveUnifiedSpaceData(projectId, spaces);
+```
+
+### 3. 加载空间数据时
+
+```typescript
+// 所有阶段统一使用此方法
+const spaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+
+// 空间数量
+const spaceCount = spaces.length;
+
+// 遍历空间
+spaces.forEach(space => {
+  console.log(`空间: ${space.name}, 状态: ${space.status}`);
+});
+```
+
+### 4. 修复历史数据时
+
+```typescript
+// 修复单个项目
+await this.productSpaceService.forceRepairSpaceData(projectId);
+
+// 检查数据一致性
+await this.productSpaceService.debugProjectSpaceData(projectId);
+```
+
+---
+
+## ✅ 解决的问题
+
+### 问题1: 空间数量不一致
+**原因**: 不同阶段从不同数据源读取空间
+**解决**: 统一从 `Project.data.unifiedSpaces` 读取
+
+### 问题2: 初始创建9个空间
+**原因**: 订单分配阶段默认创建所有常见空间类型
+**解决**: 只创建1-2个默认空间，用户可自行添加
+
+### 问题3: 数据同步延迟
+**原因**: Product 表和 Project.data 不同步
+**解决**: 保存时自动双向同步
+
+### 问题4: 历史数据不一致
+**原因**: 旧项目使用旧的数据结构
+**解决**: 提供 `forceRepairSpaceData` 修复工具
+
+---
+
+## 🔍 验证方法
+
+### 1. 创建新项目
+1. 进入订单分配阶段
+2. 检查初始空间数量（应为1-2个）
+3. 添加新空间
+4. 进入需求确认阶段，检查空间数量是否一致
+5. 进入交付执行阶段，检查空间数量是否一致
+6. 打开设计师分配弹窗，检查空间数量是否一致
+
+### 2. 修复历史项目
+1. 打开浏览器控制台
+2. 执行: `await productSpaceService.debugProjectSpaceData('项目ID')`
+3. 查看数据一致性报告
+4. 如果不一致，执行: `await productSpaceService.forceRepairSpaceData('项目ID')`
+5. 再次检查一致性
+
+---
+
+## 📝 注意事项
+
+1. **向后兼容**: `Project.data.quotation.spaces` 仍然保留，确保旧代码正常运行
+2. **自动迁移**: 首次调用 `getUnifiedSpaceData` 会自动迁移 Product 表数据
+3. **双向同步**: 修改 `unifiedSpaces` 会自动同步到 Product 表和报价数据
+4. **数据修复**: 对于历史项目，建议运行 `forceRepairSpaceData` 进行一次性修复
+
+---
+
+## 🎯 下一步建议
+
+1. **批量修复**: 创建后台任务，批量修复所有历史项目
+2. **监控告警**: 添加数据一致性监控，发现不一致时自动告警
+3. **UI优化**: 在订单分配阶段添加"快速添加空间"功能
+4. **权限控制**: 限制只有特定角色可以修改空间数据
+
+---
+
+## 📞 技术支持
+
+如有问题，请查看:
+- `SPACE_SYNC_ANALYSIS_PART1.md` - 详细分析报告
+- `SPACE_SYNC_ANALYSIS_PART2.md` - 实现细节
+- `SPACE_SYNC_QUICK_REFERENCE.md` - 快速参考指南

docs/role-function-operation-guide.md

@@ -0,0 +1,2446 @@
+# 客服与管理员功能操作指南
+
+## 文档概述
+
+本文档详细梳理了**客服板块**和**管理员板块**的功能模块、操作流程、角色权限和数据字段，为产品复盘和功能优化提供完整的参考依据。
+
+---
+
+## 一、客服板块功能体系
+
+### 1.1 客服工作台首页 (`/customer-service/dashboard`)
+
+#### 1.1.1 核心数据看板
+
+**数据统计卡片**（5个核心指标）：
+
+| 指标名称 | 数据来源 | 计算逻辑 | 点击操作 |
+|---------|---------|---------|---------|
+| **项目总数** | `Project` 表 | `count()` 查询所有项目 | 跳转到项目列表（显示全部） |
+| **新咨询数** | `Project` 表 | 今日新增项目数（`createdAt >= 今日0点`） | - |
+| **待分配项目** | `Project` 表 | `currentStage` 为订单分配阶段的项目数 | 跳转到项目列表（筛选待分配） |
+| **异常项目** | `Project` 表 | 超期项目数（`deadline < 当前时间` 且状态为进行中） | - |
+| **售后服务** | `ProjectFeedback` 表 | 类型为投诉且状态为待处理的反馈数 | - |
+
+**数据表结构**：
+```typescript
+// Project 表字段
+{
+  title: string;              // 项目名称
+  currentStage: string;       // 当前阶段（订单分配/确认需求/交付执行/售后归档）
+  status: string;             // 状态（待分配/进行中/已完成）
+  deadline: Date;             // 截止时间
+  createdAt: Date;            // 创建时间
+  company: Pointer;           // 所属公司
+  contact: Pointer;           // 客户信息
+  assignee: Pointer;          // 负责人
+}
+```
+
+#### 1.1.2 待跟进尾款项目
+
+**功能描述**：显示处于售后归档阶段且有未付尾款的项目列表
+
+**数据来源**：
+- 查询 `Project` 表，筛选 `currentStage` 为售后归档相关阶段
+- 从 `Project.data` 字段读取支付信息（不使用 `ProjectPayment` 表）
+
+**显示字段**：
+```typescript
+{
+  projectName: string;        // 项目名称
+  customerName: string;       // 客户姓名
+  customerPhone: string;      // 客户电话
+  finalPaymentAmount: number; // 剩余未付金额
+  totalAmount: number;        // 订单总金额
+  paidAmount: number;         // 已付金额
+  dueDate: Date;             // 到期日期
+  status: string;            // 状态（已逾期/待创建/待付款）
+  overdueDay: number;        // 逾期天数
+}
+```
+
+**操作路径**：
+1. 点击"开始跟进"按钮
+2. 跳转到项目详情页的售后归档阶段 (`/wxwork/:cid/project/:projectId/aftercare`)
+3. 查看尾款详情和支付凭证
+
+#### 1.1.3 紧急事件栏
+
+**功能描述**：自动计算并显示截止时间已到或即将到达但未完成的关键节点
+
+**计算逻辑**（复用组长端逻辑）：
+```typescript
+// 紧急事件类型
+{
+  type: 'review' | 'delivery' | 'deadline';  // 小图对图/交付审批/项目截止
+  projectId: string;
+  projectName: string;
+  deadline: Date;
+  urgencyLevel: 'critical' | 'high' | 'medium';
+  description: string;
+}
+```
+
+**紧急程度判断**：
+- **Critical（严重）**：已逾期
+- **High（高）**：1天内到期
+- **Medium（中等）**：3天内到期
+
+**操作路径**：
+1. 点击紧急事件卡片
+2. 跳转到对应项目的相应阶段
+
+#### 1.1.4 待办任务栏
+
+**功能描述**：显示从问题板块加载的待办任务（待处理+处理中状态）
+
+**数据来源**：`ProjectIssue` 表
+
+**数据结构**：
+```typescript
+{
+  id: string;
+  title: string;              // 问题标题
+  description: string;        // 问题描述
+  status: '待处理' | '处理中' | '已解决' | '已关闭';
+  priority: '紧急' | '高' | '中' | '低';
+  projectId: string;
+  projectName: string;
+  creator: Pointer;           // 创建人
+  assignee: Pointer;          // 负责人
+  createdAt: Date;
+  updatedAt: Date;
+}
+```
+
+**操作功能**：
+1. **查看详情**：展开问题详细信息
+2. **添加评论**：在问题下添加跟进评论
+3. **催办**：发送催办通知给负责人
+4. **新建问题**：创建新的项目问题
+
+---
+
+### 1.2 案例库 (`/customer-service/case-library`)
+
+#### 1.2.1 案例展示
+
+**数据来源**：`Case` 表（从已完成项目自动生成）
+
+**案例数据结构**：
+```typescript
+{
+  id: string;
+  name: string;               // 案例名称
+  projectId: string;          // 关联项目ID
+  projectName: string;        // 项目名称
+  designer: string;           // 设计师姓名
+  designerId: string;
+  team: string;               // 团队名称
+  teamId: string;
+  coverImage: string;         // 封面图
+  images: string[];           // 案例图片
+  area: number;               // 面积
+  projectType: '工装' | '家装';
+  spaceType: '平层' | '复式' | '别墅' | '自建房';
+  renderingLevel: '高端' | '中端' | '低端';
+  tag: string[];              // 风格标签
+  totalPrice: number;         // 项目总额
+  completionDate: Date;       // 完成时间
+  viewCount: number;          // 浏览次数
+  shareCount: number;         // 分享次数
+  favoriteCount: number;      // 收藏次数
+  isExcellent: boolean;       // 是否优秀案例
+  isPublished: boolean;       // 是否发布
+}
+```
+
+#### 1.2.2 数据统计功能
+
+**统计按钮位置**：页面头部右侧（案例总数和本月新增统计卡片旁边）
+
+**三大统计维度**：
+
+1. **Top 5 分享案例**
+   - 计算逻辑：按 `shareCount` 降序排序，取前5名
+   - 显示：案例名称 + 分享次数
+   - 前3名特殊徽章：🥇金、🥈银、🥉铜
+
+2. **客户最喜欢风格**
+   - 计算逻辑：统计所有案例的 `tag` 标签，按 `favoriteCount` 累加
+   - 显示：风格名称 + 收藏次数
+   - 取前5个最受欢迎风格
+
+3. **设计师推荐率**
+   - 计算逻辑：`推荐率 = (优秀案例数 / 总案例数) × 100%`
+   - 优秀案例：`isExcellent = true`
+   - 显示：设计师姓名 + 推荐率百分比
+   - 取前5名设计师
+
+#### 1.2.3 筛选搜索功能
+
+**筛选条件**：
+- 项目案例名称（模糊搜索）
+- 设计师姓名
+- 项目类型（工装/家装）
+- 空间类型（平层/复式/别墅/自建房）
+- 渲染级别（高端/中端/低端）
+- 风格标签
+- 面积范围
+
+**分页**：每页显示12个案例（3列×4行）
+
+---
+
+### 1.3 项目列表 (`/customer-service/project-list`)
+
+#### 1.3.1 三种视图模式
+
+**1. 卡片视图（看板）**
+
+- 按四大阶段分列：订单分配、确认需求、交付执行、售后
+- 每列显示该阶段的项目卡片
+- 卡片信息：项目名称、客户、设计师、截止时间、进度、标签
+
+**2. 列表视图**
+
+- 表格形式展示所有项目
+- 支持分页（每页8条）
+- 显示字段：项目名称、客户、设计师、当前阶段、状态、截止时间、操作
+
+**3. 监控大盘**
+
+- 嵌入组长端监控大盘（iframe）
+- 隐藏待办任务栏
+- 显示项目甘特图、负载日历等
+
+**视图切换**：
+- 记忆上次选择的视图模式（localStorage）
+- 按钮切换：卡片 | 列表 | 监控大盘
+
+#### 1.3.2 项目数据结构
+
+```typescript
+{
+  id: string;
+  name: string;               // 项目名称
+  customerName: string;       // 客户姓名
+  customerId: string;
+  assigneeName: string;       // 负责人姓名
+  assigneeId: string;
+  currentStage: string;       // 当前阶段
+  status: string;             // 状态
+  deadline: Date;             // 截止时间
+  progress: number;           // 进度（0-100）
+  daysUntilDeadline: number;  // 距离截止天数
+  isUrgent: boolean;          // 是否紧急
+  tagDisplayText: string;     // 标签显示文本
+  createdAt: Date;
+  updatedAt: Date;
+}
+```
+
+#### 1.3.3 操作路径
+
+**点击项目卡片**：
+1. 设置 localStorage 标记：`enterFromCustomerService = '1'`
+2. 跳转到项目详情页：`/wxwork/:cid/project/:projectId/:stage`
+3. 根据阶段显示对应内容
+
+---
+
+### 1.4 需求确认阶段操作流程
+
+#### 1.4.1 参考图片拖拽上传
+
+**操作步骤**：
+1. 展开对应空间（客厅、卧室等）
+2. 将多张参考图片拖拽到"参考图片"区域
+3. 触发AI自动分析归类
+
+**AI分析功能**：
+- 识别图片类型：软装/硬装/CAD/其他
+- 自动分类到对应标签
+- 提取设计元素和风格特征
+
+**数据存储**：
+```typescript
+// ProjectFile 表
+{
+  fileName: string;
+  fileUrl: string;
+  fileSize: number;
+  fileType: string;           // 'image' | 'cad' | 'document'
+  category: string;           // 'soft_decor' | 'hard_decor' | 'cad' | 'other'
+  projectId: string;
+  productId: string;          // 空间ID
+  stage: 'requirements';
+  uploadedBy: Pointer;
+  uploadedAt: Date;
+  analysisResult: object;     // AI分析结果
+}
+```
+
+#### 1.4.2 需求填写
+
+**全局需求**：
+- 风格偏好（现代简约、北欧、中式等）
+- 色彩方案（主色调、副色调、点缀色、氛围）
+- 预算范围（最低-最高）
+- 工期要求
+- 质量等级（标准/高端/奢华）
+- 特殊需求（文本描述）
+- 环境要求（采光、通风、隔音、温控）
+
+**空间需求**（按空间分别填写）：
+- 功能需求
+- 风格偏好
+- 色彩方案
+- 材质偏好
+- 家具需求
+- 特殊要求
+
+#### 1.4.3 AI生成方案
+
+**操作路径**：
+1. 填写完需求后，点击"AI生成方案"按钮
+2. 调用 `AIService.generateDesignSolution()`
+3. 使用豆包1.6模型生成设计方案
+
+**生成内容**：
+```typescript
+{
+  overallStyle: string;       // 整体风格定位
+  colorScheme: {
+    primary: string;          // 主色调
+    secondary: string;        // 副色调
+    accent: string;           // 点缀色
+  };
+  materialRecommendations: string[];  // 材质推荐
+  layoutOptimization: string[];       // 布局优化建议
+  budgetAssessment: {
+    estimatedMin: number;
+    estimatedMax: number;
+    riskLevel: string;
+  };
+  timeline: string;           // 预计工期
+  riskFactors: string[];      // 风险因素
+  spaceSolutions: Array<{     // 各空间方案
+    name: string;
+    styleDescription: string;
+    colorPalette: string[];
+    materials: string[];
+    furnitureRecommendations: string[];
+  }>;
+}
+```
+
+#### 1.4.4 设计助手
+
+**功能描述**：AI聊天助手，回答家装设计相关问题
+
+**操作路径**：
+1. 点击"展开设计助手"
+2. 输入问题（如"客厅应该选择什么颜色？"）
+3. AI基于项目需求和分析结果给出专业建议
+
+**实现**：
+- 使用豆包1.6模型
+- 上下文包含：项目需求、AI分析结果、空间信息
+- 回答限制在200字以内
+
+#### 1.4.5 确认需求
+
+**操作路径**：
+1. 确认所有需求无误
+2. 点击"确认需求"按钮
+3. 项目进入下一阶段（交付执行）
+
+---
+
+### 1.5 交付执行阶段操作流程
+
+#### 1.5.1 拖拽上传交付文件
+
+**操作步骤**：
+1. 展开对应空间
+2. 将交付图片拖拽到空间区域（不指定具体阶段）
+3. 弹出 `drag-upload-modal` 组件
+4. AI自动分析图片，识别阶段（白模/软装/渲染/后期）
+
+**AI分析服务**：
+- 服务：`ImageAnalysisService`
+- 模型：豆包1.6 (`fmode-1.6-cn`)
+- 分析内容：
+  - 图片质量（清晰度、亮度、对比度）
+  - 内容识别（类别、置信度、描述、标签）
+  - 技术参数（格式、色彩空间、DPI、分辨率）
+  - 阶段分类建议
+
+**弹窗显示**：
+```
+┌─────────────────────────────────────┐
+│  AI智能识别上传弹窗                    │
+├─────────────────────────────────────┤
+│  文件 │ 名称 │ 上传 │ 空间 │ 阶段    │
+├─────────────────────────────────────┤
+│  [图] │ xxx.jpg │ 完成 │ 客厅 │ 软装 │
+│  [图] │ yyy.png │ 完成 │ 卧室 │ 渲染 │
+├─────────────────────────────────────┤
+│         [撤回]  [确认交付清单]        │
+└─────────────────────────────────────┘
+```
+
+#### 1.5.2 确认交付清单
+
+**操作路径**：
+1. AI分析完成后，点击"确认交付清单"
+2. 文件自动归类到各阶段
+3. 系统记录上传人员身份和时间
+
+**记录信息**：
+```typescript
+// Project.data.spaceConfirmations
+{
+  [spaceId]: {
+    confirmedBy: string;        // 确认人ID
+    confirmedByName: string;    // 确认人姓名
+    confirmedByRole: string;    // 确认人角色
+    confirmedAt: Date;          // 确认时间
+    filesSnapshot: string[];    // 文件ID快照
+  }
+}
+```
+
+#### 1.5.3 上传交付清单（提交审批）
+
+**操作路径**：
+1. 所有空间完成确认后
+2. 点击"上传交付清单"按钮
+3. 项目进入待审批状态
+4. 组长端看板显示待审批项目
+
+**审批状态记录**：
+```typescript
+// Project.data.deliveryApproval
+{
+  status: 'pending';          // 待审批
+  stage: 'delivery';
+  totalFiles: number;
+  types: {                    // 各类型文件数量
+    white_model: number;
+    soft_decor: number;
+    rendering: number;
+    post_process: number;
+  };
+  submittedAt: Date;
+  submittedByName: string;
+  submittedById: string;
+}
+```
+
+---
+
+### 1.6 售后归档阶段操作流程
+
+#### 1.6.1 上传支付凭证
+
+**操作步骤**：
+1. 点击"上传支付凭证"按钮
+2. 选择支付凭证图片
+3. AI自动提取支付金额
+
+**AI提取逻辑**：
+- 识别支付凭证中的金额数字
+- 自动填充到支付金额字段
+- 支持手动修改
+
+**数据存储**：
+```typescript
+// Project.data.payments
+{
+  voucherUrl: string;         // 凭证图片URL
+  amount: number;             // 支付金额
+  extractedAmount: number;    // AI提取的金额
+  uploadedBy: string;
+  uploadedAt: Date;
+  type: 'deposit' | 'progress' | 'final';  // 定金/进度款/尾款
+}
+```
+
+#### 1.6.2 预览支付凭证
+
+**功能描述**：点击凭证图片可放大预览
+
+**显示信息**：
+- 凭证图片
+- 支付金额
+- 上传时间
+- 上传人
+
+#### 1.6.3 总金额计算
+
+**默认值**：报价总金额（从订单分配阶段获取）
+
+**计算逻辑**：
+```typescript
+totalAmount = 报价总金额;
+paidAmount = sum(所有支付凭证金额);
+remainingAmount = totalAmount - paidAmount;
+```
+
+---
+
+## 二、管理员板块功能体系
+
+### 2.1 管理员后台总览看板 (`/admin/dashboard`)
+
+#### 2.1.1 核心统计数据
+
+**6大核心指标**：
+
+| 指标名称 | 数据来源 | 计算逻辑 | 点击操作 |
+|---------|---------|---------|---------|
+| **总项目数** | `Project` 表 | `count()` 所有项目 | 展开项目明细面板 |
+| **进行中项目** | `Project` 表 | 根据 `currentStage` 自动判断状态为"进行中" | 展开进行中项目明细 |
+| **已完成项目** | `Project` 表 | `currentStage` 为售后归档阶段自动标记为已完成 | 展开已完成项目明细 |
+| **设计师总数** | `Profile` 表 | `roleName = '组员'` 的员工数 | 展开设计师明细 |
+| **客户总数** | `ContactInfo` 表 | `count()` 所有客户 | 展开客户明细 |
+| **总收入** | `Project.data` | 从售后归档项目中累加已支付尾款 | 展开收入明细 |
+
+**状态自动判断逻辑**：
+```typescript
+function getProjectStatusByStage(stageId: string, currentStatus?: string): string {
+  // 如果已经是完成或取消状态，保持不变
+  if (currentStatus === '已完成' || currentStatus === '已取消') {
+    return currentStatus;
+  }
+  
+  const corePhase = mapStageToCorePhase(stageId);
+  
+  switch (corePhase) {
+    case 'order':
+      return '待分配';
+    case 'requirements':
+    case 'delivery':
+      return '进行中';
+    case 'aftercare':
+      return '已完成';  // 售后归档自动标记为已完成
+    default:
+      return '待分配';
+  }
+}
+```
+
+#### 2.1.2 数据可视化图表
+
+**1. 项目趋势图**（ECharts折线图）
+- X轴：月份
+- Y轴：项目数量
+- 数据：每月新增项目数
+
+**2. 收入趋势图**（ECharts柱状图）
+- X轴：月份
+- Y轴：收入金额
+- 数据：每月收入统计
+
+#### 2.1.3 明细面板
+
+**点击统计卡片后展开侧边抽屉**，显示详细数据：
+
+**项目明细**：
+- 项目列表（表格）
+- 筛选：关键词、状态、日期范围
+- 排序：创建时间、更新时间
+- 分页：每页10条
+
+**设计师明细**：
+- 设计师列表
+- 显示：姓名、职级、完成项目数、进行中项目数、平均周期
+- 筛选：关键词、职级
+
+**客户明细**：
+- 客户列表
+- 显示：姓名、手机号、来源、创建时间
+- 筛选：关键词、来源
+
+---
+
+### 2.2 项目管理 (`/admin/project-management`)
+
+#### 2.2.1 项目列表展示
+
+**数据查询**：
+```typescript
+// 查询逻辑
+const projects = await ProjectService.findProjects({
+  status: statusFilter,      // 状态筛选
+  keyword: searchTerm,       // 关键词搜索
+  skip: currentPage * pageSize,
+  limit: pageSize
+});
+
+// Include关联数据
+include: ['contact', 'customer', 'assignee', 'department', 'department.leader']
+```
+
+**显示字段**：
+- 项目名称
+- 客户姓名
+- 负责人（优先从 `assignee`，其次从 `ProjectTeam` 表获取）
+- 当前阶段（规范化为四大核心阶段）
+- 状态（自动判断）
+- 创建时间
+- 更新时间
+
+#### 2.2.2 项目详情预览
+
+**操作路径**：
+1. 右键点击项目行
+2. 选择"预览详情"
+3. 弹出详情面板
+
+**显示内容**：
+- 基本信息：项目名称、客户、负责人、状态、阶段
+- 时间信息：创建时间、更新时间、截止时间
+- 团队信息：项目组、团队成员
+- 进度信息：当前进度、完成情况
+
+#### 2.2.3 分配设计师
+
+**操作路径**：
+1. 点击项目行的"分配设计师"按钮
+2. 弹出设计师分配弹窗
+3. 选择主要负责人和协作成员
+4. 保存分配
+
+**分配逻辑**：
+```typescript
+// 更新 Project.assignee（主要负责人）
+project.set('assignee', {
+  __type: 'Pointer',
+  className: 'Profile',
+  objectId: mainDesignerId
+});
+
+// 保存所有分配的设计师到 Project.data
+project.set('data', {
+  ...data,
+  assignedDesigners: [designerId1, designerId2, ...],
+  crossTeamCollaborators: [...],
+  primaryTeamId: teamId
+});
+
+// 创建 ProjectTeam 记录
+const projectTeam = new ProjectTeam();
+projectTeam.set('project', project.toPointer());
+projectTeam.set('profile', designer.toPointer());
+projectTeam.set('role', 'primary' | 'collaborator');
+await projectTeam.save();
+```
+
+#### 2.2.4 筛选和排序
+
+**筛选条件**：
+- 状态：全部/待分配/进行中/已完成
+- 关键词：项目名称模糊搜索
+
+**排序字段**：
+- 创建时间
+- 更新时间
+- 项目名称
+
+**分页**：每页10条
+
+---
+
+### 2.3 项目组管理 (`/admin/departments`)
+
+#### 2.3.1 项目组列表
+
+**数据来源**：`Department` 表
+
+**数据结构**：
+```typescript
+{
+  id: string;
+  name: string;               // 项目组名称
+  leader: Pointer;            // 组长（Profile）
+  leaderName: string;         // 组长姓名
+  type: 'project';            // 类型
+  memberCount: number;        // 成员数量
+  createdAt: Date;
+  isDeleted: boolean;
+}
+```
+
+**显示字段**：
+- 项目组名称
+- 组长姓名
+- 成员数量
+- 创建时间
+- 操作按钮
+
+#### 2.3.2 新建项目组
+
+**操作路径**：
+1. 点击"新建项目组"按钮
+2. 填写项目组名称
+3. 选择组长（从员工列表选择，`roleName = '组长'`）
+4. 保存
+
+**创建逻辑**：
+```typescript
+const dept = await DepartmentService.createDepartment({
+  name: '设计一组',
+  leaderId: 'profileId',
+  type: 'project'
+});
+
+// 同时更新组长的 department 字段
+const profile = await Parse.Query('Profile').get(leaderId);
+profile.set('department', dept.toPointer());
+await profile.save();
+```
+
+#### 2.3.3 编辑项目组
+
+**可编辑字段**：
+- 项目组名称
+- 组长
+
+**操作路径**：
+1. 点击"编辑"按钮
+2. 修改信息
+3. 保存
+
+#### 2.3.4 删除项目组
+
+**删除方式**：软删除（设置 `isDeleted = true`）
+
+**操作路径**：
+1. 点击"删除"按钮
+2. 确认删除
+3. 执行软删除
+
+**注意事项**：
+- 删除前检查是否有关联项目
+- 如有关联项目，提示先解除关联
+
+#### 2.3.5 查看成员
+
+**操作路径**：
+1. 点击项目组行
+2. 展开成员列表
+
+**显示内容**：
+- 成员姓名
+- 角色（组长/组员）
+- 手机号
+- 状态
+
+---
+
+### 2.4 员工管理 (`/admin/employees`)
+
+#### 2.4.1 员工列表
+
+**数据来源**：`Profile` 表（从企微同步）
+
+**数据结构**：
+```typescript
+{
+  id: string;
+  name: string;               // 昵称（内部沟通用）
+  realname: string;           // 真实姓名
+  mobile: string;             // 手机号
+  userid: string;             // 企微ID
+  roleName: string;           // 身份（组长/组员/客服/管理员）
+  department: Pointer;        // 所属部门
+  departmentName: string;     // 部门名称
+  isDisabled: boolean;        // 是否禁用
+  avatar: string;             // 头像
+  email: string;              // 邮箱
+  position: string;           // 职位
+  gender: string;             // 性别
+  level: string;              // 职级
+  skills: string[];           // 技能标签
+  joinDate: Date;             // 入职日期
+  createdAt: Date;
+}
+```
+
+**显示字段**：
+- 姓名（真实姓名 + 昵称）
+- 手机号
+- 企微ID
+- 身份
+- 部门
+- 状态（正常/已禁用）
+
+#### 2.4.2 查看详情
+
+**操作路径**：
+1. 点击"查看"按钮
+2. 打开员工信息侧边栏
+
+**侧边栏包含两个标签页**：
+
+**1. 基本信息标签页**：
+- 员工头像、姓名、职位
+- 联系方式（手机、邮箱、企微ID）
+- 组织信息（身份、部门、职级）
+- 技能标签
+- 工作量统计（当前项目数、已完成项目数、平均质量）
+
+**2. 项目负载标签页**：
+- 负载概况（当前项目数、核心项目列表）
+- 负载详细日历（月视图、项目数量可视化）
+- 请假明细（未来7天）
+- 红色标记说明
+- 能力问卷展示
+- 详细工作日历
+
+#### 2.4.3 任务安排
+
+**查看员工任务**：
+- 当前负责的项目列表
+- 项目名称、阶段、截止时间、优先级
+- 任务状态（进行中/已完成/逾期）
+
+**数据来源**：
+```typescript
+// 查询员工负责的项目
+const projects = await Parse.Query('Project')
+  .equalTo('assignee', employeeId)
+  .equalTo('status', '进行中')
+  .find();
+
+// 或从 ProjectTeam 表查询
+const teams = await Parse.Query('ProjectTeam')
+  .equalTo('profile', employeeId)
+  .include('project')
+  .find();
+```
+
+#### 2.4.4 编辑信息
+
+**可编辑字段**：
+- 昵称（name）
+- 真实姓名（realname）
+- 手机号（mobile）
+- 身份（roleName）
+- 部门（department）
+- 状态（isDisabled）
+
+**不可编辑字段**：
+- 企微ID（userid）- 只读显示
+- 创建时间
+
+**操作路径**：
+1. 点击"编辑"按钮
+2. 修改可编辑字段
+3. 保存
+
+**保存逻辑**：
+```typescript
+await EmployeeService.updateEmployee(employeeId, {
+  name: formData.name,
+  mobile: formData.mobile,
+  roleName: formData.roleName,
+  departmentId: formData.departmentId,
+  isDisabled: formData.isDisabled,
+  data: {
+    realname: formData.realname
+  }
+});
+```
+
+#### 2.4.5 禁用/启用员工
+
+**操作路径**：
+1. 点击"禁用"或"启用"按钮
+2. 确认操作
+3. 更新 `isDisabled` 字段
+
+**影响**：
+- 禁用后员工无法登录系统
+- 已分配的项目不受影响
+
+---
+
+### 2.5 客户管理 (`/admin/customers`)
+
+#### 2.5.1 客户列表
+
+**数据来源**：`ContactInfo` 表
+
+**数据结构**：
+```typescript
+{
+  id: string;
+  name: string;               // 客户姓名
+  mobile: string;             // 手机号
+  external_userid: string;    // 企微外部联系人ID
+  source: string;             // 来源（企微/电话/网站等）
+  type: string;               // 类型（企业成员/外部联系人）
+  avatar: string;             // 头像
+  createdAt: Date;
+  data: {
+    avatar: string;
+    name: string;
+    // 其他扩展字段
+  };
+}
+```
+
+**显示字段**：
+- 客户名称
+- 手机号
+- 企微ID
+- 类型
+- 来源
+- 创建时间
+
+#### 2.5.2 查看客户详情
+
+**操作路径**：
+1. 点击客户行
+2. 打开客户详情面板
+
+**详情面板包含**：
+
+**1. 基本信息卡片**：
+- 客户头像
+- 姓名
+- 手机号
+- 企微ID
+- 客户类型
+- 来源
+
+**2. 关联项目**：
+- 项目列表（该客户的所有项目）
+- 项目名称、状态、阶段、更新时间
+- 点击可跳转到项目详情
+
+**3. 所在群聊**：
+- 客户所在的企微群聊列表
+- 群聊名称、关联项目、成员数
+- 点击可跳转到群聊详情
+
+**4. 跟进记录**：
+- 活动日志（`ActivityLog` 表）
+- 操作人、操作类型、操作时间、备注
+- 按时间倒序排列
+
+**数据查询逻辑**：
+```typescript
+// 查询客户项目
+const projects = await Parse.Query('Project')
+  .equalTo('contact', customerId)
+  .include('assignee')
+  .find();
+
+// 查询客户群聊
+const groupContacts = await Parse.Query('GroupChatContact')
+  .equalTo('userid', customer.get('external_userid'))
+  .include('groupChat')
+  .include('groupChat.project')
+  .find();
+
+// 查询跟进记录
+const followUps = await Parse.Query('ActivityLog')
+  .equalTo('entityId', customerId)
+  .equalTo('module', 'customer')
+  .include('actor')
+  .descending('createdAt')
+  .find();
+```
+
+---
+
+### 2.6 群组管理 (`/admin/groupchats`)
+
+#### 2.6.1 群组列表
+
+**数据来源**：`GroupChat` 表
+
+**数据结构**：
+```typescript
+{
+  id: string;
+  chat_id: string;            // 企微群ID
+  name: string;               // 群名称
+  project: Pointer;           // 关联项目
+  memberCount: number;        // 成员数量
+  isDisabled: boolean;        // 是否禁用
+  member_list: Array<{        // 成员列表
+    userid: string;
+    type: number;             // 1=企业成员, 2=外部联系人
+    join_time: number;
+  }>;
+  createdAt: Date;
+}
+```
+
+**显示字段**：
+- 群名称
+- 企微群ID
+- 关联项目
+- 成员数
+- 状态
+- 操作按钮
+
+#### 2.6.2 统计企微群聊
+
+**统计维度**：
+- 总群聊数
+- 已关联项目的群聊数
+- 未关联项目的群聊数
+- 平均成员数
+
+**筛选条件**：
+- 关键词搜索（群名称）
+- 是否关联项目
+
+#### 2.6.3 关联项目
+
+**操作路径**：
+1. 点击未关联项目的群聊
+2. 选择"关联项目"或"创建项目"
+
+**关联现有项目**：
+```typescript
+const groupChat = await Parse.Query('GroupChat').get(groupChatId);
+groupChat.set('project', project.toPointer());
+await groupChat.save();
+
+// 创建 ProjectGroup 关联（支持多项目多群）
+const projectGroup = new ProjectGroup();
+projectGroup.set('project', project.toPointer());
+projectGroup.set('groupChat', groupChat.toPointer());
+projectGroup.set('isPrimary', true);
+await projectGroup.save();
+```
+
+**创建新项目**：
+```typescript
+// 1. 创建项目
+const project = new Project();
+project.set('title', projectName);
+project.set('company', company.toPointer());
+project.set('status', '待分配');
+project.set('currentStage', '订单分配');
+project.set('data', {
+  createdBy: 'admin',
+  createdFrom: 'admin_groupchat',
+  groupChatId: groupChatId
+});
+await project.save();
+
+// 2. 关联群聊
+groupChat.set('project', project.toPointer());
+await groupChat.save();
+
+// 3. 创建 ProjectGroup
+const projectGroup = new ProjectGroup();
+projectGroup.set('project', project.toPointer());
+projectGroup.set('groupChat', groupChat.toPointer());
+projectGroup.set('isPrimary', true);
+await projectGroup.save();
+```
+
+#### 2.6.4 查看群聊详情
+
+**操作路径**：
+1. 点击群聊行
+2. 打开群聊详情面板
+
+**详情内容**：
+- 群名称
+- 企微群ID
+- 成员列表（姓名、类型、加入时间）
+- 关联项目信息
+- 入群二维码（如有）
+
+**数据来源**：
+```typescript
+// 从企微API获取群聊详情
+const chatInfo = await WxworkCorp.externalContact.groupChat.get(chat_id);
+```
+
+#### 2.6.5 修改群聊信息
+
+**可修改字段**：
+- 关联项目
+- 是否禁用
+
+**操作路径**：
+1. 点击"编辑"按钮
+2. 修改信息
+3. 保存
+
+---
+
+## 三、数据字段汇总
+
+### 3.1 核心数据表
+
+#### Project（项目表）
+```typescript
+{
+  objectId: string;
+  title: string;              // 项目名称
+  company: Pointer<Company>;
+  contact: Pointer<ContactInfo>;  // 客户
+  assignee: Pointer<Profile>;     // 负责人
+  department: Pointer<Department>; // 项目组
+  status: string;             // 状态（待分配/进行中/已完成/已取消）
+  currentStage: string;       // 当前阶段
+  deadline: Date;             // 截止时间
+  createdAt: Date;
+  updatedAt: Date;
+  isDeleted: boolean;
+  data: {
+    // 订单分配阶段
+    orderApproval: object;    // 订单审批信息
+    quotation: object;        // 报价信息
+    
+    // 需求确认阶段
+    requirements: object;     // 需求信息
+    aiAnalysis: object;       // AI分析结果
+    
+    // 交付执行阶段
+    deliveryApproval: object; // 交付审批信息
+    deliveryStageStatus: object; // 各阶段状态
+    spaceConfirmations: object;  // 空间确认记录
+    
+    // 售后归档阶段
+    payments: array;          // 支付记录
+    totalAmount: number;      // 总金额
+    paidAmount: number;       // 已付金额
+    
+    // 其他
+    assignedDesigners: string[]; // 分配的设计师
+    crossTeamCollaborators: string[]; // 跨组协作者
+    primaryTeamId: string;    // 主要团队ID
+  };
+}
+```
+
+#### Profile（员工表）
+```typescript
+{
+  objectId: string;
+  name: string;               // 昵称
+  mobile: string;
+  userid: string;             // 企微ID
+  roleName: string;           // 身份
+  department: Pointer<Department>;
+  company: Pointer<Company>;
+  isDeleted: boolean;
+  createdAt: Date;
+  data: {
+    realname: string;         // 真实姓名
+    avatar: string;
+    email: string;
+    position: string;
+    gender: string;
+    level: string;
+    skills: string[];
+  };
+}
+```
+
+#### ContactInfo（客户表）
+```typescript
+{
+  objectId: string;
+  name: string;
+  mobile: string;
+  external_userid: string;    // 企微外部联系人ID
+  source: string;             // 来源
+  company: Pointer<Company>;
+  isDeleted: boolean;
+  createdAt: Date;
+  data: {
+    avatar: string;
+    name: string;
+    type: string;
+  };
+}
+```
+
+#### Department（部门/项目组表）
+```typescript
+{
+  objectId: string;
+  name: string;
+  leader: Pointer<Profile>;
+  type: string;               // 'project'
+  company: Pointer<Company>;
+  isDeleted: boolean;
+  createdAt: Date;
+  data: object;
+}
+```
+
+#### GroupChat（群聊表）
+```typescript
+{
+  objectId: string;
+  chat_id: string;            // 企微群ID
+  name: string;
+  project: Pointer<Project>;
+  company: Pointer<Company>;
+  isDisabled: boolean;
+  member_list: array;
+  createdAt: Date;
+}
+```
+
+#### Case（案例表）
+```typescript
+{
+  objectId: string;
+  name: string;
+  projectId: string;
+  projectName: string;
+  designer: string;
+  designerId: string;
+  team: string;
+  teamId: string;
+  coverImage: string;
+  images: string[];
+  area: number;
+  projectType: string;
+  spaceType: string;
+  renderingLevel: string;
+  tag: string[];
+  totalPrice: number;
+  completionDate: Date;
+  viewCount: number;
+  shareCount: number;
+  favoriteCount: number;
+  isExcellent: boolean;
+  isPublished: boolean;
+  company: Pointer<Company>;
+  isDeleted: boolean;
+  createdAt: Date;
+}
+```
+
+#### ProjectIssue（项目问题表）
+```typescript
+{
+  objectId: string;
+  title: string;
+  description: string;
+  status: string;             // 待处理/处理中/已解决/已关闭
+  priority: string;           // 紧急/高/中/低
+  project: Pointer<Project>;
+  creator: Pointer<Profile>;
+  assignee: Pointer<Profile>;
+  company: Pointer<Company>;
+  isDeleted: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+```
+
+#### ProjectFile（项目文件表）
+```typescript
+{
+  objectId: string;
+  fileName: string;
+  fileUrl: string;
+  fileSize: number;
+  fileType: string;
+  category: string;
+  project: Pointer<Project>;
+  product: Pointer<Product>;  // 空间
+  stage: string;              // 阶段
+  uploadedBy: Pointer<Profile>;
+  uploadedAt: Date;
+  analysisResult: object;     // AI分析结果
+  approvalStatus: string;     // 审批状态
+  company: Pointer<Company>;
+  isDeleted: boolean;
+}
+```
+
+---
+
+## 四、操作路径总结
+
+### 4.1 客服操作路径
+
+```
+客服工作台首页
+├── 查看项目总数 → 跳转项目列表（全部）
+├── 查看待分配项目 → 跳转项目列表（筛选待分配）
+├── 待跟进尾款项目
+│   └── 点击"开始跟进" → 跳转项目详情（售后归档阶段）
+├── 紧急事件
+│   └── 点击事件卡片 → 跳转对应项目阶段
+└── 待办任务
+    ├── 查看详情 → 展开问题详情
+    ├── 添加评论 → 在问题下评论
+    ├── 催办 → 发送催办通知
+    └── 新建问题 → 创建项目问题
+
+案例库
+├── 浏览案例 → 查看案例详情
+├── 点击数据统计 → 展开统计面板
+│   ├── Top 5 分享案例
+│   ├── 客户最喜欢风格
+│   └── 设计师推荐率
+└── 筛选搜索 → 按条件筛选案例
+
+项目列表
+├── 切换视图模式
+│   ├── 卡片视图（看板）
+│   ├── 列表视图
+│   └── 监控大盘
+├── 点击项目卡片 → 跳转项目详情
+└── 筛选排序 → 按条件筛选项目
+
+需求确认阶段
+├── 拖拽参考图片 → AI自动分析归类
+├── 填写需求信息
+│   ├── 全局需求
+│   └── 空间需求
+├── 点击AI生成方案 → 生成设计方案
+├── 展开设计助手 → AI聊天助手
+└── 确认需求 → 进入下一阶段
+
+交付执行阶段
+├── 拖拽交付图片 → 弹出AI分析弹窗
+├── AI自动识别阶段 → 显示分析结果
+├── 确认交付清单 → 文件归类到各阶段
+└── 上传交付清单 → 提交审批
+
+售后归档阶段
+├── 上传支付凭证 → AI提取金额
+├── 预览支付凭证 → 放大查看
+└── 查看尾款详情 → 显示支付记录
+```
+
+### 4.2 管理员操作路径
+
+```
+管理员后台总览
+├── 点击统计卡片 → 展开明细面板
+│   ├── 总项目数 → 项目明细
+│   ├── 进行中项目 → 进行中项目明细
+│   ├── 已完成项目 → 已完成项目明细
+│   ├── 设计师总数 → 设计师明细
+│   ├── 客户总数 → 客户明细
+│   └── 总收入 → 收入明细
+└── 查看图表 → 项目趋势图、收入趋势图
+
+项目管理
+├── 查看项目列表 → 表格展示
+├── 右键预览详情 → 弹出详情面板
+├── 分配设计师 → 打开分配弹窗
+│   ├── 选择主要负责人
+│   ├── 选择协作成员
+│   └── 保存分配
+├── 筛选排序 → 按条件筛选
+└── 跳转项目详情 → 查看完整信息
+
+项目组管理
+├── 查看项目组列表
+├── 新建项目组
+│   ├── 填写名称
+│   ├── 选择组长
+│   └── 保存
+├── 编辑项目组
+│   ├── 修改名称
+│   ├── 更换组长
+│   └── 保存
+├── 删除项目组 → 软删除
+└── 查看成员 → 展开成员列表
+
+员工管理
+├── 查看员工列表
+├── 查看详情 → 打开员工信息侧边栏
+│   ├── 基本信息标签页
+│   └── 项目负载标签页
+├── 查看任务安排 → 显示负责的项目
+├── 编辑信息
+│   ├── 修改可编辑字段
+│   └── 保存
+└── 禁用/启用员工 → 更新状态
+
+客户管理
+├── 查看客户列表
+├── 点击客户 → 打开详情面板
+│   ├── 基本信息
+│   ├── 关联项目
+│   ├── 所在群聊
+│   └── 跟进记录
+└── 筛选搜索 → 按条件筛选
+
+群组管理
+├── 查看群组列表
+├── 统计企微群聊 → 显示统计数据
+├── 关联项目
+│   ├── 关联现有项目
+│   └── 创建新项目
+├── 查看群聊详情 → 打开详情面板
+│   ├── 群信息
+│   ├── 成员列表
+│   └── 关联项目
+└── 修改群聊信息 → 编辑保存
+```
+
+---
+
+## 五、可计算分析的数据指标
+
+### 5.1 项目维度
+
+**项目统计**：
+- 总项目数
+- 各阶段项目数（订单分配/确认需求/交付执行/售后归档）
+- 各状态项目数（待分配/进行中/已完成/已取消）
+- 平均项目周期
+- 项目完成率 = 已完成项目数 / 总项目数
+- 项目逾期率 = 逾期项目数 / 总项目数
+
+**时间分析**：
+- 每月新增项目数
+- 每月完成项目数
+- 各阶段平均停留时间
+- 项目平均周期趋势
+
+**客户分析**：
+- 客户项目数分布
+- 客户复购率
+- 客户满意度（从反馈表）
+
+### 5.2 设计师维度
+
+**工作量统计**：
+- 当前负责项目数
+- 已完成项目数
+- 平均项目周期
+- 负载率 = 当前项目数 / 标准负载
+
+**绩效分析**：
+- 项目完成率
+- 项目逾期率
+- 客户满意度
+- 优秀案例数
+- 推荐率 = 优秀案例数 / 总案例数
+
+**能力评估**：
+- 擅长风格（从案例标签统计）
+- 擅长空间类型
+- 平均项目金额
+
+### 5.3 案例维度
+
+**案例统计**：
+- 总案例数
+- 各风格案例数
+- 各空间类型案例数
+- 各渲染级别案例数
+- 平均浏览量
+- 平均分享量
+- 平均收藏量
+
+**热门分析**：
+- Top 5 分享案例
+- Top 5 收藏案例
+- 最受欢迎风格（按收藏数）
+- 最受欢迎空间类型
+
+**设计师分析**：
+- 各设计师案例数
+- 各设计师推荐率
+- 各设计师平均浏览量
+
+### 5.4 财务维度
+
+**收入统计**：
+- 总收入（已支付尾款累加）
+- 每月收入
+- 平均项目金额
+- 收入增长率
+
+**回款分析**：
+- 总应收金额
+- 已收金额
+- 未收金额
+- 回款率 = 已收金额 / 总应收金额
+- 逾期未收金额
+
+**项目金额分布**：
+- 各金额区间项目数
+- 平均项目金额趋势
+
+### 5.5 问题维度
+
+**问题统计**：
+- 总问题数
+- 各状态问题数（待处理/处理中/已解决/已关闭）
+- 各优先级问题数
+- 平均解决时间
+- 问题解决率
+
+**问题分析**：
+- 各阶段问题数分布
+- 各类型问题数分布
+- 问题高发项目
+- 问题高发设计师
+
+---
+
+## 六、总结
+
+本文档详细梳理了客服板块和管理员板块的所有功能模块、操作流程、数据字段和计算逻辑。主要特点：
+
+1. **客服板块**：以项目全生命周期管理为核心，提供工作台首页、案例库、项目列表、需求确认、交付执行、售后归档等完整功能
+2. **管理员板块**：以数据统计和资源管理为核心，提供总览看板、项目管理、项目组管理、员工管理、客户管理、群组管理等功能
+3. **数据驱动**：所有功能都基于Parse Server数据库，数据结构清晰，关联关系明确
+4. **AI赋能**：在需求确认和交付执行阶段集成AI分析功能，提升工作效率
+5. **角色权限**：不同角色有不同的操作权限和视图
+
+本文档可作为产品复盘、功能优化、培训教材的重要参考资料。
+
+---
+
+## 七、角色权限矩阵
+
+### 7.1 功能权限对照表
+
+| 功能模块 | 客服 | 组长 | 设计师 | 管理员 |
+|---------|-----|------|--------|--------|
+| **工作台首页** | ✅ | ✅ | ✅ | ✅ |
+| **项目列表** | ✅ | ✅ | ✅ | ✅ |
+| **案例库** | ✅ | ✅ | ✅ | ✅ |
+| **订单分配** | ✅ | ✅审批 | ❌ | ✅ |
+| **需求确认** | ✅ | ✅ | ✅ | ✅ |
+| **交付执行** | ✅ | ✅审批 | ✅ | ✅ |
+| **售后归档** | ✅ | ✅ | ✅ | ✅ |
+| **项目管理** | ❌ | ❌ | ❌ | ✅ |
+| **项目组管理** | ❌ | ❌ | ❌ | ✅ |
+| **员工管理** | ❌ | ❌ | ❌ | ✅ |
+| **客户管理** | ❌ | ❌ | ❌ | ✅ |
+| **群组管理** | ❌ | ❌ | ❌ | ✅ |
+| **分配设计师** | ❌ | ✅ | ❌ | ✅ |
+| **审批订单** | ❌ | ✅ | ❌ | ✅ |
+| **审批交付** | ❌ | ✅ | ❌ | ✅ |
+
+### 7.2 数据权限
+
+**客服**：
+- 查看：所有项目
+- 编辑：自己创建的项目
+- 删除：❌
+
+**组长**：
+- 查看：所有项目
+- 编辑：所有项目
+- 删除：❌
+- 审批：订单分配、交付执行
+
+**设计师**：
+- 查看：自己负责的项目
+- 编辑：自己负责的项目
+- 删除：❌
+
+**管理员**：
+- 查看：所有数据
+- 编辑：所有数据
+- 删除：软删除所有数据
+- 审批：所有审批
+
+---
+
+## 八、业务流程图
+
+### 8.1 客服完整工作流程
+
+```mermaid
+graph TD
+    A[客服登录系统] --> B[查看工作台首页]
+    B --> C{选择工作内容}
+
+    C -->|处理新咨询| D[创建新项目]
+    D --> E[填写客户信息]
+    E --> F[填写项目基本信息]
+    F --> G[提交订单分配]
+    G --> H[等待组长审批]
+
+    C -->|跟进尾款| I[查看待跟进尾款列表]
+    I --> J[点击开始跟进]
+    J --> K[进入售后归档阶段]
+    K --> L[查看尾款详情]
+    L --> M[联系客户催款]
+
+    C -->|处理紧急事件| N[查看紧急事件列表]
+    N --> O[点击紧急事件]
+    O --> P[进入对应项目阶段]
+    P --> Q[处理紧急事项]
+
+    C -->|处理待办任务| R[查看待办任务列表]
+    R --> S[点击任务详情]
+    S --> T{任务类型}
+    T -->|添加评论| U[输入评论内容]
+    T -->|催办| V[发送催办通知]
+    T -->|新建问题| W[创建项目问题]
+
+    H --> X{审批结果}
+    X -->|通过| Y[进入需求确认阶段]
+    X -->|驳回| Z[修改订单信息]
+    Z --> G
+
+    Y --> AA[填写需求信息]
+    AA --> AB[拖拽参考图片]
+    AB --> AC[AI自动分析]
+    AC --> AD[点击AI生成方案]
+    AD --> AE[确认需求]
+    AE --> AF[进入交付执行阶段]
+```
+
+### 8.2 管理员项目管理流程
+
+```mermaid
+graph TD
+    A[管理员登录系统] --> B[查看总览看板]
+    B --> C[查看统计数据]
+    C --> D{选择管理内容}
+
+    D -->|项目管理| E[进入项目管理页面]
+    E --> F[查看项目列表]
+    F --> G{项目操作}
+    G -->|预览详情| H[打开详情面板]
+    G -->|分配设计师| I[打开分配弹窗]
+    I --> J[选择主要负责人]
+    J --> K[选择协作成员]
+    K --> L[保存分配]
+    L --> M[更新项目信息]
+
+    D -->|项目组管理| N[进入项目组管理]
+    N --> O{项目组操作}
+    O -->|新建| P[填写项目组信息]
+    P --> Q[选择组长]
+    Q --> R[保存项目组]
+    O -->|编辑| S[修改项目组信息]
+    S --> T[保存修改]
+    O -->|删除| U[确认删除]
+    U --> V[软删除项目组]
+
+    D -->|员工管理| W[进入员工管理]
+    W --> X{员工操作}
+    X -->|查看详情| Y[打开员工信息面板]
+    Y --> Z[查看基本信息]
+    Y --> AA[查看项目负载]
+    X -->|编辑信息| AB[修改员工信息]
+    AB --> AC[保存修改]
+    X -->|禁用/启用| AD[更新员工状态]
+
+    D -->|客户管理| AE[进入客户管理]
+    AE --> AF[查看客户列表]
+    AF --> AG[点击客户]
+    AG --> AH[查看客户详情]
+    AH --> AI[查看关联项目]
+    AH --> AJ[查看所在群聊]
+    AH --> AK[查看跟进记录]
+
+    D -->|群组管理| AL[进入群组管理]
+    AL --> AM[查看群组列表]
+    AM --> AN{群组操作}
+    AN -->|关联项目| AO[选择现有项目]
+    AN -->|创建项目| AP[填写项目信息]
+    AP --> AQ[保存新项目]
+    AQ --> AR[关联群聊]
+    AN -->|查看详情| AS[打开群聊详情]
+    AS --> AT[查看成员列表]
+```
+
+### 8.3 项目生命周期流程
+
+```mermaid
+graph LR
+    A[订单分配] --> B{组长审批}
+    B -->|通过| C[确认需求]
+    B -->|驳回| A
+
+    C --> D[填写需求]
+    D --> E[AI生成方案]
+    E --> F[确认需求]
+    F --> G[交付执行]
+
+    G --> H[白模阶段]
+    H --> I[软装阶段]
+    I --> J[渲染阶段]
+    J --> K[后期阶段]
+
+    K --> L[上传交付清单]
+    L --> M{组长审批}
+    M -->|通过| N[售后归档]
+    M -->|驳回| G
+
+    N --> O[上传支付凭证]
+    O --> P[确认尾款]
+    P --> Q[项目完成]
+```
+
+---
+
+## 九、数据流转图
+
+### 9.1 项目数据流转
+
+```
+客服创建项目
+    ↓
+Project表（status: 待分配, currentStage: 订单分配）
+    ↓
+组长审批
+    ↓
+Project.data.orderApproval（status: approved）
+    ↓
+自动更新 Project（status: 进行中, currentStage: 确认需求）
+    ↓
+客服填写需求
+    ↓
+Project.data.requirements
+    ↓
+AI生成方案
+    ↓
+Project.data.aiAnalysis
+    ↓
+确认需求
+    ↓
+Project（currentStage: 交付执行）
+    ↓
+设计师上传文件
+    ↓
+ProjectFile表（stage: white_model/soft_decor/rendering/post_process）
+    ↓
+AI分析文件
+    ↓
+ProjectFile.analysisResult
+    ↓
+客服确认空间
+    ↓
+Project.data.spaceConfirmations
+    ↓
+上传交付清单
+    ↓
+Project.data.deliveryApproval（status: pending）
+    ↓
+组长审批
+    ↓
+Project.data.deliveryApproval（status: approved）
+    ↓
+自动更新 Project（currentStage: 售后归档）
+    ↓
+客服上传支付凭证
+    ↓
+Project.data.payments
+    ↓
+AI提取金额
+    ↓
+更新 Project.data.paidAmount
+    ↓
+确认尾款
+    ↓
+Project（status: 已完成）
+    ↓
+自动生成案例
+    ↓
+Case表（isPublished: false）
+```
+
+### 9.2 设计师分配数据流转
+
+```
+管理员/组长分配设计师
+    ↓
+选择主要负责人
+    ↓
+Project.assignee = Pointer<Profile>
+    ↓
+选择协作成员
+    ↓
+Project.data.assignedDesigners = [id1, id2, ...]
+    ↓
+创建 ProjectTeam 记录
+    ↓
+ProjectTeam（project, profile, role: primary/collaborator）
+    ↓
+设计师可见项目
+    ↓
+设计师工作台显示项目
+```
+
+### 9.3 群聊关联项目数据流转
+
+```
+管理员查看群组列表
+    ↓
+选择未关联项目的群聊
+    ↓
+创建新项目 或 关联现有项目
+    ↓
+Project表（新建或更新）
+    ↓
+GroupChat.project = Pointer<Project>
+    ↓
+创建 ProjectGroup 记录
+    ↓
+ProjectGroup（project, groupChat, isPrimary: true）
+    ↓
+群聊成员可见项目
+    ↓
+企微群聊中显示项目卡片
+```
+
+---
+
+## 十、关键技术实现
+
+### 10.1 AI图像分析
+
+**服务**：`ImageAnalysisService`
+
+**模型**：豆包1.6 (`fmode-1.6-cn`)
+
+**分析流程**：
+```typescript
+1. 接收图片文件
+2. 转换为Base64编码
+3. 调用豆包API
+4. 解析返回结果
+5. 提取关键信息：
+   - 图片质量（清晰度、亮度、对比度）
+   - 内容识别（类别、置信度、描述、标签）
+   - 技术参数（格式、色彩空间、DPI、分辨率）
+   - 阶段分类建议（white_model/soft_decor/rendering/post_process）
+6. 返回分析结果
+```
+
+**应用场景**：
+- 需求确认阶段：参考图片分类
+- 交付执行阶段：交付文件阶段识别
+- 售后归档阶段：支付凭证金额提取
+
+### 10.2 项目状态自动判断
+
+**核心函数**：`getProjectStatusByStage()`
+
+**判断逻辑**：
+```typescript
+function getProjectStatusByStage(stageId: string, currentStatus?: string): string {
+  // 如果已经是完成或取消状态，保持不变
+  if (currentStatus === '已完成' || currentStatus === '已取消') {
+    return currentStatus;
+  }
+
+  const corePhase = mapStageToCorePhase(stageId);
+
+  switch (corePhase) {
+    case 'order':
+      return '待分配';
+    case 'requirements':
+    case 'delivery':
+      return '进行中';
+    case 'aftercare':
+      return '已完成';
+    default:
+      return '待分配';
+  }
+}
+```
+
+**应用场景**：
+- 客服端项目列表
+- 组长端监控大盘
+- 管理员端项目管理
+- 统计数据计算
+
+### 10.3 拖拽上传
+
+**技术**：HTML5 Drag and Drop API
+
+**实现步骤**：
+```typescript
+1. 监听 dragover 事件
+   - event.preventDefault()
+   - event.dataTransfer.dropEffect = 'move'
+   - 显示拖拽提示
+
+2. 监听 dragleave 事件
+   - 隐藏拖拽提示
+
+3. 监听 drop 事件
+   - event.preventDefault()
+   - 获取文件列表：event.dataTransfer.files
+   - 过滤文件类型（只允许图片）
+   - 打开上传弹窗
+
+4. 自动触发AI分析
+   - 延迟500ms
+   - 遍历文件列表
+   - 调用 ImageAnalysisService.analyzeImage()
+   - 显示分析结果
+
+5. 确认上传
+   - 批量上传文件到服务器
+   - 保存文件记录到 ProjectFile 表
+   - 更新项目数据
+```
+
+### 10.4 审批流程
+
+**数据结构**：
+```typescript
+// 订单审批
+Project.data.orderApproval = {
+  status: 'pending' | 'approved' | 'rejected';
+  submittedAt: Date;
+  submittedBy: string;
+  submittedByName: string;
+  approvedAt?: Date;
+  approvedBy?: string;
+  approvedByName?: string;
+  rejectedAt?: Date;
+  rejectedBy?: string;
+  rejectedByName?: string;
+  rejectionReason?: string;
+};
+
+// 交付审批
+Project.data.deliveryApproval = {
+  status: 'pending' | 'approved' | 'rejected';
+  stage: 'delivery';
+  totalFiles: number;
+  types: {
+    white_model: number;
+    soft_decor: number;
+    rendering: number;
+    post_process: number;
+  };
+  submittedAt: Date;
+  submittedByName: string;
+  submittedById: string;
+  approvedAt?: Date;
+  approvedBy?: string;
+  approvedByName?: string;
+  rejectedAt?: Date;
+  rejectedBy?: string;
+  rejectedByName?: string;
+  rejectionReason?: string;
+};
+```
+
+**审批流程**：
+```typescript
+1. 提交审批
+   - 设置 status = 'pending'
+   - 记录提交人和时间
+   - 通知组长
+
+2. 组长审批
+   - 查看审批详情
+   - 选择通过或驳回
+   - 填写驳回原因（如驳回）
+   - 保存审批结果
+
+3. 审批通过
+   - 设置 status = 'approved'
+   - 记录审批人和时间
+   - 自动更新项目阶段
+   - 通知提交人
+
+4. 审批驳回
+   - 设置 status = 'rejected'
+   - 记录驳回人、时间和原因
+   - 通知提交人
+   - 项目回退到上一阶段
+```
+
+---
+
+## 十一、常见问题与解决方案
+
+### 11.1 数据一致性问题
+
+**问题**：项目负责人显示不一致
+
+**原因**：
+- `Project.assignee` 字段为空
+- `ProjectTeam` 表中有主要负责人记录
+
+**解决方案**：
+```typescript
+// 优先从 assignee 获取，其次从 ProjectTeam 获取
+let assigneeName = project.get('assignee')?.get('name');
+if (!assigneeName || assigneeName === '未分配') {
+  const primaryDesigner = await getPrimaryDesignerFromProjectTeam(projectId);
+  if (primaryDesigner) {
+    assigneeName = primaryDesigner.name;
+  }
+}
+```
+
+### 11.2 状态判断不准确
+
+**问题**：项目状态与实际阶段不符
+
+**原因**：
+- 手动设置的 `status` 字段未更新
+- 阶段变更后状态未同步
+
+**解决方案**：
+```typescript
+// 使用自动判断函数，而不是直接读取 status 字段
+const autoStatus = getProjectStatusByStage(currentStage, status);
+```
+
+### 11.3 文件上传失败
+
+**问题**：拖拽上传后文件未保存
+
+**原因**：
+- 文件大小超限
+- 网络超时
+- 权限不足
+
+**解决方案**：
+```typescript
+// 1. 检查文件大小
+if (file.size > 10 * 1024 * 1024) {
+  alert('文件大小不能超过10MB');
+  return;
+}
+
+// 2. 添加重试机制
+async function uploadWithRetry(file, maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await uploadFile(file);
+    } catch (error) {
+      if (i === maxRetries - 1) throw error;
+      await sleep(1000 * (i + 1));
+    }
+  }
+}
+
+// 3. 检查权限
+const currentUser = Parse.User.current();
+if (!currentUser) {
+  alert('请先登录');
+  return;
+}
+```
+
+### 11.4 AI分析超时
+
+**问题**：AI分析长时间无响应
+
+**原因**：
+- 图片过大
+- API调用超时
+- 网络问题
+
+**解决方案**：
+```typescript
+// 1. 压缩图片
+async function compressImage(file) {
+  if (file.size > 2 * 1024 * 1024) {
+    // 压缩到2MB以下
+    return await imageCompression(file, {
+      maxSizeMB: 2,
+      maxWidthOrHeight: 1920
+    });
+  }
+  return file;
+}
+
+// 2. 设置超时
+const analysisPromise = ImageAnalysisService.analyzeImage(file);
+const timeoutPromise = new Promise((_, reject) =>
+  setTimeout(() => reject(new Error('分析超时')), 30000)
+);
+const result = await Promise.race([analysisPromise, timeoutPromise]);
+
+// 3. 降级处理
+try {
+  const result = await analyzeImage(file);
+} catch (error) {
+  console.error('AI分析失败，使用默认分类', error);
+  return {
+    category: 'unknown',
+    confidence: 0,
+    description: '自动分类失败，请手动选择'
+  };
+}
+```
+
+---
+
+## 十二、性能优化建议
+
+### 12.1 数据查询优化
+
+**问题**：项目列表加载慢
+
+**优化方案**：
+```typescript
+// 1. 使用分页
+query.limit(20);
+query.skip(page * 20);
+
+// 2. 只查询必要字段
+query.select('title', 'status', 'currentStage', 'deadline', 'updatedAt');
+
+// 3. 使用索引
+// 在Parse Server后台为常用查询字段创建索引
+// - status
+// - currentStage
+// - company
+// - assignee
+// - createdAt
+// - updatedAt
+
+// 4. 缓存查询结果
+const cacheKey = `projects_${status}_${page}`;
+let projects = cache.get(cacheKey);
+if (!projects) {
+  projects = await query.find();
+  cache.set(cacheKey, projects, 60); // 缓存60秒
+}
+```
+
+### 12.2 文件上传优化
+
+**优化方案**：
+```typescript
+// 1. 并发上传（限制并发数）
+async function uploadFiles(files) {
+  const concurrency = 3;
+  const results = [];
+  for (let i = 0; i < files.length; i += concurrency) {
+    const batch = files.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(file => uploadFile(file))
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// 2. 断点续传
+async function uploadLargeFile(file) {
+  const chunkSize = 1024 * 1024; // 1MB
+  const chunks = Math.ceil(file.size / chunkSize);
+  for (let i = 0; i < chunks; i++) {
+    const start = i * chunkSize;
+    const end = Math.min(start + chunkSize, file.size);
+    const chunk = file.slice(start, end);
+    await uploadChunk(chunk, i, chunks);
+  }
+}
+
+// 3. 压缩图片
+async function compressAndUpload(file) {
+  const compressed = await imageCompression(file, {
+    maxSizeMB: 2,
+    maxWidthOrHeight: 1920,
+    useWebWorker: true
+  });
+  return await uploadFile(compressed);
+}
+```
+
+### 12.3 前端渲染优化
+
+**优化方案**：
+```typescript
+// 1. 虚拟滚动（大列表）
+<cdk-virtual-scroll-viewport itemSize="80" class="project-list">
+  <div *cdkVirtualFor="let project of projects">
+    {{ project.title }}
+  </div>
+</cdk-virtual-scroll-viewport>
+
+// 2. 懒加载图片
+<img [src]="placeholder" [lazyLoad]="imageUrl" />
+
+// 3. 使用 OnPush 变更检测
+@Component({
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+
+// 4. 使用 trackBy
+<div *ngFor="let project of projects; trackBy: trackByProjectId">
+  {{ project.title }}
+</div>
+
+trackByProjectId(index: number, project: Project): string {
+  return project.id;
+}
+```
+
+---
+
+## 十三、安全性考虑
+
+### 13.1 权限控制
+
+**实现方式**：
+```typescript
+// 1. 路由守卫
+@Injectable()
+export class RoleGuard implements CanActivate {
+  canActivate(route: ActivatedRouteSnapshot): boolean {
+    const currentUser = Parse.User.current();
+    const requiredRole = route.data['role'];
+    const userRole = currentUser?.get('roleName');
+    return userRole === requiredRole;
+  }
+}
+
+// 2. 数据权限
+async function getProjects(userId: string, role: string) {
+  const query = new Parse.Query('Project');
+
+  if (role === '设计师') {
+    // 设计师只能查看自己负责的项目
+    query.equalTo('assignee', userId);
+  } else if (role === '客服' || role === '组长') {
+    // 客服和组长可以查看所有项目
+    // 不添加额外筛选
+  }
+
+  return await query.find();
+}
+
+// 3. 操作权限
+function canEditProject(project: Project, user: User): boolean {
+  const role = user.get('roleName');
+  const assigneeId = project.get('assignee')?.id;
+
+  if (role === '管理员' || role === '组长') {
+    return true;
+  }
+
+  if (role === '客服') {
+    const createdBy = project.get('data')?.createdBy;
+    return createdBy === user.id;
+  }
+
+  if (role === '设计师') {
+    return assigneeId === user.id;
+  }
+
+  return false;
+}
+```
+
+### 13.2 数据验证
+
+**实现方式**：
+```typescript
+// 1. 前端验证
+function validateProjectData(data: any): string[] {
+  const errors: string[] = [];
+
+  if (!data.title || data.title.trim().length === 0) {
+    errors.push('项目名称不能为空');
+  }
+
+  if (!data.customerId) {
+    errors.push('请选择客户');
+  }
+
+  if (data.deadline && new Date(data.deadline) < new Date()) {
+    errors.push('截止时间不能早于当前时间');
+  }
+
+  return errors;
+}
+
+// 2. 后端验证（Parse Cloud Code）
+Parse.Cloud.beforeSave('Project', async (request) => {
+  const project = request.object;
+
+  // 验证必填字段
+  if (!project.get('title')) {
+    throw new Parse.Error(400, '项目名称不能为空');
+  }
+
+  // 验证数据格式
+  const deadline = project.get('deadline');
+  if (deadline && !(deadline instanceof Date)) {
+    throw new Parse.Error(400, '截止时间格式错误');
+  }
+
+  // 验证权限
+  const user = request.user;
+  if (!user) {
+    throw new Parse.Error(401, '未登录');
+  }
+
+  const role = user.get('roleName');
+  if (!['客服', '组长', '管理员'].includes(role)) {
+    throw new Parse.Error(403, '无权限创建项目');
+  }
+});
+```
+
+### 13.3 敏感数据保护
+
+**实现方式**：
+```typescript
+// 1. 脱敏显示
+function maskPhone(phone: string): string {
+  if (!phone || phone.length < 11) return phone;
+  return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
+}
+
+function maskIdCard(idCard: string): string {
+  if (!idCard || idCard.length < 18) return idCard;
+  return idCard.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2');
+}
+
+// 2. 加密存储
+async function savePaymentInfo(data: any) {
+  const encrypted = await encrypt(JSON.stringify(data));
+  project.set('paymentInfo', encrypted);
+  await project.save();
+}
+
+async function getPaymentInfo(project: Project) {
+  const encrypted = project.get('paymentInfo');
+  const decrypted = await decrypt(encrypted);
+  return JSON.parse(decrypted);
+}
+
+// 3. 日志记录
+async function logSensitiveOperation(
+  userId: string,
+  action: string,
+  entityId: string,
+  details: any
+) {
+  const log = new Parse.Object('AuditLog');
+  log.set('user', userId);
+  log.set('action', action);
+  log.set('entityId', entityId);
+  log.set('details', details);
+  log.set('timestamp', new Date());
+  log.set('ip', request.ip);
+  await log.save();
+}
+```
+
+---
+
+## 十四、未来扩展方向
+
+### 14.1 功能扩展
+
+**1. 智能推荐**
+- 根据客户需求推荐设计师
+- 根据项目类型推荐设计方案
+- 根据历史数据推荐报价
+
+**2. 数据分析**
+- 项目周期分析
+- 设计师绩效分析
+- 客户满意度分析
+- 收入趋势分析
+
+**3. 自动化流程**
+- 自动分配设计师（基于负载和能力）
+- 自动催办逾期任务
+- 自动生成周报/月报
+- 自动结算设计师费用
+
+**4. 移动端支持**
+- 响应式设计
+- 移动端专属功能
+- 离线支持
+- 推送通知
+
+### 14.2 技术升级
+
+**1. 性能优化**
+- 服务端渲染（SSR）
+- 静态站点生成（SSG）
+- 边缘计算（Edge Computing）
+- CDN加速
+
+**2. AI能力增强**
+- 更精准的图像识别
+- 自然语言处理（NLP）
+- 智能客服机器人
+- 设计方案生成
+
+**3. 数据安全**
+- 端到端加密
+- 区块链存证
+- 多因素认证（MFA）
+- 零信任架构
+
+**4. 集成能力**
+- 第三方设计工具集成
+- 财务系统集成
+- CRM系统集成
+- 项目管理工具集成
+
+---
+
+## 附录
+
+### A. 数据表完整字段清单
+
+详见第三章"数据字段汇总"
+
+### B. API接口文档
+
+详见独立API文档
+
+### C. 错误码对照表
+
+| 错误码 | 说明 | 解决方案 |
+|-------|------|---------|
+| 400 | 请求参数错误 | 检查请求参数格式 |
+| 401 | 未登录 | 重新登录 |
+| 403 | 无权限 | 联系管理员分配权限 |
+| 404 | 资源不存在 | 检查资源ID是否正确 |
+| 500 | 服务器错误 | 联系技术支持 |
+
+### D. 版本更新日志
+
+**v1.0.0** (2025-01-15)
+- 初始版本发布
+- 客服板块基础功能
+- 管理员板块基础功能
+
+**v1.1.0** (2025-02-01)
+- 新增AI图像分析功能
+- 优化拖拽上传体验
+- 修复已知问题
+
+**v1.2.0** (2025-03-01)
+- 新增案例库统计功能
+- 优化项目列表性能
+- 新增员工信息面板
+
+---
+
+**文档版本**：v1.0
+**最后更新**：2025-01-15
+**维护人员**：产品团队
+**联系方式**：product@example.com
+

src/app/pages/admin/dashboard/dashboard.ts

@@ -8,6 +8,7 @@ import { ProfileService } from '../../../services/profile.service';
 import { ActivityLogService } from '../../../services/activity-log.service';
 import { FmodeParse, FmodeObject } from 'fmode-ng/parse';
 import * as echarts from 'echarts';
+import { getProjectStatusByStage } from '../../../utils/project-stage-mapper';
 
 const Parse = FmodeParse.with('nova');
 
@@ -217,13 +218,10 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
   // 加载项目统计数据
   private async loadProjectStats(): Promise<void> {
     try {
-      const companyId = this.company?.id || 'cDL6R1hgSi';
-      console.log(`🔍 [项目统计] 使用公司ID: ${companyId}`);
-      
       const companyPointer = {
         __type: 'Pointer',
         className: 'Company',
-        objectId: companyId
+        objectId: this.company?.id || 'cDL6R1hgSi'
       };
 
       // 总项目数
@@ -232,45 +230,44 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
       totalProjectQuery.notEqualTo('isDeleted', true);
       const totalProjects = await totalProjectQuery.count();
       this.stats.totalProjects.set(totalProjects);
-      console.log(`📊 [项目统计] 总项目数: ${totalProjects}`);
-
-      // 已完成项目数
-      // 状态为"已完成"或者阶段为"售后归档"
-      const completedQuery1 = new Parse.Query('Project');
-      completedQuery1.equalTo('company', companyPointer);
-      completedQuery1.notEqualTo('isDeleted', true);
-      completedQuery1.equalTo('status', '已完成');
-      const completedByStatus = await completedQuery1.count();
-      console.log(`  - 状态为'已完成'的项目: ${completedByStatus}`);
+
+      // 🔥 修复：使用与项目管理完全相同的状态判断逻辑
+      // 导入getProjectStatusByStage函数来自动判断项目状态
       
-      const completedQuery2 = new Parse.Query('Project');
-      completedQuery2.equalTo('company', companyPointer);
-      completedQuery2.notEqualTo('isDeleted', true);
-      completedQuery2.equalTo('currentStage', '售后归档');
-      const completedByStage = await completedQuery2.count();
-      console.log(`  - 阶段为'售后归档'的项目: ${completedByStage}`);
+      // 查询所有项目，手动统计（避免复杂的OR查询）
+      const allProjectsQuery = new Parse.Query('Project');
+      allProjectsQuery.equalTo('company', companyPointer);
+      allProjectsQuery.notEqualTo('isDeleted', true);
+      allProjectsQuery.limit(1000);
       
-      const completedProjectQuery = Parse.Query.or(completedQuery1, completedQuery2);
-      const completedProjects = await completedProjectQuery.count();
-      this.stats.completedProjects.set(completedProjects);
-      console.log(`📊 [项目统计] 已完成项目数: ${completedProjects}`);
-
-      // 进行中项目数
-      // 🔥 修复：进行中 = 总项目数 - 已完成项目数 - 已取消项目数
-      const cancelledQuery = new Parse.Query('Project');
-      cancelledQuery.equalTo('company', companyPointer);
-      cancelledQuery.notEqualTo('isDeleted', true);
-      cancelledQuery.equalTo('status', '已取消');
+      const allProjects = await allProjectsQuery.find();
+      console.log(`📊 [Dashboard] 查询到 ${allProjects.length} 个项目`);
       
-      const cancelledProjects = await cancelledQuery.count();
-      console.log(`  - 已取消项目数: ${cancelledProjects}`);
+      let completedProjects = 0;
+      let activeProjects = 0;
+      
+      // 遍历所有项目，使用与项目管理相同的状态判断逻辑
+      for (const project of allProjects) {
+        const rawStage = project.get('currentStage') || project.get('stage') || '订单分配';
+        const currentStatus = project.get('status') || '';
+        
+        // 🔥 使用getProjectStatusByStage函数来自动判断状态（与项目管理保持一致）
+        const autoStatus = getProjectStatusByStage(rawStage, currentStatus);
+        
+        console.log(`  项目 "${project.get('title')}": ${autoStatus} (原始阶段: ${rawStage}, 原始状态: ${currentStatus})`);
+        
+        // 根据自动判断的状态统计
+        if (autoStatus === '已完成' || autoStatus === '已取消') {
+          completedProjects++;
+        } else {
+          activeProjects++;
+        }
+      }
       
-      // 进行中 = 总数 - 已完成 - 已取消
-      const activeProjects = totalProjects - completedProjects - cancelledProjects;
-      this.stats.activeProjects.set(Math.max(0, activeProjects));
-      console.log(`📊 [项目统计] 进行中项目数: ${activeProjects} (${totalProjects} - ${completedProjects} - ${cancelledProjects})`);
+      this.stats.completedProjects.set(completedProjects);
+      this.stats.activeProjects.set(activeProjects);
 
-      console.log(`✅ 项目统计完成: 总计${totalProjects}, 进行中${activeProjects}, 已完成${completedProjects}`);
+      console.log(`✅ 项目统计: 总计${totalProjects}, 进行中${activeProjects}, 已完成${completedProjects}`);
     } catch (error) {
       console.error('❌ 项目统计加载失败:', error);
       throw error;
@@ -349,13 +346,10 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
   // 加载收入统计数据
   private async loadRevenueStats(): Promise<void> {
     try {
-      const companyId = this.company?.id || 'cDL6R1hgSi';
-      console.log(`🔍 [收入统计] 使用公司ID: ${companyId}`);
-      
       const companyPointer = {
         __type: 'Pointer',
         className: 'Company',
-        objectId: companyId
+        objectId: this.company?.id || 'cDL6R1hgSi'
       };
 
       // 🔥 修复：从售后归档阶段的项目中获取已支付的尾款
@@ -370,13 +364,11 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
         projectQuery.limit(1000);
         
         const aftercareProjects = await projectQuery.find();
-        console.log(`📊 [收入统计] 找到 ${aftercareProjects.length} 个售后归档项目`);
+        console.log(`📊 找到 ${aftercareProjects.length} 个售后归档项目`);
         
         // 2️⃣ 从每个项目的data字段中获取已支付的尾款
-        let projectsWithPayment = 0;
         for (const project of aftercareProjects) {
           const data = project.get('data') || {};
-          const projectTitle = project.get('title') || '未命名项目';
           
           // 检查多个可能的尾款字段
           const finalPayment = 
@@ -388,14 +380,12 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
           
           if (finalPayment > 0) {
             totalRevenue += finalPayment;
-            projectsWithPayment++;
-            console.log(`  ✅ 项目 "${projectTitle}": ¥${finalPayment.toLocaleString()}`);
-          } else {
-            console.log(`  ⚠️ 项目 "${projectTitle}": 没有尾款数据`);
+            const projectTitle = project.get('title') || '未命名项目';
+            console.log(`  项目 "${projectTitle}": ¥${finalPayment.toLocaleString()}`);
           }
         }
         
-        console.log(`✅ 收入统计: 已收到尾款 ¥${totalRevenue.toLocaleString()} (${projectsWithPayment}/${aftercareProjects.length}个项目有支付)`);
+        console.log(`✅ 收入统计: 已收到尾款 ¥${totalRevenue.toLocaleString()} (来自${aftercareProjects.length}个项目)`);
       } catch (projectError) {
         console.warn('⚠️ 项目查询失败，尝试从ProjectPayment表获取:', projectError);
         
@@ -407,13 +397,12 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
           paymentQuery.limit(1000);
           
           const payments = await paymentQuery.find();
-          console.log(`📊 [收入统计] 找到 ${payments.length} 条支付记录`);
+          console.log(`📊 找到 ${payments.length} 条支付记录`);
           
           payments.forEach(payment => {
             const amount = payment.get('amount') || 0;
             if (amount > 0) {
               totalRevenue += amount;
-              console.log(`  ✅ 支付记录: ¥${amount.toLocaleString()}`);
             }
           });
           
@@ -430,7 +419,6 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
             fileQuery.limit(1000);
             
             const voucherFiles = await fileQuery.find();
-            console.log(`📊 [收入统计] 找到 ${voucherFiles.length} 张支付凭证`);
             
             voucherFiles.forEach(file => {
               const data = file.get('data') || {};
@@ -439,7 +427,6 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
               
               if (amount > 0) {
                 totalRevenue += amount;
-                console.log(`  ✅ 凭证: ¥${amount.toLocaleString()}`);
               }
             });
             
@@ -452,7 +439,6 @@ export class AdminDashboard implements OnInit, AfterViewInit, OnDestroy {
       }
 
       this.stats.totalRevenue.set(totalRevenue);
-      console.log(`💰 [收入统计] 最终总收入: ¥${totalRevenue.toLocaleString()}`);
     } catch (error) {
       console.error('❌ 收入统计加载失败:', error);
       throw error;

src/app/pages/admin/groupchats/groupchats.ts

@@ -80,37 +80,13 @@ export class GroupChats implements OnInit {
     try {
       const groups = await this.groupChatService.findGroupChats();
       console.log("groups",groups)
-      
-      // 🔥 使用Map去重，避免同一项目关联多个群组时重复显示
-      const projectTitleMap = new Map<string, string>();
-      
       const groupList: GroupChat[] = groups.map(g => {
         const json = this.groupChatService.toJSON(g);
-        const projectObj = g.get("project");
-        
-        // 🔥 获取project的完整信息（已通过include加载）
-        let projectTitle = '';
-        if (projectObj) {
-          // 如果project是完整对象，直接获取title
-          if (typeof projectObj.get === 'function') {
-            projectTitle = projectObj.get('title') || '';
-          } else if (projectObj.title) {
-            projectTitle = projectObj.title;
-          }
-          
-          // 🔥 使用projectId作为key进行去重
-          const projectId = projectObj.id || projectObj.objectId;
-          if (projectId && !projectTitleMap.has(projectId)) {
-            projectTitleMap.set(projectId, projectTitle);
-            console.log(`📌 项目 "${projectTitle}" (${projectId}) 已记录`);
-          }
-        }
-        
         return {
           id: json.objectId,
           chat_id: json.chat_id || '',
           name: json.name || '未命名群组',
-          project: projectObj,
+          project: g.get("project"),
           projectId: json.projectId,
           memberCount: json.member_list?.length || 0,
           isDisabled: json.isDisabled || false,
@@ -120,8 +96,6 @@ export class GroupChats implements OnInit {
 
       this.groupChats.set(groupList);
       this.total.set(groupList.length);
-      
-      console.log(`✅ 加载群组完成: 共${groupList.length}个群组, ${projectTitleMap.size}个不同项目`);
     } catch (error) {
       console.error('加载群组列表失败:', error);
     } finally {
@@ -148,8 +122,29 @@ export class GroupChats implements OnInit {
 
   get filtered() {
     const kw = this.keyword().trim().toLowerCase();
-    if (!kw) return this.groupChats();
-    return this.groupChats().filter(g => g.name.toLowerCase().includes(kw));
+    let result = !kw ? this.groupChats() : this.groupChats().filter(g => g.name.toLowerCase().includes(kw));
+    
+    // 🔥 去重：移除相同项目名称的重复群组
+    // 保留每个项目名称的第一个群组，移除后续重复的
+    const seenProjectTitles = new Set<string>();
+    const uniqueResult: GroupChat[] = [];
+    
+    for (const group of result) {
+      if (group.project) {
+        const projectTitle = group.project.get("title") || '';
+        if (!seenProjectTitles.has(projectTitle)) {
+          seenProjectTitles.add(projectTitle);
+          uniqueResult.push(group);
+        } else {
+          console.log(`⚠️ [Groupchats] 移除重复项目群组: "${group.name}" (项目: "${projectTitle}")`);
+        }
+      } else {
+        // 未关联项目的群组不去重
+        uniqueResult.push(group);
+      }
+    }
+    
+    return uniqueResult;
   }
 
   resetFilters() {

src/app/pages/customer-service/dashboard/dashboard.html

@@ -63,8 +63,8 @@
         </div>
       </div>
 
-      <!-- 异常项目 -->
-      <div class="stat-card" (click)="handleExceptionProjectsClick()" title="点击查看异常项目详情">
+      <!-- 异常项目 - 已隐藏 -->
+      <!-- <div class="stat-card" (click)="handleExceptionProjectsClick()" title="点击查看异常项目详情">
         <div class="stat-icon danger">
           <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor">
             <path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"></path>
@@ -76,10 +76,10 @@
           <div class="stat-value">{{ stats.exceptionProjects() }}</div>
           <div class="stat-label">异常项目</div>
         </div>
-      </div>
+      </div> -->
 
-      <!-- 售后服务 -->
-      <div class="stat-card" (click)="handleAfterSalesClick()" title="点击查看售后服务详情">
+      <!-- 售后服务 - 已隐藏 -->
+      <!-- <div class="stat-card" (click)="handleAfterSalesClick()" title="点击查看售后服务详情">
         <div class="stat-icon success">
           <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor">
             <path d="M12 2l3.09 6.26L22 9.27l-5 4.87 1.18 6.88L12 17.77l-6.18 3.25L7 14.14 2 9.27l6.91-1.01L12 2z"></path>
@@ -89,7 +89,7 @@
           <div class="stat-value">{{ stats.afterSalesCount() }}</div>
           <div class="stat-label">售后服务</div>
         </div>
-      </div>
+      </div> -->
 
     </div>
 </section>
@@ -249,25 +249,30 @@
   </div>
 </section>
 
-<!-- 紧急事件和待办任务流 -->
-<div class="content-grid">
-  <!-- 紧急事件列表（⭐ 使用可复用组件） -->
-  <section class="urgent-tasks-section">
-    <div class="section-header">
-      <h3>紧急事件</h3>
-      <div style="display: flex; gap: 12px; align-items: center;">
-        <button 
-          class="btn-primary"
-          (click)="showTaskForm()"
-          style="font-size: 14px; padding: 6px 16px;"
-        >
-          添加紧急事项
-        </button>
-        <a href="/customer-service/project-list" class="view-all-link">查看全部</a>
+<!-- 🆕 待办任务双栏布局（待办问题 + 紧急事件） -->
+<section class="urgent-tasks-section">
+  <div class="section-header">
+    <h2>待办事项</h2>
+  </div>
+  
+  <!-- 🆕 双栏容器 -->
+  <div class="todo-dual-columns">
+    <!-- ========== 左栏：紧急事件 ========== -->
+    <div class="todo-column todo-column-urgent">
+      <div class="column-header">
+        <h3>
+          <svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor">
+            <path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/>
+          </svg>
+          紧急事件
+          @if (urgentEventsList().length > 0) {
+            <span class="task-count urgent">({{ urgentEventsList().length }})</span>
+          }
+        </h3>
+        <span class="column-subtitle">自动计算的截止事件</span>
       </div>
-    </div>
-    
-    <div class="tasks-list">
+      
+      <!-- 加载状态 -->
       @if (loadingUrgentEvents()) {
         <div class="loading-state">
           <svg class="spinner" viewBox="0 0 50 50">
@@ -276,6 +281,8 @@
           <p>计算紧急事件中...</p>
         </div>
       }
+      
+      <!-- 空状态 -->
       @if (!loadingUrgentEvents() && urgentEventsList().length === 0) {
         <div class="empty-state">
           <svg viewBox="0 0 24 24" width="64" height="64" fill="#d1d5db">
@@ -285,12 +292,18 @@
           <p class="hint">所有项目时间节点正常 ✅</p>
         </div>
       }
+      
+      <!-- 紧急事件列表 -->
       @if (!loadingUrgentEvents() && urgentEventsList().length > 0) {
         <div class="todo-list-compact urgent-list">
           @for (event of urgentEventsList(); track event.id) {
             <div class="todo-item-compact urgent-item" [attr.data-urgency]="event.urgencyLevel">
+              <!-- 左侧紧急程度色条 -->
               <div class="urgency-indicator" [attr.data-urgency]="event.urgencyLevel"></div>
+              
+              <!-- 事件内容 -->
               <div class="task-content">
+                <!-- 标题行 -->
                 <div class="task-header">
                   <span class="task-title">{{ event.title }}</span>
                   <div class="task-badges">
@@ -306,7 +319,13 @@
                     </span>
                   </div>
                 </div>
-                <div class="task-description">{{ event.description }}</div>
+                
+                <!-- 描述 -->
+                <div class="task-description">
+                  {{ event.description }}
+                </div>
+                
+                <!-- 项目信息行 -->
                 <div class="task-meta">
                   <span class="project-info">
                     <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
@@ -323,16 +342,25 @@
                     </span>
                   }
                 </div>
+                
+                <!-- 底部信息行 -->
                 <div class="task-footer">
                   <span class="deadline-info" [class.overdue]="event.overdueDays && event.overdueDays > 0">
                     <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
                       <path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"/>
                     </svg>
                     截止: {{ event.deadline | date:'MM-dd HH:mm' }}
-                    @if (event.overdueDays && event.overdueDays > 0) { <span class="overdue-label">(逾期{{ event.overdueDays }}天)</span> }
-                    @else if (event.overdueDays && event.overdueDays < 0) { <span class="upcoming-label">(还剩{{ -event.overdueDays }}天)</span> }
-                    @else { <span class="today-label">(今天)</span> }
+                    @if (event.overdueDays && event.overdueDays > 0) {
+                      <span class="overdue-label">(逾期{{ event.overdueDays }}天)</span>
+                    }
+                    @else if (event.overdueDays && event.overdueDays < 0) {
+                      <span class="upcoming-label">(还剩{{ -event.overdueDays }}天)</span>
+                    }
+                    @else {
+                      <span class="today-label">(今天)</span>
+                    }
                   </span>
+                  
                   @if (event.completionRate !== undefined) {
                     <span class="completion-info">
                       <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
@@ -343,15 +371,158 @@
                   }
                 </div>
               </div>
+              
+              <!-- 右侧操作按钮 -->
+              <div class="task-actions">
+                <button 
+                  class="btn-action btn-view" 
+                  (click)="onUrgentEventViewProject(event.projectId)"
+                  title="查看项目">
+                  <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor">
+                    <path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"/>
+                  </svg>
+                  查看项目
+                </button>
+              </div>
+            </div>
+          }
+        </div>
+      }
+    </div>
+    <!-- ========== 左栏结束 ========== -->
+    
+    <!-- ========== 右栏：待办任务 ========== -->
+    <div class="todo-column todo-column-issues">
+      <div class="column-header">
+        <h3>
+          <svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor">
+            <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/>
+          </svg>
+          待办任务
+          @if (todoTasksFromIssues().length > 0) {
+            <span class="task-count">({{ todoTasksFromIssues().length }})</span>
+          }
+        </h3>
+        <span class="column-subtitle">来自项目问题板块</span>
+      </div>
+      
+      <!-- 加载状态 -->
+      @if (loadingTodoTasks()) {
+        <div class="loading-state">
+          <svg class="spinner" viewBox="0 0 50 50">
+            <circle cx="25" cy="25" r="20" fill="none" stroke-width="4"></circle>
+          </svg>
+          <p>加载待办任务中...</p>
+        </div>
+      }
+      
+      <!-- 错误状态 -->
+      @if (!loadingTodoTasks() && todoTaskError()) {
+        <div class="error-state">
+          <svg viewBox="0 0 24 24" width="48" height="48" fill="#ef4444">
+            <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/>
+          </svg>
+          <p>{{ todoTaskError() }}</p>
+          <button class="btn-retry" (click)="refreshTodoTasks()">重试</button>
+        </div>
+      }
+      
+      <!-- 空状态 -->
+      @if (!loadingTodoTasks() && !todoTaskError() && todoTasksFromIssues().length === 0) {
+        <div class="empty-state">
+          <svg viewBox="0 0 24 24" width="64" height="64" fill="#d1d5db">
+            <path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"/>
+          </svg>
+          <p>暂无待办任务</p>
+          <p class="hint">所有项目问题都已处理完毕 🎉</p>
+        </div>
+      }
+      
+      <!-- 待办任务列表 -->
+      @if (!loadingTodoTasks() && !todoTaskError() && todoTasksFromIssues().length > 0) {
+        <div class="todo-list-compact">
+          @for (task of todoTasksFromIssues(); track task.id) {
+            <div class="todo-item-compact" [attr.data-priority]="task.priority">
+              <!-- 左侧优先级色条 -->
+              <div class="priority-indicator" [attr.data-priority]="task.priority"></div>
+              
+              <!-- 任务内容 -->
+              <div class="task-content">
+                <!-- 标题行 -->
+                <div class="task-header">
+                  <span class="task-title">{{ task.title }}</span>
+                  <div class="task-badges">
+                    <span class="badge badge-priority" [attr.data-priority]="task.priority">
+                      {{ getPriorityConfig(task.priority).label }}
+                    </span>
+                    <span class="badge badge-type">{{ getIssueTypeLabel(task.type) }}</span>
+                  </div>
+                </div>
+                
+                <!-- 项目信息行 -->
+                <div class="task-meta">
+                  <span class="project-info">
+                    <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
+                      <path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"/>
+                    </svg>
+                    项目: {{ task.projectName }}
+                    @if (task.relatedSpace) {
+                      | {{ task.relatedSpace }}
+                    }
+                    @if (task.relatedStage) {
+                      | {{ task.relatedStage }}
+                    }
+                  </span>
+                </div>
+                
+                <!-- 底部信息行 -->
+                <div class="task-footer">
+                  <span class="time-info" [title]="formatExactTime(task.createdAt)">
+                    <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
+                      <path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"/>
+                    </svg>
+                    创建于 {{ formatRelativeTime(task.createdAt) }}
+                  </span>
+                  
+                  <span class="assignee-info">
+                    <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
+                      <path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/>
+                    </svg>
+                    指派给: {{ task.assigneeName }}
+                  </span>
+                </div>
+              </div>
+              
+              <!-- 右侧操作按钮 -->
               <div class="task-actions">
-                <button class="btn-action btn-view" (click)="onUrgentEventViewProject(event.projectId)">查看项目</button>
+                <button 
+                  class="btn-action btn-view" 
+                  (click)="navigateToIssue(task)"
+                  title="查看详情">
+                  <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor">
+                    <path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"/>
+                  </svg>
+                  查看详情
+                </button>
+                <button 
+                  class="btn-action btn-mark-read" 
+                  (click)="onTodoTaskMarkAsRead(task)"
+                  title="标记已读">
+                  <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor">
+                    <path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/>
+                  </svg>
+                  标记已读
+                </button>
               </div>
             </div>
           }
         </div>
       }
     </div>
-  </section>
+    <!-- ========== 右栏结束 ========== -->
+  </div>
+  <!-- ========== 双栏容器结束 ========== -->
+</section>
 
   <!-- iOS风格的添加紧急事项面板 -->
   @if (isTaskFormVisible()) {
@@ -580,139 +751,10 @@
   </div>
   }
 
-  <!-- 待办任务流（复用组长端设计） -->
-  <section class="project-updates-section todo-section-customer-service">
-    <div class="section-header">
-      <h2>
-        待办任务
-        @if (todoTasksFromIssues().length > 0) {
-          <span class="task-count">({{ todoTasksFromIssues().length }})</span>
-        }
-      </h2>
-      <button 
-        class="btn-refresh" 
-        (click)="onRefreshTodoTasks()"
-        [disabled]="loadingTodoTasks()"
-        title="刷新待办任务">
-        <svg viewBox="0 0 24 24" width="16" height="16" [class.rotating]="loadingTodoTasks()">
-          <path fill="currentColor" d="M17.65 6.35A7.958 7.958 0 0 0 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08A5.99 5.99 0 0 1 12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/>
-        </svg>
-      </button>
-    </div>
-    
-    <!-- 加载状态 -->
-    @if (loadingTodoTasks()) {
-      <div class="loading-state">
-        <svg class="spinner" viewBox="0 0 50 50">
-          <circle cx="25" cy="25" r="20" fill="none" stroke-width="4"></circle>
-        </svg>
-        <p>加载待办任务中...</p>
-      </div>
-      }
-      
-    <!-- 错误状态 -->
-    @if (!loadingTodoTasks() && todoTaskError()) {
-      <div class="error-state">
-        <svg viewBox="0 0 24 24" width="48" height="48" fill="#ef4444">
-          <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/>
-          </svg>
-        <p>{{ todoTaskError() }}</p>
-        <button class="btn-retry" (click)="onRefreshTodoTasks()">重试</button>
-          </div>
-          }
-    
-    <!-- 空状态 -->
-    @if (!loadingTodoTasks() && !todoTaskError() && todoTasksFromIssues().length === 0) {
-      <div class="empty-state">
-        <svg viewBox="0 0 24 24" width="64" height="64" fill="#d1d5db">
-          <path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"/>
-        </svg>
-        <p>暂无待办任务</p>
-        <p class="hint">所有项目问题都已处理完毕 🎉</p>
-          </div>
-          }
-    
-    <!-- 待办任务列表 -->
-    @if (!loadingTodoTasks() && !todoTaskError() && todoTasksFromIssues().length > 0) {
-      <div class="todo-list-compact">
-        @for (task of todoTasksFromIssues(); track task.id) {
-          <div class="todo-item-compact" [attr.data-priority]="task.priority">
-            <!-- 左侧优先级色条 -->
-            <div class="priority-indicator" [attr.data-priority]="task.priority"></div>
-            
-            <!-- 任务内容 -->
-            <div class="task-content">
-              <!-- 标题行 -->
-              <div class="task-header">
-                <span class="task-title">{{ task.title }}</span>
-                <div class="task-badges">
-                  <span class="badge badge-priority" [attr.data-priority]="task.priority">
-                    {{ getPriorityConfig(task.priority).label }}
-                  </span>
-                  <span class="badge badge-type">{{ getIssueTypeLabel(task.type) }}</span>
-          </div>
-          </div>
-              
-              <!-- 项目信息行 -->
-              <div class="task-meta">
-                <span class="project-info">
-                  <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
-                    <path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"/>
-                  </svg>
-                  项目: {{ task.projectName }}
-                  @if (task.relatedSpace) {
-                    | {{ task.relatedSpace }}
-                  }
-                  @if (task.relatedStage) {
-                    | {{ task.relatedStage }}
-                  }
-                </span>
-              </div>
-              
-              <!-- 底部信息行 -->
-              <div class="task-footer">
-                <span class="time-info" [title]="formatExactTime(task.createdAt)">
-                  <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
-                    <path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"/>
-                  </svg>
-                  创建于 {{ formatRelativeTime(task.createdAt) }}
-                </span>
-                
-                <span class="assignee-info">
-                  <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor">
-                    <path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/>
-                  </svg>
-                  指派给: {{ task.assigneeName }}
-            </span>
-          </div>
-        </div>
-            
-            <!-- 右侧操作按钮（⭐ 使用新的事件处理方法） -->
-            <div class="task-actions">
-              <button 
-                class="btn-action btn-view" 
-                (click)="onTodoTaskViewDetails(task)"
-                title="查看详情">
-                <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor">
-                  <path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"/>
-                </svg>
-                查看详情
-              </button>
-              <button 
-                class="btn-action btn-mark-read" 
-                (click)="onTodoTaskMarkAsRead(task)"
-                title="标记已读">
-                <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor">
-                  <path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/>
-                </svg>
-                标记已读
-              </button>
-            </div>
-      </div>
-      }
-    </div>
-    }
-  </section>
+  <!-- 待办任务流（复用组长端设计） - 已隐藏 -->
+  <!-- <section class="project-updates-section todo-section-customer-service">
+    ... 已隐藏的待办任务流代码 ...
+  </section> -->
 
 <!-- 回到顶部按钮 -->
 <button class="back-to-top" (click)="scrollToTop()" [class.visible]="showBackToTop()">

src/app/pages/customer-service/dashboard/dashboard.scss

@@ -3686,4 +3686,403 @@ input[type="datetime-local"]::-webkit-calendar-picker-indicator {
   .quick-actions {
     grid-template-columns: 1fr;
   }
+}
+
+// 🆕 待办事项双栏布局样式
+.urgent-tasks-section {
+  .section-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px 20px;
+    border-bottom: 1px solid #e5e7eb;
+    
+    h2 {
+      margin: 0;
+      font-size: 18px;
+      font-weight: 600;
+      color: #1c1c1e;
+    }
+  }
+
+  // 双栏容器
+  .todo-dual-columns {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+    padding: 20px;
+    
+    @media (max-width: 1200px) {
+      grid-template-columns: 1fr;
+      gap: 16px;
+    }
+  }
+
+  // 列样式
+  .todo-column {
+    display: flex;
+    flex-direction: column;
+    background: #ffffff;
+    border-radius: 12px;
+    border: 1px solid #e5e7eb;
+    overflow: hidden;
+    
+    .column-header {
+      padding: 16px;
+      background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
+      color: white;
+      
+      h3 {
+        margin: 0;
+        font-size: 16px;
+        font-weight: 600;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        
+        .task-count {
+          margin-left: auto;
+          font-size: 14px;
+          font-weight: 500;
+          background: rgba(255, 255, 255, 0.2);
+          padding: 2px 8px;
+          border-radius: 12px;
+          
+          &.urgent {
+            background: rgba(239, 68, 68, 0.3);
+          }
+        }
+      }
+      
+      .column-subtitle {
+        font-size: 12px;
+        opacity: 0.8;
+        margin-top: 4px;
+        display: block;
+      }
+    }
+    
+    .loading-state,
+    .error-state,
+    .empty-state {
+      padding: 40px 20px;
+      text-align: center;
+      color: #6b7280;
+      
+      svg {
+        margin-bottom: 12px;
+      }
+      
+      p {
+        margin: 8px 0;
+        font-size: 14px;
+        
+        &.hint {
+          font-size: 12px;
+          color: #9ca3af;
+        }
+      }
+      
+      .btn-retry {
+        margin-top: 12px;
+        padding: 8px 16px;
+        background: #007aff;
+        color: white;
+        border: none;
+        border-radius: 6px;
+        cursor: pointer;
+        font-size: 14px;
+        
+        &:hover {
+          background: #0051a8;
+        }
+      }
+    }
+    
+    .todo-list-compact {
+      flex: 1;
+      overflow-y: auto;
+      max-height: 600px;
+      
+      .todo-item-compact {
+        display: flex;
+        gap: 12px;
+        padding: 12px;
+        border-bottom: 1px solid #f3f4f6;
+        transition: background-color 0.2s ease;
+        
+        &:hover {
+          background-color: #f9fafb;
+        }
+        
+        .priority-indicator {
+          width: 4px;
+          flex-shrink: 0;
+          border-radius: 2px;
+          
+          &[data-priority="urgent"],
+          &[data-priority="critical"] {
+            background: #dc2626;
+          }
+          
+          &[data-priority="high"] {
+            background: #f97316;
+          }
+          
+          &[data-priority="medium"] {
+            background: #f59e0b;
+          }
+          
+          &[data-priority="low"] {
+            background: #6b7280;
+          }
+        }
+        
+        .task-content {
+          flex: 1;
+          min-width: 0;
+          
+          .task-header {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            margin-bottom: 6px;
+            
+            .task-title {
+              font-size: 13px;
+              font-weight: 600;
+              color: #1c1c1e;
+              flex: 1;
+              white-space: nowrap;
+              overflow: hidden;
+              text-overflow: ellipsis;
+            }
+            
+            .task-badges {
+              display: flex;
+              gap: 6px;
+              flex-shrink: 0;
+              
+              .badge {
+                display: inline-block;
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-size: 11px;
+                font-weight: 600;
+                white-space: nowrap;
+                
+                &.badge-priority {
+                  &[data-priority="urgent"],
+                  &[data-priority="critical"] {
+                    background: #fee2e2;
+                    color: #dc2626;
+                  }
+                  
+                  &[data-priority="high"] {
+                    background: #ffedd5;
+                    color: #f97316;
+                  }
+                  
+                  &[data-priority="medium"] {
+                    background: #fef3c7;
+                    color: #f59e0b;
+                  }
+                  
+                  &[data-priority="low"] {
+                    background: #f3f4f6;
+                    color: #6b7280;
+                  }
+                }
+                
+                &.badge-type {
+                  background: #dbeafe;
+                  color: #1e40af;
+                }
+              }
+            }
+          }
+          
+          .task-meta {
+            font-size: 12px;
+            color: #6b7280;
+            margin-bottom: 6px;
+            display: flex;
+            gap: 8px;
+            flex-wrap: wrap;
+            
+            .project-info,
+            .designer-info {
+              display: flex;
+              align-items: center;
+              gap: 4px;
+              white-space: nowrap;
+              overflow: hidden;
+              text-overflow: ellipsis;
+            }
+          }
+          
+          .task-footer {
+            font-size: 11px;
+            color: #9ca3af;
+            display: flex;
+            gap: 12px;
+            flex-wrap: wrap;
+            
+            .time-info,
+            .assignee-info {
+              display: flex;
+              align-items: center;
+              gap: 4px;
+              white-space: nowrap;
+            }
+          }
+        }
+        
+        .task-actions {
+          display: flex;
+          gap: 6px;
+          flex-shrink: 0;
+          
+          .btn-action {
+            padding: 6px 10px;
+            border: 1px solid #d1d5db;
+            background: white;
+            color: #6b7280;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 12px;
+            display: flex;
+            align-items: center;
+            gap: 4px;
+            transition: all 0.2s ease;
+            white-space: nowrap;
+            
+            &:hover {
+              background: #f3f4f6;
+              color: #1c1c1e;
+              border-color: #9ca3af;
+            }
+            
+            &.btn-view {
+              color: #007aff;
+              border-color: #007aff;
+              
+              &:hover {
+                background: #f0f9ff;
+              }
+            }
+            
+            &.btn-mark-read {
+              color: #34c759;
+              border-color: #34c759;
+              
+              &:hover {
+                background: #f0fdf4;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+// 🆕 紧急事件样式（复用设计师组长端）
+  .todo-column-urgent {
+    .column-header {
+      background: linear-gradient(135deg, #f97316 0%, #dc2626 100%);
+    }
+    
+    // 紧急事件特定样式
+    .urgent-item {
+      background: #fff8f8;
+      border-left-width: 4px;
+      
+      &[data-urgency="critical"] {
+        border-left-color: #dc2626;
+        background: #fef2f2;
+      }
+      
+      &[data-urgency="high"] {
+        border-left-color: #f97316;
+        background: #fff7ed;
+      }
+      
+      &[data-urgency="medium"] {
+        border-left-color: #f59e0b;
+        background: #fffbeb;
+      }
+    }
+    
+    .urgency-indicator {
+      width: 4px;
+      
+      &[data-urgency="critical"] {
+        background: linear-gradient(180deg, #dc2626 0%, #b91c1c 100%);
+        box-shadow: 0 0 10px rgba(220, 38, 38, 0.5);
+      }
+      
+      &[data-urgency="high"] {
+        background: linear-gradient(180deg, #f97316 0%, #ea580c 100%);
+      }
+      
+      &[data-urgency="medium"] {
+        background: linear-gradient(180deg, #f59e0b 0%, #d97706 100%);
+      }
+    }
+    
+    .badge-urgency {
+      &[data-urgency="critical"] {
+        background: #fee2e2;
+        color: #dc2626;
+        font-weight: 700;
+      }
+      
+      &[data-urgency="high"] {
+        background: #ffedd5;
+        color: #f97316;
+      }
+      
+      &[data-urgency="medium"] {
+        background: #fef3c7;
+        color: #f59e0b;
+      }
+    }
+    
+    .badge-event-type {
+      background: #dbeafe;
+      color: #1e40af;
+    }
+    
+    .task-description {
+      font-size: 13px;
+      color: #6b7280;
+      margin: 8px 0;
+      line-height: 1.5;
+    }
+    
+    .deadline-info {
+      &.overdue {
+        color: #dc2626;
+        font-weight: 600;
+      }
+      
+      .overdue-label {
+        color: #dc2626;
+        font-weight: 600;
+      }
+      
+      .upcoming-label {
+        color: #f97316;
+      }
+      
+      .today-label {
+        color: #f59e0b;
+        font-weight: 600;
+      }
+    }
+    
+    .completion-info {
+      font-weight: 500;
+    }
+  }
 }

src/app/pages/customer-service/dashboard/dashboard.ts

@@ -1918,6 +1918,22 @@ onSearchInput(event: Event): void {
     });
   }
   
+  /**
+   * ⭐ 从待办任务面板查看详情（跳转到项目并显示问题弹窗）
+   */
+  navigateToIssue(task: TodoTaskFromIssue): void {
+    console.log('🔍 [待办任务] 查看详情:', task.title);
+    // 跳转到项目详情页，并打开问题板块
+    const cid = localStorage.getItem('company') || 'cDL6R1hgSi';
+    this.router.navigate(['/wxwork', cid, 'project', task.projectId, 'order'], {
+      queryParams: {
+        openIssues: 'true',
+        highlightIssue: task.id,
+        roleName: 'customer-service'
+      }
+    });
+  }
+  
   /**
    * ⭐ 从待办任务面板查看详情
    */
@@ -2027,20 +2043,6 @@ onSearchInput(event: Event): void {
     return labels[status] || '待处理';
   }
   
-  /**
-   * 跳转到项目问题详情
-   */
-  navigateToIssue(task: TodoTaskFromIssue): void {
-    console.log(`📋 跳转到问题详情: ${task.id}, 项目ID: ${task.projectId}`);
-    
-    // 获取当前公司ID
-    const cid = localStorage.getItem('company') || 'cDL6R1hgSi';
-    
-    // 导航到wxwork模块的项目问题详情页
-    this.router.navigate(['/wxwork', cid, 'project', task.projectId, 'issues'], {
-      queryParams: { issueId: task.id }
-    });
-  }
 
   // 新增：一键发送大图
   sendLargeImages(projectId: string): void {

src/app/pages/customer-service/project-list/project-list.ts

@@ -158,6 +158,112 @@ export class ProjectList implements OnInit, OnDestroy {
       }
     };
     window.addEventListener('message', this.messageListener);
+    
+    // 🔍 添加全局调试方法
+    (window as any).debugCustomerServiceProjects = () => {
+      console.log('🔍 [客服端项目调试] 当前项目列表:');
+      const projects = this.allProjects();
+      projects.forEach((project, index) => {
+        console.log(`项目${index + 1}: "${project.name}"`);
+        console.log(`  - currentStage: ${project.currentStage}`);
+        console.log(`  - stage: ${project.stage}`);
+        console.log(`  - status: ${project.status}`);
+        console.log(`  - 看板列: ${this.getColumnIdForProject(project as ProjectListItem)}`);
+        console.log('  ---');
+      });
+    };
+    console.log('🔍 调试方法已添加到全局: window.debugCustomerServiceProjects()');
+  }
+
+  // 🎯 判断是否为交付执行阶段（用于统一显示）
+  private isDeliveryExecutionStage(stage: string): boolean {
+    if (!stage) return false;
+    const trimmedStage = stage.trim();
+    const lowerStage = trimmedStage.toLowerCase();
+    
+    return trimmedStage === '交付执行' || 
+           lowerStage === 'delivery' || 
+           // 建模相关
+           trimmedStage === '建模' || 
+           trimmedStage === '建模阶段' || 
+           trimmedStage === '白模' ||
+           trimmedStage === '白膜' ||
+           lowerStage === 'modeling' ||
+           // 软装相关
+           trimmedStage === '软装' || 
+           trimmedStage === '软装阶段' ||
+           lowerStage === 'soft_decor' ||
+           lowerStage === 'decoration' ||
+           // 渲染相关
+           trimmedStage === '渲染' || 
+           trimmedStage === '渲染阶段' || 
+           lowerStage === 'rendering' ||
+           // 后期相关
+           trimmedStage === '后期制作' || 
+           trimmedStage === '后期处理' || 
+           trimmedStage === '后期' || 
+           lowerStage === 'postproduction' ||
+           // 评审修改相关
+           trimmedStage === '评审' || 
+           trimmedStage === '方案评审' || 
+           trimmedStage === '修改' || 
+           trimmedStage === '方案修改' || 
+           trimmedStage === '修订' ||
+           lowerStage === 'review' ||
+           lowerStage === 'revision' ||
+           // 其他可能的交付执行子阶段
+           trimmedStage === '设计' ||
+           trimmedStage === '设计阶段' ||
+           trimmedStage === '制作' ||
+           trimmedStage === '制作阶段' ||
+           trimmedStage === '完善' ||
+           trimmedStage === '优化' ||
+           trimmedStage === '调整';
+  }
+
+  // 🔍 验证项目分配统计
+  private validateProjectDistribution(projects: Project[]): void {
+    const orderCount = projects.filter(p => this.isOrderAssignment(p)).length;
+    const requirementsCount = projects.filter(p => this.isRequirementsConfirmation(p)).length;
+    const deliveryCount = projects.filter(p => this.isDeliveryExecution(p)).length;
+    const aftercareCount = projects.filter(p => this.isAftercare(p)).length;
+    
+    console.log('🔍 [客服端项目分配统计]:');
+    console.log(`  订单分配: ${orderCount} 个项目`);
+    console.log(`  确认需求: ${requirementsCount} 个项目`);
+    console.log(`  交付执行: ${deliveryCount} 个项目`);
+    console.log(`  售后: ${aftercareCount} 个项目`);
+    console.log(`  总计: ${projects.length} 个项目`);
+    
+    // 🎯 与期望值对比
+    const expected = { order: 3, requirements: 4, delivery: 8, aftercare: 5 };
+    console.log('🎯 [期望值对比]:');
+    console.log(`  订单分配: 实际${orderCount} vs 期望${expected.order} ${orderCount === expected.order ? '✅' : '❌'}`);
+    console.log(`  确认需求: 实际${requirementsCount} vs 期望${expected.requirements} ${requirementsCount === expected.requirements ? '✅' : '❌'}`);
+    console.log(`  交付执行: 实际${deliveryCount} vs 期望${expected.delivery} ${deliveryCount === expected.delivery ? '✅' : '❌'}`);
+    console.log(`  售后: 实际${aftercareCount} vs 期望${expected.aftercare} ${aftercareCount === expected.aftercare ? '✅' : '❌'}`);
+    
+    // 🔍 如果数量不匹配，显示详细信息
+    if (orderCount !== expected.order) {
+      console.log('🔍 [订单分配阶段项目详情]:');
+      projects.filter(p => this.isOrderAssignment(p)).forEach(p => {
+        console.log(`  - "${p.name}": currentStage="${p.currentStage}"`);
+      });
+    }
+    
+    if (deliveryCount !== expected.delivery) {
+      console.log('🔍 [交付执行阶段项目详情]:');
+      projects.filter(p => this.isDeliveryExecution(p)).forEach(p => {
+        console.log(`  - "${p.name}": currentStage="${p.currentStage}"`);
+      });
+      
+      // 🔍 显示所有项目的原始阶段，帮助识别遗漏的阶段
+      console.log('🔍 [所有项目的原始阶段]:');
+      projects.forEach(p => {
+        const isDelivery = this.isDeliveryExecution(p);
+        console.log(`  - "${p.name}": "${p.currentStage}" ${isDelivery ? '✅交付执行' : ''}`);
+      });
+    }
   }
 
   ngOnDestroy(): void {
@@ -337,6 +443,25 @@ export class ProjectList implements OnInit, OnDestroy {
       const projectObjects = await ProjectQuery.find();
       console.log(`✅ 从Parse Server加载了 ${projectObjects.length} 个项目`);
       
+      // 🔍 调试：检查前5个项目的阶段数据
+      if (projectObjects.length > 0) {
+        console.log('🔍 [客服端调试] 检查前5个项目的阶段数据:');
+        for (let i = 0; i < Math.min(5, projectObjects.length); i++) {
+          const proj = projectObjects[i];
+          const title = proj.get('title') || '未命名项目';
+          const currentStage = proj.get('currentStage');
+          const stage = proj.get('stage');
+          const status = proj.get('status');
+          
+          console.log(`  项目${i + 1}: "${title}"`);
+          console.log(`    - currentStage: ${currentStage}`);
+          console.log(`    - stage: ${stage}`);
+          console.log(`    - status: ${status}`);
+          console.log(`    - 最终使用阶段: ${currentStage || stage || '订单分配'}`);
+          console.log('    ---');
+        }
+      }
+      
       // 如果没有数据，打印调试信息
       if (projectObjects.length === 0) {
         console.warn('⚠️ 未找到项目数据，请检查：');
@@ -350,35 +475,25 @@ export class ProjectList implements OnInit, OnDestroy {
         const contact = obj.get('contact');
         const assignee = obj.get('assignee');
         
-        // 🔄 从Product表读取最新阶段（与组长端保持一致）
+        // 🔄 直接从Project表读取阶段（与组长端保持严格一致）
         let rawStage = obj.get('currentStage') || obj.get('stage') || '订单分配';
-        try {
-          const ProductQuery = new Parse.Query('Product');
-          ProductQuery.equalTo('project', { __type: 'Pointer', className: 'Project', objectId: obj.id });
-          ProductQuery.notEqualTo('isDeleted', true);
-          ProductQuery.descending('updatedAt');
-          ProductQuery.limit(1);
-          
-          const latestProduct = await ProductQuery.first();
-          if (latestProduct) {
-            const productStage = latestProduct.get('stage');
-            if (productStage) {
-              rawStage = productStage;
-              console.log(`📦 项目 ${obj.get('title')} 从Product同步阶段: ${productStage}`);
-            }
-          }
-        } catch (error) {
-          console.warn(`⚠️ 查询项目 ${obj.id} 的Product失败:`, error);
-        }
+        console.log(`📊 项目 ${obj.get('title')} 原始阶段数据: currentStage=${obj.get('currentStage')}, stage=${obj.get('stage')}`);
+        
+        // 🔥 关键修复：统一交付执行子阶段的显示
+        let finalStage = rawStage;
         
-        // 🔄 规范化阶段名称（统一为四大核心阶段）
-        const normalizedStage = normalizeStage(rawStage);
+        // 🎯 将交付执行的所有子阶段统一显示为"交付执行"
+        const tempProject = { currentStage: rawStage, status: obj.get('status') };
+        if (this.isDeliveryExecutionStage(rawStage)) {
+          finalStage = '交付执行';
+          console.log(`🔄 统一阶段显示: "${obj.get('title')}" 从 "${rawStage}" → "交付执行"`);
+        }
         
         // 🔄 根据阶段自动判断状态（与组长端、管理端保持一致）
         const projectStatus = obj.get('status');
         const autoStatus = getProjectStatusByStage(rawStage, projectStatus);
         
-        console.log(`📊 客服项目 "${obj.get('title')}": 原始阶段=${rawStage}, 规范化阶段=${normalizedStage}, 原状态=${projectStatus}, 自动状态=${autoStatus}`);
+        console.log(`📊 客服项目 "${obj.get('title')}": 原始阶段=${rawStage}, 最终阶段=${finalStage}, 原状态=${projectStatus}, 自动状态=${autoStatus}`);
         
         // 确保updatedAt是Date对象
         const updatedAt = obj.get('updatedAt');
@@ -390,8 +505,8 @@ export class ProjectList implements OnInit, OnDestroy {
           customerName: contact?.get('name') || '未知客户',
           customerId: contact?.id || '',
           status: autoStatus as ProjectStatus, // 使用根据阶段自动判断的状态
-          currentStage: normalizedStage as ProjectStage,
-          stage: normalizedStage as ProjectStage, // stage和currentStage保持一致
+          currentStage: finalStage as ProjectStage,
+          stage: finalStage as ProjectStage, // stage和currentStage保持一致
           assigneeId: assignee?.id || '',
           assigneeName: assignee?.get('name') || '未分配',
           deadline: obj.get('deadline') || new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
@@ -410,6 +525,9 @@ export class ProjectList implements OnInit, OnDestroy {
       this.baseProjects = projects;
       this.processProjects(projects);
       
+      // 🔍 验证项目分配统计
+      this.validateProjectDistribution(projects);
+      
       console.log('项目数据处理完成');
     } catch (error) {
       console.error('加载项目列表失败:', error);
@@ -646,44 +764,121 @@ export class ProjectList implements OnInit, OnDestroy {
   }
 
   // 看板分组逻辑 - 按照订单分配、确认需求、交付执行、售后四个阶段
-  // 🔄 使用规范化后的四大核心阶段名称进行匹配
+  // 🔥 修复：直接使用原始阶段名称进行匹配（与组长端完全一致）
   private isOrderAssignment(p: Project): boolean {
-    // 订单分配阶段：currentStage为"订单分配"
-    const stage = p.currentStage as string;
-    return stage === '订单分配';
+    const stage = (p.currentStage as string)?.trim();
+    if (!stage) return false;
+    const lowerStage = stage.toLowerCase();
+    return stage === '订单分配' || 
+           lowerStage === 'order' || 
+           stage === '待分配' || 
+           stage === '待审批';
   }
 
   private isRequirementsConfirmation(p: Project): boolean {
-    // 确认需求阶段：currentStage为"确认需求"
-    // 注意：阶段已经通过normalizeStage规范化为四大核心阶段
-    const stage = p.currentStage as string;
-    return stage === '确认需求';
+    const stage = (p.currentStage as string)?.trim();
+    if (!stage) return false;
+    const lowerStage = stage.toLowerCase();
+    return stage === '确认需求' || 
+           lowerStage === 'requirements' || 
+           stage === '需求沟通' || 
+           stage === '需求确认' || 
+           stage === '方案规划' || 
+           stage === '方案确认' || 
+           stage === '方案深化';
   }
 
   private isDeliveryExecution(p: Project): boolean {
-    // 交付执行阶段：currentStage为"交付执行"
-    const stage = p.currentStage as string;
-    return stage === '交付执行';
+    const stage = (p.currentStage as string)?.trim();
+    if (!stage) return false;
+    const lowerStage = stage.toLowerCase();
+    
+    // 🔥 扩展交付执行阶段的识别范围，包含所有子阶段
+    return stage === '交付执行' || 
+           lowerStage === 'delivery' || 
+           // 建模相关
+           stage === '建模' || 
+           stage === '建模阶段' || 
+           stage === '白模' ||
+           stage === '白膜' ||
+           lowerStage === 'modeling' ||
+           // 软装相关
+           stage === '软装' || 
+           stage === '软装阶段' ||
+           lowerStage === 'soft_decor' ||
+           lowerStage === 'decoration' ||
+           // 渲染相关
+           stage === '渲染' || 
+           stage === '渲染阶段' || 
+           lowerStage === 'rendering' ||
+           // 后期相关
+           stage === '后期制作' || 
+           stage === '后期处理' || 
+           stage === '后期' || 
+           lowerStage === 'postproduction' ||
+           // 评审修改相关
+           stage === '评审' || 
+           stage === '方案评审' || 
+           stage === '修改' || 
+           stage === '方案修改' || 
+           stage === '修订' ||
+           lowerStage === 'review' ||
+           lowerStage === 'revision' ||
+           // 其他可能的交付执行子阶段
+           stage === '设计' ||
+           stage === '设计阶段' ||
+           stage === '制作' ||
+           stage === '制作阶段' ||
+           stage === '完善' ||
+           stage === '优化' ||
+           stage === '调整';
   }
 
   private isAftercare(p: Project): boolean {
-    // 售后归档阶段：currentStage为"售后归档" 或 状态为"已完成"
-    const stage = p.currentStage as string;
-    return stage === '售后归档' || p.status === '已完成';
+    const stage = (p.currentStage as string)?.trim();
+    if (!stage) return false;
+    const lowerStage = stage.toLowerCase();
+    return stage === '售后归档' || 
+           lowerStage === 'aftercare' || 
+           stage === '售后' || 
+           stage === '归档' || 
+           stage === '尾款结算' || 
+           stage === '客户评价' || 
+           stage === '投诉处理' || 
+           stage === '已归档' || 
+           p.status === '已完成';
   }
 
   getProjectsByColumn(columnId: 'order' | 'requirements' | 'delivery' | 'aftercare'): ProjectListItem[] {
     const list = this.projects();
+    let result: ProjectListItem[] = [];
+    
     switch (columnId) {
       case 'order':
-        return list.filter(p => this.isOrderAssignment(p));
+        result = list.filter(p => this.isOrderAssignment(p));
+        break;
       case 'requirements':
-        return list.filter(p => this.isRequirementsConfirmation(p));
+        result = list.filter(p => this.isRequirementsConfirmation(p));
+        break;
       case 'delivery':
-        return list.filter(p => this.isDeliveryExecution(p));
+        result = list.filter(p => this.isDeliveryExecution(p));
+        break;
       case 'aftercare':
-        return list.filter(p => this.isAftercare(p));
+        result = list.filter(p => this.isAftercare(p));
+        break;
+      default:
+        result = [];
     }
+    
+    // 🔍 调试日志
+    console.log(`🔍 [getProjectsByColumn] ${columnId}: ${result.length} 个项目`);
+    if (result.length > 0) {
+      result.forEach(p => {
+        console.log(`  - "${p.name}": currentStage="${p.currentStage}"`);
+      });
+    }
+    
+    return result;
   }
 
   // 新增：根据项目状态与阶段推断所在看板列

src/app/pages/designer/project-detail/components/designer-team-assignment-modal/designer-team-assignment-modal.component.ts

@@ -946,7 +946,7 @@ export class DesignerTeamAssignmentModalComponent implements OnInit, OnChanges {
   }
 
   /**
-   * 从Parse Server加载真实的项目空间数据（从Product表）
+   * 从Parse Server加载真实的项目空间数据 - 使用统一空间管理
    */
   async loadRealProjectSpaces() {
     if (!this.projectId) {
@@ -957,12 +957,38 @@ export class DesignerTeamAssignmentModalComponent implements OnInit, OnChanges {
     try {
       this.loadingSpaces = true;
       this.spaceLoadError = '';
+      console.log('🔄 [设计师分配] 开始加载项目空间...');
 
-      // 使用ProductSpaceService查询项目的所有空间产品
-      this.parseProducts = await this.productSpaceService.getProjectProductSpaces(this.projectId);
+      // ✅ 使用统一空间管理查询项目的所有空间
+      const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(this.projectId);
+
+      if (unifiedSpaces.length > 0) {
+        console.log(`✅ [设计师分配] 从统一存储加载到 ${unifiedSpaces.length} 个空间`);
+        
+        // 转换为ProductSpace格式
+        this.parseProducts = unifiedSpaces.map(space => ({
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area,
+          priority: space.priority,
+          status: space.status,
+          complexity: space.complexity,
+          estimatedBudget: space.estimatedBudget,
+          order: space.order,
+          projectId: this.projectId,
+          metadata: {},
+          quotation: space.quotation,
+          requirements: space.requirements,
+          designerId: space.designerId
+        }));
+      } else {
+        console.log('⚠️ [设计师分配] 没有找到统一空间数据，尝试从Product表加载...');
+        this.parseProducts = await this.productSpaceService.getProjectProductSpaces(this.projectId);
+      }
 
       if (this.parseProducts.length === 0) {
-        console.warn('未找到项目空间数据');
+        console.warn('❌ [设计师分配] 未找到项目空间数据');
         this.spaceLoadError = '未找到项目空间数据';
         return;
       }
@@ -970,15 +996,15 @@ export class DesignerTeamAssignmentModalComponent implements OnInit, OnChanges {
       // 转换为SpaceScene格式
       this.spaceScenes = this.parseProducts.map(product => ({
         id: product.id,
-        name: product.name, // productName
+        name: product.name,
         area: product.area,
         description: this.getProductDescription(product)
       }));
 
-      console.log('成功加载项目空间数据:', this.spaceScenes);
+      console.log(`✅ [设计师分配] 空间加载完成，共 ${this.spaceScenes.length} 个空间:`, this.spaceScenes.map(s => s.name));
 
     } catch (err) {
-      console.error('加载项目空间数据失败:', err);
+      console.error('❌ [设计师分配] 加载项目空间数据失败:', err);
       this.spaceLoadError = '加载项目空间数据失败';
     } finally {
       this.loadingSpaces = false;

src/modules/project/components/quotation-editor.component.ts

@@ -1,4 +1,4 @@
-import { Component, Input, Output, EventEmitter, OnChanges, SimpleChanges, OnInit, OnDestroy } from '@angular/core';
+import { Component, Input, Output, EventEmitter, OnChanges, SimpleChanges, OnInit, OnDestroy, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { FmodeParse } from 'fmode-ng/parse';
@@ -15,6 +15,7 @@ import {
   ARCHITECTURE_TYPES,
   type Allocation
 } from '../config/quotation-rules';
+import { ProductSpaceService } from '../services/product-space.service';
 
 const Parse = FmodeParse.with('nova');
 
@@ -36,6 +37,9 @@ const Parse = FmodeParse.with('nova');
   styleUrls: ['./quotation-editor.component.scss']
 })
 export class QuotationEditorComponent implements OnInit, OnChanges, OnDestroy {
+  // 注入服务
+  private productSpaceService = inject(ProductSpaceService);
+  
   // 输入属性
   @Input() projectId: string = '';
   @Input() project: any = null;
@@ -642,20 +646,71 @@ export class QuotationEditorComponent implements OnInit, OnChanges, OnDestroy {
   }
 
   /**
-   * 保存报价到项目
+   * 保存报价到项目 - 集成统一空间管理
    */
   private async saveQuotationToProject(): Promise<void> {
     if (!this.project) return;
 
     try {
+      console.log('💾 [报价管理器] 开始保存报价数据...');
+      
+      // 1️⃣ 保存到 Project.data.quotation（保持向后兼容）
       const data = this.project.get('data') || {};
       data.quotation = this.quotation;
       this.project.set('data', data);
-      await this.project.save();
-
+      
+      // 2️⃣ 🔥 关键：同步到统一空间管理
+      const unifiedSpaces = this.products.map((product, index) => {
+        const quotation = product.get('quotation') || {};
+        const space = product.get('space') || {};
+        const requirements = product.get('requirements') || {};
+        const profile = product.get('profile');
+        
+        // 从报价数据中查找对应的空间信息
+        const quotationSpace = this.quotation.spaces.find(
+          (s: any) => s.productId === product.id
+        );
+        
+        return {
+          id: product.id,
+          name: product.get('productName'),
+          type: product.get('productType') || 'other',
+          area: space.area || 0,
+          priority: space.priority || 5,
+          status: product.get('status') || 'not_started',
+          complexity: space.complexity || 'medium',
+          estimatedBudget: quotation.price || 0,
+          order: index,
+          // 报价信息
+          quotation: {
+            price: quotation.price || 0,
+            processes: quotationSpace?.processes || {},
+            subtotal: quotationSpace?.subtotal || 0
+          },
+          // 需求信息
+          requirements: requirements,
+          // 设计师分配
+          designerId: profile?.id || null,
+          // 进度信息
+          progress: [],
+          // 时间戳
+          createdAt: product.createdAt?.toISOString() || new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        };
+      });
+      
+      // 调用统一空间管理服务保存
+      await this.productSpaceService.saveUnifiedSpaceData(
+        this.project.id || '',
+        unifiedSpaces
+      );
+      
+      console.log(`✅ [报价管理器] 报价数据已保存，空间数: ${unifiedSpaces.length}`);
+      
       this.quotationChange.emit(this.quotation);
     } catch (error) {
-      console.error('保存报价失败:', error);
+      console.error('❌ [报价管理器] 保存报价失败:', error);
+      throw error;
     }
   }
 

src/modules/project/pages/project-detail/project-detail.component.ts

@@ -569,7 +569,7 @@ export class ProjectDetailComponent implements OnInit, OnDestroy {
     // 如果是中文名称，转换为英文ID
     if (stageNameToId[workflowCurrent]) {
       workflowCurrent = stageNameToId[workflowCurrent];
-      console.log('🔄 阶段名称映射:', this.project?.get('currentStage'), '->', workflowCurrent);
+     // console.log('🔄 阶段名称映射:', this.project?.get('currentStage'), '->', workflowCurrent);
     }
 
     // 如果没有当前阶段（新创建的项目），默认订单分配为active（红色）

src/modules/project/pages/project-detail/stages/stage-delivery.component.ts

@@ -495,7 +495,35 @@ export class StageDeliveryComponent implements OnInit, OnDestroy {
         projectName: this.project.get('name') || this.project.get('title')
       });
       
-      this.projectProducts = await this.productSpaceService.getProjectProductSpaces(this.project.id!);
+      // ✅ 使用统一空间管理加载Product数据
+      console.log('🔄 [交付执行] 开始加载项目空间...');
+      
+      const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(this.project.id!);
+      
+      if (unifiedSpaces.length > 0) {
+        console.log(`✅ [交付执行] 从统一存储加载到 ${unifiedSpaces.length} 个空间`);
+        
+        // 转换为组件使用的格式
+        this.projectProducts = unifiedSpaces.map(space => ({
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area,
+          priority: space.priority,
+          status: space.status,
+          complexity: space.complexity,
+          estimatedBudget: space.estimatedBudget,
+          order: space.order,
+          projectId: this.project!.id || '',
+          metadata: {},
+          quotation: space.quotation,
+          requirements: space.requirements,
+          designerId: space.designerId
+        }));
+      } else {
+        console.log('⚠️ [交付执行] 没有找到统一空间数据，尝试从Product表加载...');
+        this.projectProducts = await this.productSpaceService.getProjectProductSpaces(this.project.id!);
+      }
       
       console.log('🔍 [加载Product] 原始查询结果:', this.projectProducts.length, '个');
       if (this.projectProducts.length > 0) {
@@ -522,14 +550,14 @@ export class StageDeliveryComponent implements OnInit, OnDestroy {
         console.log('🔍 [加载Product] 默认选中第一个Product:', this.activeProductId);
       }
 
-      console.log(`✅ [加载Product] 已加载 ${this.projectProducts.length} 个场景Product`);
+      console.log(`✅ [交付执行] 空间加载完成，共 ${this.projectProducts.length} 个空间`);
       console.log('📊 canEdit:', this.canEdit);
       console.log('📊 projectProducts.length:', this.projectProducts.length);
       console.log('📊 显示完成交付按钮条件:', this.canEdit && this.projectProducts.length > 0);
       
       // 🔥 如果没有Product，提示用户
       if (this.projectProducts.length === 0) {
-        console.warn('⚠️ [加载Product] 未找到任何Product数据！请检查：');
+        console.warn('⚠️ [交付执行] 未找到任何Product数据！请检查：');
         console.warn('1. 订单分配阶段是否已创建报价空间');
         console.warn('2. Product表中是否有对应项目的数据');
         console.warn('3. project字段是否正确指向当前项目');

src/modules/project/pages/project-detail/stages/stage-order.component.ts

@@ -690,56 +690,76 @@ export class StageOrderComponent implements OnInit {
   }
 
   /**
-   * 加载项目空间
+   * 加载项目空间 - 使用统一空间管理
    */
   async loadProjectSpaces(): Promise<void> {
     if (!this.project) return;
 
     try {
       this.loadingSpaces = true;
+      console.log('🔄 [订单分配] 开始加载项目空间...');
 
-      // 从ProjectSpace表加载空间数据
-      this.projectSpaces = await this.productSpaceService.getProjectProductSpaces(this.project.id || '');
-
-      // 如果没有空间数据，但从项目数据中有报价信息，则转换创建默认空间
-      if (this.projectSpaces.length === 0) {
-        const data = this.project.get('data') || {};
-        if (data.quotation?.spaces) {
-          await this.createSpacesFromQuotation(data.quotation.spaces);
-        }
-      }
-
-      // ⭐ 同步缺失空间：当已有部分 ProductSpace 时，补齐与报价明细一致
-      if (this.projectSpaces.length > 0) {
-        const data = this.project.get('data') || {};
-        const quotationSpaces = Array.isArray(data.quotation?.spaces) ? data.quotation.spaces : [];
-        if (quotationSpaces.length > 0) {
-          const existingNames = new Set(
-            this.projectSpaces.map(s => (s.name || '').trim().toLowerCase())
-          );
-          const missing = quotationSpaces.filter((s: any) => {
-            const n = (s?.name || '').trim().toLowerCase();
-            return n && !existingNames.has(n);
-          });
-          if (missing.length > 0) {
-            for (const spaceData of missing) {
-              try {
-                const space: Partial<Project> = {
-                  name: spaceData.name,
-                  type: this.inferSpaceType(spaceData.name),
-                  priority: 5,
-                  status: 'not_started',
-                  complexity: 'medium',
-                  estimatedBudget: this.calculateSpaceRate(spaceData),
-                  order: this.projectSpaces.length
-                };
-                await this.productSpaceService.createProductSpace(this.project!.id || '', space);
-              } catch (e) {
-                console.warn('⚠️ 同步创建缺失空间失败:', spaceData?.name, e);
-              }
-            }
-            // 重新加载补齐后的空间列表
-            this.projectSpaces = await this.productSpaceService.getProjectProductSpaces(this.project.id || '');
+      // ✅ 使用统一空间管理获取数据
+      const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(this.project.id || '');
+      
+      if (unifiedSpaces.length > 0) {
+        console.log(`✅ [订单分配] 从统一存储加载到 ${unifiedSpaces.length} 个空间`);
+        
+        // 转换为组件使用的格式
+        this.projectSpaces = unifiedSpaces.map(space => ({
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area,
+          priority: space.priority,
+          status: space.status,
+          complexity: space.complexity,
+          estimatedBudget: space.estimatedBudget,
+          order: space.order,
+          projectId: this.project!.id || '',
+          metadata: {},
+          quotation: space.quotation,
+          requirements: space.requirements,
+          designerId: space.designerId
+        }));
+      } else {
+        console.log('⚠️ [订单分配] 没有找到空间数据，尝试从旧数据迁移...');
+        
+        // 如果没有统一数据，尝试从Product表加载
+        this.projectSpaces = await this.productSpaceService.getProjectProductSpaces(this.project.id || '');
+        
+        // 如果Product表也没有，但有报价数据，则创建初始空间
+        if (this.projectSpaces.length === 0) {
+          const data = this.project.get('data') || {};
+          if (data.quotation?.spaces && data.quotation.spaces.length > 0) {
+            console.log('🔄 [订单分配] 从报价数据创建空间...');
+            await this.createSpacesFromQuotation(data.quotation.spaces);
+          } else {
+            // 创建默认初始空间（1-2个）
+            console.log('🏠 [订单分配] 创建初始空间...');
+            const projectType = this.projectInfo.projectType === '工装' ? '工装' : '家装';
+            const initialSpaces = await this.productSpaceService.createInitialSpaces(
+              this.project.id || '',
+              projectType
+            );
+            
+            // 转换为组件格式
+            this.projectSpaces = initialSpaces.map(space => ({
+              id: space.id,
+              name: space.name,
+              type: space.type,
+              area: space.area,
+              priority: space.priority,
+              status: space.status,
+              complexity: space.complexity,
+              estimatedBudget: space.estimatedBudget,
+              order: space.order,
+              projectId: this.project!.id || '',
+              metadata: {},
+              quotation: space.quotation,
+              requirements: space.requirements,
+              designerId: space.designerId
+            }));
           }
         }
       }
@@ -749,8 +769,10 @@ export class StageOrderComponent implements OnInit {
         this.activeSpaceId = this.projectSpaces[0].id;
       }
 
+      console.log(`✅ [订单分配] 空间加载完成，共 ${this.projectSpaces.length} 个空间`);
+
     } catch (error) {
-      console.error('加载项目空间失败:', error);
+      console.error('❌ [订单分配] 加载项目空间失败:', error);
     } finally {
       this.loadingSpaces = false;
       this.cdr.markForCheck();
@@ -789,7 +811,7 @@ export class StageOrderComponent implements OnInit {
   private inferSpaceType(spaceName: string): string {
     const lowerName = spaceName.toLowerCase();
     for (const [type, name] of Object.entries(this.spaceTypeMap)) {
-      if (typeof name == "string" && lowerName.includes(name)) {
+      if (typeof name === 'string' && lowerName.includes(name.toLowerCase())) {
         return type;
       }
     }
@@ -797,150 +819,100 @@ export class StageOrderComponent implements OnInit {
   }
 
   /**
-   * 计算空间预算
+   * 计算空间报价
    */
   private calculateSpaceRate(spaceData: any): number {
-    let total = 0;
-    for (const process of Object.values(spaceData.processes || {})) {
-      const proc = process as any;
-      if (proc.enabled) {
-        total += proc.price * proc.quantity;
-      }
-    }
-    return total;
-  }
-
-  /**
-   * 切换空间类型
-   */
-  onSpaceTypeChange() {
-    this.quotation.spaces = [];
-    this.quotation.total = 0;
-
-    if (this.projectInfo.projectType === '家装') {
-      this.homeScenes = {
-        spaceType: '',
-        styleLevel: '',
-        rooms: []
-      };
-      this.commercialScenes = { businessType: '', spaces: [] };
-    } else if (this.projectInfo.projectType === '工装') {
-      this.commercialScenes = {
-        businessType: '',
-        spaces: []
-      };
-      this.homeScenes = { spaceType: '', styleLevel: '', rooms: [] };
-    }
-  }
-
-  /**
-   * 项目空间模式改变（单空间/多空间）
-   */
-  async onProjectSpaceModeChange() {
-    this.isMultiSpaceProject = this.projectInfo.spaceType === 'multi';
-
-    if (!this.isMultiSpaceProject) {
-      // 单空间模式：重置为第一个空间
-      if (this.projectSpaces.length > 0) {
-        this.activeSpaceId = this.projectSpaces[0].id;
-      }
-      this.quotation.spaces = this.quotation.spaces.slice(0, 1);
-      this.calculateTotal();
-    } else {
-      // 多空间模式：恢复所有空间
-      await this.regenerateQuotationFromSpaces();
-    }
-  }
-
-  /**
-   * 添加新空间
-   */
-  async addSpace() {
-    const spaceName =await window?.fmode?.input('请输入空间名称:');
-    if (!spaceName) return;
-
-    try {
-      const spaceData: Partial<Project> = {
-        name: spaceName,
-        type: 'other',
-        priority: 5,
-        status: 'not_started',
-        complexity: 'medium',
-        order: this.projectSpaces.length
-      };
-
-      const createdSpace = await this.productSpaceService.createProductSpace(this.projectId!, spaceData);
-      this.projectSpaces.push(createdSpace);
-
-      // 如果是第一个空间，设置为当前空间
-      if (this.projectSpaces.length === 1) {
-        this.activeSpaceId = createdSpace.id;
-      }
-
-      // 重新生成报价
-      await this.regenerateQuotationFromSpaces();
-
-     window?.fmode?.alert('空间添加成功');
-    } catch (error) {
-      console.error('添加空间失败:', error);
-     window?.fmode?.alert('添加失败，请重试');
+    // 从报价数据中提取价格
+    if (spaceData.subtotal) {
+      return spaceData.subtotal;
     }
-  }
-
-  /**
-   * 编辑空间
-   */
-  async editSpace(spaceId: string) {
-    const space = this.projectSpaces.find(s => s.id === spaceId);
-    if (!space) return;
-
-    const newName =await window?.fmode?.input('修改空间名称:', space.name);
-    if (!newName || newName === space.name) return;
-
-    try {
-      await this.productSpaceService.updateProductSpace(spaceId, { name: newName });
-      space.name = newName;
-
-      // 更新报价中的空间名称
-      const quotationSpace = this.quotation.spaces.find(s => s.spaceId === spaceId);
-      if (quotationSpace) {
-        quotationSpace.name = newName;
+    
+    // 如果有processes，计算总价
+    if (spaceData.processes) {
+      let total = 0;
+      for (const processKey of Object.keys(spaceData.processes)) {
+        const process = spaceData.processes[processKey];
+        if (process.enabled && process.price) {
+          total += process.price * (process.quantity || 1);
+        }
       }
-
-      // 保存到项目数据
-      await this.saveDraft();
-
-     window?.fmode?.alert('空间更新成功');
-    } catch (error) {
-      console.error('更新空间失败:', error);
-     window?.fmode?.alert('更新失败，请重试');
+      return total;
     }
+    
+    // 默认返回0
+    return 0;
   }
 
   /**
-   * 删除空间
+   * 删除空间 - 使用统一空间管理
    */
   async deleteSpace(spaceId: string) {
     if (!await window?.fmode?.confirm('确定要删除这个空间吗？相关数据将被清除。')) return;
 
     try {
-      await this.productSpaceService.deleteProductSpace(spaceId);
-
+      console.log(`🗑️ [订单分配] 开始删除空间: ${spaceId}`);
+      
       // 从本地列表中移除
       this.projectSpaces = this.projectSpaces.filter(s => s.id !== spaceId);
+      
+      // 同时从报价数据中移除
+      this.quotation.spaces = this.quotation.spaces.filter((s: any) => s.spaceId !== spaceId);
+
+      // ✅ 保存到统一存储（这会自动同步到Product表和报价数据）
+      const unifiedSpaces = this.projectSpaces.map(space => {
+        // 从报价数据中查找对应的processes信息
+        const quotationSpace = this.quotation.spaces.find((q: any) => q.spaceId === space.id);
+        
+        return {
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area || 0,
+          priority: space.priority || 5,
+          status: space.status || 'not_started',
+          complexity: space.complexity || 'medium',
+          estimatedBudget: space.estimatedBudget || 0,
+          order: space.order || 0,
+          quotation: {
+            price: quotationSpace?.subtotal || space.estimatedBudget || 0,
+            processes: quotationSpace?.processes || {},
+            subtotal: quotationSpace?.subtotal || space.estimatedBudget || 0
+          },
+          requirements: space.requirements || {},
+          designerId: space.designerId || null,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        };
+      });
+      
+      await this.productSpaceService.saveUnifiedSpaceData(this.project!.id || '', unifiedSpaces);
+      console.log(`✅ [订单分配] 空间删除成功，剩余 ${unifiedSpaces.length} 个空间`);
+
+      // 🔥 关键：重新加载项目数据以获取最新的同步结果
+      const Parse = FmodeParse.with('nova');
+      const query = new Parse.Query('Project');
+      query.include('contact', 'assignee', 'department');
+      this.project = await query.get(this.project!.id);
+      
+      // 更新本地quotation数据
+      const data = this.project.get('data') || {};
+      if (data.quotation) {
+        this.quotation = data.quotation;
+      }
+      
+      console.log(`✅ [订单分配] 项目数据已刷新，报价空间数: ${this.quotation.spaces?.length || 0}`);
 
       // 如果删除的是当前空间，切换到第一个空间
       if (this.activeSpaceId === spaceId && this.projectSpaces.length > 0) {
         this.activeSpaceId = this.projectSpaces[0].id;
       }
 
-      // 重新生成报价
-      await this.regenerateQuotationFromSpaces();
-
-     window?.fmode?.alert('空间删除成功');
+      window?.fmode?.alert('空间删除成功');
+      this.cdr.markForCheck();
     } catch (error) {
-      console.error('删除空间失败:', error);
-     window?.fmode?.alert('删除失败，请重试');
+      console.error('❌ [订单分配] 删除空间失败:', error);
+      window?.fmode?.alert('删除失败，请重试');
     }
   }
 

src/modules/project/pages/project-detail/stages/stage-requirements.component.ts

@@ -323,12 +323,40 @@ export class StageRequirementsComponent implements OnInit {
         currentStage: this.project.get?.('currentStage')
       });
 
-      // 从项目ID加载Product数据
-      if (this.projectId) {
-        this.projectProducts = await this.productSpaceService.getProjectProductSpaces(this.projectId);
-      } else if (this.project) {
-        // 如果有project对象，使用其ID
-        this.projectProducts = await this.productSpaceService.getProjectProductSpaces(this.project.id);
+      // ✅ 使用统一空间管理加载Product数据
+      const projectId = this.projectId || this.project?.id || '';
+      if (projectId) {
+        console.log('🔄 [需求确认] 开始加载项目空间...');
+        
+        // 从统一存储获取空间数据
+        const unifiedSpaces = await this.productSpaceService.getUnifiedSpaceData(projectId);
+        
+        if (unifiedSpaces.length > 0) {
+          console.log(`✅ [需求确认] 从统一存储加载到 ${unifiedSpaces.length} 个空间`);
+          
+          // 转换为组件使用的格式
+          this.projectProducts = unifiedSpaces.map(space => ({
+            id: space.id,
+            name: space.name,
+            type: space.type,
+            area: space.area,
+            priority: space.priority,
+            status: space.status,
+            complexity: space.complexity,
+            estimatedBudget: space.estimatedBudget,
+            order: space.order,
+            projectId: projectId,
+            metadata: {},
+            quotation: space.quotation,
+            requirements: space.requirements,
+            designerId: space.designerId
+          }));
+        } else {
+          console.log('⚠️ [需求确认] 没有找到统一空间数据，尝试从Product表加载...');
+          this.projectProducts = await this.productSpaceService.getProjectProductSpaces(projectId);
+        }
+        
+        console.log(`✅ [需求确认] 空间加载完成，共 ${this.projectProducts.length} 个空间`);
       }
 
       // 防御性去重：避免同名空间重复展示

src/modules/project/services/product-space.service.ts

@@ -501,4 +501,395 @@ export class ProductSpaceService {
       reviews: product.get('reviews')
     };
   }
+
+  /**
+   * 统一空间数据管理 - 核心方法
+   * 将所有空间数据统一存储到Project.data.unifiedSpaces中
+   */
+  async saveUnifiedSpaceData(projectId: string, spaces: any[]): Promise<void> {
+    try {
+      console.log(`🔄 [统一空间管理] 开始保存统一空间数据，项目ID: ${projectId}, 空间数: ${spaces.length}`);
+      
+      const projectQuery = new Parse.Query('Project');
+      const project = await projectQuery.get(projectId);
+      
+      const data = project.get('data') || {};
+      
+      // 统一空间数据结构
+      data.unifiedSpaces = spaces.map((space, index) => ({
+        id: space.id || `space_${Date.now()}_${index}`,
+        name: space.name || `空间${index + 1}`,
+        type: space.type || 'other',
+        area: space.area || 0,
+        priority: space.priority || 5,
+        status: space.status || 'not_started',
+        complexity: space.complexity || 'medium',
+        estimatedBudget: space.estimatedBudget || 0,
+        order: space.order !== undefined ? space.order : index,
+        // 报价信息
+        quotation: {
+          price: space.estimatedBudget || 0,
+          processes: space.processes || {},
+          subtotal: space.subtotal || 0
+        },
+        // 需求信息
+        requirements: space.requirements || {},
+        // 设计师分配
+        designerId: space.designerId || null,
+        // 进度信息
+        progress: space.progress || [],
+        // 创建和更新时间
+        createdAt: space.createdAt || new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }));
+      
+      // 同时保存到quotation.spaces以保持向后兼容
+      if (!data.quotation) data.quotation = {};
+      data.quotation.spaces = data.unifiedSpaces.map(space => ({
+        name: space.name,
+        spaceId: space.id,
+        processes: space.quotation.processes,
+        subtotal: space.quotation.subtotal
+      }));
+      
+      project.set('data', data);
+      await project.save();
+    
+    // 同步到Product表
+    await this.syncUnifiedSpacesToProducts(projectId, data.unifiedSpaces);
+    
+    console.log(`✅ [统一空间管理] 统一空间数据保存完成`);
+  } catch (error) {
+    console.error('❌ [统一空间管理] 保存统一空间数据失败:', error);
+    throw error;
+  }
+  }
+
+  /**
+   * 获取统一空间数据
+   */
+  async getUnifiedSpaceData(projectId: string): Promise<any[]> {
+    try {
+      const projectQuery = new Parse.Query('Project');
+      const project = await projectQuery.get(projectId);
+      
+      const data = project.get('data') || {};
+      
+      // 优先返回统一空间数据
+      if (data.unifiedSpaces && data.unifiedSpaces.length > 0) {
+        console.log(`✅ [统一空间管理] 从unifiedSpaces获取到 ${data.unifiedSpaces.length} 个空间`);
+        return data.unifiedSpaces;
+      }
+      
+      // 如果没有统一数据，尝试从Product表迁移
+      const productSpaces = await this.getProjectProductSpaces(projectId);
+      if (productSpaces.length > 0) {
+        console.log(`🔄 [统一空间管理] 从Product表迁移 ${productSpaces.length} 个空间到统一存储`);
+        const unifiedSpaces = productSpaces.map((space, index) => ({
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area,
+          priority: space.priority,
+          status: space.status,
+          complexity: space.complexity,
+          estimatedBudget: space.estimatedBudget,
+          order: index,
+          quotation: {
+            price: space.estimatedBudget || 0,
+            processes: {},
+            subtotal: space.estimatedBudget || 0
+          },
+          requirements: space.requirements || {},
+          designerId: space.designerId,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        }));
+        
+        // 保存迁移后的数据
+        await this.saveUnifiedSpaceData(projectId, unifiedSpaces);
+        return unifiedSpaces;
+      }
+      
+      // 如果都没有，返回空数组
+      console.log(`⚠️ [统一空间管理] 项目 ${projectId} 没有找到任何空间数据`);
+      return [];
+    } catch (error) {
+      console.error('❌ [统一空间管理] 获取统一空间数据失败:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 将统一空间数据同步到Product表
+   */
+  private async syncUnifiedSpacesToProducts(projectId: string, unifiedSpaces: any[]): Promise<void> {
+    try {
+      console.log(`🔄 [统一空间管理] 开始同步统一空间到Product表`);
+      
+      // 获取现有的Product列表
+      const existingProducts = await this.getProjectProductSpaces(projectId);
+      const existingById = new Map(existingProducts.map(p => [p.id, p]));
+      
+      for (const space of unifiedSpaces) {
+        const existingProduct = existingById.get(space.id);
+        
+        if (existingProduct) {
+          // 更新现有Product
+          await this.updateProductSpace(space.id, {
+            name: space.name,
+            type: space.type,
+            area: space.area,
+            priority: space.priority,
+            status: space.status,
+            complexity: space.complexity,
+            estimatedBudget: space.quotation.price,
+            requirements: space.requirements,
+            designerId: space.designerId
+          });
+        } else {
+          // 创建新Product
+          await this.createProductSpace(projectId, {
+            name: space.name,
+            type: space.type,
+            area: space.area,
+            priority: space.priority,
+            status: space.status,
+            complexity: space.complexity,
+            estimatedBudget: space.quotation.price,
+            requirements: space.requirements,
+            designerId: space.designerId,
+            order: space.order
+          });
+        }
+      }
+      
+      console.log(`✅ [统一空间管理] 统一空间同步到Product表完成`);
+    } catch (error) {
+      console.error('❌ [统一空间管理] 同步统一空间到Product表失败:', error);
+    }
+  }
+
+  /**
+   * 创建初始空间（只创建1-2个默认空间）
+   */
+  async createInitialSpaces(projectId: string, projectType: '家装' | '工装' = '家装'): Promise<any[]> {
+    try {
+    console.log(`🏠 [初始空间] 为项目 ${projectId} 创建初始空间，类型: ${projectType}`);
+    
+    let initialSpaces: any[] = [];
+    
+    if (projectType === '家装') {
+      // 家装项目：只创建客厅和主卧两个空间
+      initialSpaces = [
+        {
+          id: `space_${Date.now()}_1`,
+          name: '客厅',
+          type: 'living_room',
+          area: 0,
+          priority: 5,
+          status: 'not_started',
+          complexity: 'medium',
+          estimatedBudget: 300,
+          order: 0,
+          quotation: {
+            price: 300,
+            processes: {
+              modeling: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              softDecor: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              rendering: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              postProcess: { enabled: false, price: 0, unit: '张', quantity: 1 }
+            },
+            subtotal: 300
+          },
+          requirements: {},
+          designerId: null,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        },
+        {
+          id: `space_${Date.now()}_2`,
+          name: '主卧',
+          type: 'bedroom',
+          area: 0,
+          priority: 5,
+          status: 'not_started',
+          complexity: 'medium',
+          estimatedBudget: 300,
+          order: 1,
+          quotation: {
+            price: 300,
+            processes: {
+              modeling: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              softDecor: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              rendering: { enabled: true, price: 100, unit: '张', quantity: 1 },
+              postProcess: { enabled: false, price: 0, unit: '张', quantity: 1 }
+            },
+            subtotal: 300
+          },
+          requirements: {},
+          designerId: null,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        }
+      ];
+    } else {
+      // 工装项目：只创建一个主要空间
+      initialSpaces = [
+        {
+          id: `space_${Date.now()}_1`,
+          name: '主要空间',
+          type: 'other',
+          area: 0,
+          priority: 5,
+          status: 'not_started',
+          complexity: 'medium',
+          estimatedBudget: 500,
+          order: 0,
+          quotation: {
+            price: 500,
+            processes: {
+              modeling: { enabled: true, price: 150, unit: '张', quantity: 1 },
+              softDecor: { enabled: true, price: 150, unit: '张', quantity: 1 },
+              rendering: { enabled: true, price: 150, unit: '张', quantity: 1 },
+              postProcess: { enabled: true, price: 50, unit: '张', quantity: 1 }
+            },
+            subtotal: 500
+          },
+          requirements: {},
+          designerId: null,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        }
+      ];
+    }
+    
+    // 保存到统一存储
+    await this.saveUnifiedSpaceData(projectId, initialSpaces);
+    
+    console.log(`✅ [初始空间] 已创建 ${initialSpaces.length} 个初始空间`);
+    return initialSpaces;
+    } catch (error) {
+      console.error('❌ [初始空间] 创建初始空间失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 数据修复：强制同步当前项目的空间数据到统一存储
+   */
+  async forceRepairSpaceData(projectId: string): Promise<void> {
+    try {
+      console.log(`🔧 [数据修复] 开始修复项目 ${projectId} 的空间数据...`);
+      
+      // 1. 获取项目数据
+      const projectQuery = new Parse.Query('Project');
+      const project = await projectQuery.get(projectId);
+      const data = project.get('data') || {};
+      
+      // 2. 获取Product表中的空间数据
+      const productSpaces = await this.getProjectProductSpaces(projectId);
+      console.log(`🔧 [数据修复] Product表中有 ${productSpaces.length} 个空间`);
+      
+      // 3. 获取报价数据中的空间
+      const quotationSpaces = Array.isArray(data.quotation?.spaces) ? data.quotation.spaces : [];
+      console.log(`🔧 [数据修复] 报价数据中有 ${quotationSpaces.length} 个空间`);
+      
+      // 4. 以Product表为准，构建统一空间数据
+      const unifiedSpaces = productSpaces.map((space, index) => {
+        // 尝试从报价数据中找到对应的空间信息
+        const quotationSpace = quotationSpaces.find((q: any) => 
+          q.spaceId === space.id || 
+          (q.name && space.name && q.name.trim().toLowerCase() === space.name.trim().toLowerCase())
+        );
+        
+        return {
+          id: space.id,
+          name: space.name,
+          type: space.type,
+          area: space.area || 0,
+          priority: space.priority || 5,
+          status: space.status || 'not_started',
+          complexity: space.complexity || 'medium',
+          estimatedBudget: space.estimatedBudget || 0,
+          order: index,
+          quotation: {
+            price: space.estimatedBudget || 0,
+            processes: quotationSpace?.processes || {},
+            subtotal: quotationSpace?.subtotal || space.estimatedBudget || 0
+          },
+          requirements: space.requirements || {},
+          designerId: space.designerId || null,
+          progress: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        };
+      });
+      
+      // 5. 保存到统一存储
+      await this.saveUnifiedSpaceData(projectId, unifiedSpaces);
+      
+      console.log(`✅ [数据修复] 项目 ${projectId} 空间数据修复完成，共 ${unifiedSpaces.length} 个空间`);
+      console.log(`🔧 [数据修复] 修复的空间:`, unifiedSpaces.map(s => s.name));
+      
+    } catch (error) {
+      console.error('❌ [数据修复] 修复空间数据失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 调试方法：检查项目的空间数据存储情况
+   */
+  async debugProjectSpaceData(projectId: string): Promise<void> {
+    try {
+      console.log(`🔍 [调试] 检查项目 ${projectId} 的空间数据存储情况...`);
+      
+      // 1. 检查Project.data.unifiedSpaces
+      const projectQuery = new Parse.Query('Project');
+      const project = await projectQuery.get(projectId);
+      const data = project.get('data') || {};
+      
+      console.log(`📊 [调试] Project.data.unifiedSpaces:`, data.unifiedSpaces?.length || 0, '个空间');
+      if (data.unifiedSpaces && data.unifiedSpaces.length > 0) {
+        console.log(`   - 统一空间列表:`, data.unifiedSpaces.map((s: any) => s.name));
+      }
+      
+      // 2. 检查Project.data.quotation.spaces
+      console.log(`📊 [调试] Project.data.quotation.spaces:`, data.quotation?.spaces?.length || 0, '个空间');
+      if (data.quotation?.spaces && data.quotation.spaces.length > 0) {
+        console.log(`   - 报价空间列表:`, data.quotation.spaces.map((s: any) => s.name));
+      }
+      
+      // 3. 检查Product表
+      const productSpaces = await this.getProjectProductSpaces(projectId);
+      console.log(`📊 [调试] Product表:`, productSpaces.length, '个空间');
+      if (productSpaces.length > 0) {
+        console.log(`   - Product空间列表:`, productSpaces.map(s => s.name));
+      }
+      
+      // 4. 数据一致性检查
+      const unifiedCount = data.unifiedSpaces?.length || 0;
+      const quotationCount = data.quotation?.spaces?.length || 0;
+      const productCount = productSpaces.length;
+      
+      console.log(`🔍 [调试] 数据一致性检查:`);
+      console.log(`   - 统一存储: ${unifiedCount} 个`);
+      console.log(`   - 报价数据: ${quotationCount} 个`);
+      console.log(`   - Product表: ${productCount} 个`);
+      
+      if (unifiedCount === quotationCount && quotationCount === productCount) {
+        console.log(`✅ [调试] 数据一致性检查通过`);
+      } else {
+        console.log(`❌ [调试] 数据不一致，需要修复`);
+      }
+      
+    } catch (error) {
+      console.error('❌ [调试] 检查项目空间数据失败:', error);
+    }
+  }
 }