内容管理模块

interface ContentListParams {
  page: number
  pageSize: number
  status?: 'draft' | 'pending' | 'published' | 'archived'
  categoryId?: string
  keyword?: string
  sortBy?: 'createdAt' | 'updatedAt' | 'publishedAt'
  sortOrder?: 'asc' | 'desc'
}
 
interface ContentListResponse {
  items: ContentItem[]
  total: number
  page: number
  pageSize: number
  totalPages: number
}

interface ModerationRule {
  id: string
  name: string
  type: 'keyword' | 'regex' | 'length' | 'format' | 'ai_model'
  config: Record<string, unknown>
  action: 'reject' | 'flag' | 'approve'
  priority: number
}
 
async function applyRules(content: string, rules: ModerationRule[]): Promise<ModerationResult> {
  const sortedRules = rules.sort((a, b) => b.priority - a.priority)
 
  for (const rule of sortedRules) {
    const result = await executeRule(content, rule)
    if (result.action === 'reject') {
      return { status: 'rejected', reason: rule.name, details: result.details }
    }
    if (result.action === 'flag') {
      return { status: 'flagged', reason: rule.name, details: result.details }
    }
  }
 
  return { status: 'approved', reason: null, details: null }
}

// 树形分类
interface Category {
  id: string
  parentId: string | null
  name: string
  slug: string
  description?: string
  sortOrder: number
  level: number
  path: string // 例如 "/tech/frontend/react"
  contentCount: number
}
 
// 标签
interface Tag {
  id: string
  name: string
  slug: string
  usageCount: number
}
 
// 内容与分类/标签的关联
interface ContentTaxonomy {
  contentId: string
  categoryId: string
  tagIds: string[]
}

-- 查询 /tech 分类下所有内容（包括子分类）
SELECT c.* FROM content c
JOIN content_taxonomy ct ON c.id = ct.content_id
JOIN category cat ON ct.category_id = cat.id
WHERE cat.path LIKE '/tech/%'

interface MultilingualCategory {
  id: string
  slug: string
  name: { en: string; zh: string; ja: string }
  description: { en: string; zh: string; ja: string }
}

interface CategoryTranslation {
  categoryId: string
  locale: string
  name: string
  slug: string
  description?: string
}

interface SeoMetadata {
  title: string
  description: string
  slug: string
  canonicalUrl?: string
  robots: 'index' | 'noindex' | 'nofollow'
  ogTitle?: string
  ogDescription?: string
  ogImage?: string
  twitterCard?: 'summary' | 'summary_large_image'
  structuredData?: Record<string, unknown> // JSON-LD
}

function generateArticleJsonLd(content: ContentItem): Record<string, unknown> {
  return {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: content.seo.title,
    description: content.seo.description,
    image: content.seo.ogImage,
    datePublished: content.publishedAt,
    dateModified: content.updatedAt,
    author: {
      '@type': 'Person',
      name: content.author.name,
    },
    publisher: {
      '@type': 'Organization',
      name: 'Your Brand',
      logo: {
        '@type': 'ImageObject',
        url: 'https://yourbrand.com/logo.png',
      },
    },
  }
}

// 数据库 Schema（Prisma 风格）
model Content {
  id            String    @id @default(cuid())
  title         String
  slug          String    @unique
  body          String
  status        ContentStatus @default(DRAFT)
  categoryId    String?
  authorId      String
  publishedAt   DateTime?
  createdAt     DateTime  @default(now())
  updatedAt     DateTime  @updatedAt
 
  category      Category? @relation(fields: [categoryId], references: [id])
  author        User      @relation(fields: [authorId], references: [id])
  tags          ContentTag[]
  seo           ContentSeo?
  auditLogs     ContentAuditLog[]
  moderationLogs ContentModerationLog[]
}
 
model ContentSeo {
  id              String  @id @default(cuid())
  contentId       String  @unique
  metaTitle       String?
  metaDescription String?
  canonicalUrl    String?
  robots          String  @default("index")
  ogImage         String?
  structuredData  Json?
 
  content         Content @relation(fields: [contentId], references: [id])
}
 
model ContentAuditLog {
  id          String   @id @default(cuid())
  contentId   String
  action      String   // "created" | "updated" | "status_changed" | "published"
  fromStatus  String?
  toStatus    String?
  operatorId  String
  comment     String?
  createdAt   DateTime @default(now())
 
  content     Content  @relation(fields: [contentId], references: [id])
}
 
