README.md

@@ -0,0 +1,2 @@
+# study_helper
+

app.json

@@ -1,4 +1,5 @@
 {
+
   "pages": [
     "pages/guiding/guiding",
     "pages/login/login",
@@ -7,18 +8,20 @@
     "pages/search/search",
     "pages/recite/recite",
     "pages/review/review",
+    "pages/keyWord/keyWord",
     "pages/question/question",
     "pages/managePoems/managePoems"
   ],
   "window": {
     "navigationBarTitleText": "古诗学习助手",
-    "navigationBarTextStyle": "black",
+    "navigationBarTextStyle":"black",
     "navigationBarBackgroundColor": "#FFFBF3",
     "enablePullDownRefresh": true,
     "backgroundColor": "#FFFFFF",
-    "backgroundTextStyle": "dark"
+    "backgroundTextStyle":"dark"
   },
   "style": "v2",
   "sitemapLocation": "sitemap.json",
   "lazyCodeLoading": "requiredComponents"
+
 }

cloudfunctions/auth/index.js

@@ -0,0 +1,248 @@
+const cloud = require('wx-server-sdk')
+cloud.init({
+  env: cloud.DYNAMIC_CURRENT_ENV
+})
+
+const db = cloud.database()
+
+exports.main = async (event, context) => {
+  const { action } = event
+
+  try {
+    switch (action) {
+      case 'loginWithCode':
+        return await handleLoginWithCode(event)
+      case 'registerUser':
+        return await handleRegisterUser(event)
+      case 'getUserByOpenid':  
+        return await handleGetUserByOpenid(event);
+      default:
+        return {
+          success: false,
+          message: '未知操作'
+        }
+    }
+  } catch (error) {
+    console.error('云函数执行错误:', error)
+    return {
+      success: false,
+      message: '服务器内部错误'
+    }
+  }
+}
+
+// 使用code登录
+async function handleLoginWithCode(event) {
+  const { code } = event
+  
+  if (!code) {
+    return {
+      success: false,
+      message: '缺少code参数'
+    }
+  }
+
+  try {
+    // 1. 通过code调用微信接口获取openid
+    const authResult = await getOpenIdByCode(code)
+    
+    if (!authResult.openid) {
+      return {
+        success: false,
+        message: '获取openid失败'
+      }
+    }
+
+    const openid = authResult.openid
+
+    // 2. 通过openid查询数据库
+    const userResult = await db.collection('users')
+      .where({
+        openid: openid
+      })
+      .get()
+
+    // 3. 如果查询到用户数据，完成登录流程
+    if (userResult.data.length > 0) {
+      const user = userResult.data[0]
+      
+      return {
+        success: true,
+        data: {
+          userInfo: {
+            _id: user._id,
+            openid: user.openid,
+            nickname: user.nickname,
+            avatarUrl: user.avatarUrl,
+            role: user.role,
+            reviewedPoems: user.reviewedPoems,
+            learningStats: user. learningStats,
+          }
+        }
+      }
+    } else {
+      // 4. 如果查询不到用户，返回未注册状态和openid
+      return {
+        success: false,
+        message: '用户未注册',
+        code: 'USER_NOT_REGISTERED',
+        openid: openid
+      }
+    }
+
+  } catch (error) {
+    console.error('登录处理错误:', error)
+    return {
+      success: false,
+      message: '登录失败'
+    }
+  }
+}
+// 注册用户
+async function handleRegisterUser(event) {
+  const { openid, userInfo } = event
+  
+  if (!openid || !userInfo) {
+    return {
+      success: false,
+      message: '缺少必要参数'
+    }
+  }
+
+  try {
+    
+    // 直接创建新用户
+    const newUser = {
+      openid: openid,
+      nickname: userInfo.nickName || '勤奋的小朋友',
+      avatarUrl: userInfo.avatarUrl || 'defaultAvatar',
+      createdAt: db.serverDate(),
+      updatedAt: db.serverDate(),
+      role: true,
+      reviewedPoems:{},
+      // 复习相关数据直接嵌入在用户文档中
+      learningStats: {
+      totalLearned: 0,
+      totalReviewed: 0,
+      lastLearnDate: null
+      }
+    }
+    // 先查询用户是否存在
+    const existingUser = await db.collection('users')
+    .where({ openid: openid })
+    .get()
+    let userId
+    let finalUser
+
+    if (existingUser.data.length > 0) {
+      // 用户存在，更新信息
+      await db.collection('users')
+        .where({ openid: openid })
+        .update({
+          data:{
+            updatedAt: newUser.updatedAt
+          }
+        })
+      userId = existingUser.data[0]._id
+      const updatedUser = await db.collection('users').doc(userId).get()
+      finalUser = updatedUser.data
+    }else{
+      const addResult = await db.collection('users').add({
+        data: newUser
+      })
+      userId = addResult._id
+      // 获取新创建的用户信息
+      const user = await db.collection('users').doc(addResult._id).get()
+      finalUser = user.data
+    }
+    
+
+    // 返回创建的用户信息
+    return {
+      success: true,
+      data: {
+        userInfo: {
+          _id: userId,
+          openid: finalUser.openid,
+          nickname: finalUser.nickname,
+          avatarUrl: finalUser.avatarUrl,
+          role: finalUser.role,
+          reviewedPoems: finalUser.reviewedPoems|| {},
+          learningStats: finalUser.learningStats|| {
+            totalLearned: 0,
+            totalReviewed: 0,
+            lastLearnDate: null
+          }
+        }
+      }
+    }
+
+  } catch (error) {
+    console.error('注册用户错误:', error)
+    return {
+      success: false,
+      message: '注册失败'
+    }
+  }
+}
+// 通过code获取openid
+async function getOpenIdByCode(code) {
+  // 在云函数中，我们可以直接获取到openid，不需要再用code换取
+  // 因为云函数自动包含了用户身份信息
+  const wxContext = cloud.getWXContext()
+  
+  return {
+    openid: wxContext.OPENID,
+    appid: wxContext.APPID,
+    unionid: wxContext.UNIONID
+  }
+}
+async function handleGetUserByOpenid(event) {
+  const { openid } = event;
+  
+  if (!openid) {
+    return {
+      success: false,
+      message: '缺少openid参数'
+    };
+  }
+
+  try {
+    const userResult = await db.collection('users')
+      .where({ openid: openid })
+      .get();
+
+    if (userResult.data.length > 0) {
+      const user = userResult.data[0];
+      return {
+        success: true,
+        data: {
+          userInfo: {
+            _id: user._id,
+            openid: user.openid,
+            nickname: user.nickname,
+            avatarUrl: user.avatarUrl,
+            role: user.role,
+            reviewedPoems: user.reviewedPoems || {},
+            learningStats: user.learningStats || {
+              totalLearned: 0,
+              totalReviewed: 0,
+              lastLearnDate: null
+            }
+          }
+        }
+      };
+    } else {
+      return {
+        success: false,
+        message: '用户不存在'
+      };
+    }
+  } catch (error) {
+    console.error('获取用户信息错误:', error);
+    return {
+      success: false,
+      message: '获取用户信息失败'
+    };
+  }
+}

cloudfunctions/getOpenId/config.json

@@ -0,0 +1,6 @@
+{
+    "permissions": {
+        "openapi": [
+        ]
+    }
+}

cloudfunctions/getOpenId/index.js

