辣评用户手册系统的实现（十一）

// Manual 用户手册模型
type Manual struct {
    ID              uint      `gorm:"primaryKey"`
    Title           string    `gorm:"index"`
    Description     string    `gorm:"type:text"`
    Content         string    `gorm:"type:longtext"`
    Version         int       // 版本号
    IsPublished     bool      // 是否已发布
    PublishedAt     *time.Time
    CreatedBy       uint      // 创建者
    UpdatedBy       uint      // 更新者
    CreatedAt       time.Time
    UpdatedAt       time.Time
    DeletedAt       gorm.DeletedAt `gorm:"index"`
}

// ManualChapter 手册章节模型
type ManualChapter struct {
    ID              uint      `gorm:"primaryKey"`
    ManualID        uint      `gorm:"index"`
    Title           string
    Content         string    `gorm:"type:longtext"`
    Order           int       // 章节顺序
    Level           int       // 层级（1-3）
    ParentID        *uint     // 父章节ID
    IsVisible       bool      // 是否可见
    CreatedAt       time.Time
    UpdatedAt       time.Time
    
    // 关联
    Manual          *Manual
    Children        []ManualChapter `gorm:"foreignKey:ParentID"`
}

// ManualVersion 手册版本历史
type ManualVersion struct {
    ID              uint
    ManualID        uint
    VersionNumber   int
    Content         string    `gorm:"type:longtext"`
    ChangeSummary   string
    CreatedBy       uint
    CreatedAt       time.Time
}

// GetManualChapters 获取手册章节树
func (s *ManualService) GetManualChapters(ctx context.Context, manualID uint) ([]ManualChapter, error) {
    var chapters []ManualChapter
    
    // 获取所有章节
    if err := s.db.Where("manual_id = ? AND is_visible = ?", manualID, true).
        Order("order ASC").
        Find(&chapters).Error; err != nil {
        return nil, err
    }
    
    // 构建树结构
    return s.buildChapterTree(chapters), nil
}

// buildChapterTree 构建章节树
func (s *ManualService) buildChapterTree(chapters []ManualChapter) []ManualChapter {
    // 创建 map 用于快速查找
    chapterMap := make(map[uint]*ManualChapter)
    for i := range chapters {
        chapterMap[chapters[i].ID] = &chapters[i]
    }
    
    // 构建树结构
    var roots []ManualChapter
    for _, chapter := range chapters {
        if chapter.ParentID == nil {
            roots = append(roots, chapter)
        } else if parent, ok := chapterMap[*chapter.ParentID]; ok {
            parent.Children = append(parent.Children, chapter)
        }
    }
    
    return roots
}

// GetChapterByID 获取章节详情
func (s *ManualService) GetChapterByID(ctx context.Context, chapterID uint) (*ManualChapter, error) {
    chapter := &ManualChapter{}
    
    if err := s.db.Preload("Children").
        First(chapter, chapterID).Error; err != nil {
        return nil, err
    }
    
    return chapter, nil
}

// PublishManual 发布手册
func (s *ManualService) PublishManual(ctx context.Context, manualID uint) error {
    // 1. 验证手册内容完整性
    manual := &Manual{}
    if err := s.db.First(manual, manualID).Error; err != nil {
        return err
    }
    
    if manual.Title == "" || manual.Content == "" {
        return errors.New("手册内容不完整")
    }
    
    // 2. 验证所有章节
    var chapters []ManualChapter
    if err := s.db.Where("manual_id = ?", manualID).Find(&chapters).Error; err != nil {
        return err
    }
    
    for _, chapter := range chapters {
        if chapter.Title == "" || chapter.Content == "" {
            return fmt.Errorf("章节 %s 内容不完整", chapter.Title)
        }
    }
    
    // 3. 创建版本记录
    version := &ManualVersion{
        ManualID:      manualID,
        VersionNumber: manual.Version + 1,
        Content:       manual.Content,
        ChangeSummary: "发布版本",
        CreatedBy:     getUserID(ctx),
    }
    
    if err := s.db.Create(version).Error; err != nil {
        return err
    }
    
    // 4. 更新手册状态
    now := time.Now()
    return s.db.Model(manual).Updates(map[string]interface{}{
        "is_published": true,
        "published_at": now,
        "version":      manual.Version + 1,
    }).Error
}

// GetManualVersions 获取手册版本历史
func (s *ManualService) GetManualVersions(ctx context.Context, manualID uint) ([]ManualVersion, error) {
    var versions []ManualVersion
    
    if err := s.db.Where("manual_id = ?", manualID).
        Order("version_number DESC").
        Find(&versions).Error; err != nil {
        return nil, err
    }
    
    return versions, nil
}

// RestoreManualVersion 恢复手册版本
func (s *ManualService) RestoreManualVersion(ctx context.Context, versionID uint) error {
    version := &ManualVersion{}
    if err := s.db.First(version, versionID).Error; err != nil {
        return err
    }
    
    manual := &Manual{}
    if err := s.db.First(manual, version.ManualID).Error; err != nil {
        return err
    }
    
    // 更新手册内容
    return s.db.Model(manual).Updates(map[string]interface{}{
        "content": version.Content,
        "version": version.VersionNumber,
    }).Error
}