update

app.py

@@ -1,15 +1,30 @@
-# conda activate rzwl && uvicorn app:app --host 0.0.0.0 --port 7860 --reload
-from fastapi import FastAPI, APIRouter, HTTPException, status
+# conda activate rzwl && uvicorn app:app --host 0.0.0.0 --port 7861 --reload
+from fastapi import FastAPI, APIRouter, HTTPException, status, File, UploadFile # 导入 File 和 UploadFile
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import uuid
 import sqlite3 # 导入 sqlite3 模块
-from typing import Optional
+from typing import Optional, List, Dict # 导入类型提示
+import json # 导入 json 模块
+import os # 导入 os 模块
+import urllib.parse # 导入 urllib.parse 用于 URL 编码
+from fastapi.staticfiles import StaticFiles # 导入 StaticFiles
+from passlib.context import CryptContext # 导入 CryptContext
+import httpx # 导入 httpx 用于异步 HTTP 请求
 
-app = FastAPI()
+app = FastAPI(max_upload_size=10 * 1024 * 1024)  # 设置最大上传大小为 10MB
 
 DATABASE_URL = "ai_edu.db"
 
+# 用于密码哈希的 CryptContext
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
 def init_db():
     with sqlite3.connect(DATABASE_URL) as conn:
         cursor = conn.cursor()