@@ -0,0 +1,16 @@
+// cloudfunctions/getOpenId/index.js
+const cloud = require('wx-server-sdk')
+
+cloud.init({
+  env: cloud.DYNAMIC_CURRENT_ENV
+})
+
+exports.main = async (event, context) => {
+  const wxContext = cloud.getWXContext()
+
+  return {
+    openid: wxContext.OPENID,
+    appid: wxContext.APPID,
+    unionid: wxContext.UNIONID,
+  }
+}

cloudfunctions/getOpenId/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "getOpenId",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "wx-server-sdk": "~3.0.1"
+    }
+}

cloudfunctions/getPoemDetail/config.json

@@ -0,0 +1,6 @@
+{
+  "permissions": {
+    "openapi": [
+    ]
+  }
+}

cloudfunctions/getPoemDetail/index.js

@@ -0,0 +1,52 @@
+const cloud = require('wx-server-sdk')
+cloud.init({
+  env: cloud.DYNAMIC_CURRENT_ENV
+})
+
+exports.main = async (event, context) => {
+  const db = cloud.database()
+  const { id } = event
+  
+  console.log('获取古诗详情，ID:', id)
+  
+  try {
+    // 根据ID从poeties集合中获取古诗详情
+    const result = await db.collection('poeties')
+      .doc(id)
+      .get()
+    
+    console.log('数据库查询结果:', result)
+    
+    if (result.data) {
+      return {
+        success: true,
+        data: result.data
+      }
+    } else {
+      return {
+        success: false,
+        message: '古诗不存在'
+      }
+    }
+  } catch (error) {
+    console.error('获取古诗详情失败:', error)
+    
+    // 更详细的错误信息
+    if (error.errCode === -502005) {
+      return {
+        success: false,
+        message: '古诗不存在或已被删除'
+      }
+    } else if (error.errCode === -501000) {
+      return {
+        success: false,
+        message: '数据库连接失败'
+      }
+    } else {
+      return {
+        success: false,
+        message: '获取古诗详情失败: ' + error.message
+      }
+    }
+  }
+}

cloudfunctions/getPoemDetail/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "getPoemDetail",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "wx-server-sdk": "~3.0.1"
+  }
+}

cloudfunctions/poemManagement/index.js

@@ -1,33 +1,33 @@
 const cloud = require('wx-server-sdk')
-// 初始化云开发环境
 cloud.init({
   env: 'cloud1-0g2sr1117862afae'
 })
 
 const db = cloud.database()
-const poemsCollection = db.collection('poeties') // 古诗集合
+const poemsCollection = db.collection('poeties')
 const _ = db.command
 