enum ContentStatus {
  DRAFT
  PENDING_REVIEW
  APPROVED
  REJECTED
  PUBLISHED
  ARCHIVED
}

class ContentService {
  async createContent(input: CreateContentInput, operatorId: string): Promise<Content> {
    // 自动生成 slug
    const slug = generateSlug(input.title)
 
    // 检查 slug 唯一性
    const existing = await this.db.content.findUnique({ where: { slug } })
    if (existing) {
      throw new SlugConflictError(slug)
    }
 
    const content = await this.db.content.create({
      data: {
        title: input.title,
        slug,
        body: input.body,
        status: 'DRAFT',
        categoryId: input.categoryId,
        authorId: operatorId,
      },
    })
 
    // 记录审计日志
    await this.logAudit(content.id, 'created', operatorId)
 
    return content
  }
 
  async submitForReview(contentId: string, operatorId: string): Promise<Content> {
    const content = await this.getContentOrThrow(contentId)
 
    if (content.status !== 'DRAFT' && content.status !== 'REJECTED') {
      throw new InvalidStatusTransitionError(content.status, 'PENDING_REVIEW')
    }
 
    const updated = await this.db.content.update({
      where: { id: contentId },
      data: { status: 'PENDING_REVIEW' },
    })
 
    await this.logAudit(contentId, 'status_changed', operatorId, {
      from: content.status,
      to: 'PENDING_REVIEW',
    })
 
    // 触发审核通知
    await this.notifyReviewers(contentId)
 
    return updated
  }
 
  async approveContent(contentId: string, reviewerId: string, comment?: string): Promise<Content> {
    const content = await this.getContentOrThrow(contentId)
 
    if (content.status !== 'PENDING_REVIEW') {
      throw new InvalidStatusTransitionError(content.status, 'APPROVED')
    }
 
    const updated = await this.db.content.update({
      where: { id: contentId },
      data: {
        status: 'APPROVED',
      },
    })
 
    await this.logAudit(contentId, 'status_changed', reviewerId, {
      from: 'PENDING_REVIEW',
      to: 'APPROVED',
      comment,
    })
 
    return updated
  }
 
  async publishContent(contentId: string, operatorId: string): Promise<Content> {
    const content = await this.getContentOrThrow(contentId)
 
    if (content.status !== 'APPROVED') {
      throw new InvalidStatusTransitionError(content.status, 'PUBLISHED')
    }
 
    const updated = await this.db.content.update({
      where: { id: contentId },
      data: {
        status: 'PUBLISHED',
        publishedAt: new Date(),
      },
    })
 
    // 更新 sitemap
    await this.sitemapService.updateEntry(content.slug, updated.publishedAt!)
 
    // 触发 CDN 缓存刷新
    await this.cdnService.purgeCache(content.slug)
 
    await this.logAudit(contentId, 'published', operatorId)
 
    return updated
  }
 
  private async logAudit(
    contentId: string,
    action: string,
    operatorId: string,
    details?: { from?: string; to?: string; comment?: string }
  ): Promise<void> {
    await this.db.contentAuditLog.create({
      data: {
        contentId,
        action,
        fromStatus: details?.from ?? null,
        toStatus: details?.to ?? null,
        operatorId,
        comment: details?.comment ?? null,
      },
    })
  }
}

class ModerationService {
  async moderate(content: Content): Promise<ModerationResult> {
    // 第一层：规则引擎
    const ruleResult = await this.ruleEngine.evaluate(content)
    if (ruleResult.action === 'reject') {
      return { status: 'rejected', source: 'rule_engine', reason: ruleResult.reason }
    }
    if (ruleResult.action === 'flag') {
      return { status: 'flagged', source: 'rule_engine', reason: ruleResult.reason }
    }
 
    // 第二层：AI 模型审核
    const aiResult = await this.aiModerator.evaluate(content)
    if (aiResult.confidence > 0.95 && aiResult.verdict === 'safe') {
      return { status: 'auto_approved', source: 'ai_model' }
    }
    if (aiResult.confidence > 0.95 && aiResult.verdict === 'unsafe') {
      return {
        status: 'auto_rejected',
        source: 'ai_model',
        reason: aiResult.categories.join(', '),
      }
    }
 
    // 第三层：转人工审核
    return {
      status: 'needs_human_review',
      source: 'ai_model',
      confidence: aiResult.confidence,
    }
  }
}