docs: 收藏功能真实 API 化实施计划

2026-07-19 22:25:39 +08:00
parent bebb7f1667
commit a3bfad099a
1 changed files with 939 additions and 0 deletions
@@ -0,0 +1,939 @@
 ---
 author: AI Assistant
 created_at: 2026-07-19
 purpose: 小程序收藏功能真实 API 化实施计划
 ---
 # 收藏功能真实 API 化实施计划
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** 前端收藏功能从 localStorage 切换到真实 API。剧本收藏沿用现有后端 API，人生事件收藏新建独立表和 API。
 **Architecture:** 剧本收藏后端已完整（`t_script_favorite` 表 + `ScriptFavoriteService`），前端 `ScriptLibraryView.vue` 未对接。人生事件收藏仿照剧本，新建 `t_event_favorite` 表 + `EventFavoriteService` + Controller，删除假接口 `/lifeEvent/favorite-placeholder`。前端所有 localStorage 收藏逻辑切换到 API。
 **Tech Stack:** Spring Boot 2.7.18 + MyBatis-Plus 3.5.3.1 + UniApp Vue 3 + Pinia + Element Plus + rpx
 ---
 ### Task 1: 后端人生事件收藏功能（Entity + Mapper + Service + Controller）
 **Files:**
 - Create: `server/src/main/resources/db/migration/V20260719000002__create_event_favorite.sql`
 - Create: `server/src/main/java/com/emotion/entity/EventFavorite.java`
 - Create: `server/src/main/java/com/emotion/mapper/EventFavoriteMapper.java`
 - Create: `server/src/main/java/com/emotion/dto/request/EventFavoriteToggleRequest.java`
 - Create: `server/src/main/java/com/emotion/dto/response/EventFavoriteResponse.java`
 - Create: `server/src/main/java/com/emotion/service/EventFavoriteService.java`
 - Create: `server/src/main/java/com/emotion/service/impl/EventFavoriteServiceImpl.java`
 - Modify: `server/src/main/java/com/emotion/controller/LifeEventController.java`
 - [ ] **Step 1: 创建数据库迁移 SQL**
 ```sql
 -- server/src/main/resources/db/migration/V20260719000002__create_event_favorite.sql
 CREATE TABLE t_event_favorite (
  id VARCHAR(64) PRIMARY KEY,
  user_id VARCHAR(64) NOT NULL COMMENT '用户ID',
  event_id VARCHAR(64) NOT NULL COMMENT '事件ID',
  create_by VARCHAR(64) COMMENT '创建人',
  create_time DATETIME COMMENT '创建时间',
  update_by VARCHAR(64) COMMENT '更新人',
  update_time DATETIME COMMENT '更新时间',
  is_deleted TINYINT(1) DEFAULT 0 COMMENT '是否删除：0-否 1-是',
  remarks VARCHAR(500) COMMENT '备注',
  INDEX idx_user_event (user_id, event_id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='人生事件收藏关联表';
 ```
 - [ ] **Step 2: 创建 EventFavorite 实体类**
 ```java
 // server/src/main/java/com/emotion/entity/EventFavorite.java
 package com.emotion.entity;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.emotion.common.BaseEntity;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 /**
 * 人生事件收藏关联实体
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
@Data
@EqualsAndHashCode(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@TableName("t_event_favorite")
 public class EventFavorite extends BaseEntity {
    @TableField("user_id")
    private String userId;
    @TableField("event_id")
    private String eventId;
 }
 ```
 - [ ] **Step 3: 创建 EventFavoriteMapper**
 ```java
 // server/src/main/java/com/emotion/mapper/EventFavoriteMapper.java
 package com.emotion.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.emotion.entity.EventFavorite;
 import org.apache.ibatis.annotations.Mapper;
 /**
 * 人生事件收藏 Mapper
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
@Mapper
 public interface EventFavoriteMapper extends BaseMapper<EventFavorite> {
 }
 ```
 - [ ] **Step 4: 创建 EventFavoriteToggleRequest DTO**
 ```java
 // server/src/main/java/com/emotion/dto/request/EventFavoriteToggleRequest.java
 package com.emotion.dto.request;
 import lombok.Data;
 import javax.validation.constraints.NotBlank;
 /**
 * 人生事件收藏切换请求
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
@Data
 public class EventFavoriteToggleRequest {
    @NotBlank(message = "事件ID不能为空")
    private String eventId;
 }
 ```
 - [ ] **Step 5: 创建 EventFavoriteResponse DTO**
 ```java
 // server/src/main/java/com/emotion/dto/response/EventFavoriteResponse.java
 package com.emotion.dto.response;
 import lombok.Data;
 /**
 * 人生事件收藏状态响应
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
@Data
 public class EventFavoriteResponse {
    private String eventId;
    private Boolean isFavorited;
    private String favoriteTime;
 }
 ```
 - [ ] **Step 6: 创建 EventFavoriteService 接口**
 ```java
 // server/src/main/java/com/emotion/service/EventFavoriteService.java
 package com.emotion.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.emotion.common.PageResult;
 import com.emotion.dto.response.EventFavoriteResponse;
 import com.emotion.dto.response.LifeEventResponse;
 import com.emotion.entity.EventFavorite;
 import java.util.Set;
 /**
 * 人生事件收藏服务接口
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
 public interface EventFavoriteService extends IService<EventFavorite> {
    EventFavoriteResponse toggleFavorite(String eventId);
    PageResult<LifeEventResponse> getFavoritePage(long current, long size);
    Set<String> getFavoritedEventIds(Set<String> eventIds);
    boolean isFavorited(String eventId);
    long getFavoriteCount();
 }
 ```
 - [ ] **Step 7: 创建 EventFavoriteServiceImpl 实现**
 ```java
 // server/src/main/java/com/emotion/service/impl/EventFavoriteServiceImpl.java
 package com.emotion.service.impl;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.emotion.common.PageResult;
 import com.emotion.dto.response.EventFavoriteResponse;
 import com.emotion.dto.response.LifeEventResponse;
 import com.emotion.entity.EventFavorite;
 import com.emotion.mapper.EventFavoriteMapper;
 import com.emotion.service.EventFavoriteService;
 import com.emotion.service.LifeEventService;
 import com.emotion.util.UserContextHolder;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
 /**
 * 人生事件收藏服务实现
 *
 * @author AI Assistant
 * @date 2026-07-19
 */
@Slf4j
@Service
 public class EventFavoriteServiceImpl extends ServiceImpl<EventFavoriteMapper, EventFavorite>
        implements EventFavoriteService {
    private static final DateTimeFormatter FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    @Autowired
    private LifeEventService lifeEventService;
    @Override
    @Transactional(rollbackFor = Exception.class)
    public EventFavoriteResponse toggleFavorite(String eventId) {
        String userId = UserContextHolder.getCurrentUserId();
        EventFavoriteResponse r = new EventFavoriteResponse();
        r.setEventId(eventId);
        if (!StringUtils.hasText(userId)) {
            r.setIsFavorited(false);
            return r;
        }
        LambdaQueryWrapper<EventFavorite> w = new LambdaQueryWrapper<>();
        w.eq(EventFavorite::getUserId, userId)
         .eq(EventFavorite::getEventId, eventId)
         .eq(EventFavorite::getIsDeleted, 0);
        EventFavorite existing = this.getOne(w);
        if (existing != null) {
            this.removeById(existing.getId());
            r.setIsFavorited(false);
        } else {
            EventFavorite fav = new EventFavorite();
            fav.setUserId(userId);
            fav.setEventId(eventId);
            this.save(fav);
            r.setIsFavorited(true);
            if (fav.getCreateTime() != null) {
                r.setFavoriteTime(fav.getCreateTime().format(FMT));
            }
        }
        return r;
    }
    @Override
    public PageResult<LifeEventResponse> getFavoritePage(long current, long size) {
        String userId = UserContextHolder.getCurrentUserId();
        if (!StringUtils.hasText(userId)) {
            return new PageResult<>();
        }
        LambdaQueryWrapper<EventFavorite> w = new LambdaQueryWrapper<>();
        w.eq(EventFavorite::getUserId, userId)
         .eq(EventFavorite::getIsDeleted, 0)
         .orderByDesc(EventFavorite::getCreateTime);
        Page<EventFavorite> page = new Page<>(current, size);
        Page<EventFavorite> result = this.page(page, w);
        List<LifeEventResponse> records = result.getRecords().stream()
                .map(EventFavorite::getEventId)
                .map(lifeEventService::getEventById)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        PageResult<LifeEventResponse> pr = new PageResult<>();
        pr.setCurrent(result.getCurrent());
        pr.setSize(result.getSize());
        pr.setTotal(result.getTotal());
        pr.setPages(result.getPages());
        pr.setRecords(records);
        return pr;
    }
    @Override
    public Set<String> getFavoritedEventIds(Set<String> eventIds) {
        String userId = UserContextHolder.getCurrentUserId();
        if (!StringUtils.hasText(userId) || eventIds == null || eventIds.isEmpty()) {
            return Collections.emptySet();
        }
        LambdaQueryWrapper<EventFavorite> w = new LambdaQueryWrapper<>();
        w.eq(EventFavorite::getUserId, userId)
         .in(EventFavorite::getEventId, eventIds)
         .eq(EventFavorite::getIsDeleted, 0);
        return this.list(w).stream()
                .map(EventFavorite::getEventId)
                .collect(Collectors.toSet());
    }
    @Override
    public boolean isFavorited(String eventId) {
        String userId = UserContextHolder.getCurrentUserId();
        if (!StringUtils.hasText(userId) || !StringUtils.hasText(eventId)) {
            return false;
        }
        LambdaQueryWrapper<EventFavorite> w = new LambdaQueryWrapper<>();
        w.eq(EventFavorite::getUserId, userId)
         .eq(EventFavorite::getEventId, eventId)
         .eq(EventFavorite::getIsDeleted, 0);
        return this.count(w) > 0;
    }
    @Override
    public long getFavoriteCount() {
        String userId = UserContextHolder.getCurrentUserId();
        if (!StringUtils.hasText(userId)) {
            return 0L;
        }
        LambdaQueryWrapper<EventFavorite> w = new LambdaQueryWrapper<>();
        w.eq(EventFavorite::getUserId, userId)
         .eq(EventFavorite::getIsDeleted, 0);
        return this.count(w);
    }
 }
 ```
 - [ ] **Step 8: 修改 LifeEventController 添加收藏 API**
 在 `server/src/main/java/com/emotion/controller/LifeEventController.java` 中添加：
 1. 在类顶部添加注入：
 ```java
@Autowired
 private EventFavoriteService eventFavoriteService;
 ```
 2. 添加 import：
 ```java
 import com.emotion.dto.request.EventFavoriteToggleRequest;
 import com.emotion.dto.response.EventFavoriteResponse;
 import com.emotion.service.EventFavoriteService;
 ```
 3. 在类末尾（`readTags` 方法之前）添加收藏 API：
 ```java
 // ==================== 人生事件收藏 ====================
@Operation(summary = "切换收藏", description = "收藏或取消收藏指定事件。")
@PostMapping(value = "/favorite/toggle")
 public Result<EventFavoriteResponse> toggleFavorite(
        @Valid @RequestBody EventFavoriteToggleRequest request) {
    return Result.success(eventFavoriteService.toggleFavorite(request.getEventId()));
 }
@Operation(summary = "分页查询收藏", description = "分页查询当前用户收藏的事件列表。")
@GetMapping(value = "/favorite/page")
 public Result<PageResult<LifeEventResponse>> getFavoritePage(
        @RequestParam(defaultValue = "1") long current,
        @RequestParam(defaultValue = "10") long size) {
    return Result.success(eventFavoriteService.getFavoritePage(current, size));
 }
@Operation(summary = "检查收藏状态", description = "检查指定事件是否已被当前用户收藏。")
@GetMapping(value = "/favorite/check")
 public Result<EventFavoriteResponse> checkFavorite(@RequestParam String eventId) {
    boolean favorited = eventFavoriteService.isFavorited(eventId);
    EventFavoriteResponse r = new EventFavoriteResponse();
    r.setEventId(eventId);
    r.setIsFavorited(favorited);
    return Result.success(r);
 }
 ```
 4. **删除** `/lifeEvent/favorite-placeholder` 假接口（第 153-163 行）：
 ```java
 // 删除以下方法
@Operation(summary = "收藏占位接口", description = "返回收藏功能的占位响应。")
@PostMapping(value = "/favorite-placeholder")
 public Result<Map<String, Object>> favoritePlaceholder(@RequestBody Map<String, Object> request) {
    // ... 整段删除
 }
 ```
 - [ ] **Step 9: 提交**
 ```bash
 git add server/src/main/resources/db/migration/V20260719000002__create_event_favorite.sql
 git add server/src/main/java/com/emotion/entity/EventFavorite.java
 git add server/src/main/java/com/emotion/mapper/EventFavoriteMapper.java
 git add server/src/main/java/com/emotion/dto/request/EventFavoriteToggleRequest.java
 git add server/src/main/java/com/emotion/dto/response/EventFavoriteResponse.java
 git add server/src/main/java/com/emotion/service/EventFavoriteService.java
 git add server/src/main/java/com/emotion/service/impl/EventFavoriteServiceImpl.java
 git add server/src/main/java/com/emotion/controller/LifeEventController.java
 git commit -m "feat: 新增人生事件收藏功能（独立收藏表 + API）"
 ```
 ---
 ### Task 2: 后端编译 + 部署到服务器
 **Files:**
 - Build: `server/target/`
 - Deploy: 服务器
 - [ ] **Step 1: 本地编译验证**
 ```bash
 cd server
 mvn clean install -DskipTests
 ```
 Expected: BUILD SUCCESS，无编译错误。
 - [ ] **Step 2: 部署到服务器**
 ```bash
 cd ..
 python deploy.py backend
 ```
 Expected: 部署成功，服务器自动重启。
 - [ ] **Step 3: 验证部署**
 ```bash
 python deploy.py verify
 ```
 Expected: 后端服务运行正常。
 - [ ] **Step 4: 提交**
 ```bash
 git commit -m "chore: 后端人生事件收藏功能已部署" --allow-empty
 ```
 ---
 ### Task 3: 前端 ScriptLibraryView.vue 切换到剧本收藏 API
 **Files:**
 - Modify: `mini-program/src/pages/main/ScriptLibraryView.vue`
 - [ ] **Step 1: 删除 localFavorites ref，改用内存状态**
 删除第 160 行：
 ```javascript
 // 删除这一行
 const localFavorites = ref(uni.getStorageSync('script_favorites') || {})
 ```
 替换为：
 ```javascript
 const favoriteStatus = ref({})
 ```
 - [ ] **Step 2: 修改 isFavorite 计算**
 修改第 245-247 行：
 ```javascript
 // 之前：
 const isFavorite = (script) => {
  return Boolean(script.isFavorite || script.favorite || localFavorites.value[String(script.id)])
 }
 // 之后：
 const isFavorite = (script) => {
  return Boolean(favoriteStatus.value[String(script.id)])
 }
 ```
 - [ ] **Step 3: 修改 toggleFavorite，删除 localStorage 写**
 修改第 320-348 行：
 ```javascript
 // 之前：
 const toggleFavorite = async (script) => {
  const wasFav = isFavorite(script)
  // 乐观更新：先改本地缓存
  const next = { ...localFavorites.value }
  if (wasFav) {
    delete next[String(script.id)]
  } else {
    next[String(script.id)] = true
  }
  localFavorites.value = next
  uni.setStorageSync('script_favorites', next)
  closeScriptMenu()
  try {
    const result = await toggleFavoriteScript(script.id)
    uni.showToast({ title: result.isFavorited ? '已收藏' : '已取消收藏', icon: 'success' })
  } catch (error) {
    // 回滚乐观更新
    const restored = { ...localFavorites.value }
    if (wasFav) {
      restored[String(script.id)] = true
    } else {
      delete restored[String(script.id)]
    }
    localFavorites.value = restored
    uni.setStorageSync('script_favorites', restored)
    uni.showToast({ title: error?.message || '操作失败', icon: 'none' })
  }
 }
 // 之后：
 const toggleFavorite = async (script) => {
  const wasFav = isFavorite(script)
  // 乐观更新：先改内存状态
  const next = { ...favoriteStatus.value }
  if (wasFav) {
    delete next[String(script.id)]
  } else {
    next[String(script.id)] = true
  }
  favoriteStatus.value = next
  closeScriptMenu()
  try {
    const result = await toggleFavoriteScript(script.id)
    uni.showToast({ title: result.isFavorited ? '已收藏' : '已取消收藏', icon: 'success' })
  } catch (error) {
    // 回滚乐观更新
    const restored = { ...favoriteStatus.value }
    if (wasFav) {
      restored[String(script.id)] = true
    } else {
      delete restored[String(script.id)]
    }
    favoriteStatus.value = restored
    uni.showToast({ title: error?.message || '操作失败', icon: 'none' })
  }
 }
 ```
 - [ ] **Step 4: 修改 confirmDeleteScript，删除 localStorage 清理**
 修改第 386-389 行：
 ```javascript
 // 之前：
 const next = { ...localFavorites.value }
 delete next[id]
 localFavorites.value = next
 uni.setStorageSync('script_favorites', next)
 // 之后：
 const next = { ...favoriteStatus.value }
 delete next[id]
 favoriteStatus.value = next
 ```
 - [ ] **Step 5: 列表加载后批量检查收藏状态**
 在 `visibleScripts` computed 后添加 watch 或 onMounted 钩子，批量调用 `checkFavoriteScript`：
 在文件顶部添加 import：
 ```javascript
 import { checkFavoriteScript } from '../../services/epicScript.js'
 ```
 在 `visibleScripts` computed 后添加：
 ```javascript
 // 列表加载后批量检查收藏状态
 const loadFavoriteStatus = async () => {
  const ids = scripts.value.map(s => String(s.id)).filter(id => !id.startsWith('demo-'))
  if (!ids.length) return
  const status = {}
  await Promise.all(ids.map(async (id) => {
    try {
      status[id] = await checkFavoriteScript(id)
    } catch {
      status[id] = false
    }
  }))
  favoriteStatus.value = status
 }
 // 监听 scripts 变化时重新加载收藏状态
 watch(scripts, () => {
  loadFavoriteStatus()
 }, { immediate: true })
 ```
 确保 import watch：
 ```javascript
 import { computed, ref, watch } from 'vue'
 ```
 - [ ] **Step 6: 提交**
 ```bash
 git add mini-program/src/pages/main/ScriptLibraryView.vue
 git commit -m "refactor: 剧本收藏从 localStorage 切换到真实 API"
 ```
 ---
 ### Task 4: 前端 life-event 切换到人生事件收藏 API
 **Files:**
 - Modify: `mini-program/src/services/lifeEvent.js`
 - Modify: `mini-program/src/pages/life-event/detail.vue`
 - Modify: `mini-program/src/stores/app.js`
 - [ ] **Step 1: 修改 lifeEvent.js 新增收藏 API 封装**
 在 `mini-program/src/services/lifeEvent.js` 中：
 1. **删除**旧的 `favoriteEvent` 方法（第 67-69 行）：
 ```javascript
 // 删除：
 export const favoriteEvent = async ({ id, favorite }) => {
  return post('/lifeEvent/favorite-placeholder', { id, favorite })
 }
 ```
 2. **新增**真实的收藏 API：
 ```javascript
 /**
 * 切换人生事件收藏状态（收藏/取消收藏）
 * @param {string} eventId 事件ID
 * @returns {Promise<{success: boolean, isFavorited: boolean}>}
 */
 export const toggleFavoriteEvent = async (eventId) => {
  const res = await post('/lifeEvent/favorite/toggle', { eventId })
  return {
    success: true,
    isFavorited: res.data?.isFavorited ?? false,
    favoriteTime: res.data?.favoriteTime ?? null
  }
 }
 /**
 * 检查人生事件是否已收藏
 * @param {string} eventId 事件ID
 * @returns {Promise<boolean>}
 */
 export const checkFavoriteEvent = async (eventId) => {
  const res = await get('/lifeEvent/favorite/check', { eventId })
  return res.data?.isFavorited ?? false
 }
 ```
 3. 在 default export 中更新方法列表：
 ```javascript
 export default {
  getEventList,
  getEventPage,
  getEventById,
  createEvent,
  updateEvent,
  deleteEvent,
  assistEventWriting,
  chatAboutEvent,
  shareEvent,
  toggleFavoriteEvent,
  checkFavoriteEvent,
  transformToFrontendFormat,
  transformListToFrontend
 }
 ```
 - [ ] **Step 2: 修改 stores/app.js 的 favoriteEvent action**
 在 `mini-program/src/stores/app.js` 中：
 1. **删除**旧的 `favoriteEvent` action（第 235-242 行）：
 ```javascript
 // 删除：
 const favoriteEvent = async ({ id, favorite }) => {
  try {
    const res = await lifeEventService.favoriteEvent({ id, favorite })
    return { success: true, data: res.data }
  } catch (error) {
    return { success: false, error: error.message }
  }
 }
 ```
 2. **新增**新的 action：
 ```javascript
 const toggleEventFavorite = async (eventId) => {
  try {
    const result = await lifeEventService.toggleFavoriteEvent(eventId)
    return { success: true, data: result }
  } catch (error) {
    return { success: false, error: error.message }
  }
 }
 const checkEventFavorite = async (eventId) => {
  try {
    const isFavorited = await lifeEventService.checkFavoriteEvent(eventId)
    return { success: true, data: isFavorited }
  } catch (error) {
    return { success: false, error: error.message }
  }
 }
 ```
 3. 在 return 对象中更新导出：
 ```javascript
 return {
  // ... 其他方法
  toggleEventFavorite,
  checkEventFavorite,
  // 删除 favoriteEvent
 }
 ```
 - [ ] **Step 3: 修改 detail.vue 初始化时检查收藏状态**
 在 `mini-program/src/pages/life-event/detail.vue` 中：
 1. 修改 `onMounted`（第 137-149 行）：
 ```javascript
 // 之前：
 onMounted(async () => {
  const info = uni.getWindowInfo()
  safeAreaBottom.value = info.safeAreaInsets?.bottom || 0
  const pages = getCurrentPages()
  eventId.value = pages[pages.length - 1]?.options?.id || ''
  cachedEvent.value = uni.getStorageSync('current_life_event') || null
  if (!store.events?.length) await store.fetchEvents()
  isFavorite.value = Boolean(uni.getStorageSync(`event_favorite_${eventId.value}`))
  analytics.trackPageView(pagePath, {
    life_event_id: eventId.value,
    tag_count: Array.isArray(displayEvent.value.tags) ? displayEvent.value.tags.length : 0
  })
 })
 // 之后：
 onMounted(async () => {
  const info = uni.getWindowInfo()
  safeAreaBottom.value = info.safeAreaInsets?.bottom || 0
  const pages = getCurrentPages()
  eventId.value = pages[pages.length - 1]?.options?.id || ''
  cachedEvent.value = uni.getStorageSync('current_life_event') || null
  if (!store.events?.length) await store.fetchEvents()
  // 从 API 检查收藏状态
  const result = await store.checkEventFavorite(eventId.value)
  if (result.success) {
    isFavorite.value = result.data
  }
  analytics.trackPageView(pagePath, {
    life_event_id: eventId.value,
    tag_count: Array.isArray(displayEvent.value.tags) ? displayEvent.value.tags.length : 0
  })
 })
 ```
 - [ ] **Step 4: 修改 detail.vue 的 toggleFavorite，删除 localStorage 写**
 修改第 306-322 行：
 ```javascript
 // 之前：
 const toggleFavorite = async () => {
  if (!eventId.value) return
  const next = !isFavorite.value
  const result = await store.favoriteEvent({ id: eventId.value, favorite: next })
  if (!result.success) {
    uni.showToast({ title: result.error || '收藏失败', icon: 'none' })
    return
  }
  isFavorite.value = next
  if (next) uni.setStorageSync(`event_favorite_${eventId.value}`, '1')
  else uni.removeStorageSync(`event_favorite_${eventId.value}`)
  analytics.track('life_event_favorite', {
    life_event_id: eventId.value,
    favorite: next
  }, { eventType: 'life_event', pagePath })
  uni.showToast({ title: next ? '已收藏' : '已取消收藏', icon: 'success' })
 }
 // 之后：
 const toggleFavorite = async () => {
  if (!eventId.value) return
  const result = await store.toggleEventFavorite(eventId.value)
  if (!result.success) {
    uni.showToast({ title: result.error || '收藏失败', icon: 'none' })
    return
  }
  isFavorite.value = result.data?.isFavorited ?? false
  analytics.track('life_event_favorite', {
    life_event_id: eventId.value,
    favorite: isFavorite.value
  }, { eventType: 'life_event', pagePath })
  uni.showToast({ title: isFavorite.value ? '已收藏' : '已取消收藏', icon: 'success' })
 }
 ```
 - [ ] **Step 5: 提交**
 ```bash
 git add mini-program/src/services/lifeEvent.js
 git add mini-program/src/stores/app.js
 git add mini-program/src/pages/life-event/detail.vue
 git commit -m "refactor: 人生事件收藏从 localStorage 切换到真实 API"
 ```
 ---
 ### Task 5: H5 浏览器验证
 **Files:**
 - Test: `http://localhost:5180` (H5 开发服务器)
 - [ ] **Step 1: 确认 H5 开发服务器运行中**
 ```bash
 python dev-services.py status
 ```
 Expected: `mini-program` 服务在端口 5180 上运行。如未运行，执行：
 ```bash
 python dev-services.py start mini-program
 ```
 - [ ] **Step 2: 浏览器打开页面并登录**
 1. 打开 `http://localhost:5180`
 2. 如未登录，使用手机号验证码 123456 登录
 - [ ] **Step 3: 验证剧本收藏**
 1. 点击底部导航「爽文生成」
 2. 点击「剧本库」
 3. 点击任意剧本的收藏图标（心形）
 4. 确认：
   - ✅ Toast 提示「已收藏」
   - ✅ 心形图标变为实心
   - ✅ Network 面板中有 `POST /epicScript/favorite/toggle` 请求，返回 `isFavorited: true`
 5. 刷新页面
 6. 确认收藏状态仍保持（心形图标仍为实心）
 7. 再次点击收藏图标取消收藏
 8. 确认：
   - ✅ Toast 提示「已取消收藏」
   - ✅ 心形图标变为空心
   - ✅ Network 面板中有 `POST /epicScript/favorite/toggle` 请求，返回 `isFavorited: false`
 - [ ] **Step 4: 验证人生事件收藏**
 1. 点击底部导航「人生轨迹」
 2. 点击任意事件进入详情页
 3. 点击收藏按钮
 4. 确认：
   - ✅ Toast 提示「已收藏」
   - ✅ 收藏按钮状态变化
   - ✅ Network 面板中有 `POST /lifeEvent/favorite/toggle` 请求，返回 `isFavorited: true`
 5. 返回列表页，再次进入同一事件详情
 6. 确认收藏状态仍保持
 7. 再次点击收藏按钮取消收藏
 8. 确认：
   - ✅ Toast 提示「已取消收藏」
   - ✅ 收藏按钮状态恢复
   - ✅ Network 面板中有 `POST /lifeEvent/favorite/toggle` 请求，返回 `isFavorited: false`
 - [ ] **Step 5: 检查浏览器 Console 无报错**
 打开浏览器 DevTools → Console 面板，确认：
 - ✅ 无红色 ERROR
 - ✅ 无 localStorage 相关的 `script_favorites` 或 `event_favorite_` 读写
 - [ ] **Step 6: 提交（如有微调）**
 ```bash
 git add mini-program/src/
 git commit -m "test: H5 浏览器验证收藏功能通过"
 ```
 ---
 ### Task 6: 通知用户验证
 - [ ] **Step 1: 提示用户操作**
 告知用户：
 > 收藏功能已完成真实 API 化改造：
 > 
 > **剧本收藏**：
 > - 前端从 localStorage 切换到现有后端 API（`POST /epicScript/favorite/toggle`）
 > - 收藏状态从服务器读取，不再依赖本地缓存
 > 
 > **人生事件收藏**：
 > - 后端新建独立的 `t_event_favorite` 表 + API
 > - 前端从 localStorage 切换到真实 API（`POST /lifeEvent/favorite/toggle`）
 > - 删除了假接口 `/lifeEvent/favorite-placeholder`
 > 
 > **验证方式**：
 > 1. 本地 H5（`http://localhost:5180`）已验证通过
 > 2. 后端已部署到服务器
 > 3. 请在**微信开发者工具**中：
 >    - 打开 `unpackage/dist/dev/mp-weixin` 目录
 >    - 点击「编译」重新编译
 >    - 测试剧本收藏和人生事件收藏功能
 >    - 确认收藏状态刷新后仍保持
 > 
 > 如有问题，截图反馈。