-// 云函数主入口
 exports.main = async (event, context) => {
   const { action, data, poemId, searchQuery, keyword, page = 1, pageSize = 20 } = event
   
   try {
     switch (action) {
       case 'getAllPoems':
-        return await handleGetAllPoems(event); // 获取所有古诗
+        return await handleGetAllPoems(event);
       case 'getPoemDetail':
-          return await getPoemDetail(event); // 获取古诗详情
+          return await getPoemDetail(event);
+      case 'getInitialPoems':
+        return await getInitialPoems()
       case 'searchPoemsManager':
-        return await searchPoemsManager(searchQuery) // 管理端搜索古诗
+        return await searchPoemsManager(searchQuery)
       case 'searchPoems':
-          return await searchPoems(event) // 搜索古诗
+          return await searchPoems(event)
       case 'addPoem':
-        return await addPoem(data) // 添加古诗
+        return await addPoem(data)
       case 'updatePoem':
-        return await updatePoem(poemId, data) // 更新古诗
+        return await updatePoem(poemId, data)
       case 'deletePoem':
-        return await deletePoem(poemId) // 删除古诗
+        return await deletePoem(poemId)
       default:
         return {
           success: false,
@@ -42,9 +42,8 @@ exports.main = async (event, context) => {
   }
 }
 
-// 获取古诗详情
 async function getPoemDetail(event){
-  const { id } = event; // 古诗ID
+  const { id } = event;
   console.log('获取古诗详情，ID:', id)
   
   try {
@@ -69,7 +68,7 @@ async function getPoemDetail(event){
   } catch (error) {
     console.error('获取古诗详情失败:', error)
     
-    // 错误处理
+    // 更详细的错误信息
     if (error.errCode === -502005) {
       return {
         success: false,
@@ -89,38 +88,17 @@ async function getPoemDetail(event){
   }
 }
 
-// 获取所有古诗
 async function handleGetAllPoems(event) {
   try {
-    const db = cloud.database();
-    const { page = 1, pageSize = 20, fields } = event;
-    
-    // 构建查询条件
-    let query = db.collection('poeties').orderBy('title', 'asc');
-    
-    // 字段筛选
-    if (fields && Array.isArray(fields)) {
-      const projection = {};
-      fields.forEach(field => {
-        projection[field] = true;
-      });
-      query = query.field(projection);
-    }
-    
-    // 分页查询
-    const [dataResult, countResult] = await Promise.all([
-      query.skip((page - 1) * pageSize).limit(pageSize).get(),
-      db.collection('poeties').count()
-    ]);
+    const result = await db.collection('poeties')
+      .orderBy('title', 'asc')
+      .get();
 
     return {
       success: true,
       data: {
-        poems: dataResult.data,
-        total: countResult.total,
-        page: parseInt(page),
-        pageSize: parseInt(pageSize),
-        totalPages: Math.ceil(countResult.total / pageSize)
+        poems: result.data,
+        total: result.data.length
       }
     };
   } catch (error) {
@@ -131,17 +109,24 @@ async function handleGetAllPoems(event) {
     };
   }
 }
+// 获取初始的100条古诗
+async function getInitialPoems() {
+  const result = await poemsCollection.limit(100).get()
+  return {
+    success: true,
+    data: result.data
+  }
+}
 
-
-// 管理端搜索古诗
+// 搜索古诗
 async function searchPoemsManager(searchQuery) {
   const _ = db.command
   const result = await poemsCollection.where(
     _.or([
       {
         title: db.RegExp({
-          regexp: searchQuery, // 搜索关键词
-          options: 'i' // 不区分大小写
+          regexp: searchQuery,
+          options: 'i'
         })
       },
       {
@@ -183,21 +168,20 @@ async function searchPoemsManager(searchQuery) {
   }
 }
 
-// 搜索古诗
 async function searchPoems(event){
-  const { keyword, page = 1, pageSize = 20 } = event; // 搜索关键词，页码，页大小
+  const { keyword, page = 1, pageSize = 20 } = event;
   console.log('搜索请求参数:', { keyword, page, pageSize })
   
   try {
     // 如果关键词为空，返回所有数据
     if (!keyword || keyword.trim() === '') {
-      const allData = await db.collection('poeties')
+      const allData = await db.collection('poeties')  // 注意集合名称
         .orderBy('title', 'asc')
-        .skip((page - 1) * pageSize) // 跳过记录数
-        .limit(pageSize) // 限制返回数量
+        .skip((page - 1) * pageSize)
+        .limit(pageSize)
         .get()
       
-      const countResult = await db.collection('poeties').count() // 获取总数
+      const countResult = await db.collection('poeties').count()
       
       return {
         success: true,
@@ -213,7 +197,7 @@ async function searchPoems(event){
     const searchKeyword = keyword.trim()
     console.log('搜索关键词:', searchKeyword)
     
-    // 构建搜索条件
+    // 根据你的数据结构构建搜索条件
     const searchCondition = _.or([
       {
         title: db.RegExp({
@@ -261,15 +245,15 @@ async function searchPoems(event){
     
     console.log('搜索条件:', searchCondition)
     
-    // 执行搜索查询
+    // 执行搜索查询 - 使用正确的集合名称 poeties
     const [dataResult, countResult] = await Promise.all([
-      db.collection('poeties')
+      db.collection('poeties')  
         .where(searchCondition)
         .orderBy('title', 'asc')
         .skip((page - 1) * pageSize)
         .limit(pageSize)
         .get(),
-      db.collection('poeties')
+      db.collection('poeties')  
         .where(searchCondition)
         .count()
     ])
@@ -306,7 +290,6 @@ async function searchPoems(event){
 
 // 添加古诗
 async function addPoem(poemData) {
-  // 验证必要字段
   if (!poemData.title || !poemData.dynasty || !poemData.author || !poemData.content) {
     return {
       success: false,
@@ -314,19 +297,18 @@ async function addPoem(poemData) {
     }
   }
 
-  // 构建古诗数据对象
   const newPoem = {
-    title: poemData.title, // 标题
-    dynasty: poemData.dynasty, // 朝代
-    author: poemData.author, // 作者
-    content: poemData.content, // 内容
-    translation: poemData.translation || '', // 翻译
-    background: poemData.background || '', // 背景
-    author_info: poemData.author_info || {}, // 作者信息
-    theme: poemData.theme || [], // 主题
-    type: poemData.type || '诗', // 类型
-    createTime: db.serverDate(), // 创建时间
-    updateTime: db.serverDate() // 更新时间
+    title: poemData.title,
+    dynasty: poemData.dynasty,
+    author: poemData.author,
+    content: poemData.content,
+    translation: poemData.translation || '',
+    background: poemData.background || '',
+    author_info: poemData.author_info || {},
+    theme: poemData.theme || [],
+    type: poemData.type || '诗',
+    createTime: db.serverDate(),
+    updateTime: db.serverDate()
   }
 
   const result = await poemsCollection.add({
@@ -342,7 +324,6 @@ async function addPoem(poemData) {
 
 // 更新古诗
 async function updatePoem(poemId, updateData) {
-  // 验证古诗ID
   if (!poemId) {
     return {
       success: false,
@@ -350,7 +331,6 @@ async function updatePoem(poemId, updateData) {
     }
   }
 
-  // 验证必要字段
   if (!updateData.title || !updateData.dynasty || !updateData.author || !updateData.content) {
     return {
       success: false,
@@ -358,7 +338,6 @@ async function updatePoem(poemId, updateData) {
     }
   }
 
-  // 构建更新数据对象
   const updateInfo = {
     title: updateData.title,
     dynasty: updateData.dynasty,
@@ -385,7 +364,6 @@ async function updatePoem(poemId, updateData) {
 
 // 删除古诗
 async function deletePoem(poemId) {
-  // 验证古诗ID
   if (!poemId) {
     return {
       success: false,

cloudfunctions/reviewManagement/index.js

@@ -0,0 +1,481 @@
+// cloudfunctions/reviewManagement/index.js
+const cloud = require('wx-server-sdk')
+cloud.init({
+  env: cloud.DYNAMIC_CURRENT_ENV
+})
+
+const db = cloud.database()
+const _ = db.command
+const reviewCollection = db.collection('Review')
+
+exports.main = async (event, context) => {
+  const { 
+    action, 
+    reviewData, 
+    recordId, 
+    openid, 
+    poemId, 
+    page = 1, 
+    pageSize = 20 
+  } = event
+  
+  try {
+    switch (action) {
+      case 'addReviewRecord':
+        return await addReviewRecord(reviewData)
+      case 'getReviewRecord':
+        return await getReviewRecord(recordId)
+      case 'getUserReviews':
+        return await getUserReviews(openid, page, pageSize)
+      case 'getPoemReviews':
+        return await getPoemReviews(poemId, page, pageSize)
+      case 'deleteReviewRecord':
+        return await deleteReviewRecord(recordId)
+      case 'getReviewStats':
+        return await getReviewStats(openid)
+      case 'checkExistingRecord': // 检查是否存在记录
+        return await checkExistingRecord(poemId, openid)
+      case 'updateReviewRecord': // 更新已有记录
+        return await updateReviewRecord(recordId, reviewData)
+      default:
+        return {
+          success: false,
+          message: `未知操作: ${action}`
+        }
+    }
+  } catch (error) {
+    console.error('云函数执行失败:', {
+      message: error.message,
+      code: error.code,
+      stack: error.stack,
+      error: JSON.stringify(error)
+    })
+    
+    // 统一的错误处理逻辑
+    if (error.code === -502001) {
+      return {
+        success: false,
+        message: '数据库权限不足，请确认云函数配置正确'
+      }
+    } else if (error.code === -502007) {
+      return {
+        success: false,
+        message: '数据库请求超时，请稍后重试'
+      }
+    } else if (error.code === -502023) {
+      return {
+        success: false,
+        message: '数据库容量已满，请联系管理员'
+      }
+    } else if (error.code === -404011) {
+      return {
+        success: false,
+        message: '云函数权限不足，请检查云函数配置'
+      }
+    } else if (error.code === -502005) {
+      return {
+        success: false,
+        message: '数据库集合不存在，请确保数据库初始化成功',
+        errorCode: error.code,
+        errorDetail: '请尝试重新初始化数据库，或检查集合名称是否正确'
+      }
+    } else {
+      return {
+        success: false,
+        message: `服务器错误: ${error.message || error}`,
+        errorCode: error.code,
+        errorDetail: process.env.NODE_ENV === 'production' ? '详细信息已记录' : String(error)
+      }
+    }
+  }
+}
+
+// 检查是否已存在该用户该诗歌的记录
+async function checkExistingRecord(poemId, openid) {
+  if (!poemId || !openid) {
+    return {
+      success: false,
+      message: '古诗ID和用户ID不能为空'
+    }
+  }
+  
+  try {
+    console.log('检查是否存在记录，poemId:', poemId, 'openid:', openid);
+    
+    const result = await reviewCollection
+      .where({
+        poemId: poemId,
+        openid: openid
+      })
+      .orderBy('reciteDateTime', 'desc')
+      .limit(1)
+      .get()
+    
+    console.log('查询结果:', result);
+    
+    if (result.data && result.data.length > 0) {
+      const existingRecord = result.data[0];
+      console.log('找到已存在记录，ID:', existingRecord._id);
+      
+      return {
+        success: true,
+        exists: true,
+        recordId: existingRecord._id,
+        recordData: existingRecord
+      }
+    } else {
+      console.log('未找到已存在记录');
+      return {
+        success: true,
+        exists: false,
+        recordId: null
+      }
+    }
+  } catch (error) {
+    console.error('检查记录失败:', error);
+    throw error;
+  }
+}
+
+// 更新已有背诵记录
+async function updateReviewRecord(recordId, reviewData) {
+  if (!recordId) {
+    return {
+      success: false,
+      message: '记录ID不能为空'
+    }
+  }
+  
+  // 验证必要字段
+  if (!reviewData || !reviewData.poemId || !reviewData.openid) {
+    return {
+      success: false,
+      message: '缺少必要字段'
+    }
+  }
+  
+  // 详细日志记录输入数据
+  console.log('更新记录 - 接收到的原始reviewData数据结构:', Object.keys(reviewData).join(', '))
+  console.log('更新记录 - 接收到的reviewData是否包含content字段:', reviewData.hasOwnProperty('content'))
+  console.log('更新记录 - 接收到的reviewData是否包含score字段:', reviewData.hasOwnProperty('score'))
+  
+  // 先从传入的数据中删除content和score字段，确保不被保存
+  if (reviewData.hasOwnProperty('content')) {
+    console.warn('更新记录 - 发现并删除content字段:', reviewData.content)
+    delete reviewData.content;
+  }
+  if (reviewData.hasOwnProperty('score')) {
+    console.warn('更新记录 - 发现并删除score字段:', reviewData.score)
+    delete reviewData.score;
+  }
+  
+  // 详细日志记录清理后的数据
+  console.log('更新记录 - 清理后reviewData的数据结构:', Object.keys(reviewData).join(', '))
+  
+  // 准备更新数据，只包含需要更新的字段
+  const updateData = {};
+  updateData.poemName = reviewData.poemName || ''; // 古诗名称
+  updateData.accuracy = Number(reviewData.accuracy) || 0; // 正确率，确保是数字类型
+  updateData.duration = Number(reviewData.duration) || 0; // 背诵时长（秒），确保是数字类型
+  updateData.reciteDateTime = reviewData.reciteDateTime || new Date().toISOString(); // 背诵时间
+  updateData.updateTime = db.serverDate(); // 更新时间
+  
+  // 再次明确确认updateData中没有content和score字段
+  if (updateData.hasOwnProperty('content')) {
+    console.error('更新记录 - 警告: updateData中仍存在content字段，将被强制删除!')
+    delete updateData.content;
+  }
+  if (updateData.hasOwnProperty('score')) {
+    console.error('更新记录 - 警告: updateData中仍存在score字段，将被强制删除!')
+    delete updateData.score;
+  }
+  
+  // 详细日志记录最终更新的数据
+  console.log('更新记录 - 最终准备更新的数据结构:', Object.keys(updateData).join(', '))
+  console.log('更新记录 - 最终准备更新的数据:', JSON.stringify(updateData))
+  
+  try {
+    // 执行更新操作
+    const result = await reviewCollection.doc(recordId).update({
+      data: updateData
+    })
+    
+    console.log('背诵记录更新成功，ID:', recordId, '更新结果:', result)
+    
+    // 返回结果
+    return {
+      success: true,
+      _id: recordId,
+      message: '背诵记录更新成功',
+      updatedFields: Object.keys(updateData), // 返回实际更新的字段列表，便于调试
+      stats: result.stats // 返回更新统计信息
+    }
+  } catch (error) {
+    if (error.errCode === -502005) {
+      return {
+        success: false,
+        message: '背诵记录不存在或已被删除'
+      }
+    }
+    throw error
+  }
+}
+
+// 添加背诵记录
+async function addReviewRecord(reviewData) {
+  // 验证必要字段
+  if (!reviewData || !reviewData.poemId || !reviewData.openid) {
+    return {
+      success: false,
+      message: '缺少必要字段'
+    }
+  }
+  
+  // 详细日志记录输入数据
+  console.log('接收到的原始reviewData数据结构:', Object.keys(reviewData).join(', '))
+  console.log('接收到的reviewData是否包含content字段:', reviewData.hasOwnProperty('content'))
+  console.log('接收到的reviewData是否包含score字段:', reviewData.hasOwnProperty('score'))
+  
+  // 先从传入的数据中删除content和score字段，确保不被保存
+  if (reviewData.hasOwnProperty('content')) {
+    console.warn('发现并删除content字段:', reviewData.content)
+    delete reviewData.content;
+  }
+  if (reviewData.hasOwnProperty('score')) {
+    console.warn('发现并删除score字段:', reviewData.score)
+    delete reviewData.score;
+  }
+  
+  // 详细日志记录清理后的数据
+  console.log('清理后reviewData的数据结构:', Object.keys(reviewData).join(', '))
+  
+  // 准备数据，只包含需要的字段 - 使用全新对象创建，不继承任何其他属性
+  const dataToSave = {};
+  dataToSave.openid = reviewData.openid; // 用户ID（必填）
+  dataToSave.poemId = reviewData.poemId; // 古诗ID（必填）
+  dataToSave.poemName = reviewData.poemName || ''; // 古诗名称（与古诗ID挨着放）
+  dataToSave.accuracy = Number(reviewData.accuracy) || 0; // 正确率，确保是数字类型
+  dataToSave.duration = Number(reviewData.duration) || 0; // 背诵时长（秒），确保是数字类型
+  dataToSave.reciteDateTime = reviewData.reciteDateTime || new Date().toISOString(); // 背诵时间
+  dataToSave.createTime = db.serverDate(); // 服务器时间
+  
+  // 再次明确确认dataToSave中没有content和score字段
+  if (dataToSave.hasOwnProperty('content')) {
+    console.error('警告: dataToSave中仍存在content字段，将被强制删除!')
+    delete dataToSave.content;
+  }
+  if (dataToSave.hasOwnProperty('score')) {
+    console.error('警告: dataToSave中仍存在score字段，将被强制删除!')
+    delete dataToSave.score;
+  }
+  
+  // 详细日志记录最终保存的数据
+  console.log('最终准备保存的数据结构:', Object.keys(dataToSave).join(', '))
+  console.log('最终准备保存的背诵记录数据:', JSON.stringify(dataToSave))
+  
+  // 执行保存操作
+  const result = await reviewCollection.add({
+    data: dataToSave
+  })
+  
+  console.log('背诵记录保存成功，ID:', result._id)
+  
+  // 返回结果
+  return {
+    success: true,
+    _id: result._id,
+    message: '背诵记录添加成功',
+    savedFields: Object.keys(dataToSave) // 返回实际保存的字段列表，便于调试
+  }
+}
+
+// 获取单条背诵记录详情
+async function getReviewRecord(recordId) {
+  if (!recordId) {
+    return {
+      success: false,
+      message: '记录ID不能为空'
+    }
+  }
+  
+  try {
+    const result = await reviewCollection.doc(recordId).get()
+    
+    if (result.data) {
+      return {
+        success: true,
+        data: result.data
+      }
+    } else {
+      return {
+        success: false,
+        message: '背诵记录不存在'
+      }
+    }
+  } catch (error) {
+    if (error.errCode === -502005) {
+      return {
+        success: false,
+        message: '背诵记录不存在或已被删除'
+      }
+    }
+    throw error
+  }
+}
+
+// 获取用户的背诵记录列表
+async function getUserReviews(openid, page = 1, pageSize = 20) {
+  if (!openid) {
+    return {
+      success: false,
+      message: '用户ID不能为空'
+    }
+  }
+  
+  try {
+    // 查询总数
+    const countResult = await reviewCollection.where({
+      openid: openid
+    }).count()
+    
+    // 查询分页数据
+    const dataResult = await reviewCollection.where({
+      openid: openid
+    })
+    .orderBy('reciteDateTime', 'desc')
+    .skip((page - 1) * pageSize)
+    .limit(pageSize)
+    .get()
+    
+    return {
+      success: true,
+      data: {
+        reviews: dataResult.data,
+        total: countResult.total,
+        page,
+        pageSize
+      }
+    }
+  } catch (error) {
+    console.error('获取用户背诵记录失败:', error)
+    throw error
+  }
+}
+
+// 获取某首诗的所有背诵记录
+async function getPoemReviews(poemId, page = 1, pageSize = 20) {
+  if (!poemId) {
+    return {
+      success: false,
+      message: '古诗ID不能为空'
+    }
+  }
+  
+  try {
+    // 查询总数
+    const countResult = await reviewCollection.where({
+      poemId: poemId
+    }).count()
+    
+    // 查询分页数据
+    const dataResult = await reviewCollection.where({
+      poemId: poemId
+    })
+    .orderBy('reciteDateTime', 'desc')
+    .skip((page - 1) * pageSize)
+    .limit(pageSize)
+    .get()
+    
+    return {
+      success: true,
+      data: {
+        reviews: dataResult.data,
+        total: countResult.total,
+        page,
+        pageSize
+      }
+    }
+  } catch (error) {
+    console.error('获取古诗背诵记录失败:', error)
+    throw error
+  }
+}
+
+// 删除背诵记录
+async function deleteReviewRecord(recordId) {
+  if (!recordId) {
+    return {
+      success: false,
+      message: '记录ID不能为空'
+    }
+  }
+  
+  try {
+    const result = await reviewCollection.doc(recordId).remove()
+    return {
+      success: true,
+      message: '背诵记录删除成功',
+      data: result
+    }
+  } catch (error) {
+    if (error.errCode === -502005) {
+      return {
+        success: false,
+        message: '背诵记录不存在或已被删除'
+      }
+    }
+    throw error
+  }
+}
+
+// 获取用户背诵统计信息
+async function getReviewStats(openid) {
+  if (!openid) {
+    return {
+      success: false,
+      message: '用户ID不能为空'
+    }
+  }
+  
+  try {
+    // 查询总背诵次数
+    const totalCount = await reviewCollection.where({
+      openid: openid
+    }).count()
+    
+    // 查询今日背诵次数
+    const today = new Date()
+    today.setHours(0, 0, 0, 0)
+    const todayCount = await reviewCollection.where({
+      openid: openid,
+      reciteDateTime: _.gte(today)
+    }).count()
+    
+    // 查询平均正确率（如果有这个字段）
+    const avgResult = await reviewCollection.aggregate()
+      .match({
+        openid: openid
+      })
+      .group({
+        _id: null,
+        avgAccuracy: _.avg('$accuracy'),
+        avgScore: _.avg('$score'),
+        avgDuration: _.avg('$duration')
+      })
+      .end()
+    
+    return {
+      success: true,
+      data: {
+        totalReviews: totalCount.total,
+        todayReviews: todayCount.total,
+        avgAccuracy: avgResult.list[0]?.avgAccuracy || 0,
+        avgScore: avgResult.list[0]?.avgScore || 0,
+        avgDuration: avgResult.list[0]?.avgDuration || 0
+      }
+    }
+  } catch (error) {
+    console.error('获取背诵统计失败:', error)
+    throw error
+  }
+}

pages/cloudfunctions/auth/.tcb_tmp/config.json

@@ -0,0 +1,3 @@
+{
+  "codeChanged": true
+}

pages/cloudfunctions/auth/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "files.autoSave": "afterDelay",
+    "workbench.startupEditor": "readme",
+    "explorer.compactFolders": false,
+    "editor.formatOnSave": true,
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true,
+        "**/*.crswap": true,
+        ".tcb_tmp": true
+    }
+}

pages/cloudfunctions/auth/Readme.md

@@ -0,0 +1,5 @@
+# 云函数空白模板
+
+此模板为云函数的空白文档，使用 Nodejs 运行环境部署。
+
+运行后会返回：{"hello":"world"}，以及请求参数，环境参数。

pages/cloudfunctions/auth/index.js

@@ -0,0 +1,248 @@
+const cloud = require('wx-server-sdk')
+cloud.init({
+  env: cloud.DYNAMIC_CURRENT_ENV
+})
+
+const db = cloud.database()
+
+exports.main = async (event, context) => {
+  const { action } = event
+
+  try {
+    switch (action) {
+      case 'loginWithCode':
+        return await handleLoginWithCode(event)
+      case 'registerUser':
+        return await handleRegisterUser(event)
+      case 'getUserByOpenid':  
+        return await handleGetUserByOpenid(event);
+      default:
+        return {
+          success: false,
+          message: '未知操作'
+        }
+    }
+  } catch (error) {
+    console.error('云函数执行错误:', error)
+    return {
+      success: false,
+      message: '服务器内部错误'
+    }
+  }
+}
+
+// 使用code登录
+async function handleLoginWithCode(event) {
+  const { code } = event
+  
+  if (!code) {
+    return {
+      success: false,
+      message: '缺少code参数'
+    }
+  }
+
+  try {
+    // 1. 通过code调用微信接口获取openid
+    const authResult = await getOpenIdByCode(code)
+    
+    if (!authResult.openid) {
+      return {
+        success: false,
+        message: '获取openid失败'
+      }
+    }
+
+    const openid = authResult.openid
+
+    // 2. 通过openid查询数据库
+    const userResult = await db.collection('users')
+      .where({
+        openid: openid
+      })
+      .get()
+
+    // 3. 如果查询到用户数据，完成登录流程
+    if (userResult.data.length > 0) {
+      const user = userResult.data[0]
+      
+      return {
+        success: true,
+        data: {
+          userInfo: {
+            _id: user._id,
+            openid: user.openid,
+            nickname: user.nickname,
+            avatarUrl: user.avatarUrl,
+            role: user.role,
+            reviewedPoems: user.reviewedPoems,
+            learningStats: user. learningStats,
+          }
+        }
+      }
+    } else {
+      // 4. 如果查询不到用户，返回未注册状态和openid
+      return {
+        success: false,
+        message: '用户未注册',
+        code: 'USER_NOT_REGISTERED',
+        openid: openid
+      }
+    }
+
+  } catch (error) {
+    console.error('登录处理错误:', error)
+    return {
+      success: false,
+      message: '登录失败'
+    }
+  }
+}
+// 注册用户
+async function handleRegisterUser(event) {
+  const { openid, userInfo } = event
+  
+  if (!openid || !userInfo) {
+    return {
+      success: false,
+      message: '缺少必要参数'
+    }
+  }
+
+  try {
+    
+    // 直接创建新用户
+    const newUser = {
+      openid: openid,
+      nickname: userInfo.nickName || '勤奋的小朋友',
+      avatarUrl: userInfo.avatarUrl || 'defaultAvatar',
+      createdAt: db.serverDate(),
+      updatedAt: db.serverDate(),
+      role: true,
+      reviewedPoems:{},
+      // 复习相关数据直接嵌入在用户文档中
+      learningStats: {
+      totalLearned: 0,
+      totalReviewed: 0,
+      lastLearnDate: null
+      }
+    }
+    // 先查询用户是否存在
+    const existingUser = await db.collection('users')
+    .where({ openid: openid })
+    .get()
+    let userId
+    let finalUser
+
+    if (existingUser.data.length > 0) {
+      // 用户存在，更新信息
+      await db.collection('users')
+        .where({ openid: openid })
+        .update({
+          data:{
+            updatedAt: newUser.updatedAt
+          }
+        })
+      userId = existingUser.data[0]._id
+      const updatedUser = await db.collection('users').doc(userId).get()
+      finalUser = updatedUser.data
+    }else{
+      const addResult = await db.collection('users').add({
+        data: newUser
+      })
+      userId = addResult._id
+      // 获取新创建的用户信息
+      const user = await db.collection('users').doc(addResult._id).get()
+      finalUser = user.data
+    }
+    
+
+    // 返回创建的用户信息
+    return {
+      success: true,
+      data: {
+        userInfo: {
+          _id: userId,
+          openid: finalUser.openid,
+          nickname: finalUser.nickname,
+          avatarUrl: finalUser.avatarUrl,
+          role: finalUser.role,
+          reviewedPoems: finalUser.reviewedPoems|| {},
+          learningStats: finalUser.learningStats|| {
+            totalLearned: 0,
+            totalReviewed: 0,
+            lastLearnDate: null
+          }
+        }
+      }
+    }
+
+  } catch (error) {
+    console.error('注册用户错误:', error)
+    return {
+      success: false,
+      message: '注册失败'
+    }
+  }
+}
+// 通过code获取openid
+async function getOpenIdByCode(code) {
+  // 在云函数中，我们可以直接获取到openid，不需要再用code换取
+  // 因为云函数自动包含了用户身份信息
+  const wxContext = cloud.getWXContext()
+  
+  return {
+    openid: wxContext.OPENID,
+    appid: wxContext.APPID,
+    unionid: wxContext.UNIONID
+  }
+}
+async function handleGetUserByOpenid(event) {
+  const { openid } = event;
+  
+  if (!openid) {
+    return {
+      success: false,
+      message: '缺少openid参数'
+    };
+  }
+
+  try {
+    const userResult = await db.collection('users')
+      .where({ openid: openid })
+      .get();
+
+    if (userResult.data.length > 0) {
+      const user = userResult.data[0];
+      return {
+        success: true,
+        data: {
+          userInfo: {
+            _id: user._id,
+            openid: user.openid,
+            nickname: user.nickname,
+            avatarUrl: user.avatarUrl,
+            role: user.role,
+            reviewedPoems: user.reviewedPoems || {},
+            learningStats: user.learningStats || {
+              totalLearned: 0,
+              totalReviewed: 0,
+              lastLearnDate: null
+            }
+          }
+        }
+      };
+    } else {
+      return {
+        success: false,
+        message: '用户不存在'
+      };
+    }
+  } catch (error) {
+    console.error('获取用户信息错误:', error);
+    return {
+      success: false,
+      message: '获取用户信息失败'
+    };
+  }
+}

pages/cloudfunctions/auth/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "auth",
+  "version": "1.0.0",
+  "description": "用户认证云函数",
+  "main": "index.js",
+  "dependencies": {
+    "wx-server-sdk": "~2.6.3"
+  }
+}

pages/cloudfunctions/poemManagement/.tcb_tmp/config.json

@@ -0,0 +1,3 @@
+{
+  "codeChanged": false
+}

pages/cloudfunctions/poemManagement/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "files.autoSave": "afterDelay",
+    "workbench.startupEditor": "readme",
+    "explorer.compactFolders": false,
+    "editor.formatOnSave": true,
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true,
+        "**/*.crswap": true,
+        ".tcb_tmp": true
+    }
+}

pages/cloudfunctions/poemManagement/Readme.md

@@ -0,0 +1,5 @@
+# 云函数空白模板
+
+此模板为云函数的空白文档，使用 Nodejs 运行环境部署。
+
+运行后会返回：{"hello":"world"}，以及请求参数，环境参数。

pages/cloudfunctions/poemManagement/index.js

@@ -0,0 +1,381 @@
+const cloud = require('wx-server-sdk')
+cloud.init({
+  env: 'cloud1-0g2sr1117862afae'
+})
+
+const db = cloud.database()
+const poemsCollection = db.collection('poeties')
+const _ = db.command
+
+exports.main = async (event, context) => {
+  const { action, data, poemId, searchQuery, keyword, page = 1, pageSize = 20 } = event
+  
+  try {
+    switch (action) {
+      case 'getAllPoems':
+        return await handleGetAllPoems(event);
+      case 'getPoemDetail':
+          return await getPoemDetail(event);
+      case 'getInitialPoems':
+        return await getInitialPoems()
+      case 'searchPoemsManager':
+        return await searchPoemsManager(searchQuery)
+      case 'searchPoems':
+          return await searchPoems(event)
+      case 'addPoem':
+        return await addPoem(data)
+      case 'updatePoem':
+        return await updatePoem(poemId, data)
+      case 'deletePoem':
+        return await deletePoem(poemId)
+      default:
+        return {
+          success: false,
+          message: '未知操作类型'
+        }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: error.message
+    }
+  }
+}
+
+async function getPoemDetail(event){
+  const { id } = event;
+  console.log('获取古诗详情，ID:', id)
+  
+  try {
+    // 根据ID从poeties集合中获取古诗详情
+    const result = await db.collection('poeties')
+      .doc(id)
+      .get()
+    
+    console.log('数据库查询结果:', result)
+    
+    if (result.data) {
+      return {
+        success: true,
+        data: result.data
+      }
+    } else {
+      return {
+        success: false,
+        message: '古诗不存在'
+      }
+    }
+  } catch (error) {
+    console.error('获取古诗详情失败:', error)
+    
+    // 更详细的错误信息
+    if (error.errCode === -502005) {
+      return {
+        success: false,
+        message: '古诗不存在或已被删除'
+      }
+    } else if (error.errCode === -501000) {
+      return {
+        success: false,
+        message: '数据库连接失败'
+      }
+    } else {
+      return {
+        success: false,
+        message: '获取古诗详情失败: ' + error.message
+      }
+    }
+  }
+}
+
+async function handleGetAllPoems(event) {
+  try {
+    const result = await db.collection('poeties')
+      .orderBy('title', 'asc')
+      .get();
+
+    return {
+      success: true,
+      data: {
+        poems: result.data,
+        total: result.data.length
+      }
+    };
+  } catch (error) {
+    console.error('获取诗词列表错误:', error);
+    return {
+      success: false,
+      message: '获取诗词失败'
+    };
+  }
+}
+// 获取初始的100条古诗
+async function getInitialPoems() {
+  const result = await poemsCollection.limit(100).get()
+  return {
+    success: true,
+    data: result.data
+  }
+}
+
+// 搜索古诗
+async function searchPoemsManager(searchQuery) {
+  const _ = db.command
+  const result = await poemsCollection.where(
+    _.or([
+      {
+        title: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      },
+      {
+        author: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      },
+      {
+        dynasty: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      },
+      {
+        content: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      },
+      {
+        translation: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      },
+      {
+        background: db.RegExp({
+          regexp: searchQuery,
+          options: 'i'
+        })
+      }
+    ])
+  ).get()
+  
+  return {
+    success: true,
+    data: result.data
+  }
+}
+
+async function searchPoems(event){
+  const { keyword, page = 1, pageSize = 20 } = event;
+  console.log('搜索请求参数:', { keyword, page, pageSize })
+  
+  try {
+    // 如果关键词为空，返回所有数据
+    if (!keyword || keyword.trim() === '') {
+      const allData = await db.collection('poeties')  // 注意集合名称
+        .orderBy('title', 'asc')
+        .skip((page - 1) * pageSize)
+        .limit(pageSize)
+        .get()
+      
+      const countResult = await db.collection('poeties').count()
+      
+      return {
+        success: true,
+        data: {
+          poems: allData.data,
+          total: countResult.total,
+          page,
+          pageSize
+        }
+      }
+    }
+    
+    const searchKeyword = keyword.trim()
+    console.log('搜索关键词:', searchKeyword)
+    
+    // 根据你的数据结构构建搜索条件
+    const searchCondition = _.or([
+      {
+        title: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        author: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        content: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        dynasty: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        'author_info.name': db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        theme: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      },
+      {
+        type: db.RegExp({
+          regexp: searchKeyword,
+          options: 'i'
+        })
+      }
+    ])
+    
+    console.log('搜索条件:', searchCondition)
+    
+    // 执行搜索查询 - 使用正确的集合名称 poeties
+    const [dataResult, countResult] = await Promise.all([
+      db.collection('poeties')  
+        .where(searchCondition)
+        .orderBy('title', 'asc')
+        .skip((page - 1) * pageSize)
+        .limit(pageSize)
+        .get(),
+      db.collection('poeties')  
+        .where(searchCondition)
+        .count()
+    ])
+    
+    console.log('搜索结果:', {
+      找到数据条数: dataResult.data.length,
+      总条数: countResult.total
+    })
+    
+    // 打印第一条数据检查结构
+    if (dataResult.data.length > 0) {
+      console.log('第一条数据样例:', JSON.stringify(dataResult.data[0], null, 2))
+    }
+    
+    return {
+      success: true,
+      data: {
+        poems: dataResult.data,
+        total: countResult.total,
+        page,
+        pageSize
+      }
+    }
+    
+  } catch (error) {
+    console.error('搜索云函数错误:', error)
+    return {
+      success: false,
+      message: '搜索失败: ' + error.message,
+      error: error.message
+    }
+  }
+}
+
+// 添加古诗
+async function addPoem(poemData) {
+  if (!poemData.title || !poemData.dynasty || !poemData.author || !poemData.content) {
+    return {
+      success: false,
+      message: '缺少必要字段'
+    }
+  }
+
+  const newPoem = {
+    title: poemData.title,
+    dynasty: poemData.dynasty,
+    author: poemData.author,
+    content: poemData.content,
+    translation: poemData.translation || '',
+    background: poemData.background || '',
+    author_info: poemData.author_info || {},
+    theme: poemData.theme || [],
+    type: poemData.type || '诗',
+    createTime: db.serverDate(),
+    updateTime: db.serverDate()
+  }
+
+  const result = await poemsCollection.add({
+    data: newPoem
+  })
+  
+  return {
+    success: true,
+    data: result,
+    message: '添加成功'
+  }
+}
+
+// 更新古诗
+async function updatePoem(poemId, updateData) {
+  if (!poemId) {
+    return {
+      success: false,
+      message: '古诗ID不能为空'
+    }
+  }
+
+  if (!updateData.title || !updateData.dynasty || !updateData.author || !updateData.content) {
+    return {
+      success: false,
+      message: '缺少必要字段'
+    }
+  }
+
+  const updateInfo = {
+    title: updateData.title,
+    dynasty: updateData.dynasty,
+    author: updateData.author,
+    content: updateData.content,
+    translation: updateData.translation || '',
+    background: updateData.background || '',
+    author_info: updateData.author_info || {},
+    theme: updateData.theme || [],
+    type: updateData.type || '诗',
+    updateTime: db.serverDate()
+  }
+
+  const result = await poemsCollection.doc(poemId).update({
+    data: updateInfo
+  })
+  
+  return {
+    success: true,
+    data: result,
+    message: '更新成功'
+  }
+}
+
+// 删除古诗
+async function deletePoem(poemId) {
+  if (!poemId) {
+    return {
+      success: false,
+      message: '古诗ID不能为空'
+    }
+  }
+
+  const result = await poemsCollection.doc(poemId).remove()
+  
+  return {
+    success: true,
+    data: result,
+    message: '删除成功'
+  }
+}

pages/cloudfunctions/poemManagement/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "poemManagement",
+  "version": "1.0.0",
+  "description": "古诗管理云函数",
+  "main": "index.js",
+  "dependencies": {
+    "wx-server-sdk": "~2.6.3"
+  }
+}

pages/guiding/guiding.js

@@ -0,0 +1,134 @@
+Page({
+  data: {
+    ifEntry: false,
+    userInfo: null
+  },
+
+  onLoad(options) {
+    // 页面加载时先检查本地缓存
+    this.checkLocalLoginStatus();
+  },
+   // 检查本地登录状态（快速检查）
+   checkLocalLoginStatus() {
+    try {
+      const cachedUserInfo = wx.getStorageSync('userInfo');
+      if (cachedUserInfo) {
+        this.setData({
+          ifEntry: true,
+          userInfo: cachedUserInfo
+        });
+        console.log('从缓存读取用户信息:', cachedUserInfo);
+      } else {
+        this.setData({
+          ifEntry: false,
+          userInfo: null
+        });
+      }
+    } catch (error) {
+      console.error('读取缓存失败:', error);
+      this.setData({ ifEntry: false });
+    }
+  },
+//检查登录状态
+  async checkLoginStatus() {
+    try {
+      // 强制清除缓存，确保从服务器获取最新的用户信息
+      this.clearStorage();
+        // 先检查本地是否有缓存
+      const cachedUserInfo = wx.getStorageSync('userInfo');
+      if (cachedUserInfo) {
+        console.log('使用缓存用户信息，直接进入主页');
+        this.setData({
+          ifEntry: true,
+          userInfo: cachedUserInfo
+        });
+        // 调试日志：查看缓存中的用户角色值
+        console.log('缓存用户角色值:', cachedUserInfo.role, '类型:', typeof cachedUserInfo.role);
+        
+        // 有缓存时直接跳转到主页 - 安全比较，处理不同类型的值
+        if (cachedUserInfo.role === true || cachedUserInfo.role === 'true') {
+          console.log('缓存中为普通用户，跳转到index页面');
+          wx.reLaunch({
+            url: `/pages/index/index?openid=${cachedUserInfo.openid}`
+          });
+        } else {
+          console.log('缓存中为管理员，跳转到managePoem页面');
+          wx.reLaunch({
+            url: `/pages/managePoems/managePoems?openid=${cachedUserInfo.openid}`
+          });
+        }
+        return; // 跳转后可以return，避免后续代码执行
+      }
+      // 1. 如果没有缓存，调用 wx.login() 获取 code
+      const loginRes = await wx.login();
+      const code = loginRes.code;
+
+      if (!code) {
+        console.error('获取code失败');
+        return;
+      }
+      
+       // 2. 调用后端登录接口，将code传给后端
+       const result = await wx.cloud.callFunction({
+        name: 'auth',
+        data: {
+          action: 'loginWithCode',
+          code: code
+        }
+      });
+      if (result.result.success) {
+        const userInfo = result.result.data.userInfo;
+        wx.setStorageSync('userInfo', userInfo);
+        // 登录成功，直接进入用户页面
+        this.setData({
+          ifEntry: true,
+          userInfo: userInfo
+        });
+
+        // 调试日志：查看用户角色值
+        console.log('用户角色值:', userInfo.role, '类型:', typeof userInfo.role);
+        
+        // 跳转到用户首页 - 安全比较，处理不同类型的值
+        if (userInfo.role === true || userInfo.role === 'true') {
+          console.log('普通用户，跳转到index页面');
+          wx.reLaunch({
+            url: `/pages/index/index?openid=${userInfo.openid}`
+          });
+        } else {
+          console.log('管理员，跳转到managePoems页面');
+          wx.reLaunch({
+            url: `/pages/managePoems/managePoems?openid=${userInfo.openid}`
+          });
+        }
+        
+      } else {
+        // 登录失败
+        console.error('登录失败:', result.result.message);
+        this.setData({
+          ifEntry: false
+        });
+        const openid = result.result.openid || '';
+        wx.reLaunch({
+          url: `/pages/login/login?openid=${openid}`
+        });
+      }
+    } catch (error) {
+      console.error('检查登录状态失败:', error);
+      this.clearStorage();
+    }
+  },
+
+  clearStorage() {
+    wx.removeStorageSync('token');
+    wx.removeStorageSync('userInfo');
+    this.setData({ ifEntry: false });
+  },
+  
+
+  // 进入按钮
+  async request_enter() {
+    this.checkLoginStatus();
+    
+    
+  }
+});

pages/index/index.js

@@ -0,0 +1,219 @@
+Page({
+  data: {
+    userInfo: {},
+    openid: '',
+    poems: [],           // 所有诗词列表
+    reviewedPoems: [],   // 需要复习的诗词
+    otherPoems: [], // 其他诗词
+    isLoading: false
+  },
+
+  onLoad(options) {
+    console.log('首页加载完成');
+    if (options.openid) {
+      this.setData({
+        openid: options.openid
+      });
+      console.log('获取到openid:', options.openid);
+      
+      // 根据openid加载用户数据和诗词数据
+      this.loadUserDataAndPoems();
+    } else {
+      console.error('未收到openid参数');
+      wx.showToast({
+        title: '参数错误',
+        icon: 'none'
+      });
+    }
+  },
+
+  // 加载用户数据和诗词数据
+  async loadUserDataAndPoems() {
+    try {
+      this.setData({ isLoading: true });
+      
+      // 并行执行：获取用户信息和诗词列表
+      const [userResult, poemsResult] = await Promise.all([
+        this.getUserInfo(this.data.openid),
+        this.getAllPoems()
+      ]);
+
+      if (userResult.success) {
+        const userInfo = userResult.data.userInfo;
+        this.setData({ 
+          userInfo: userInfo
+        });
+      }
+
+      if (poemsResult.success) {
+        const allPoems = poemsResult.data.poems;
+        
+        // 获取用户的复习记录
+        const reviewResult = await this.getUserReviewRecords(this.data.openid);
+        const reviewedPoemIds = reviewResult.success ? reviewResult.data.reviews.map(item => item.poemId) : [];
+        
+        // 分类诗词：把需要复习的古诗放到末尾
+        const { reviewedPoems, otherPoems, poems } = this.classifyPoems(allPoems, reviewedPoemIds);
+        
+        this.setData({
+          poems: poems,
+          reviewedPoems: reviewedPoems,
+          otherPoems: otherPoems
+        });
+        
+        console.log('复习诗词数量:', reviewedPoems.length);
+        console.log('其他诗词数量:', otherPoems.length);
+      }
+
+    } catch (error) {
+      console.error('加载数据失败:', error);
+      wx.showToast({
+        title: '加载失败',
+        icon: 'none'
+      });
+    } finally {
+      this.setData({ isLoading: false });
+    }
+  },
+
+  // 从Review表获取用户的复习记录
+  async getUserReviewRecords(openid) {
+    try {
+      const result = await wx.cloud.callFunction({
+        name: 'reviewManagement',
+        data: {
+          action: 'getUserReviews',
+          openid: openid,
+          page: 1,
+          pageSize: 100 // 获取所有复习记录
+        }
+      });
+      return result.result;
+    } catch (error) {
+      console.error('获取复习记录失败:', error);
+      return { success: false, message: '获取复习记录失败' };
+    }
+  },
+
+  // 获取用户信息
+  async getUserInfo(openid) {
+    try {
+      const result = await wx.cloud.callFunction({
+        name: 'auth',
+        data: {
+          action: 'getUserByOpenid',
+          openid: openid
+        }
+      });
+      return result.result;
+    } catch (error) {
+      console.error('获取用户信息失败:', error);
+      return { success: false, message: '获取用户信息失败' };
+    }
+  },
+
+  // 获取所有诗词
+  async getAllPoems() {
+    try {
+      const result = await wx.cloud.callFunction({
+        name: 'poemManagement',
+        data: {
+          action: 'getAllPoems'
+        }
+      });
+      return result.result;
+    } catch (error) {
+      console.error('获取诗词列表失败:', error);
+      return { success: false, message: '获取诗词失败' };
+    }
+  },
+
+  // 分类诗词：把需要复习的古诗放到末尾
+  classifyPoems(allPoems, reviewedPoemIds) {
+    const reviewedPoems = [];
+    const otherPoems = [];
+    
+    allPoems.forEach(poem => {
+      if (reviewedPoemIds.includes(poem._id)) {
+        // 需要复习的诗词
+        reviewedPoems.push(poem);
+      } else {
+        // 其他诗词
+        otherPoems.push(poem);
+      }
+    });
+    
+    // 把需要复习的诗词放到其他诗词的末尾
+    const finalPoems = [...otherPoems, ...reviewedPoems];
+    
+    return {
+      reviewedPoems: reviewedPoems,
+      otherPoems: otherPoems,
+      poems: finalPoems  // 最终的诗词列表，复习的放在末尾
+    };
+  },
+
+  // 进入学习页面
+  goToStudy(e) {
+    const poemId = e.currentTarget.dataset.id;
+    wx.navigateTo({
+      url: `/pages/study/study?id=${poemId}`
+    });
+  },
+
+  // 进入背诵页面
+  goToRecite(e) {
+    const poemId = e.currentTarget.dataset.id;
+    console.log('跳转到背诵页面，诗歌ID:', poemId);
+    const poem = this.data.poems.find(p => p._id === poemId);
+    if (poemId && poem) {
+      wx.navigateTo({
+        url: `/pages/recite/recite?id=${poemId}&title=${encodeURIComponent(poem.title)}&author=${encodeURIComponent(poem.author)}`
+      });
+    }
+  },
+
+  review(){
+    const userInfo = this.data.userInfo;
+    console.log('跳转到复习页面，用户信息:', userInfo);
+    wx.navigateTo({
+      url: `/pages/review/review?userInfo=${encodeURIComponent(JSON.stringify(userInfo))}`
+    })
+  },
+
+  question(){
+    wx.navigateTo({
+      url: '/pages/question/question'
+    })
+  },
+
+  search(){
+    wx.navigateTo({
+      url: '/pages/search/search'
+    })
+  },
+
+  onShow() {
+    // 每次显示页面时检查数据
+    if (this.data.openid && this.data.poems.length === 0 && !this.data.isLoading) {
+      this.loadUserDataAndPoems();
+    }
+  },
+
+  onPullDownRefresh() {
+    if (this.data.openid) {
+      this.loadUserDataAndPoems().finally(() => {
+        wx.stopPullDownRefresh();
+      });
+    } else {
+      wx.stopPullDownRefresh();
+    }
+  },
+
+  onShareAppMessage() {
+    return {
+      title: '古诗学习小程序',
+      path: '/pages/index/index'
+    };
+  }
+})