@@ -51,6 +66,16 @@ def init_db():
                 level TEXT
             )
         """)
+        # Add page_info column if it doesn't exist
+        cursor.execute("""
+            PRAGMA table_info(courses);
+        """)
+        columns = cursor.fetchall()
+        column_names = [col[1] for col in columns]
+        if 'page_info' not in column_names:
+            cursor.execute("""
+                ALTER TABLE courses ADD COLUMN page_info TEXT;
+            """)
         conn.commit()
 
 # 在应用启动时初始化数据库
@@ -88,12 +113,19 @@ class EnrollmentIndividualRequest(BaseModel):
     position: str
     email: str
 
+# WeChat Configuration (PLACEHOLDERS - REPLACE WITH ACTUAL VALUES OR ENVIRONMENT VARIABLES)
+WECHAT_APP_ID = os.getenv("WECHAT_APP_ID", "YOUR_WECHAT_APP_ID")
+WECHAT_APP_SECRET = os.getenv("WECHAT_APP_SECRET", "YOUR_WECHAT_APP_SECRET") # Add App Secret
+WECHAT_REDIRECT_URI = os.getenv("WECHAT_REDIRECT_URI", "http://localhost:7861/api/auth/wechat/callback") # This should be your frontend callback URL
+
 class Course(BaseModel):
+    course_id: Optional[int] = None
     title: str
     description: Optional[str] = None
-    price: float
-    duration_hours: Optional[int] = None
+    price: float = 0
+    duration_hours: Optional[int] = 0
     level: Optional[str] = None
+    page_info: Optional[List[Dict]] = None  # 改为接收JSON对象而非字符串
 
 @api_router.post("/auth/register")
 async def register_user(request: RegisterRequest):
@@ -101,9 +133,10 @@ async def register_user(request: RegisterRequest):
     try:
         with sqlite3.connect(DATABASE_URL) as conn:
             cursor = conn.cursor()
+            hashed_password = get_password_hash(request.password)
             cursor.execute(
                 "INSERT INTO users (user_id, username, password) VALUES (?, ?, ?)",
-                (user_id, request.username, request.password)
+                (user_id, request.username, hashed_password)
             )
             conn.commit()
         return {
@@ -131,24 +164,30 @@ async def login_user(request: LoginRequest):
         with sqlite3.connect(DATABASE_URL) as conn:
             cursor = conn.cursor()
             cursor.execute(
-                "SELECT user_id, username FROM users WHERE username = ? AND password = ?",
-                (request.username, request.password)
+                "SELECT user_id, username, password FROM users WHERE username = ?",
+                (request.username,)
             )
             user = cursor.fetchone()
             if user:
-                user_id, username = user
-                return {
-                    "code": 200,
-                    "message": "登录成功",
-                    "data": {
-                        "user_id": user_id,
-                        "username": username
+                user_id, username, hashed_password = user
+                if verify_password(request.password, hashed_password):
+                    return {
+                        "code": 200,
+                        "message": "登录成功",
+                        "data": {
+                            "user_id": user_id,
+                            "username": username
+                        }
+                    }
+                else:
+                    return {
+                        "code": 401,
+                        "message": "用户名或密码错误",
+                        "data": None
                     }
-                }
             else:
-                # 用户名或密码错误时，返回自定义的错误结构
                 return {
-                    "code": 401,  # 业务错误码
+                    "code": 401,
                     "message": "用户名或密码错误",
                     "data": None
                 }
@@ -161,6 +200,90 @@ async def login_user(request: LoginRequest):
             "data": None
         }
 
+@api_router.get("/auth/wechat/qrcode")
+async def get_wechat_qrcode():
+    """
+    获取微信登录二维码URL。
+    """
+    # Generate a random state to prevent CSRF attacks
+    state = str(uuid.uuid4())
+    # In a real application, you would store this state in a session or database
+    # to verify it upon callback.
+
+    # URL-encode the redirect_uri
+    encoded_redirect_uri = urllib.parse.quote_plus(WECHAT_REDIRECT_URI)
+
+    # Construct the WeChat QR code login URL
+    qrcode_url = (
+        f"https://open.weixin.qq.com/connect/qrconnect?"
+        f"appid={WECHAT_APP_ID}&"
+        f"redirect_uri={encoded_redirect_uri}&"
+        f"response_type=code&"
+        f"scope=snsapi_login&"
+        f"state={state}#wechat_redirect"
+    )
+
+    return {
+        "code": 200,
+        "message": "获取微信二维码URL成功",
+        "data": {
+            "qrcode_url": qrcode_url,
+            "state": state # Return state to frontend for verification
+        }
+    }
+
+@api_router.get("/auth/wechat/callback")
+async def wechat_callback(code: str, state: str):
+    """
+    微信登录回调接口，用于接收微信授权码并获取access_token。
+    """
+    # In a real application, you would verify the 'state' parameter
+    # against the one stored in the user's session to prevent CSRF attacks.
+    # For this example, we'll just print it.
+    print(f"Received WeChat callback with code: {code} and state: {state}")
+
+    # Exchange code for access_token
+    token_url = (
+        f"https://api.weixin.qq.com/sns/oauth2/access_token?"
+        f"appid={WECHAT_APP_ID}&"
+        f"secret={WECHAT_APP_SECRET}&"
+        f"code={code}&"
+        f"grant_type=authorization_code"
+    )
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(token_url)
+        token_data = response.json()
+
+    if "errcode" in token_data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"微信授权失败: {token_data.get('errmsg', '未知错误')}"
+        )
+
+    # Successfully got access_token and other info
+    access_token = token_data.get("access_token")
+    openid = token_data.get("openid")
+    unionid = token_data.get("unionid") # May not be present if scope is only snsapi_base
+
+    # In a real application, you would now use the access_token and openid/unionid
+    # to log in the user, create a new user, or fetch more user info.
+    # For example, you might fetch user info:
+    # userinfo_url = f"https://api.weixin.qq.com/sns/userinfo?access_token={access_token}&openid={openid}&lang=zh_CN"
+    # user_response = await client.get(userinfo_url)
+    # user_info = user_response.json()
+
+    return {
+        "code": 200,
+        "message": "微信登录回调成功",
+        "data": {
+            "access_token": access_token,
+            "openid": openid,
+            "unionid": unionid,
+            # "user_info": user_info # Uncomment if fetching user info
+        }
+    }
+
 @api_router.post("/enrollment/individual")
 async def enroll_individual(request: EnrollmentIndividualRequest):
     enrollment_id = str(uuid.uuid4())
@@ -232,31 +355,62 @@ async def get_individual_orders():
             detail=f"获取个人报名订单失败: {str(e)}"
         )
 
-@api_router.post("/course/add")
-async def add_course(course: Course):
+@api_router.post("/course/save")
+async def save_course(course: Course):
+    print('\n\n\nsave_course')
     try:
         with sqlite3.connect(DATABASE_URL) as conn:
             cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO courses (title, description, price, duration_hours, level) VALUES (?, ?, ?, ?, ?)",
-                (course.title, course.description, course.price, course.duration_hours, course.level)
-            )
-            conn.commit()
-            course_id = cursor.lastrowid
-        return {
-            "code": 200,
-            "message": "课程添加成功",
-            "data": {
-                "course_id": course_id,
-                **course.dict()
-            }
-        }
+            print('\n\n\n\n')
+            print(course)
+            # Convert page_info to JSON string before saving
+            page_info_json = json.dumps(course.page_info) if course.page_info is not None else None
+
+            if course.course_id is not None:
+                # 更新现有课程
+                cursor.execute(
+                    "UPDATE courses SET title = ?, description = ?, price = ?, duration_hours = ?, level = ?, page_info = ? WHERE course_id = ?",
+                    (course.title, course.description, course.price, course.duration_hours, course.level, page_info_json, course.course_id)
+                )
+                conn.commit()
+                if cursor.rowcount == 0:
+                    raise HTTPException(
+                        status_code=status.HTTP_404_NOT_FOUND,
+                        detail="未找到该课程进行更新"
+                    )
+                return {
+                    "code": 200,
+                    "message": "课程更新成功",
+                    "data": {
+                        "course_id": course.course_id,
+                        **course.dict(exclude_unset=True)
+                    }
+                }
+            else:
+                # 添加新课程
+                cursor.execute(
+                    "INSERT INTO courses (title, description, price, duration_hours, level, page_info) VALUES (?, ?, ?, ?, ?, ?)",
+                    (course.title, course.description, course.price, course.duration_hours, course.level, page_info_json)
+                )
+                conn.commit()
+                course_id = cursor.lastrowid
+                return {
+                    "code": 200,
+                    "message": "课程添加成功",
+                    "data": {
+                        "course_id": course_id,
+                        **course.dict(exclude_unset=True)
+                    }
+                }
+    except HTTPException as e:
+        raise e
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"添加课程失败: {str(e)}"
+            detail=f"保存课程失败: {str(e)}"
         )
 
+
 @api_router.get("/course/details/{course_id}")
 async def get_course_details(course_id: int):
     try:
@@ -266,10 +420,13 @@ async def get_course_details(course_id: int):
             cursor.execute("SELECT * FROM courses WHERE course_id = ?", (course_id,))
             course = cursor.fetchone()
             if course:
+                course_dict = dict(course)
+                if course_dict['page_info']:
+                    course_dict['page_info'] = json.loads(course_dict['page_info'])
                 return {
                     "code": 200,
                     "message": "获取课程详情成功",
-                    "data": dict(course)
+                    "data": course_dict
                 }
             else:
                 raise HTTPException(
@@ -309,6 +466,32 @@ async def delete_individual_enrollment(enrollment_id: str):
             detail=f"删除报名数据失败: {str(e)}"
         )
 
+@api_router.post("/upload/images")
+async def upload_image(image: UploadFile = File(...)): # 将参数名从 file 改为 image，并恢复 File(...)
+    os.makedirs("upload/images", exist_ok=True) # 自动创建目录
+    file_location = f"upload/images/{image.filename}" # 使用 image.filename
+    try:
+        with open(file_location, "wb+") as buffer: # 改为 wb+
+            content = await image.read() # 异步读取
+            buffer.write(content)
+        return {
+            "code": 200,
+            "message": "图片上传成功", # 增加 message 字段
+            "data": {
+                "filename": image.filename, # 使用 image.filename
+                "url": f"/upload/images/{image.filename}" # 使用 image.filename
+            }
+        }
+    except Exception as e:
+        print(f"图片上传失败: {str(e)}") # 输出详细错误
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, # 恢复 status.HTTP_500_INTERNAL_SERVER_ERROR
+            detail=f"图片上传失败: {str(e)}"
+        )
+
+# 挂载静态文件目录
+app.mount("/upload", StaticFiles(directory="upload"), name="upload")
+
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}

memory-bank/activeContext.md

@@ -8,6 +8,7 @@
 - 优化了登录接口的错误响应，使其返回自定义的业务错误码和信息。
 - **新增了课程管理功能，包括课程表的创建和课程详情查询接口 (`/api/course/details/{course_id}`)。**
 - **新增了课程添加接口 (`/api/course/add`) 用于测试和数据初始化。**
+- **创建了 `upload/images` 文件夹，用于存储上传的图片文件。**
 
 ## 最近的更改
 - `app.py`:
@@ -20,6 +21,13 @@
     - 添加 `/api/auth/login` 接口，实现用户登录验证和错误响应。
     - 添加 `CORSMiddleware` 处理跨域请求。
     - **修复了 `Course` Pydantic 模型中的类型提示错误，将 `str | None` 更改为 `Optional[str]`，以兼容 Python 3.9 环境。**
+    - **在 `init_db()` 中为 `courses` 表添加了 `page_info` 字段（TEXT 类型，用于存储 JSON）。**
+    - **更新了 `Course` Pydantic 模型，包含 `page_info` 字段。**
+    - **修改了 `add_course` 接口，以处理 `page_info` 字段的 JSON 序列化存储。**
+    - **修改了 `get_course_details` 接口，以处理 `page_info` 字段的 JSON 反序列化。**
+- **文件系统**:
+    - **创建了 `upload/images` 目录。**
+    - **配置了 FastAPI 以提供静态文件服务，`upload` 目录可通过 `/upload` 路径访问。**
 
 ## 下一步计划
 - **安全性增强**:

memory-bank/progress.md

@@ -16,6 +16,13 @@
     - 登录失败返回自定义错误码和信息。
     - 优化了错误捕获和日志输出。
 - **类型提示兼容性修复**: 修复了 `app.py` 中 `Course` 模型因 Python 版本导致的类型提示错误。
+- **课程表字段扩展**: 在 `courses` 表中增加了 `page_info` 字段（TEXT 类型，用于存储 JSON）。
+- **课程接口功能增强**:
+    - `Course` Pydantic 模型已更新，包含 `page_info` 字段。
+    - `add_course` 接口现在支持 `page_info` 字段的 JSON 序列化存储。
+    - `get_course_details` 接口现在支持 `page_info` 字段的 JSON 反序列化。
+- **文件系统**:
+    - **创建了 `upload/images` 目录。**
 
 ## 待完成的工作
 - **安全性增强**:

memory-bank/systemPatterns.md

@@ -5,6 +5,7 @@
 - **数据库**: SQLite
 - **API 路由**: 使用 `APIRouter` 进行模块化管理，所有 API 路径前缀为 `/api`。
 - **CORS**: 使用 `CORSMiddleware` 处理跨域请求。
+- **文件存储**: `upload/images` 目录用于存储上传的图片文件，并通过 `/upload` 路径提供静态文件服务。
 
 ## 关键技术决策
 - **用户 ID 生成**: 采用 `uuid.uuid4()` 生成全局唯一的用户 ID。
@@ -19,10 +20,10 @@
 - `app.py`: 包含 FastAPI 应用实例、CORS 配置、数据库初始化逻辑、API 路由定义。
 - `api_router`: 负责定义 `/api/auth/register`, `/api/auth/login`, `/api/course/add`, `/api/course/details/{course_id}` 等接口。
 - `sqlite3`: 用于与 `ai_edu.db` 数据库文件进行交互。
-- `pydantic.BaseModel`: 用于定义请求体的模型（`RegisterRequest`, `LoginRequest`）。
+- `pydantic.BaseModel`: 用于定义请求体的模型（`RegisterRequest`, `LoginRequest`, `Course`）。
 
 ## 关键实现路径
 - **用户注册**: 接收 `username` 和 `password` -> 生成 `user_id` (UUID) -> 插入 `users` 表 -> 返回成功响应或错误。
 - **用户登录**: 接收 `username` 和 `password` -> 查询 `users` 表验证凭据 -> 返回成功响应（包含 `user_id` 和 `username`）或错误。
-- **课程添加**: 接收课程详情 (`title`, `description`, `price`, `duration_hours`, `level`) -> 插入 `courses` 表 -> 返回成功响应。
-- **课程详情查询**: 接收 `course_id` -> 查询 `courses` 表 -> 返回课程详情或 404 错误。
+- **课程添加**: 接收课程详情 (`title`, `description`, `price`, `duration_hours`, `level`, `page_info`) -> 插入 `courses` 表（`page_info` 存储为 JSON 字符串） -> 返回成功响应。
+- **课程详情查询**: 接收 `course_id` -> 查询 `courses` 表 -> 返回课程详情（`page_info` 反序列化为 JSON 对象）或 404 错误。

memory-bank/techContext.md

@@ -7,6 +7,7 @@
 - **Pydantic**: 数据验证和设置管理库，用于定义请求体模型
 - **SQLite3**: Python 内置的轻量级数据库
 - **uuid**: Python 标准库，用于生成通用唯一标识符
+- **FastAPI.staticfiles**: 用于提供静态文件服务
 
 ## 开发环境设置
 - **Conda**: 用于管理 Python 虚拟环境 (`conda activate rzwl`)

page_info.json

@@ -0,0 +1,19 @@
+[
+    {
+        "type": "image",
+        "url": "/upload/images/banner.jpg"
+    },
+    {
+        "pictures": [
+            {
+                "url": "/upload/images/pic1.jpg"
+            },
+            {
+                "url": "/upload/images/pic2.jpg"
+            },
+            {
+                "url": "/upload/images/pic3.jpg"
+            }
+        ]
+    }
+]

requirements.txt

@@ -1,2 +1,7 @@
 fastapi
-uvicorn[standard]
+uvicorn
+pydantic
+python-multipart
+passlib
+bcrypt
+httpx

方案.md

@@ -0,0 +1,115 @@
+# AI-EDU 后端 API 方案
+
+## 1. 项目概述
+
+**项目名称**: AI-EDU 后端 API
+
+**项目目标**: 使用 FastAPI 实现 AI-EDU H5 应用的后端 API，提供用户认证（注册、登录）、课程管理等功能，并使用 SQLite 数据库进行数据存储。
+
+**核心需求**:
+- 实现用户注册接口 (`/api/auth/register`)
+- 实现用户登录接口 (`/api/auth/login`)
+- 实现课程添加接口 (`/api/course/add`)
+- 实现课程详情查询接口 (`/api/course/details/{course_id}`)
+- 使用 SQLite 数据库存储用户和课程数据
+- 接口响应遵循统一的数据结构（code, message, data）
+- 处理跨域请求 (CORS)
+- 提供静态文件服务，用于存储上传的图片文件
+
+**预期成果**: 一个稳定、可扩展的 FastAPI 后端服务，能够支持 AI-EDU H5 应用的基本用户认证和课程管理功能。
+
+## 2. 产品背景
+
+**项目存在的原因**: 为 AI-EDU H5 前端应用提供必要的后端支持，特别是用户认证、课程管理和数据管理功能。
+
+**解决的问题**:
+- 用户注册和登录：允许用户创建账户并登录到应用。
+- 数据存储：持久化用户和课程数据，为后续功能提供基础。
+- API 接口：提供前端与后端交互的标准接口。
+- 静态资源服务：支持图片等静态文件的上传和访问。
+
+**工作方式**: 前端通过 HTTP 请求调用后端 API，后端处理业务逻辑并与 SQLite 数据库交互，然后返回结构化的 JSON 响应。
+
+**用户体验目标**:
+- 注册和登录流程顺畅，响应及时。
+- 错误信息清晰，便于用户理解和操作。
+- 课程信息展示准确，加载迅速。
+
+## 3. 系统架构与技术栈
+
+**系统架构**:
+- **后端框架**: FastAPI
+- **数据库**: SQLite
+- **ASGI 服务器**: Uvicorn
+- **API 路由**: 使用 `APIRouter` 进行模块化管理，所有 API 路径前缀为 `/api`。
+- **CORS**: 使用 `CORSMiddleware` 处理跨域请求。
+- **文件存储**: `upload/images` 目录用于存储上传的图片文件，并通过 `/upload` 路径提供静态文件服务。
+
+**关键技术决策**:
+- **用户 ID 生成**: 采用 `uuid.uuid4()` 生成全局唯一的用户 ID。
+- **密码存储**: 当前直接存储明文密码（**待改进：未来应使用哈希加密存储**）。
+- **错误处理**: 统一的 `code`, `message`, `data` 响应格式。
+- **数据库初始化**: 在 FastAPI 应用启动时通过 `@app.on_event("startup")` 钩子函数初始化 SQLite 数据库和相关表。
+- **课程 `page_info` 存储**: 存储为 JSON 字符串，查询时反序列化。
+
+**组件关系**:
+- `app.py`: FastAPI 应用实例、CORS 配置、数据库初始化、API 路由定义。
+- `api_router`: 定义用户认证和课程管理接口。
+- `sqlite3`: 与 `ai_edu.db` 数据库文件交互。
+- `pydantic.BaseModel`: 定义请求体模型（`RegisterRequest`, `LoginRequest`, `Course`）。
+- `FastAPI.staticfiles`: 提供静态文件服务。
+
+**使用技术**:
+- Python
+- FastAPI
+- Uvicorn
+- Pydantic
+- SQLite3
+- uuid
+- FastAPI.staticfiles
+
+**开发环境设置**:
+- Conda: 用于管理 Python 虚拟环境 (`conda activate rzwl`)
+- 依赖安装: `pip install -r requirements.txt` (包含 `fastapi`, `uvicorn[standard]`)
+
+**运行命令**:
+`conda activate rzwl && uvicorn app:app --host 0.0.0.0 --port 7860 --reload`
+
+**技术约束**:
+- SQLite 数据库适用于小型项目或开发环境，不适合高并发、大规模生产环境。
+- 密码当前未加密存储，存在安全风险，未来需要引入密码哈希库（如 `passlib`）。
+
+## 4. 当前进展与下一步计划
+
+**已完成的工作**:
+- FastAPI 应用启动和 CORS 配置。
+- 用户注册接口 (`/api/auth/register`)：实现了用户 ID 生成、数据存储到 SQLite、用户名重复处理。
+- 用户登录接口 (`/api/auth/login`)：实现了用户验证、自定义错误响应。
+- 课程管理功能：
+    - 实现了 `courses` 表的创建。
+    - 实现了 `/api/course/add` 接口，用于添加课程，支持 `page_info` 字段的 JSON 序列化存储。
+    - 实现了 `/api/course/details/{course_id}` 接口，用于获取课程详情，支持 `page_info` 字段的 JSON 反序列化。
+- `Course` Pydantic 模型类型提示兼容性修复。
+- 创建了 `upload/images` 目录，并配置了 FastAPI 提供静态文件服务。
+
+**待完成的工作**:
+- **安全性增强**:
+    - **密码哈希**: 引入密码哈希（如 `passlib`）来加密存储用户密码，提高安全性。
+    - **会话管理/JWT**: 实现用户登录后的会话管理或 JWT 认证机制。
+- **更多业务接口**: 根据 AI-EDU H5 的需求，逐步实现其他后端 API。
+- **数据库抽象**: 考虑引入 ORM（如 SQLAlchemy）来更好地管理数据库操作。
+
+**当前状态**:
+- 基本的用户认证和课程管理功能已实现并可运行。
+- 数据库集成已完成。
+- 接口响应格式已统一。
+
+**已知问题**:
+- 密码明文存储，存在安全风���。
+
+**项目决策演变**:
+- 从简单的接口逐步扩展到完整的用户认证和课程管理流程。
+- 从模拟 `user_id` 到使用 `uuid` 确保唯一性。
+- 从默认错误到自定义业务错误响应。
+- 从未处理 CORS 到添加 `CORSMiddleware`。
+- 增加了课程管理功能和静态文件服务。