add:教师端新增删除课程，增加并更换footer-brief模板

修复progress Bar和提示美化

Html/.gitattributes

@@ -0,0 +1 @@
+Html/config.ini merge=ours

Html/app_back.py

@@ -1,480 +0,0 @@
-from bootstrap import bootstrap_paths
-bootstrap_paths()
-from functools import wraps
-from flask import Flask, redirect, session, request, jsonify, render_template, send_from_directory, url_for
-from flask_cors import CORS
-from flask_socketio import SocketIO, join_room, emit, Namespace
-import markdown
-import os
-import uuid
-import shutil
-import sys
-import json
-from apps.auth.decorators import require_role
-parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-sys.path.insert(0, parent_dir)
-student_workspace_root_path =  os.path.abspath(os.path.join(os.path.dirname(__file__), '../study'))
-current_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '.'))
-sys.path.insert(0, current_dir)
-from AlgoriAgent.projects.algoriAgent.agent_manager import AgentManager
-
-
-import configparser
-
-from db.user_list import UserList
-from db.user import User, load_user_from_json, create_user_json
-from db.course_list import CourseList
-from db.course import Course, load_course_from_json
-GLOBAL_CONFIG = configparser.ConfigParser()
-GLOBAL_CONFIG.read('config.ini')
-VSCODE_WEB_URL = GLOBAL_CONFIG['VSCODE_WEB']['url']
-USER_DATA_DIR = GLOBAL_CONFIG['USER_DATA']['dir']
-COURSE_DATA_DIR = GLOBAL_CONFIG['COURSE_DATA']['dir']
-
-app = Flask(__name__)
-socketio = SocketIO(app, cors_allowed_origins="*",ping_timeout=60, ping_interval=5)
-# socketio = SocketIO(app, cors_allowed_origins="http://localhost:9888")  # 设置跨域支持
-import logging
-app.secret_key = 'cakebaker' 
-app.logger.setLevel(logging.DEBUG)
-# 配置 CORS
-CORS(app, resources={r"/*": {"origins": VSCODE_WEB_URL},}, supports_credentials=True)
-
-
-userid_recorder = {} # user_id&path -> session['user_id']
-
-'''
-Backboard 
-'''
-from backboardManager import BackBoardManager, Backboard
-
-backboard_manager = BackBoardManager()
-uuid2username = {}
-username2uuid = {}
-
-
-
-# 定义命名空间：用于和 VSCode 插件交流
-class VSCodeNamespace(Namespace):
-    def on_login(self,data):
-        print("VSCode client connected")
-        print(data)
-        dataconfig = data['config']
-        user_id = dataconfig.get('user_id')
-        path = dataconfig.get('path')
-        course_id = dataconfig.get('course_id')
-        lesson_id = dataconfig.get('chapter_id')
-        print(f"User {user_id} connected with path: {path}")
-        useruuid = username2uuid[user_id]
-        join_room(useruuid, namespace='/vscode')
-        if backboard_manager.get_backboard(useruuid) == None:
-            backboard_manager.add_backboard(useruuid,user_id, course_id, lesson_id, path)
-
-
-    def on_message(self, data):
-        print(f"Received from VSCode client: {data}")
-        dataconfig = data['config']
-        realtime_response(dataconfig, data)
-        # emit('response', {'message': 'Config data received and connection established'})
-    def on_disconnect(self, data):
-        print("VSCode client disconnected")
-        print("Disconnect reason:"+str(data))
-
-
-def realtime_response(config, realtime_action):
-    user_id = config['user_id']
-    folder_path = config['path']
-    useruuid = username2uuid[user_id]
-    bb = backboard_manager.get_backboard(useruuid)
-    assert type(bb) == Backboard
-
-    bb.add_history(realtime_action)
-
-    if realtime_action['type'] == 'workspaceFolders':
-        bb.file_tree = realtime_action['fileTree']
-    
-    if realtime_action['type'] == 'activeFile':
-        file_path = realtime_action['filePath']
-        assert type(file_path) == str
-        with open(f"{file_path}") as f:
-            bb.active_file_content = f.read()
-        
-    if realtime_action['type'] == 'paste':
-        file_path = realtime_action['filePath']
-        assert type(file_path) == str
-        bb.pasted_file_path = file_path
-        bb.pasted_content = realtime_action['content']
-        bb.active_file_path = file_path
-        with open(f"{file_path}") as f:
-            bb.active_file_content = f.read()
-        
-    
-    if realtime_action['type'] == 'fileEdit':
-        file_path = realtime_action['filePath']
-        assert type(file_path) == str
-        bb.active_file_path = file_path
-        with open(f"{file_path}") as f:
-            bb.active_file_content = f.read()
-
-
-
-
-    print("config"+str(config))
-    print("realtime_action"+str(realtime_action))
-    pass
-
-
-'''
-Agent and Chat
-'''
-agent_manager = AgentManager(app = app, socketio = socketio)
-user_threads = {}
-import threading
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-# 初始化线程池
-executor = ThreadPoolExecutor(max_workers=10)
-class AgentNamespace(Namespace):
-    def on_login(self, data):
-        data = json.loads(data)
-        user = data['username']
-        course_id = data['course_id']
-        chapter_id = data['chapter_id']
-        user_uuid = username2uuid[user]
-        session['user_id'] = user_uuid
-        print(f'User connected with session user_id: {user_uuid}')
-        # 从markdown、markdown_prompts、score_prompts中各读取数据folder.md并进行new_agent
-        with open(f'books/markdown/{course_id}/{chapter_id}.md','r',encoding='UTF-8') as fmd,\
-            open(f'books/markdown_prompts/{course_id}/{chapter_id}.md','r',encoding='UTF-8')as fmdp,\
-            open(f'books/score_prompts/{course_id}/{chapter_id}.md','r',encoding='UTF-8') as fsp:
-            markdown = fmd.read()
-            markdown_prompts = fmdp.read()
-            score_prompts = fsp.read()
-            user_uuid, agent = agent_manager.new_agent(course_id, chapter_id, markdown, markdown_prompts, score_prompts, id=user_uuid, 
-                                                       root_path=f'../../study/{user}/{course_id}/{chapter_id}')
-            print(user_uuid)
-            join_room(user_uuid, namespace='/agent')  # 将该用户加入以user_id为名的room
-        backboard_manager.add_backboard(user_uuid, user, course_id, chapter_id, root_path=f'../../study/{user}/{course_id}/{chapter_id}')
-
-    def on_language(self, language):
-        id = session.get('user_id')
-        agent_manager.change_language(id, language)
-
-    def on_message(self, data):
-        print(f"Message from client: {data}")
-        id = session.get('user_id')
-        if (type(data)==str):
-            data = json.loads(data)
-        print(id)
-        if data['type'] == 'text':
-            res = agent_manager.invoke(id, data['data'], backboard_manager.get_backboard(id).get_info_prompt())
-            print('=*='*20)
-            print(res.content)
-            reply = f"{res.content['speak']}"
-            with app.app_context(): 
-                emit('message',reply, room=id, namespace='/agent')
-                emit('request_function',res.content['function'], room=id, namespace='/agent')
-
-        if data['type'] == 'function':
-            agent_manager.function_call(id, data['data'])
-
-    def on_initiative(self,data):
-        print("User active function call")
-        user_id = session['user_id']
-        if data['name'] == 'sample_judge':
-            agent_manager.sample_judge(user_id, backboard_manager.get_backboard(user_id))
-        if data['name'] == 'judge':
-            agent_manager.judge(user_id, backboard_manager.get_backboard(user_id))
-
-
-
-    def on_disconnect(self,data):
-        print("VSCode client disconnected")
-        print("Disconnect reason:"+str(data))
-
-
-
-'''
-Markdown to HTML
-'''
-# 配置文件路径
-MARKDOWN_DIR = 'books/markdown'   # 存放 markdown 文件的文件夹
-STATIC_DIR = 'static'       # 存放生成的 HTML 和图片资源的文件夹
-IMAGE_DIR = 'image'         # 图片资源相对于 markdown 的位置
-
-
-
-@app.route('/<course_id>-<filename>-markdown', methods=['GET'])
-def convert_md(course_id, filename):
-    md_file_path = os.path.join(MARKDOWN_DIR,course_id, f'{filename}.md')
-    
-    if not os.path.exists(md_file_path):
-        return jsonify({'error': 'Markdown file not found'}), 404
-
-    # 读取 markdown 文件内容
-    with open(md_file_path, 'r', encoding='utf-8') as file:
-        md_content = file.read()
-
-    # 将 markdown 转换为 HTML
-    html_content = markdown.markdown(md_content)
-        # 插入 CSS 样式，限制图片最大宽度为 100%，高度自动调整
-    html_with_styles = f"""
-    <html>
-    <head>
-        <style>
-            img {{
-                max-width: 100%;
-                height: auto;
-            }}
-        </style>
-        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.2.0/github-markdown.min.css">
-    </head>
-    <body>
-        {html_content}
-    </body>
-    </html>
-    """
-    # 保存 HTML 文件到 static 文件夹
-    html_output_path = os.path.join(STATIC_DIR, f'{filename}.html')
-    with open(html_output_path, 'w', encoding='utf-8') as html_file:
-        html_file.write(html_with_styles)
-
-    # 处理图片资源，将 image/xxx 文件夹拷贝到 static/image/xxx
-    image_source_dir = os.path.join(MARKDOWN_DIR,course_id, IMAGE_DIR, filename)
-    image_target_dir = os.path.join(STATIC_DIR, IMAGE_DIR, filename)
-    print(f"Copying image resources from {image_source_dir} to {image_target_dir}")
-    if os.path.exists(image_source_dir):
-        # 确保 static/image/xxx 目录存在
-        if not os.path.exists(image_target_dir):
-            os.makedirs(image_target_dir)
-
-        # 拷贝图片资源
-        for image_file in os.listdir(image_source_dir):
-            full_image_file_path = os.path.join(image_source_dir, image_file)
-            if os.path.isfile(full_image_file_path):
-                shutil.copy(full_image_file_path, image_target_dir)
-
-    return jsonify({'html_url': f'/static/{filename}.html'})
-
-# 静态文件（HTML 和图片资源）的访问
-@app.route('/static/<path:filename>')
-def serve_static(filename):
-    return send_from_directory(STATIC_DIR, filename)
-
-
-'''
-Vscode
-'''
-@app.route('/desktop/<user_id>/<course_id>/<chapter_id>')
-def desktop(user_id, course_id, chapter_id):
-    if 'user_id' not in session:
-        # return redirect(url_for('login'))
-        session['user_id'] = 'user_' + str(uuid.uuid4())
-    print("user "+ user_id + "uuid is"+ session['user_id'])
-    username2uuid[user_id] = session['user_id']
-    uuid2username[session['user_id']] = user_id
-    userid_recorder[user_id+'&'+course_id] = session['user_id']
-
-    # 在学习目录下创建一个名为 user_id_path 的文件夹
-    path_dir = os.path.join(student_workspace_root_path, user_id, course_id,chapter_id)
-    os.makedirs(path_dir, exist_ok=True)
-    # 在此文件夹内部创建一个.config文件，并写入 user_id=user_id\n path=path
-    config_path = os.path.join(path_dir, '.config')
-    if GLOBAL_CONFIG['VSCODE_WEB_PATH']['is_wsl']: # 如果是在 WSL 中运行，则将路径转换为 WSL 路径
-        path_dir = path_dir.replace('\\', '/')
-        path_dir = path_dir.replace(GLOBAL_CONFIG['VSCODE_WEB_PATH']['windows_path'] , GLOBAL_CONFIG['VSCODE_WEB_PATH']['wsl_path'])
-    with open(config_path, 'w', encoding='utf-8') as f:
-        tmpd = {'user_id': user_id, 'course_id': course_id, 'chapter_id': chapter_id, 'path': path_dir}
-        json.dump(tmpd, f)
-    print('---------------------')
-    print(config_path)
-    return render_template('desktop.html', vscode_web_url=VSCODE_WEB_URL, user_id=user_id, course_id=course_id, chapter_id=chapter_id, workspace_path=path_dir)
-
-@app.route('/desktop_nouser/<course_id>/<chapter_id>')
-def desktop_nouser(course_id, chapter_id):
-    if 'user_id' not in session:
-        return redirect(url_for('login'))
-    user_id = session['user_id']
-    username = uuid2username[user_id]
-    return redirect(url_for('desktop', user_id=username, course_id=course_id, chapter_id=chapter_id))
-
-@app.route('/vscode_data', methods=['POST'])
-def vscode_data():
-    data = request.json
-    config = data['config']
-    realtime_response(config,data)
-    print(f"Received data from VSCode: {data}")
-    return jsonify({"status": "success", "received": data})
-
-
-
-'''
-Login
-
-'''
-users_list = UserList()
-course_list = CourseList()
-
-
-@app.route('/register')
-def register():
-    return render_template('register.html')
-
-@app.route('/register_teacher')
-def register_teacher():
-    return render_template('register_teacher.html')
-
-@app.route('/register_teacher_post', methods=['POST'])
-def register_teacher_post():
-    data = request.get_json()
-    username = data.get('username')
-    password = data.get('password')
-    if users_list.has_user(username) is not None:
-        users_list.add_user(username, password, teacher=True)
-        create_user_json(username, USER_DATA_DIR)
-        return jsonify({'success': True, 'message': '注册成功'})
-    else: return jsonify({'success': False, 'message': '用户已存在，请更换用户名'})
-
-@app.route('/register_post', methods=['POST'])
-def register_post():
-    data = request.get_json()
-    username = data.get('username')
-    password = data.get('password')
-    if users_list.has_user(username) is not None:
-        users_list.add_user(username, password)
-        create_user_json(username, USER_DATA_DIR)
-        return jsonify({'success': True, 'message': '注册成功'})
-    else: return jsonify({'success': False, 'message': '用户已存在，请更换用户名'})
-
-
-@app.route('/login')
-def login():
-    return render_template('login.html')
-    if 'user_id' not in session:
-        return render_template('login.html')
-    else:
-        return redirect(url_for('/'))
-
-@app.route('/login_post', methods=['POST'])
-def login_post():
-    # 获取请求的 JSON 数据
-    data = request.get_json()
-    
-    username = data.get('username')
-    password = data.get('password')
-
-    pswd = users_list.get_user_pswd(username) 
-    
-    if pswd is None:
-        return jsonify({'success': False, 'message': '用户名或密码错误'})
-    if pswd != password:
-        return jsonify({'success': False, 'message': '用户名或密码错误'})
-    
-    session['user_id'] = 'user_' + str(uuid.uuid4())
-    print("user "+ username + "uuid is"+ session['user_id'])
-    username2uuid[username] = session['user_id']
-    uuid2username[session['user_id']] = username
-    return jsonify({'success': True, 'message': '登录成功'})
-
-@app.route('/login_teacher_post', methods=['POST'])
-def login_teacher_post():
-    data = request.get_json()
-    username = data.get('username')
-    password = data.get('password')
-    pswd = users_list.get_user_pswd(username) 
-    is_teacher = users_list.get_user_is_teacher(username)
-    if is_teacher is None or is_teacher == False:
-        return jsonify({'success': False, 'message': '用户名不存在或非教师账号'})
-    if pswd is None:
-        return jsonify({'success': False, 'message': '用户名或密码错误'})
-    if pswd != password:
-        return jsonify({'success': False, 'message': '用户名或密码错误'})
-    session['user_id'] = 'user_' + str(uuid.uuid4())
-    print("user "+ username + "uuid is"+ session['user_id'])
-    username2uuid[username] = session['user_id']
-    uuid2username[session['user_id']] = username
-    return jsonify({'success': True, 'message': '登录成功'})
-
-@app.route('/teacherboard')
-@require_role(roles="teacher")
-def teacherboard():
-    return render_template('teacherboard.html')
-
-
-@app.route('/logout')
-def logout():
-    session.pop('user_id', None)
-    return redirect(url_for('login'))
-
-@app.route('/get_session')
-def get_session():
-    user_session = session.get('user_id', 'default_session')
-    return jsonify({"session": user_session})
-
-
-'''
-DashBoard
-'''
-user_id2UserClass = {}
-@app.route('/dashboard')
-@require_role
-def dashboard():
-    user_id = session['user_id']
-    username = uuid2username[user_id]
-    if (user_id not in user_id2UserClass):
-        user_id2UserClass[user_id] = load_user_from_json(username, user_data_dir = USER_DATA_DIR)
-    user_course_data = []
-    for course_id in user_id2UserClass[user_id].select_course:
-        course_brief_info = course_list.get_course_brief_info(course_id, load_course_from_json(course_id, course_data_dir = COURSE_DATA_DIR))
-        user_course_data.append(course_brief_info)
-    return render_template('dashboard.html',user_data = user_id2UserClass[user_id].to_json_without_dialog(), user_course_data = json.dumps(user_course_data))
-
-'''
-Course
-'''
-
-@app.route('/course/<course_id>')
-@require_role
-def course(course_id):
-    c = load_course_from_json(course_id, course_data_dir = COURSE_DATA_DIR)
-    return render_template('course.html', course_id=course_id, course_data=c)
-
-@app.route('/select_course', methods=['POST'])
-@require_role
-def select_course():
-    user = user_id2UserClass[session['user_id']]
-    data = request.get_json() 
-    course_id = data.get('course_id')
-    if course_id:
-        user.select_new_course(course_id, load_course_from_json(course_id, COURSE_DATA_DIR))
-        return jsonify({'success': True, 'message': '课程选择成功'})
-
-
-@app.route('/')
-@require_role
-def home_index():
-    selected_courses=[]
-    if ('user_id' in session):
-        if (session['user_id'] not in user_id2UserClass): return redirect(url_for('login'))
-        user = user_id2UserClass[session['user_id']]
-        for course_id in user.select_course:
-            selected_courses.append(course_id)
-    
-    return render_template('index.html', courses_data = course_list, selected_courses =selected_courses)
-
-# 一些app辅助函数，主要提供给Agent与数据库的交互能力
-
-class MyFunction:
-    def save_chapter_memory(self, id, course_id, lesson_id, subchapter_title, mem_list, score, is_rebuttal):
-        print("-=-=-=-=-=-=-=-")
-        print(id, course_id, lesson_id, subchapter_title, mem_list, score, is_rebuttal)
-        username = uuid2username[id]
-        u = load_user_from_json(username, user_data_dir = USER_DATA_DIR)
-        u.save_chapter_memory(course_id, lesson_id, subchapter_title, mem_list, score, is_rebuttal)
-
-app.my_function = MyFunction()
-if __name__ == '__main__':
-    socketio.on_namespace(VSCodeNamespace('/vscode'))
-    socketio.on_namespace(AgentNamespace('/agent'))
-    socketio.run(app, host='0.0.0.0', port=5551, debug=False,allow_unsafe_werkzeug=True)
-

Html/apps/_docs/ACK_SUPPORT_GUIDE.md

@@ -0,0 +1,124 @@
+# ACK机制支持指南
+
+## 概述
+
+客户端已实现基于emit机制的ACK确认功能，允许客户端在发送消息后等待服务器确认，从而支持同步和异步两种通信模式。
+
+## 客户端改动
+
+### 1. 新增参数
+
+客户端的三个主要发送方法 `send_text`、`send_voice` 和 `send_image` 都新增了以下参数：
+
+- `wait_for_ack: bool = False` - 是否等待服务器ACK确认
+- `timeout: int = 5` - 等待ACK的超时时间（秒）
+
+### 2. 消息格式变化
+
+客户端发送的消息中新增了 `ack_id` 字段，格式为 `{id}_{timestamp}`，其中：
+- `id` 是客户端ID
+- `timestamp` 是当前时间的格式化字符串（精确到微秒）
+
+### 3. ACK事件
+
+客户端监听 `ack` 事件，用于接收服务器的确认消息。
+
+## 后端WebSocket服务器需要的支持
+
+### 1. 接收消息处理
+
+当服务器收到客户端发送的消息时，需要：
+
+1. 检查消息中是否包含 `ack_id` 字段
+2. 如果包含 `ack_id`，立即发送ACK确认消息，不需要等待后续业务逻辑执行
+3. 继续执行后续的业务逻辑
+
+### 2. ACK消息格式
+
+服务器需要向客户端发送 `ack` 事件，消息格式如下：
+
+```json
+{
+  "ack_id": "客户端发送的ack_id值"
+}
+```
+
+### 3. 发送ACK的时机
+
+**非常重要**：服务器必须在收到客户端消息后**立即**发送ACK确认，而不是在业务逻辑执行完成后发送。这样可以确保客户端能够快速收到确认，继续执行后续操作。
+
+### 4. 实现示例（Python Socket.IO）
+
+```python
+# 服务器端示例代码
+@sio.on('text_message')  # 根据实际事件名调整
+def handle_text_message(sid, data):
+    # 1. 立即发送ACK确认
+    if 'ack_id' in data:
+        sio.emit('ack', {'ack_id': data['ack_id']}, room=sid)
+    
+    # 2. 执行后续业务逻辑（可能耗时较长）
+    # ... 业务逻辑代码 ...
+    
+@sio.on('voice_message')  # 根据实际事件名调整
+def handle_voice_message(sid, data):
+    # 1. 立即发送ACK确认
+    if 'ack_id' in data:
+        sio.emit('ack', {'ack_id': data['ack_id']}, room=sid)
+    
+    # 2. 执行后续业务逻辑（可能耗时较长）
+    # ... 业务逻辑代码 ...
+    
+@sio.on('image_message')  # 根据实际事件名调整
+def handle_image_message(sid, data):
+    # 1. 立即发送ACK确认
+    if 'ack_id' in data:
+        sio.emit('ack', {'ack_id': data['ack_id']}, room=sid)
+    
+    # 2. 执行后续业务逻辑（可能耗时较长）
+    # ... 业务逻辑代码 ...
+```
+
+## 使用示例
+
+### 客户端同步调用（等待ACK）
+
+```python
+client = ASEngineClient(server_url, namespace, id)
+client.connect()
+
+# 同步调用：等待ACK确认后再继续执行
+result = client.send_text('text_message', 'Hello', wait_for_ack=True, timeout=3)
+if result:
+    print("消息已被服务器确认收到")
+    # 执行后续操作
+else:
+    print("等待ACK超时")
+```
+
+### 客户端异步调用（不等待ACK）
+
+```python
+client = ASEngineClient(server_url, namespace, id)
+client.connect()
+
+# 异步调用：发送后立即返回，不等待ACK
+result = client.send_text('text_message', 'Hello', wait_for_ack=False)
+if result:
+    print("消息已发送")
+    # 执行后续操作，不需要等待ACK
+```
+
+## 注意事项
+
+1. **向后兼容**：客户端的改动保持了向后兼容性，现有代码无需修改即可继续使用。
+2. **超时处理**：客户端会在指定的超时时间后停止等待ACK，并返回False。
+3. **资源清理**：客户端会在收到ACK或超时时清理相关的ACK状态，避免内存泄漏。
+4. **唯一标识**：`ack_id` 确保了每个消息的唯一性，避免ACK混淆。
+5. **性能考虑**：等待ACK会阻塞当前线程，建议仅在必要时使用同步模式。
+
+## 总结
+
+通过实现基于emit机制的ACK确认功能，客户端和服务器之间的通信可以灵活支持同步和异步两种模式。服务器需要做的改动非常简单，只需要在收到消息后立即发送ACK确认即可。
+
+这种设计既保证了通信的可靠性，又不会影响业务逻辑的执行效率，是一种高效且可靠的通信方式。

Html/apps/_docs/ase_engine_data_sync.md

@@ -0,0 +1,326 @@
+# ASEngine 数据同步机制文档
+
+## 1. 概述
+
+本文档介绍了如何通过 `learning_progess_process.py` 实现与 ASEngine（大模型框架后端）之间的运行时数据下载和上传。该机制为客户端与大模型服务之间提供了可靠的数据同步方案，适用于需要在不同服务之间共享和同步用户数据的场景。
+
+## 2. 使用场景
+
+### 2.1 核心场景
+
+- **用户学习进度同步**：将用户在客户端的学习进度同步到大模型框架后端，确保跨设备访问一致性
+- **对话历史管理**：从大模型框架获取用户对话历史，用于客户端展示和分析
+- **多服务数据共享**：在客户端应用与大模型服务之间建立数据桥接，实现数据互通
+- **分布式系统协作**：支持多个服务实例之间的数据同步，确保系统一致性
+
+### 2.2 扩展场景
+
+- **离线数据同步**：支持在网络恢复后进行数据同步
+- **数据备份与恢复**：通过上传/下载机制实现数据备份和恢复。
+- **多租户数据隔离**：通过 namespace_token 实现不同租户数据隔离
+
+## 3. 实现原理
+
+### 3.1 系统架构
+
+```
+┌─────────────────────────┐       ┌─────────────────────────┐
+│       客户端应用         │       │       ASEngine          │
+│  (learning_progess_process.py) │       (大模型框架后端)    │
+├─────────────────────────┤       ├─────────────────────────┤
+│ 1. get_multiagents_dialog_list │  ←─── 下载数据 ────  │ /api/sync/download │
+│ 2. upload_learning_progress_to_cloud │  ──── 上传数据 ────→  │ /api/sync/upload   │
+└─────────────────────────┘       └─────────────────────────┘
+```
+
+### 3.2 数据流向
+
+1. **数据下载流程**：
+
+   - 客户端调用 `get_multiagents_dialog_list()` 方法
+   - 发送 POST 请求到 ASEngine 的 `/api/sync/download` 接口
+   - 获取用户对话历史数据
+   - 数据用于本地处理或存储
+2. **数据上传流程**：
+
+   - 客户端调用 `upload_learning_progress_to_cloud()` 方法
+   - 序列化待上传的数据（处理特殊类型如 datetime）
+   - 发送 POST 请求到 ASEngine 的 `/api/sync/upload` 接口
+   - 接收上传结果并记录日志
+
+## 4. 核心功能说明
+
+### 4.1 数据下载功能
+
+```python
+def get_multiagents_dialog_list(user_id: str) -> List[Dict]:
+    """
+    从 MultiAgents 框架获取用户对话列表
+  
+    参数：
+    - user_id: 用户ID
+  
+    返回：
+    - Dict[List]: 对话列表(key 为 History database)
+    """
+    # 实现细节...
+```
+
+**功能特点**：
+
+- 从配置中动态获取 ASEngine URL 和认证信息
+- 支持超时控制（10秒）
+- 完善的错误处理和日志记录
+- 返回结构化数据，便于后续处理
+
+### 4.2 数据上传功能
+
+```python
+def upload_learning_progress_to_cloud(progress: Dict) -> Dict:
+    """
+    将学习进度上传到云服务
+  
+    参数：
+    - progress: 学习进度数据字典
+  
+    返回：
+    - Dict: 上传结果，包含success和message字段
+    """
+    # 实现细节...
+```
+
+**功能特点**：
+
+- 自动处理数据序列化，支持复杂数据类型
+- 完善的错误处理机制
+- 详细的日志记录，便于问题排查
+- 返回标准化结果格式
+
+### 4.3 辅助功能
+
+#### 4.3.1 学习进度保存
+
+```python
+def save_learning_progress(chatmanager, user_id: str) -> bool:
+    """
+    保存用户学习进度到MongoDB
+    """
+    # 实现细节...
+```
+
+#### 4.3.2 学习进度加载
+
+```python
+def load_learning_progress(user_id: str, material_id: str, chapter_name: str, lesson_name: str) -> Dict:
+    """
+    加载用户学习进度
+    """
+    # 实现细节...
+```
+
+## 5. 配置方法
+
+### 5.1 环境配置
+
+在 Flask 应用的配置中添加以下配置项：
+
+```python
+# ASEngine 配置
+ASE_ENGINE_URL = "https://your-ase-engine-url.com"  # ASEngine 服务地址
+ASE_ENGINE_URL_TOKEN = "your-namespace-token"  # 命名空间认证令牌
+```
+
+### 5.2 依赖安装
+
+确保项目中已安装以下依赖：
+
+```bash
+pip install requests  # HTTP 请求库
+pip install pymongo   # MongoDB 驱动（如果使用MongoDB存储）
+```
+
+## 6. 使用示例
+
+### 6.1 数据下载示例
+
+```python
+from apps.services.course_services.learning_progess_process import get_multiagents_dialog_list
+
+# 获取用户对话历史
+dialog_list = get_multiagents_dialog_list(user_id="user123")
+
+# 处理对话数据
+his_data = dialog_list.get('data', [])
+for dialog in his_data:
+    # 处理单个对话
+    print(f"对话ID: {dialog.get('id')}, 内容: {dialog.get('content')}")
+```
+
+### 6.2 数据上传示例
+
+```python
+from apps.services.course_services.learning_progess_process import upload_learning_progress_to_cloud
+
+# 准备待上传的数据
+progress_data = {
+    "user_id": "user123",
+    "multiagents_dialogs": {
+        "databases": {...},  # 对话数据库
+        "global_databases": {...},  # 全局数据库
+        "session_info_out": {...}  # 会话信息
+    }
+}
+
+# 上传数据到 ASEngine
+result = upload_learning_progress_to_cloud(progress_data)
+
+# 处理上传结果
+if result["success"]:
+    print("数据上传成功")
+else:
+    print(f"数据上传失败: {result['message']}")
+```
+
+### 6.3 完整流程示例
+
+```python
+from apps.services.course_services.learning_progess_process import (
+    get_multiagents_dialog_list,
+    save_learning_progress,
+    load_learning_progress,
+    upload_learning_progress_to_cloud
+)
+
+# 1. 从 ASEngine 获取对话历史
+dialog_list = get_multiagents_dialog_list(user_id="user123")
+
+# 2. 保存到本地 MongoDB
+save_learning_progress(chatmanager, user_id="user123")
+
+# 3. 从本地加载学习进度
+progress = load_learning_progress(
+    user_id="user123",
+    material_id="material456",
+    chapter_name="第1章",
+    lesson_name="第1节"
+)
+
+# 4. 将学习进度上传回 ASEngine
+if progress["exists"]:
+    upload_result = upload_learning_progress_to_cloud(progress["data"])
+    print(f"上传结果: {upload_result}")
+```
+
+## 7. 代码结构与扩展
+
+### 7.1 核心模块
+
+| 模块            | 功能描述                   | 文件位置                                                      |
+| --------------- | -------------------------- | ------------------------------------------------------------- |
+| 数据同步服务    | 处理与 ASEngine 的数据交互 | `apps/services/course_services/learning_progess_process.py` |
+| JSON 序列化工具 | 处理复杂数据类型序列化     | `apps/utils/json_serializer.py`                             |
+| 配置管理        | 管理 ASEngine 连接配置     | `apps/config.py`                                            |
+
+### 7.2 扩展建议
+
+1. **添加重试机制**：
+
+   ```python
+   def upload_with_retry(progress: Dict, max_retries: int = 3) -> Dict:
+       for i in range(max_retries):
+           result = upload_learning_progress_to_cloud(progress)
+           if result["success"]:
+               return result
+           time.sleep(1)  # 指数退避算法可进一步优化
+       return {"success": False, "message": f"上传失败，已重试{max_retries}次"}
+   ```
+2. **添加数据校验**：
+
+   ```python
+   def validate_progress_data(progress: Dict) -> bool:
+       """验证进度数据格式"""
+       required_fields = ["user_id", "multiagents_dialogs"]
+       for field in required_fields:
+           if field not in progress:
+               return False
+       return True
+   ```
+3. **支持异步操作**：
+
+   ```python
+   import asyncio
+   import aiohttp
+
+   async def async_upload_learning_progress(progress: Dict) -> Dict:
+       """异步上传学习进度"""
+       # 异步实现
+       pass
+   ```
+
+## 8. 最佳实践
+
+### 8.1 错误处理
+
+- 始终检查 API 返回结果的 `success` 字段
+- 实现适当的日志记录，便于问题排查
+- 对网络异常和超时进行合理处理
+
+### 8.2 性能优化
+
+- 避免频繁的小数据上传，考虑批量处理
+- 对大文件进行压缩后上传
+- 合理设置超时时间，避免长时间阻塞
+
+### 8.3 安全性
+
+- 确保 ASEngine URL 和令牌安全存储，避免硬编码
+- 使用 HTTPS 协议进行数据传输
+- 对敏感数据进行加密处理
+
+### 8.4 监控与告警
+
+- 添加数据同步成功率监控
+- 对同步失败情况进行告警
+- 记录详细的操作日志，便于审计
+
+## 9. 后续项目参考建议
+
+### 9.1 架构设计
+
+- **分层设计**：将数据同步逻辑与业务逻辑分离，提高代码可维护性
+- **接口标准化**：定义统一的数据格式和接口规范，便于扩展
+- **依赖注入**：使用依赖注入模式，提高代码可测试性
+
+### 9.2 代码实现
+
+- **模块化**：将不同功能模块拆分为独立函数或类
+- **类型注解**：使用 Type Hints 提高代码可读性和类型安全性
+- **文档完善**：为每个函数添加详细的文档字符串
+- **测试覆盖**：编写单元测试和集成测试，确保功能正确性
+
+### 9.3 扩展功能
+
+- **支持多种数据格式**：如 JSON、Protobuf 等
+- **添加数据版本控制**：支持不同版本数据的兼容处理
+- **实现增量同步**：只同步变化的数据，提高同步效率
+- **支持断点续传**：对于大文件上传实现断点续传功能
+
+## 10. 总结
+
+本文档介绍了基于 `learning_progess_process.py` 实现的 ASEngine 数据同步机制，包括使用场景、实现原理、核心功能、配置方法和使用示例。该机制为客户端与大模型服务之间提供了可靠的数据同步方案，可作为后续项目的参考模板。
+
+通过遵循本文档中的最佳实践和扩展建议，可以构建更加健壮、高效和可扩展的数据同步系统，满足不同场景下的数据同步需求。
+
+## 11. 版本历史
+
+| 版本 | 日期       | 描述         | 作者         |
+| ---- | ---------- | ------------ | ------------ |
+| v1.0 | 2025-12-10 | 初始版本     | 系统自动生成 |
+| v1.1 | YYYY-MM-DD | 添加异步支持 | XXX          |
+| v1.2 | YYYY-MM-DD | 实现增量同步 | XXX          |
+
+## 12. 参考资料
+
+- [Flask 官方文档](https://flask.palletsprojects.com/)
+- [Requests 库文档](https://requests.readthedocs.io/)
+- [ASEngine API 文档](https://your-ase-engine-docs.com/)

Html/apps/_docs/json_serializer_usage.md

@@ -0,0 +1,113 @@
+# JSON Serializer 用法文档
+
+## 概述
+
+`json_serializer` 是一个通用的JSON序列化工具，用于处理Python中常见的非JSON序列化类型，如`datetime`、`date`、`time`、`ObjectId`等。
+
+## 支持的类型
+
+- `datetime`: 转换为ISO格式字符串
+- `date`: 转换为ISO格式字符串
+- `time`: 转换为ISO格式字符串
+- `ObjectId`: 转换为字符串
+- `bytes`: 转换为UTF-8字符串
+- `set`/`frozenset`: 转换为列表
+- 其他不可序列化类型: 转换为字符串表示
+
+## 安装位置
+
+位于 `apps/utils/json_serializer.py`
+
+## 使用方法
+
+### 导入
+
+```python
+from apps.utils.json_serializer import json_serialize, json_serialize_dict, JSONEncoder
+```
+
+### 函数说明
+
+1. **json_serialize(obj)**: 将对象序列化为JSON字符串
+   - 参数: `obj` - 要序列化的对象
+   - 返回: JSON字符串
+
+2. **json_serialize_dict(obj)**: 将对象转换为可JSON序列化的字典
+   - 参数: `obj` - 要序列化的对象
+   - 返回: 可JSON序列化的字典
+
+3. **JSONEncoder**: 自定义JSON编码器类，可直接用于`json.dumps()`
+
+### 示例
+
+#### 基本使用
+
+```python
+from datetime import datetime
+from apps.utils.json_serializer import json_serialize_dict
+
+# 创建包含datetime的字典
+data = {
+    "user_id": "test_user",
+    "updated_at": datetime.now(),
+    "scores": [85, 90, 95]
+}
+
+# 序列化
+serialized = json_serialize_dict(data)
+print(serialized)
+# 输出: {"user_id": "test_user", "updated_at": "2025-12-10T15:30:45.123456", "scores": [85, 90, 95]}
+```
+
+#### 在API请求中使用
+
+```python
+import requests
+from apps.utils.json_serializer import json_serialize_dict
+
+# 准备请求数据
+data = {
+    "user_id": "test_user",
+    "updated_at": datetime.now(),
+    "progress": {"chapter1": "completed", "chapter2": "in_progress"}
+}
+
+# 序列化数据
+serialized_data = json_serialize_dict(data)
+
+# 发送请求
+response = requests.post(
+    "https://api.example.com/upload",
+    json=serialized_data,
+    headers={"Content-Type": "application/json"}
+)
+```
+
+#### 直接使用JSONEncoder
+
+```python
+import json
+from datetime import datetime
+from apps.utils.json_serializer import JSONEncoder
+
+# 创建数据
+data = {"updated_at": datetime.now()}
+
+# 使用自定义编码器
+json_str = json.dumps(data, cls=JSONEncoder, ensure_ascii=False)
+print(json_str)
+# 输出: {"updated_at": "2025-12-10T15:30:45.123456"}
+```
+
+## 应用场景
+
+1. API请求中的数据序列化
+2. 保存数据到文件或数据库
+3. 跨服务数据传输
+4. 日志记录中的复杂对象序列化
+
+## 注意事项
+
+- 对于自定义对象，会尝试序列化其`__dict__`属性
+- 对于无法序列化的类型，会转换为字符串表示
+- 确保导入路径正确，特别是在不同模块中使用时

Html/apps/_docs/前端/helpTip.md

@@ -0,0 +1,165 @@
+# HelpTip 组件文档
+
+## 功能介绍
+
+HelpTip 是一个通用的提示框组件，用于在鼠标悬停时显示提示信息。它具有以下特点：
+
+- 提示框跟随鼠标移动
+- 支持多行文本
+- 自动防出界
+- 平滑的显示/隐藏动画
+- 支持在不同页面复用
+- 代码标准化，易于维护
+
+## 文件结构
+
+```
+/static/
+├── css/
+│   └── helpTip.css    # 样式文件
+└── js/
+    └── helpTip.js     # 核心功能文件
+```
+
+## 使用方法
+
+### 1. 引入文件
+
+在需要使用 HelpTip 的 HTML 页面中引入以下文件：
+
+```html
+<!-- 样式文件 -->
+<link rel="stylesheet" href="/static/css/helpTip.css">
+
+<!-- 功能文件 -->
+<script src="/static/js/helpTip.js"></script>
+```
+
+### 2. 基本用法
+
+```javascript
+// 获取需要绑定提示框的元素
+const element = document.getElementById('target-element');
+
+// 绑定提示框
+attachImmediateTooltip(element, '这是一条提示信息');
+```
+
+### 3. 支持换行的提示信息
+
+```javascript
+attachImmediateTooltip(element, `这是一条\n多行提示信息\n\n支持换行符`);
+```
+
+### 4. 与问号图标配合使用
+
+```html
+<!-- HTML -->
+<span>这是一个元素<span class="help-icon">?</span></span>
+```
+
+```javascript
+// JavaScript
+const helpIcon = document.querySelector('.help-icon');
+attachImmediateTooltip(helpIcon, '这是一条详细的提示信息');
+```
+
+## API 说明
+
+### attachImmediateTooltip(anchorEl, text)
+
+绑定提示框到指定元素。
+
+#### 参数
+
+- `anchorEl` (HTMLElement): 触发提示框的元素
+- `text` (string): 提示框显示的文本内容，支持换行符 `\n`
+
+#### 返回值
+
+- `Function`: 清理函数，用于移除事件监听器
+
+## 样式说明
+
+### 问号图标样式
+
+| 类名 | 说明 |
+|------|------|
+| `.help-icon` | 问号图标基础样式 |
+| `.help-icon:hover` | 问号图标悬停样式 |
+
+### 提示框样式
+
+| 类名 | 说明 |
+|------|------|
+| `.tooltip-portal` | 提示框基础样式 |
+| `.tooltip-portal.show` | 提示框显示状态 |
+| `.tooltip-portal.fade` | 提示框动画效果 |
+
+## 示例场景
+
+### 1. 进度条提示
+
+```javascript
+// 为进度条的每个阶段绑定提示框
+for (let i = 0; i < progressItems.length; i++) {
+    const item = progressItems[i];
+    attachImmediateTooltip(item, `阶段 ${i + 1}: ${item.title}`);
+}
+```
+
+### 2. 表单字段提示
+
+```javascript
+// 为表单字段绑定提示框
+const formFields = document.querySelectorAll('.form-field');
+formFields.forEach(field => {
+    const tip = field.getAttribute('data-tip');
+    if (tip) {
+        attachImmediateTooltip(field, tip);
+    }
+});
+```
+
+### 3. 工具栏图标提示
+
+```javascript
+// 为工具栏图标绑定提示框
+const toolbarIcons = document.querySelectorAll('.toolbar-icon');
+toolbarIcons.forEach(icon => {
+    const title = icon.getAttribute('title');
+    if (title) {
+        attachImmediateTooltip(icon, title);
+    }
+});
+```
+
+## 注意事项
+
+1. 确保在 DOM 加载完成后再调用 `attachImmediateTooltip` 函数
+2. 如果元素是动态生成的，需要在元素生成后再绑定提示框
+3. 提示框会自动添加到 `document.body` 中，不会被父元素的 `overflow` 属性裁切
+4. 提示框的 `z-index` 为 999999，确保它能覆盖所有元素
+5. 提示框默认支持多行文本，使用 `white-space: pre-wrap` 样式
+
+## 浏览器兼容性
+
+- Chrome/Edge (最新版)
+- Firefox (最新版)
+- Safari (最新版)
+
+## 代码优化建议
+
+1. 对于大量元素需要绑定提示框的情况，建议使用事件委托
+2. 如果页面中不再需要使用提示框，可以调用返回的清理函数移除事件监听器
+3. 提示文本应简洁明了，避免过长
+
+## 更新日志
+
+- v1.0.0: 初始版本，实现了基本的提示框功能
+- v1.0.1: 优化了样式，增加了动画效果
+- v1.0.2: 支持多行文本，自动防出界
+
+## 贡献指南
+
+如果您发现问题或有改进建议，欢迎提出 Issue 或 Pull Request。

Html/apps/config.py

@@ -48,4 +48,5 @@ class Config:
     }
 
     ASE_ENGINE_URL = GLOBAL_CONFIG['ASE_ENGINE']['url']
+    ASE_ENGINE_URL_TOKEN = GLOBAL_CONFIG['ASE_ENGINE']['url_token']
     ASE_ENGINE_NAMESPACE = GLOBAL_CONFIG['ASE_ENGINE']['namespace']

Html/apps/extension_ase/ase_client/client.py

@@ -5,6 +5,7 @@ import os
 from datetime import datetime
 from typing import Dict, Callable, Any, Optional
 from functools import partial
+from threading import Event
 
 class ASEngineClient:
     def __init__(self, server_url: str, namespace: str, id:str):
@@ -29,9 +30,8 @@ class ASEngineClient:
         self._on_connect_callback_entry=None
         self._on_connect_callback_initData=None
         
-
-
-        # 注册基础事件处理函数
+        # ACK相关
+        self.ack_events: Dict[str, Event] = {}  # 存储ack_id和对应的Event对象
         self._register_base_events()
         
     def _register_base_events(self):
@@ -43,7 +43,11 @@ class ASEngineClient:
             self.sid = self.sio.get_sid(namespace=self.namespace)
             print(f"Connected to server. SID: {self.sid}")
             if self._on_connect_callback is not None:
-                self._on_connect_callback(self._on_connect_callback_entry, self._on_connect_callback_initData)
+                self._on_connect_callback(
+                    self,
+                    self._on_connect_callback_entry,
+                    init_data=self._on_connect_callback_initData
+                )
 
         # 断开连接事件
         @self.sio.on('disconnect', namespace=self.namespace)
@@ -62,28 +66,59 @@ class ASEngineClient:
         @self.sio.on('response', namespace=self.namespace)
         def on_response(data):
             print(f"Received response: {data}")
+        
+        # ACK事件处理
+        @self.sio.on('ack', namespace=self.namespace)
+        def on_ack(data):
+            ack_id = data.get('ack_id')
+            if ack_id and ack_id in self.ack_events:
+                event = self.ack_events[ack_id]
+                event.set()  # 触发事件，通知等待的线程
             
     def register_on_connect_entry(self, callback: Callable, entry: Any, init_data: Any)->bool:
+        """注册连接事件回调函数
+        
+        参数:
+        - callback: 连接事件回调函数，接受 **kwargs 参数
+        - entry: 回调关联的条目对象
+        - init_data: 初始化数据
+        
+        回调关键字参数:
+        - entry: 回调关联的条目对象
+        - init_data: 初始化数据
+        """
         if not callable(callback):
             return False
         self._on_connect_callback = callback
         self._on_connect_callback_entry=entry
         self._on_connect_callback_initData=init_data
+        return True
 
 
     def register_route_with_entry(self, route: str,
                                 callback: Optional[Callable] = None,
                                 entry: Any = None,
                                 init_data: Optional[Any] = None) -> bool:
+        """注册带条目的路由回调函数
+        
+        参数:
+        - route: 路由名称
+        - callback: 回调函数，接受 **kwargs 参数
+        - entry: 回调关联的条目对象
+        - init_data: 初始化数据
+        
+        回调关键字参数:
+        - entry: 回调关联的条目对象
+        - data: 接收到的消息数据
+        - init_data: 初始化数据
+        """
         if not route:
             print("Route cannot be empty")
             return False
 
         if callback is None:
             bound_cb = self._default_callback
-        else:
-            bound_cb = partial(callback, entry)  # 等价于 lambda data, init: callback(entry, data, init)
-
+        else:bound_cb = callback
         self.routes[route] = {
             'callback': bound_cb,
             'entry': entry,
@@ -98,8 +133,9 @@ class ASEngineClient:
                 return
             cb = route_info['callback']          # 已经绑定过 entry
             init = route_info.get('init_data')
+            entry = route_info.get('entry')
             try:
-                cb(data, init)                   # 现在只传 data / init_data
+                cb(self, entry, data=data, init_data=init)    # 传递关键字参数
             except Exception as e:
                 print(f"Callback error on route '{_route}': {e}")
 
@@ -107,11 +143,17 @@ class ASEngineClient:
 
         
     def register_route(self, route: str, callback: Optional[Callable] = None, init_data: Optional[Any] = None):
-        """
-        注册一个路由及其回调函数
-        :param route: 路由名称
-        :param callback: 回调函数，接收消息数据作为参数
-        :return: 是否注册成功
+        """注册路由回调函数
+        
+        参数:
+        - route: 路由名称
+        - callback: 回调函数，接受 **kwargs 参数
+        - init_data: 初始化数据
+        
+        回调关键字参数:
+        - entry: 回调关联的条目对象（此处为 None）
+        - data: 接收到的消息数据
+        - init_data: 初始化数据
         """
         if not route:
             print("Route cannot be empty")
@@ -119,7 +161,9 @@ class ASEngineClient:
         
         # 存储路由和回调
         self.routes[route] = {
-            'callback': callback if callback else self._default_callback
+            'callback': callback if callback else self._default_callback,
+            'entry': None,
+            'init_data': init_data
         }
         
         # 注册事件处理器
@@ -128,15 +172,27 @@ class ASEngineClient:
             print(f"Received message on route '{route}': {data}")
             if 'callback' in self.routes[route]:
                 try:
-                    self.routes[route]['callback'](None, data, init_data)
+                    self.routes[route]['callback'](
+                        self,
+                        entry=None,
+                        data=data,
+                        init_data=init_data
+                    )
                 except Exception as e:
                     print(f"Error in callback for route '{route}': {e}")
             
         print(f"Route '{route}' registered successfully")
         return True
         
-    def _default_callback(self, entry: Any, data: Any, init_data: Optional[Any] = None):
-        """默认回调函数"""
+    def _default_callback(self, **kwargs):
+        """默认回调函数
+        
+        关键字参数:
+        - entry: 回调关联的条目对象
+        - data: 接收到的消息数据
+        - init_data: 初始化数据
+        """
+        data = kwargs.get('data', {})
         print(f"Default callback received: {data}")
         
     def connect(self, timeout: int = 5) -> bool:
@@ -169,12 +225,16 @@ class ASEngineClient:
             self.sid = None
             print("Disconnected from server")
         
-    def send_text(self, route: str, text: str, id:str="") -> bool:
+    def send_text(self, route: str, text: str, id:str="", wait_for_ack: bool = False, timeout: int = 5, return_event: bool = False) -> Any:
         """
         发送文本消息
         :param route: 目标路由
         :param text: 要发送的文本
-        :return: 是否发送成功
+        :param id: 发送者ID
+        :param wait_for_ack: 是否等待服务器ACK确认
+        :param timeout: 等待ACK的超时时间（秒）
+        :param return_event: 是否返回事件对象和ack_id而不是等待ACK
+        :return: 如果wait_for_ack为True且return_event为False，返回是否收到ACK；如果return_event为True，返回(event, ack_id)；否则返回是否发送成功
         """
         if not self.connected:
             print("Not connected to server")
@@ -183,19 +243,50 @@ class ASEngineClient:
             id = self.id
 
         try:
-            self.sio.emit(route, {'type': 'text', 'data': text, 'id': id}, namespace=self.namespace)
-            print(f"Sent text to route '{route}': {text}")
-            return True
+            # 生成唯一ack_id
+            ack_id = f"{id}_{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+            data = {
+                'type': 'text', 
+                'data': text, 
+                'id': id,
+                'ack_id': ack_id
+            }
+            self.sio.emit(route, data, namespace=self.namespace)
+            if not wait_for_ack:
+                return True
+            
+            # 初始化ACK事件
+            event = Event()
+            self.ack_events[ack_id] = event
+            
+            # 如果需要返回事件对象，直接返回
+            if return_event:
+                return event, ack_id
+            
+            # 等待ACK或超时
+            received_ack = event.wait(timeout=timeout)
+            
+            # 清理ACK事件
+            del self.ack_events[ack_id]
+            
+            if received_ack:
+                return True
+            else:
+                print(f"ACK timeout for message: {ack_id}")
+                return False
         except Exception as e:
             print(f"Failed to send text to route '{route}': {e}")
             return False
         
-    def send_voice(self, route: str, voice_data: bytes, id:str=None) -> bool:
+    def send_voice(self, route: str, voice_data: bytes, id:str=None, wait_for_ack: bool = False, timeout: int = 5) -> bool:
         """
         发送语音数据
         :param route: 目标路由
         :param voice_data: 语音数据字节流
-        :return: 是否发送成功
+        :param id: 发送者ID
+        :param wait_for_ack: 是否等待服务器ACK确认
+        :param timeout: 等待ACK的超时时间（秒）
+        :return: 是否发送成功（若wait_for_ack为True，则返回是否收到ACK）
         """
         if id is None:
             id = self.id
@@ -204,8 +295,9 @@ class ASEngineClient:
             return False
         
         try:
-            # 编码语音数据为base64
-            # voice_data = 'data:image/jpeg;base64,' +base64.b64encode(voice_data).decode('utf-8')
+            # 生成唯一ack_id
+            ack_id = f"{id}_{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+            
             # 发送数据
             self.sio.emit(
                 route,
@@ -214,24 +306,43 @@ class ASEngineClient:
                     'data': voice_data,
                     'timestamp': int(time.time() * 1000),
                     'sampleRate': 16000,
-                    'id': id
+                    'id': id,
+                    'ack_id': ack_id
                 },
                 namespace=self.namespace
             )
+            # 如果不需要等待ACK，直接返回True
+            if not wait_for_ack:
+                return True
             
-
-            print(f"Sent voice file to route '{route}'")
-            return True
+            # 初始化ACK事件
+            event = Event()
+            self.ack_events[ack_id] = event
+            
+            # 等待ACK或超时
+            received_ack = event.wait(timeout=timeout)
+            
+            # 清理ACK事件
+            del self.ack_events[ack_id]
+            
+            if received_ack:
+                return True
+            else:
+                print(f"ACK timeout for message: {ack_id}")
+                return False
         except Exception as e:
             print(f"Failed to send voice to route '{route}': {e}")
             return False
         
-    def send_image(self, route: str, file_path: str, id:str) -> bool:
+    def send_image(self, route: str, file_path: str, id:str, wait_for_ack: bool = False, timeout: int = 5) -> bool:
         """
         发送图片文件
         :param route: 目标路由
         :param file_path: 图片文件路径
-        :return: 是否发送成功
+        :param id: 发送者ID
+        :param wait_for_ack: 是否等待服务器ACK确认
+        :param timeout: 等待ACK的超时时间（秒）
+        :return: 是否发送成功（若wait_for_ack为True，则返回是否收到ACK）
         """
         if not self.connected:
             print("Not connected to server")
@@ -251,18 +362,40 @@ class ASEngineClient:
             # 获取文件名
             filename = os.path.basename(file_path)
             
+            # 生成唯一ack_id
+            ack_id = f"{id}_{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+            
             # 发送数据
             self.sio.emit(
                 route,
                 {
                     'type': 'image',
                     'data': image_data,
-                    'id': id
+                    'id': id,
+                    'ack_id': ack_id
                 },
                 namespace=self.namespace
             )
-            print(f"Sent image file to route '{route}': {filename}")
-            return True
+            
+            # 如果不需要等待ACK，直接返回True
+            if not wait_for_ack:
+                return True
+            
+            # 初始化ACK事件
+            event = Event()
+            self.ack_events[ack_id] = event
+            
+            # 等待ACK或超时
+            received_ack = event.wait(timeout=timeout)
+            
+            # 清理ACK事件
+            del self.ack_events[ack_id]
+            
+            if received_ack:
+                return True
+            else:
+                print(f"ACK timeout for message: {ack_id}")
+                return False
         except Exception as e:
             print(f"Failed to send image to route '{route}': {e}")
             return False
@@ -286,6 +419,17 @@ class HSAEngineClient(ASEngineClient):
         super().__init__(server_url, namespace, id)
         self.chatmanager = chatmanager
     def loadmarkdown(self, fmd, fmdp, fsp):
-        self.send_text('markdown-in', fmd, self.id)
-        self.send_text('markdown-prompt-in', fmdp, self.id)
-        self.send_text('score-prompt-in', fsp, self.id)
+        event1, ack_id1 = self.send_text('markdown-in', fmd, self.id, wait_for_ack=True, return_event=True)
+        event2, ack_id2 = self.send_text('markdown-prompt-in', fmdp, self.id, wait_for_ack=True, return_event=True)
+        event3, ack_id3 = self.send_text('score-prompt-in', fsp, self.id, wait_for_ack=True, return_event=True)
+        timeout = 5  # 超时时间
+        success1 = event1.wait(timeout=timeout)
+        success2 = event2.wait(timeout=timeout)
+        success3 = event3.wait(timeout=timeout)
+        if ack_id1 in self.ack_events:
+            del self.ack_events[ack_id1]
+        if ack_id2 in self.ack_events:
+            del self.ack_events[ack_id2]
+        if ack_id3 in self.ack_events:
+            del self.ack_events[ack_id3]
+        return success1 and success2 and success3

Html/apps/extension_ase/ase_client/manager.py

@@ -33,7 +33,8 @@ class ProcRecord:
 class ChatManager:
     _procs: Dict[str, ProcRecord] = {}
     _lock = threading.RLock()
-    def __init__(self):
+    def __init__(self, restart=False):
+        self.restart = restart
         self.chapter_chain_now = -1
         self.ase_client = None
         self.app = None
@@ -48,7 +49,8 @@ class ChatManager:
         self.chapter_chain = None
         self.function_manager = FunctionManager()
         self.bb = None
-        self.chat_historys = None
+        self.chat_historys = []
+        self.scores = []
         self.vscode_ws = None
         self._vscode_queue = deque()
         self._lock = Semaphore(1)
@@ -118,6 +120,7 @@ class ChatManager:
 
 
     def next_chapter(self):
+        print(f"now next chapter {self.chapter_chain_now} and len {len(self.chapter_chain)}")
         assert self.chapter_chain_now + 1 < len(self.chapter_chain), "chapter_chain_now out of range"
         self.chapter_chain_now += 1
         self.bb.next_chapter()
@@ -128,10 +131,11 @@ class ChatManager:
         self.chapter_chain_now = chapter_index
         self.chapter_chain[chapter_index].Focus()
 
-    def load_next_chapter(self):
-        print(f"now load next chapter markdown {self.chapter_chain_now}")
+    def load_now_chapter(self, load_code = True):
+        print(f"now load now chapter markdown {self.chapter_chain_now}")
         self.ase_client.loadmarkdown(self.chapter_chain[self.chapter_chain_now].chapter, self.chapter_chain[self.chapter_chain_now].chapter_prompt, self.chapter_chain[self.chapter_chain_now].score_prompt)
-        self.load_code_in_markdown()
+        if load_code:
+            self.load_code_in_markdown()
 
 
     def upload_bb(self):

Html/apps/services/asectrl_service.py

@@ -0,0 +1,83 @@
+import requests
+from flask_socketio import Namespace
+
+
+def clear_user_session(asengine_url, asengine_token, user_id):
+    '''
+    快速清理用户会话的函数
+    '''
+    try:
+        base_url = asengine_url
+        clear_url = f"{base_url}/api/sync/clear_user_session"
+        payload = {
+            'namespace_url': asengine_token,  # WebSocket命名空间URL
+            'user_id': user_id,  # 用户ID，对应session_info.id
+            'clear_type': 'all'  # 清理类型，默认为全部
+        }
+        headers = {
+            'Content-Type': 'application/json'
+        }
+        response = requests.post(clear_url, json=payload, headers=headers)
+        response.raise_for_status()  # 检查请求是否成功
+        print(f"User session {user_id} cleared successfully. Response: {response.json()}")
+    except Exception as e:
+        print(f"Error clearing user session: {e}")
+
+
+def on_connect_to_ase(client, entry, init_data, **kwargs):
+    '''
+    此时刚刚建立好aseclient连接，并向前端发送打开code-server-like指令。
+    '''
+    namespace_entry, ase_client = entry
+    namespace_entry.emit('open-iframe',"", room=init_data['room'], namespace='/agent')
+    namespace_entry.emit('message', "Agents服务已连接, 加载教案中", room=init_data['room'], namespace='/agent')
+        
+    restart = init_data.get("restart", False)
+    if restart: # 重启时，从-1章进入 0章
+        ase_client.chatmanager.next_chapter()
+    ase_client.chatmanager.load_now_chapter(load_code=restart)
+    print("load_now_chapter with restart:", restart)
+    if restart: 
+        ase_client.send_text("chapter-start", "")
+    namespace_entry.emit('message', "教案加载完毕", room=init_data['room'], namespace='/agent')
+
+
+#接受消息回来直接让message监听发送
+def receive_ase_paste_detected(client_entry, namespace_entry, data, init_data):
+    print("receive_ase_paste_detected", data)
+    client_entry.chatmanager.chat_historys.append({'role': 'assistant', 'content': data['data']})
+    namespace_entry.emit('message', data['data'], room=init_data['room'], namespace='/agent')
+
+def receive_ase_dialog(client_entry, namespace_entry, data, init_data):
+    print("receive_ase_dialog", data)
+    client_entry.chatmanager.chat_historys.append({'role': 'assistant', 'content': data['data']})
+    namespace_entry.emit('message', data['data'], room=init_data['room'], namespace='/agent')
+
+def receive_ase_message_hint(client_entry, namespace_entry, data, init_data):
+    print("receive_ase_message_hint", data)
+    namespace_entry.emit('message-hint', data['data'], room=init_data['room'], namespace='/agent')
+
+#接受语音信息
+def receive_ase_voice_out(client_entry, namespace_entry, data, init_data):
+    namespace_entry.emit('voiceMessage', data['data'], room=init_data['room'], namespace='/agent')
+
+def receive_ase_process(client_entry, namespace_entry, data, init_data):
+    namespace_entry.emit('process', data['data'], room=init_data['room'], namespace='/agent')
+
+def receive_ase_judge(client_entry, namespace_entry, data, init_data):
+    print("receive_ase_judge", data)
+    namespace_entry.emit('request_function', data, room=init_data['room'], namespace='/agent')  # data 是一个列表 /dict也支持
+
+def receive_ase_next_chapter(client_entry, namespace_entry, data, init_data):
+    print("receive_ase_next_chapter", data)
+    namespace_entry.emit('request_function',data, room=init_data['room'], namespace='/agent')  # data 是一个列表 /dict也支持
+
+def receive_ase_chapter_score(client_entry, user_and_manager, data, init_data):
+    print("load_next_chapter")
+    user, chatmanager = user_and_manager
+    if len(chatmanager.scores) >= chatmanager.chapter_chain_now:
+        chatmanager.scores[chatmanager.chapter_chain_now - 1] = data.get('data', None)
+    else: chatmanager.scores.append(data.get('data', None))
+    user.set_course_progress(chatmanager.chat_historys, chatmanager.scores, chatmanager.course_id, chatmanager.chapter_name, chatmanager.lesson_name)
+    chatmanager.load_now_chapter()
+    chatmanager.ase_client.send_text("chapter-start", "")

Html/apps/services/cos_service.py

@@ -27,7 +27,7 @@ def get_text_file(file_name):
     response = requests.get(file_name)
     
     if response.status_code == 200:
-        print(file_name)
+        # print(file_name)
         # print(f"get_text_file: {response.text}")
 
         return response.text

Html/apps/services/course_service.py

@@ -1,470 +1,14 @@
 # myapp/services/course_service.py
 import re
-from typing import Dict, List
+import requests
+import json
+from typing import Dict, List, Optional
 from flask import current_app
 from urllib.parse import urlparse
 from datetime import datetime
 from bson import ObjectId
 
-from ..services.cos_service import upload_file, delete_file
 
-from ..models.material import Material
+from .course_services.material_process import *
 
-
-def get_new_edit_materials(num: int)->List[Material]:
-    mongo = current_app.extensions["mongo"]
-    materials = mongo.db.materials.find().sort("updated_at", -1).limit(num)
-    returnCode = []
-    for material in materials:
-        returnCode.append(Material(**material))
-        returnCode[-1]._id = str(material['_id'])
-    return returnCode
-
-def user_selected_course(user_obj):
-    briefs = []
-    for cid in getattr(user_obj, "select_course", []):
-        course_obj = load_material(cid)
-        brief={}
-        brief["_id"] = cid
-        brief["name"] = course_obj.name
-        brief["description"] = course_obj.description
-        brief["image_url"] = course_obj.image_url
-        brief["created_at"] = course_obj.created_at.strftime("%Y-%m-%d %H:%M:%S")
-        brief["updated_at"] = course_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S")
-        brief["chapters"] = [chapter.model_dump() for chapter in course_obj.chapters]
-        briefs.append(brief)
-    return briefs
-
-def user_selected_course_briefs(user_obj):
-    """根据用户对象的选课列表，拼装课程简要信息数组"""
-    briefs = []
-    for cid in getattr(user_obj, "select_course", []):
-        course_obj = load_material(cid)
-        brief={}
-        brief["_id"] = cid
-        brief["name"] = course_obj.name
-        brief["description"] = course_obj.description
-        brief["image_url"] = course_obj.image_url
-        brief["created_at"] = course_obj.created_at.strftime("%Y-%m-%d %H:%M:%S")
-        brief["updated_at"] = course_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S")
-        briefs.append(brief)
-    return briefs
-
-def create_material(teacher_id, material_name, description, chapters, image_url):
-    material = Material(
-        name=material_name,
-        description=description,
-        teacher_id=teacher_id,
-        created_at=datetime.now(),
-        updated_at=datetime.now(),
-        chapters=chapters,
-        image_url=image_url
-    )
-    mongo = current_app.extensions["mongo"]
-    material_id = mongo.db.materials.insert_one(material.model_dump()).inserted_id
-    return str(material_id)
-
-def load_material(material_id):
-    mongo = current_app.extensions["mongo"]
-    material = mongo.db.materials.find_one({"_id": ObjectId(material_id)})
-    material['_id'] = material_id
-    return Material(**material)
-
-def update_material(material_id, chapters):
-    mongo = current_app.extensions["mongo"]
-    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
-    if material:
-        mongo.db.materials.update_one(
-            {'_id': ObjectId(material_id)},
-            {'$set': {'chapters': chapters, 'updated_at': datetime.now()}}
-        )
-        return True
-    return False
-
-def add_material_chapter(material_id, chapter_name, teacher_id):
-    mongo = current_app.extensions["mongo"]
-    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
-    if material['teacher_id'] != teacher_id:
-        return False
-    if material:
-        mongo.db.materials.update_one(
-            {'_id': ObjectId(material_id)},
-            {'$push': {'chapters': {'chapter_name': chapter_name, 'lessons': []}}})
-        return True
-
-def rename_material_structure(material_id, is_chapter, chapter_name, lesson_name, new_name):
-    mongo = current_app.extensions["mongo"]
-    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
-    if not material:
-        return False  # 材料不存在
-    
-    # 检查名称是否存在于列表中的辅助函数
-    def name_exists_in_list(item_list, name_key, target_name):
-        return any(item[name_key] == target_name for item in item_list)
-    
-    # 查找包含指定章节名的章节
-    def find_chapter_by_name(chapters, target_name):
-        for chapter in chapters:
-            if chapter['chapter_name'] == target_name:
-                return chapter
-        return None
-    
-    # 检查章节是否存在
-    target_chapter = find_chapter_by_name(material['chapters'], chapter_name)
-    if not target_chapter:
-        return False
-    
-    if is_chapter:
-        # 检查新章节名是否已存在
-        if name_exists_in_list(material['chapters'], 'chapter_name', new_name):
-            return False
-        
-        # 更新章节名
-        mongo.db.materials.update_one(
-            {'_id': ObjectId(material_id)},
-            {'$set': {'chapters.$[c].chapter_name': new_name}},
-            array_filters=[{'c.chapter_name': chapter_name}]
-        )
-    else:
-        # 检查课时是否存在
-        if not name_exists_in_list(target_chapter['lessons'], 'lesson_name', lesson_name):
-            return False
-        
-        # 检查新课时名是否已存在
-        if name_exists_in_list(target_chapter['lessons'], 'lesson_name', new_name):
-            return False
-        
-        # 更新课时名
-        mongo.db.materials.update_one(
-            {'_id': ObjectId(material_id)},
-            {'$set': {'chapters.$[c].lessons.$[l].lesson_name': new_name}},
-            array_filters=[{'c.chapter_name': chapter_name}, {'l.lesson_name': lesson_name}]
-        )
-    
-    return True
-
-def delete_material_chapter_lesson(material_id, chapter_name, lesson_name, teacher_id):
-    """
-    删除指定课程的课时。
-    删除后，更新 MongoDB 中对应的章节中的 lesson 列表。
-    """
-    mongo = current_app.extensions["mongo"]
-
-    # 查询 material 是否存在，且确保该 teacher_id 对应的 material
-    material = mongo.db.materials.find_one({'_id': ObjectId(material_id), 'teacher_id': teacher_id})
-
-    for chapter in material['chapters']:
-        if chapter['chapter_name'] == chapter_name:
-            for lesson in chapter['lessons']:
-                if lesson['lesson_name'] == lesson_name:
-                    if lesson['markdown_lesson_file_link']!='':
-                        delete_file(lesson['markdown_lesson_file_link'])
-                    if lesson['markdown_prompt_file_name']!='':
-                        delete_file(lesson['markdown_prompt_file_name'])
-                    if lesson['markdown_score_prompt_file_link']!='':
-                        delete_file(lesson['markdown_score_prompt_file_link'])
-    if not material:
-        return False  # 找不到对应的 material 或 teacher_id 不匹配
-
-    # 删除 lesson 的条件
-    res = mongo.db.materials.update_one(
-        {
-            "_id": ObjectId(material_id),
-            "teacher_id": teacher_id  # 确保是该教师的课程
-        },
-        {
-            "$pull": {
-                "chapters.$[c].lessons": {
-                    "lesson_name": lesson_name  # 根据 lesson_name 来删除
-                }
-            },
-            "$set": {"updated_at": datetime.now()}  # 更新修改时间
-        },
-        array_filters=[{"c.chapter_name": chapter_name}]  # 找到匹配的章节
-    )
-
-    # 如果删除操作成功，res.modified_count 应为 1
-    return res.modified_count == 1
-
-def reorder_material_structure(material_id, order):
-    mongo = current_app.extensions["mongo"]
-    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
-    if not material:
-        return False
-
-    # 1. 构建原章节映射（保留章节元信息）和原章节的课时映射
-    chapter_map = {ch["chapter_name"]: ch for ch in material["chapters"]}
-    # 每个章节的课时映射：{章节名: {课时名: 课时对象}}
-    original_chapter_lessons = {
-        ch["chapter_name"]: {ls["lesson_name"]: ls for ls in ch["lessons"]}
-        for ch in material["chapters"]
-    }
-
-    # 2. 收集所有章节“少掉的课时”到全局池（仅包含原章节有但新排序没包含的课时）
-    # 用列表存储，避免同名课时被覆盖（处理可能的重名场景）
-    global_extra_lessons = []
-    for ch_name in chapter_map:
-        original_lessons = original_chapter_lessons[ch_name]  # 原章节的所有课时
-        # 找到当前章节在order中的配置（如果没有，默认该章节所有课时都是“少掉的”）
-        chapter_order = next((item for item in order if item["chapter_name"] == ch_name), None)
-        if not chapter_order:
-            # 章节未在order中出现，所有原课时都是“少掉的”
-            global_extra_lessons.extend(original_lessons.values())
-            continue
-        # 章节在order中出现，找出原课时中不在新排序里的（即“少掉的”）
-        new_lesson_names = chapter_order["lessons"]
-        for ls_name, ls in original_lessons.items():
-            if ls_name not in new_lesson_names:
-                global_extra_lessons.append(ls)
-    print("global_extra_lessons:", global_extra_lessons)
-    new_chapters = []
-    for chapter_order in order:
-        ch_name = chapter_order["chapter_name"]
-        if ch_name not in chapter_map:
-            continue  # 跳过不存在的章节
-
-        original_ch = chapter_map[ch_name]
-        original_lessons = original_chapter_lessons[ch_name]  # 本章节原课时
-        new_lessons = []
-
-        # 3. 构建当前章节的新课时列表
-        for ls_name in chapter_order["lessons"]:
-            # 优先使用本章节原有的课时
-            if ls_name in original_lessons:
-                new_lessons.append(original_lessons[ls_name])
-                continue
-            # 本章节没有，从全局池（其他章节少掉的课时）中找
-            # 处理可能的重名：找到第一个匹配的课时
-            for i, extra_ls in enumerate(global_extra_lessons):
-                if extra_ls["lesson_name"] == ls_name:
-                    new_lessons.append(extra_ls)
-                    del global_extra_lessons[i]  # 从全局池移除，避免重复
-                    break
-
-        # 4. 构造新章节（保留原章节元信息，替换课时列表）
-        new_chapter = {**original_ch, "lessons": new_lessons}
-        new_chapters.append(new_chapter)
-
-    # 5. 处理全局池中剩余的课时（未被任何章节引用的，追加到最后一个章节）
-    if global_extra_lessons and new_chapters:
-        new_chapters[-1]["lessons"].extend(global_extra_lessons)
-    print("new_chapters:", new_chapters)
-    # 更新数据库
-    mongo.db.materials.update_one(
-        {"_id": ObjectId(material_id)},
-        {
-            "$set": {
-                "chapters": new_chapters,
-                "updated_at": datetime.now()
-            }
-        }
-    )
-    return True
-
-
-def save_materials_markdown_cos(
-    material_id: str,
-    chapter_name: str,
-    lesson_name: str,
-    docs: Dict[str, Dict[str, str]],
-    version: str | None = None,         # 目前不做并发控制，保留参数
-    actor=None                           # 可记录操作者到审计日志
-) -> Dict[str, str]:
-    """
-    docs 结构：
-    {
-      "lesson": {"cdn_link": "...lesson.md", "content": "..."},
-      "prompt": {"cdn_link": "...prompt.md", "content": "..."},
-      "score":  {"cdn_link": "...score_prompt.md", "content": "..."}
-    }
-    约定：cdn_link 与对象存储的 key 一一映射（同路径/同文件名），
-    我们通过解析 URL 的 path 作为 key 进行覆盖写入（不改文件名）。
-    """
-
-    def _cdn_to_key(cdn_link: str) -> str:
-        """
-        把 CDN URL 映射成对象存储的 key：
-        - 若 CDN 与存储是“同 key 直出”，则直接取 path（去掉前导 /）
-        - 若你有自定义映射规则，在此处改写
-        """
-        p = urlparse(cdn_link)
-        key = p.path.lstrip("/")
-        if not key:
-            raise ValueError(f"非法 cdn_link：{cdn_link}")
-        return key
-
-    # 1) 覆盖写入三份文件
-    results: Dict[str, Dict[str, str]] = {}
-    for kind in ("lesson", "prompt", "score"):
-        item = docs.get(kind)
-        if not item or "cdn_link" not in item or "content" not in item:
-            raise ValueError(f"缺少 {kind} 的 cdn_link 或 content")
-
-        key = _cdn_to_key(item["cdn_link"])
-        content = item["content"]
-        # 覆盖写入（注意：upload_file 内部需实现覆盖同 key）
-        try:
-            # 约定：upload_file 返回可访问的 URL（覆盖后可与原相同）
-            url = upload_file(content.encode("utf-8"), key)
-        except Exception as e:
-            current_app.logger.exception("覆盖写入失败 kind=%s key=%s", kind, key)
-            raise
-
-        # 简单返回：保留原 cdn_link（一般与 url 相同），以及 md5 作为伪版本
-        import hashlib
-        etag = hashlib.md5(content.encode("utf-8")).hexdigest()
-        results[kind] = {"cdn_link": url or item["cdn_link"], "version": etag}
-
-    # 2) 写库：更新该 lesson 的更新时间（不改文件名/链接）
-    _touch_material_lesson_updated_at(material_id, chapter_name, lesson_name, actor=actor)
-
-    results["updated_at"] = datetime.now().isoformat() + "Z"
-    return results
-
-
-def _touch_material_lesson_updated_at(material_id: str, chapter_name: str, lesson_name: str, actor=None) -> None:
-    """仅刷新 materials 文档中该课时的更新时间戳（以及顶层 updated_at）"""
-    mongo = current_app.extensions["mongo"]
-    now = datetime.now()
-
-    # 更新顶层 updated_at
-    mongo.db.materials.update_one(
-        {"_id": ObjectId(material_id)},
-        {"$set": {"updated_at": now}}
-    )
-
-    # 更新嵌套 lesson 的更新时间（如果你在 lesson 内有该字段）
-    # 需要使用 arrayFilters 精确定位到对应章节/课时
-    mongo.db.materials.update_one(
-        {"_id": ObjectId(material_id)},
-        {
-            "$set": {
-                "chapters.$[c].lessons.$[l].updated_at": now,
-                # 可选：记录最近编辑人
-                "chapters.$[c].lessons.$[l].last_editor": getattr(actor, "id", None) if actor else None
-            }
-        },
-        array_filters=[
-            {"c.chapter_name": chapter_name},
-            {"l.lesson_name": lesson_name}
-        ]
-    )
-def add_material_chapter_lesson(material_id, chapter_name, lesson_name, teacher_id):
-    """
-    1) 生成占位 Markdown（lesson_prompt_score_prompt）
-    2) 上传到对象存储（返回 URL）
-    3) 将 lesson 文档（含三份 URL）push 到指定章节
-    """
-    mongo = current_app.extensions["mongo"]
-
-    # 组织对象存储的文件路径
-    chapter_slug = _slugify(chapter_name or "")
-    lesson_slug  = _slugify(lesson_name or "")
-    timestamp    = datetime.now().strftime('%Y%m%dT%H%M%SZ')
-    base_prefix  = f"materials_{material_id}_{chapter_slug}_{lesson_slug}_{timestamp}"
-
-    # 占位文本
-    lesson_md, prompt_md, score_prompt_md = _default_markdowns(lesson_name or "未命名课时")
-
-    # 生成文件名（带层级路径）
-    lesson_key = f"{base_prefix}_lesson.md"
-    prompt_key = f"{base_prefix}_prompt.md"
-    score_key  = f"{base_prefix}_score_prompt.md"
-
-    # 上传（任意一个失败则终止，不写库）
-    try:
-        lesson_url = upload_file(lesson_md.encode("utf-8"), lesson_key)
-        prompt_url = upload_file(prompt_md.encode("utf-8"), prompt_key)
-        score_url  = upload_file(score_prompt_md.encode("utf-8"), score_key)
-    except Exception as e:
-        current_app.logger.exception("Upload default markdown failed: %s", e)
-        return False
-
-    # 组装 lesson_doc
-    lesson_doc = {
-        "lesson_name": lesson_name or "",
-        "markdown_lesson_file_link": lesson_url,               # lesson 主体
-        "markdown_prompt_file_name": prompt_url,               # 给大模型的 prompt
-        "markdown_score_prompt_file_link": score_url,          # 评分 prompt
-    }
-
-    # 将 lesson push 到指定章节
-    res = mongo.db.materials.update_one(
-        {
-            "_id": ObjectId(material_id),
-            "teacher_id": teacher_id,  # 注意：若存的是 ObjectId，请确保传入的是同类型
-        },
-        {
-            "$push": {"chapters.$[c].lessons": lesson_doc},
-            "$set": {"updated_at": datetime.now()},
-        },
-        array_filters=[{"c.chapter_name": chapter_name}],
-    )
-
-    # 可选：如果 res.modified_count != 1，说明 push 失败（可能章节名不匹配）
-    # 这里可以考虑是否回滚 COS 上刚上传的 3 个文件（需实现删除逻辑）。
-    return res.modified_count == 1
-
-
-def get_materials_by_teacher(teacher_id)->List[Material]:
-    mongo = current_app.extensions["mongo"]
-    materials = mongo.db.materials.find({'teacher_id': teacher_id})
-    return [Material(**material) for material in materials]
-
-def get_materials_by_teacher_dict(teacher_id)->List[Dict]:
-    mongo = current_app.extensions["mongo"]
-    materials = mongo.db.materials.find({'teacher_id': teacher_id})
-    result = []
-    for material in materials:
-        material['_id'] = str(material['_id'])
-        result.append(material)
-    return result
-
-
-
-
-
-
-
-def _slugify(name: str) -> str:
-    """将章节/课时名转为 URL 友好的 slug。"""
-    s = name.strip().lower()
-    s = re.sub(r'\s+', '-', s)                # 空白 -> -
-    s = re.sub(r'[^a-z0-9\-_]+', '', s)       # 仅保留安全字符
-    return s or 'untitled'
-
-def _default_markdowns(lesson_name: str):
-    """三份占位 Markdown 文本。可按需调整模板内容。"""
-    ts = datetime.now().strftime('%Y-%m-%d %H:%M')
-    lesson_md = f"""# {lesson_name}
-
-## 阶段一：示例阶段
-### 步骤A
-在这里编写该步骤的教学内容（文字/代码/图片链接等）。
-
-### 步骤B
-继续补充该阶段的其它步骤内容。
-"""
-
-    prompt_md = f"""# {lesson_name}
-
-## 阶段一：示例阶段
-### 步骤A
-请基于“步骤A”的教学目标与材料，生成指导性提示词（尽量结构化，给出评估标准和示例）。
-
-### 步骤B
-请基于“步骤B”的教学目标与材料，生成指导性提示词。
-"""
-
-    score_prompt_md = f"""# {lesson_name}
-
-## 评分准则
-- 正确性、完整性、可读性、效率（按需调整权重）
-
-## 阶段一：示例阶段
-### 步骤A
-对学员在“步骤A”的输出进行评分与文字反馈，分数区间 0-100，并输出 JSON：```{{"score": <int>, "reasons": "<string>", "advices": "<string>"}}```
-### 步骤B
-同上，对“步骤B”输出进行评分与反馈。
-"""
-    return lesson_md, prompt_md, score_prompt_md
+from .course_services.learning_progess_process import *

Html/apps/services/course_services/learning_progess_process.py

@@ -0,0 +1,239 @@
+# myapp/services/course_service.py
+import re
+import requests
+import json
+from typing import Dict, List, Optional
+from flask import current_app
+from urllib.parse import urlparse
+from datetime import datetime
+from bson import ObjectId
+
+def save_learning_progress(chatmanager, user_id: str) -> bool:
+    """
+    保存用户学习进度到MongoDB
+    
+    参数：
+    - chatmanager: ChatManager实例，包含学习进度数据
+    - user_id: 用户ID
+    
+    返回：
+    - bool: 保存是否成功
+    """
+    try:
+        # 获取MongoDB连接
+        mongo = current_app.extensions["mongo"]
+        
+        # 获取MultiAgents框架中的对话列表
+        dialog_list = get_multiagents_dialog_list(user_id)
+        his_data = dialog_list['data']
+        # 构建学习进度数据
+        progress_data = {
+            "user_id": user_id,
+            "material_id": chatmanager.material_id,
+            "chapter_name": chatmanager.chapter_name,
+            "lesson_name": chatmanager.lesson_name,
+            "chapter_chain_now": chatmanager.chapter_chain_now,
+            "chat_historys": chatmanager.chat_historys,
+            "scores": chatmanager.scores,
+            "multiagents_dialogs": his_data,
+            "chapter_chain_length": len(chatmanager.chapter_chain),
+            "updated_at": datetime.now()
+        }
+        
+        # 保存到MongoDB，使用upsert操作（如果存在则更新，不存在则插入）
+        mongo.db.learning_progress.update_one(
+            {
+                "user_id": user_id,
+                "material_id": chatmanager.material_id,
+                "chapter_name": chatmanager.chapter_name,
+                "lesson_name": chatmanager.lesson_name
+            },
+            {"$set": progress_data},
+            upsert=True
+        )
+        
+        current_app.logger.info(f"学习进度保存成功: user_id={user_id}, lesson={chatmanager.lesson_name}")
+        return True
+    except Exception as e:
+        current_app.logger.error(f"保存学习进度失败: {str(e)}")
+        return False
+
+def get_multiagents_dialog_list(user_id: str) -> List[Dict]:
+    """
+    从MultiAgents框架获取用户对话列表
+    
+    参数：
+    - user_id: 用户ID
+    
+    返回：
+    - Dict[List]: 对话列表(key 为 History database)
+    """
+    try:
+        # 从配置中获取ASE引擎URL和token
+        config = current_app.config
+        url_token = config.get("ASE_ENGINE_URL_TOKEN", "")
+        
+        # 构建请求URL
+        base_url = config.get("ASE_ENGINE_URL", "")
+        api_url = f"{base_url}/api/sync/download"
+        
+        # 构建请求参数
+        payload = {
+            "namespace_url": url_token,  # 使用配置中的token作为namespace_url
+            "user_id": user_id
+        }
+        
+        # 发送POST请求
+        response = requests.post(
+            api_url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=10
+        )
+        
+        # 检查响应
+        if response.status_code == 200:
+            current_app.logger.info(f"获取MultiAgents对话列表成功: user_id={user_id}, json={response.json()}")
+            return response.json()
+        else:
+            current_app.logger.error(f"获取MultiAgents对话列表失败: HTTP {response.status_code}")
+            return []
+    except Exception as e:
+        current_app.logger.error(f"获取MultiAgents对话列表异常: {str(e)}")
+        return []
+
+def load_learning_progress(user_id: str, material_id: str, chapter_name: str, lesson_name: str) -> Dict:
+    """
+    加载用户学习进度
+    
+    参数：
+    - user_id: 用户ID
+    - material_id: 课程ID
+    - chapter_name: 章节名
+    - lesson_name: 课时名
+    
+    返回：
+    - Dict: 学习进度数据，包含以下字段：
+      - exists: bool，表示学习记录是否存在
+      - data: Dict，学习进度详细数据，包含chat_historys、scores、chapter_chain_now等字段
+      - message: str，操作结果描述
+    """
+    try:
+        mongo = current_app.extensions["mongo"]
+        progress = mongo.db.learning_progress.find_one({
+            "user_id": user_id,
+            "material_id": material_id,
+            "chapter_name": chapter_name,
+            "lesson_name": lesson_name
+        })
+        
+        if progress:
+            # 转换ObjectId为字符串
+            if "_id" in progress:
+                progress["_id"] = str(progress["_id"])
+            return {
+                "exists": True,
+                "data": progress,
+                "message": "学习记录加载成功"
+            }
+        # 返回默认值，确保即使没有学习记录也有完整的结构
+        return {
+            "exists": False,
+            "data": {
+                "user_id": user_id,
+                "material_id": material_id,
+                "chapter_name": chapter_name,
+                "lesson_name": lesson_name,
+                "chat_historys": [],
+                "scores": [],
+                "chapter_chain_now": None,
+                "chapter_chain_length": 0,
+                "updated_at": datetime.now().isoformat()
+            },
+            "message": "未找到学习记录，返回默认值"
+        }
+    except Exception as e:
+        error_msg = f"加载学习进度失败: {str(e)}"
+        current_app.logger.error(error_msg)
+        # 发生错误时返回默认结构，确保系统稳定性
+        return {
+            "exists": False,
+            "data": {
+                "user_id": user_id,
+                "material_id": material_id,
+                "chapter_name": chapter_name,
+                "lesson_name": lesson_name,
+                "chat_historys": [],
+                "scores": [],
+                "chapter_chain_now": None,
+                "chapter_chain_length": 0,
+                "updated_at": datetime.now().isoformat()
+            },
+            "message": error_msg
+        }
+
+
+def upload_learning_progress_to_cloud(progress: Dict) -> Dict:
+    """
+    将学习进度上传到云服务
+    
+    参数：
+    - progress: 学习进度数据字典{'databases':{}, 'global_databases':{}, 'session_info_out':{}}
+    
+    返回：
+    - Dict: 上传结果，包含success和message字段
+    """
+    try:
+        # 从配置中获取ASE引擎URL和token
+        config = current_app.config
+        url_token = config.get("ASE_ENGINE_URL_TOKEN", "")
+        
+        # 构建请求URL
+        base_url = config.get("ASE_ENGINE_URL", "")
+        api_url = f"{base_url}/api/sync/upload"
+        
+        # 导入JSON序列化工具
+        from ...utils.json_serializer import json_serialize_dict
+        
+        # 序列化进度数据，处理datetime等特殊类型
+        serialized_progress = json_serialize_dict(progress['multiagents_dialogs'])
+        
+        # 构建请求参数
+        payload = {
+            "namespace_url": url_token,  # 使用配置中的token作为namespace_url
+            "user_id": progress.get("user_id", ""),
+            "data": serialized_progress
+        }
+        
+        # 发送POST请求
+        response = requests.post(
+            api_url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=10
+        )
+        
+        # 处理响应
+        if response.status_code == 200:
+            result = response.json()
+            current_app.logger.info(f"学习进度上传成功: user_id={progress.get('user_id')}， 内容：{serialized_progress}")
+
+            return {
+                "success": True,
+                "message": "学习进度上传成功",
+                "data": result
+            }
+        else:
+            error_msg = f"上传失败，HTTP状态码: {response.status_code}"
+            current_app.logger.error(f"学习进度上传失败: {error_msg}")
+            return {
+                "success": False,
+                "message": error_msg
+            }
+    except Exception as e:
+        error_msg = f"上传异常: {str(e)}"
+        current_app.logger.error(f"学习进度上传异常: {error_msg}")
+        return {
+            "success": False,
+            "message": error_msg
+        }

Html/apps/services/course_services/material_process.py

@@ -0,0 +1,473 @@
+import re
+import requests
+import json
+from typing import Dict, List, Optional
+from flask import current_app
+from urllib.parse import urlparse
+from datetime import datetime
+from bson import ObjectId
+
+from apps.services.cos_service import upload_file, delete_file
+
+from apps.models.material import Material
+
+
+def get_new_edit_materials(num: int)->List[Material]:
+    mongo = current_app.extensions["mongo"]
+    materials = mongo.db.materials.find().sort("updated_at", -1).limit(num)
+    returnCode = []
+    for material in materials:
+        returnCode.append(Material(**material))
+        returnCode[-1]._id = str(material['_id'])
+    return returnCode
+
+def user_selected_course(user_obj):
+    briefs = []
+    for cid in getattr(user_obj, "select_course", []):
+        course_obj = load_material(cid)
+        brief={}
+        brief["_id"] = cid
+        brief["name"] = course_obj.name
+        brief["description"] = course_obj.description
+        brief["image_url"] = course_obj.image_url
+        brief["created_at"] = course_obj.created_at.strftime("%Y-%m-%d %H:%M:%S")
+        brief["updated_at"] = course_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S")
+        brief["chapters"] = [chapter.model_dump() for chapter in course_obj.chapters]
+        briefs.append(brief)
+    return briefs
+
+def user_selected_course_briefs(user_obj):
+    """根据用户对象的选课列表，拼装课程简要信息数组"""
+    briefs = []
+    for cid in getattr(user_obj, "select_course", []):
+        course_obj = load_material(cid)
+        brief={}
+        brief["_id"] = cid
+        brief["name"] = course_obj.name
+        brief["description"] = course_obj.description
+        brief["image_url"] = course_obj.image_url
+        brief["created_at"] = course_obj.created_at.strftime("%Y-%m-%d %H:%M:%S")
+        brief["updated_at"] = course_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S")
+        briefs.append(brief)
+    return briefs
+
+def create_material(teacher_id, material_name, description, chapters, image_url):
+    material = Material(
+        name=material_name,
+        description=description,
+        teacher_id=teacher_id,
+        created_at=datetime.now(),
+        updated_at=datetime.now(),
+        chapters=chapters,
+        image_url=image_url
+    )
+    mongo = current_app.extensions["mongo"]
+    material_id = mongo.db.materials.insert_one(material.model_dump()).inserted_id
+    return str(material_id)
+
+def load_material(material_id):
+    mongo = current_app.extensions["mongo"]
+    material = mongo.db.materials.find_one({"_id": ObjectId(material_id)})
+    material['_id'] = material_id
+    return Material(**material)
+
+def update_material(material_id, chapters):
+    mongo = current_app.extensions["mongo"]
+    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
+    if material:
+        mongo.db.materials.update_one(
+            {'_id': ObjectId(material_id)},
+            {'$set': {'chapters': chapters, 'updated_at': datetime.now()}}
+        )
+        return True
+    return False
+
+def add_material_chapter(material_id, chapter_name, teacher_id):
+    mongo = current_app.extensions["mongo"]
+    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
+    if material['teacher_id'] != teacher_id:
+        return False
+    if material:
+        mongo.db.materials.update_one(
+            {'_id': ObjectId(material_id)},
+            {'$push': {'chapters': {'chapter_name': chapter_name, 'lessons': []}}})
+        return True
+
+def rename_material_structure(material_id, is_chapter, chapter_name, lesson_name, new_name):
+    mongo = current_app.extensions["mongo"]
+    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
+    if not material:
+        return False  # 材料不存在
+    
+    # 检查名称是否存在于列表中的辅助函数
+    def name_exists_in_list(item_list, name_key, target_name):
+        return any(item[name_key] == target_name for item in item_list)
+    
+    # 查找包含指定章节名的章节
+    def find_chapter_by_name(chapters, target_name):
+        for chapter in chapters:
+            if chapter['chapter_name'] == target_name:
+                return chapter
+        return None
+    
+    # 检查章节是否存在
+    target_chapter = find_chapter_by_name(material['chapters'], chapter_name)
+    if not target_chapter:
+        return False
+    
+    if is_chapter:
+        # 检查新章节名是否已存在
+        if name_exists_in_list(material['chapters'], 'chapter_name', new_name):
+            return False
+        
+        # 更新章节名
+        mongo.db.materials.update_one(
+            {'_id': ObjectId(material_id)},
+            {'$set': {'chapters.$[c].chapter_name': new_name}},
+            array_filters=[{'c.chapter_name': chapter_name}]
+        )
+    else:
+        # 检查课时是否存在
+        if not name_exists_in_list(target_chapter['lessons'], 'lesson_name', lesson_name):
+            return False
+        
+        # 检查新课时名是否已存在
+        if name_exists_in_list(target_chapter['lessons'], 'lesson_name', new_name):
+            return False
+        
+        # 更新课时名
+        mongo.db.materials.update_one(
+            {'_id': ObjectId(material_id)},
+            {'$set': {'chapters.$[c].lessons.$[l].lesson_name': new_name}},
+            array_filters=[{'c.chapter_name': chapter_name}, {'l.lesson_name': lesson_name}]
+        )
+    
+    return True
+
+def delete_material_chapter_lesson(material_id, chapter_name, lesson_name, teacher_id):
+    """
+    删除指定课程的课时。
+    删除后，更新 MongoDB 中对应的章节中的 lesson 列表。
+    """
+    mongo = current_app.extensions["mongo"]
+
+    # 查询 material 是否存在，且确保该 teacher_id 对应的 material
+    material = mongo.db.materials.find_one({'_id': ObjectId(material_id), 'teacher_id': teacher_id})
+
+    for chapter in material['chapters']:
+        if chapter['chapter_name'] == chapter_name:
+            for lesson in chapter['lessons']:
+                if lesson['lesson_name'] == lesson_name:
+                    if lesson['markdown_lesson_file_link']!='':
+                        delete_file(lesson['markdown_lesson_file_link'])
+                    if lesson['markdown_prompt_file_name']!='':
+                        delete_file(lesson['markdown_prompt_file_name'])
+                    if lesson['markdown_score_prompt_file_link']!='':
+                        delete_file(lesson['markdown_score_prompt_file_link'])
+    if not material:
+        return False  # 找不到对应的 material 或 teacher_id 不匹配
+
+    # 删除 lesson 的条件
+    res = mongo.db.materials.update_one(
+        {
+            "_id": ObjectId(material_id),
+            "teacher_id": teacher_id  # 确保是该教师的课程
+        },
+        {
+            "$pull": {
+                "chapters.$[c].lessons": {
+                    "lesson_name": lesson_name  # 根据 lesson_name 来删除
+                }
+            },
+            "$set": {"updated_at": datetime.now()}  # 更新修改时间
+        },
+        array_filters=[{"c.chapter_name": chapter_name}]  # 找到匹配的章节
+    )
+
+    # 如果删除操作成功，res.modified_count 应为 1
+    return res.modified_count == 1
+
+def reorder_material_structure(material_id, order):
+    mongo = current_app.extensions["mongo"]
+    material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
+    if not material:
+        return False
+
+    # 1. 构建原章节映射（保留章节元信息）和原章节的课时映射
+    chapter_map = {ch["chapter_name"]: ch for ch in material["chapters"]}
+    # 每个章节的课时映射：{章节名: {课时名: 课时对象}}
+    original_chapter_lessons = {
+        ch["chapter_name"]: {ls["lesson_name"]: ls for ls in ch["lessons"]}
+        for ch in material["chapters"]
+    }
+
+    # 2. 收集所有章节“少掉的课时”到全局池（仅包含原章节有但新排序没包含的课时）
+    # 用列表存储，避免同名课时被覆盖（处理可能的重名场景）
+    global_extra_lessons = []
+    for ch_name in chapter_map:
+        original_lessons = original_chapter_lessons[ch_name]  # 原章节的所有课时
+        # 找到当前章节在order中的配置（如果没有，默认该章节所有课时都是“少掉的”）
+        chapter_order = next((item for item in order if item["chapter_name"] == ch_name), None)
+        if not chapter_order:
+            # 章节未在order中出现，所有原课时都是“少掉的”
+            global_extra_lessons.extend(original_lessons.values())
+            continue
+        # 章节在order中出现，找出原课时中不在新排序里的（即“少掉的”）
+        new_lesson_names = chapter_order["lessons"]
+        for ls_name, ls in original_lessons.items():
+            if ls_name not in new_lesson_names:
+                global_extra_lessons.append(ls)
+    print("global_extra_lessons:", global_extra_lessons)
+    new_chapters = []
+    for chapter_order in order:
+        ch_name = chapter_order["chapter_name"]
+        if ch_name not in chapter_map:
+            continue  # 跳过不存在的章节
+
+        original_ch = chapter_map[ch_name]
+        original_lessons = original_chapter_lessons[ch_name]  # 本章节原课时
+        new_lessons = []
+
+        # 3. 构建当前章节的新课时列表
+        for ls_name in chapter_order["lessons"]:
+            # 优先使用本章节原有的课时
+            if ls_name in original_lessons:
+                new_lessons.append(original_lessons[ls_name])
+                continue
+            # 本章节没有，从全局池（其他章节少掉的课时）中找
+            # 处理可能的重名：找到第一个匹配的课时
+            for i, extra_ls in enumerate(global_extra_lessons):
+                if extra_ls["lesson_name"] == ls_name:
+                    new_lessons.append(extra_ls)
+                    del global_extra_lessons[i]  # 从全局池移除，避免重复
+                    break
+
+        # 4. 构造新章节（保留原章节元信息，替换课时列表）
+        new_chapter = {**original_ch, "lessons": new_lessons}
+        new_chapters.append(new_chapter)
+
+    # 5. 处理全局池中剩余的课时（未被任何章节引用的，追加到最后一个章节）
+    if global_extra_lessons and new_chapters:
+        new_chapters[-1]["lessons"].extend(global_extra_lessons)
+    print("new_chapters:", new_chapters)
+    # 更新数据库
+    mongo.db.materials.update_one(
+        {"_id": ObjectId(material_id)},
+        {
+            "$set": {
+                "chapters": new_chapters,
+                "updated_at": datetime.now()
+            }
+        }
+    )
+    return True
+
+
+
+
+def save_materials_markdown_cos(
+    material_id: str,
+    chapter_name: str,
+    lesson_name: str,
+    docs: Dict[str, Dict[str, str]],
+    version: str | None = None,         # 目前不做并发控制，保留参数
+    actor=None                           # 可记录操作者到审计日志
+) -> Dict[str, str]:
+    """
+    docs 结构：
+    {
+      "lesson": {"cdn_link": "...lesson.md", "content": "..."},
+      "prompt": {"cdn_link": "...prompt.md", "content": "..."},
+      "score":  {"cdn_link": "...score_prompt.md", "content": "..."}
+    }
+    约定：cdn_link 与对象存储的 key 一一映射（同路径/同文件名），
+    我们通过解析 URL 的 path 作为 key 进行覆盖写入（不改文件名）。
+    """
+
+    def _cdn_to_key(cdn_link: str) -> str:
+        """
+        把 CDN URL 映射成对象存储的 key：
+        - 若 CDN 与存储是“同 key 直出”，则直接取 path（去掉前导 /）
+        - 若你有自定义映射规则，在此处改写
+        """
+        p = urlparse(cdn_link)
+        key = p.path.lstrip("/")
+        if not key:
+            raise ValueError(f"非法 cdn_link：{cdn_link}")
+        return key
+
+    # 1) 覆盖写入三份文件
+    results: Dict[str, Dict[str, str]] = {}
+    for kind in ("lesson", "prompt", "score"):
+        item = docs.get(kind)
+        if not item or "cdn_link" not in item or "content" not in item:
+            raise ValueError(f"缺少 {kind} 的 cdn_link 或 content")
+
+        key = _cdn_to_key(item["cdn_link"])
+        content = item["content"]
+        # 覆盖写入（注意：upload_file 内部需实现覆盖同 key）
+        try:
+            # 约定：upload_file 返回可访问的 URL（覆盖后可与原相同）
+            url = upload_file(content.encode("utf-8"), key)
+        except Exception as e:
+            current_app.logger.exception("覆盖写入失败 kind=%s key=%s", kind, key)
+            raise
+
+        # 简单返回：保留原 cdn_link（一般与 url 相同），以及 md5 作为伪版本
+        import hashlib
+        etag = hashlib.md5(content.encode("utf-8")).hexdigest()
+        results[kind] = {"cdn_link": url or item["cdn_link"], "version": etag}
+
+    # 2) 写库：更新该 lesson 的更新时间（不改文件名/链接）
+    _touch_material_lesson_updated_at(material_id, chapter_name, lesson_name, actor=actor)
+
+    results["updated_at"] = datetime.now().isoformat() + "Z"
+    return results
+
+
+def _touch_material_lesson_updated_at(material_id: str, chapter_name: str, lesson_name: str, actor=None) -> None:
+    """仅刷新 materials 文档中该课时的更新时间戳（以及顶层 updated_at）"""
+    mongo = current_app.extensions["mongo"]
+    now = datetime.now()
+
+    # 更新顶层 updated_at
+    mongo.db.materials.update_one(
+        {"_id": ObjectId(material_id)},
+        {"$set": {"updated_at": now}}
+    )
+
+    # 更新嵌套 lesson 的更新时间（如果你在 lesson 内有该字段）
+    # 需要使用 arrayFilters 精确定位到对应章节/课时
+    mongo.db.materials.update_one(
+        {"_id": ObjectId(material_id)},
+        {
+            "$set": {
+                "chapters.$[c].lessons.$[l].updated_at": now,
+                # 可选：记录最近编辑人
+                "chapters.$[c].lessons.$[l].last_editor": getattr(actor, "id", None) if actor else None
+            }
+        },
+        array_filters=[
+            {"c.chapter_name": chapter_name},
+            {"l.lesson_name": lesson_name}
+        ]
+    )
+def add_material_chapter_lesson(material_id, chapter_name, lesson_name, teacher_id):
+    """
+    1) 生成占位 Markdown（lesson_prompt_score_prompt）
+    2) 上传到对象存储（返回 URL）
+    3) 将 lesson 文档（含三份 URL）push 到指定章节
+    """
+    mongo = current_app.extensions["mongo"]
+
+    # 组织对象存储的文件路径
+    chapter_slug = _slugify(chapter_name or "")
+    lesson_slug  = _slugify(lesson_name or "")
+    timestamp    = datetime.now().strftime('%Y%m%dT%H%M%SZ')
+    base_prefix  = f"materials_{material_id}_{chapter_slug}_{lesson_slug}_{timestamp}"
+
+    # 占位文本
+    lesson_md, prompt_md, score_prompt_md = _default_markdowns(lesson_name or "未命名课时")
+
+    # 生成文件名（带层级路径）
+    lesson_key = f"{base_prefix}_lesson.md"
+    prompt_key = f"{base_prefix}_prompt.md"
+    score_key  = f"{base_prefix}_score_prompt.md"
+
+    # 上传（任意一个失败则终止，不写库）
+    try:
+        lesson_url = upload_file(lesson_md.encode("utf-8"), lesson_key)
+        prompt_url = upload_file(prompt_md.encode("utf-8"), prompt_key)
+        score_url  = upload_file(score_prompt_md.encode("utf-8"), score_key)
+    except Exception as e:
+        current_app.logger.exception("Upload default markdown failed: %s", e)
+        return False
+
+    # 组装 lesson_doc
+    lesson_doc = {
+        "lesson_name": lesson_name or "",
+        "markdown_lesson_file_link": lesson_url,               # lesson 主体
+        "markdown_prompt_file_name": prompt_url,               # 给大模型的 prompt
+        "markdown_score_prompt_file_link": score_url,          # 评分 prompt
+    }
+
+    # 将 lesson push 到指定章节
+    res = mongo.db.materials.update_one(
+        {
+            "_id": ObjectId(material_id),
+            "teacher_id": teacher_id,  # 注意：若存的是 ObjectId，请确保传入的是同类型
+        },
+        {
+            "$push": {"chapters.$[c].lessons": lesson_doc},
+            "$set": {"updated_at": datetime.now()},
+        },
+        array_filters=[{"c.chapter_name": chapter_name}],
+    )
+
+    # 可选：如果 res.modified_count != 1，说明 push 失败（可能章节名不匹配）
+    # 这里可以考虑是否回滚 COS 上刚上传的 3 个文件（需实现删除逻辑）。
+    return res.modified_count == 1
+
+
+def get_materials_by_teacher(teacher_id)->List[Material]:
+    mongo = current_app.extensions["mongo"]
+    materials = mongo.db.materials.find({'teacher_id': teacher_id})
+    return [Material(**material) for material in materials]
+
+def get_materials_by_teacher_dict(teacher_id)->List[Dict]:
+    mongo = current_app.extensions["mongo"]
+    materials = mongo.db.materials.find({'teacher_id': teacher_id})
+    result = []
+    for material in materials:
+        material['_id'] = str(material['_id'])
+        result.append(material)
+    return result
+
+
+
+
+
+
+
+def _slugify(name: str) -> str:
+    """将章节/课时名转为 URL 友好的 slug。"""
+    s = name.strip().lower()
+    s = re.sub(r'\s+', '-', s)                # 空白 -> -
+    s = re.sub(r'[^a-z0-9\-_]+', '', s)       # 仅保留安全字符
+    return s or 'untitled'
+
+def _default_markdowns(lesson_name: str):
+    """三份占位 Markdown 文本。可按需调整模板内容。"""
+    ts = datetime.now().strftime('%Y-%m-%d %H:%M')
+    lesson_md = f"""# {lesson_name}
+
+## 阶段一：示例阶段
+### 步骤A
+在这里编写该步骤的教学内容（文字/代码/图片链接等）。
+
+### 步骤B
+继续补充该阶段的其它步骤内容。
+"""
+
+    prompt_md = f"""# {lesson_name}
+
+## 阶段一：示例阶段
+### 步骤A
+请基于"步骤A"的教学目标与材料，生成指导性提示词（尽量结构化，给出评估标准和示例）。
+
+### 步骤B
+请基于"步骤B"的教学目标与材料，生成指导性提示词。
+"""
+
+    score_prompt_md = f"""# {lesson_name}
+
+## 评分准则
+- 正确性、完整性、可读性、效率（按需调整权重）
+
+## 阶段一：示例阶段
+### 步骤A
+对学员在"步骤A"的输出进行评分与文字反馈，分数区间 0-100，并输出 JSON：```{{"score": <int>, "reasons": "<string>", "advices": "<string>"}}```
+### 步骤B
+同上，对"步骤B"输出进行评分与反馈。
+"""
+    return lesson_md, prompt_md, score_prompt_md

Html/apps/services/markdown_service.py

@@ -24,7 +24,6 @@ def load_markdown_file(course_id, chapter_name, lesson_name):
             break
     if file_link is None:
         return None
-    print(f"load_markdown_file: {file_link}")
     return get_text_file(file_link)
 
 def convert_markdown_to_html(md_file: str) -> str:

Html/apps/sockets/namespaces.py

@@ -1,23 +1,37 @@
 # myapp/sockets/namespaces.py
 import json
 import time
-from flask import current_app, request, session
+import requests
+from flask import current_app, request, session, url_for
 from flask_socketio import Namespace, join_room, leave_room, emit
+from ..config import Config
 
 from ..function_tools import judge
 from ..function_tools import next_chapter
 from ..services.backboard_service import realtime_response
-from ..services.markdown_service import load_full_markdown_file
+from ..services.markdown_service import  load_full_markdown_file
+from ..services.course_service import save_learning_progress, upload_learning_progress_to_cloud
 from ..extension_ase.ase_client import HSAEngineClient
 from ..services.user_service import get_or_load_current_user
+from ..services.course_service import load_learning_progress
+from ..services.asectrl_service import (
+    on_connect_to_ase,
+    receive_ase_paste_detected,
+    receive_ase_dialog,
+    receive_ase_message_hint,
+    receive_ase_voice_out,
+    receive_ase_process,
+    receive_ase_judge,
+    receive_ase_next_chapter,
+    receive_ase_chapter_score,
+    clear_user_session
+)
 
 
 
 class VSCodeNamespace(Namespace):
-    
-
-
     def on_login(self,data):        
+        self.app = current_app
         ex = current_app.extensions
         print("VSCode client connected")
         dataconfig = data['config']
@@ -49,8 +63,52 @@ class VSCodeNamespace(Namespace):
 
 
 class AgentNamespace(Namespace):
+    def _load_learning_progress(self, chatmanager, user_id, course_id, chapter_name, lesson_name, continue_learn):
+        """加载并恢复用户学习进度
+        
+        Args:
+            chatmanager: 聊天管理器实例
+            user_id: 用户ID
+            course_id: 课程ID
+            chapter_name: 章节名称
+            lesson_name: 课时名称
+            continue_learn: 是否继续学习
+            
+        Returns:
+            int: 需要跳过的章节数
+        """
+        need_skip_chapters = 0
+        
+        if continue_learn:  # 尝试加载用户学习进度
+            progress_result = load_learning_progress(user_id, course_id, chapter_name, lesson_name)
+            
+            if progress_result['exists']:
+                progress = progress_result['data']
+                # 恢复学习进度数据
+                if 'scores' in progress:
+                    # 根据scores的数量确定需要跳过的章节数
+                    need_skip_chapters = len(progress['scores'])
+                    chatmanager.scores = progress['scores']
+                
+                # 恢复聊天历史
+                if 'chat_historys' in progress:
+                    chatmanager.chat_historys = progress['chat_historys']
+                else:
+                    chatmanager.chat_historys = []
+                
+                # 恢复当前章节链
+                if 'chapter_chain_now' in progress:
+                    chatmanager.chapter_chain_now = progress['chapter_chain_now']
+                upload_learning_progress_to_cloud(progress)
+            else:
+                # 使用默认值，确保有完整的结构
+                chatmanager.chat_historys = progress_result['data']['chat_historys']
+                chatmanager.scores = progress_result['data']['scores']
+        
+        return need_skip_chapters
+    
     def on_login(self, data):
-        self.current_app = current_app
+        self.app = current_app
         ex = current_app.extensions
         uuid2username    = ex["uuid2username"]
         backboard_manager = ex["backboard_manager"]
@@ -71,67 +129,79 @@ class AgentNamespace(Namespace):
         chatmanager = user_uuid2chatmanager[user_uuid]
         chatmanager.function_manager.add_function(judge, {'course_id': course_id, 'root_path': f'/home/{user_id}/{course_id}/{chapter_name}/{lesson_name}'})
         chatmanager.function_manager.add_function(next_chapter, {'user_uuid': user_uuid})
-        chatmanager.chat_historys = []
-        chatmanager.scores = []
+
+        clear_user_session(current_app.config["ASE_ENGINE_URL"], current_app.config["ASE_ENGINE_URL_TOKEN"], user_id)
+        continue_learn = not chatmanager.restart
+        need_skip_chapters = self._load_learning_progress(chatmanager, user_id, course_id, chapter_name, lesson_name, continue_learn)
 
         fmd,fmdp,fsp = load_full_markdown_file(course_id, chapter_name, lesson_name)
         user_uuid2ase_client[user_uuid] = HSAEngineClient(current_app.config["ASE_ENGINE_URL"], current_app.config["ASE_ENGINE_NAMESPACE"],id=user_id, chatmanager = chatmanager)
-        chatmanager.init(user_uuid, user_uuid2ase_client[user_uuid], fmd, fmdp, fsp, course_id, chapter_name, lesson_name, max_iter=5, app=current_app, socketio=self)
-        backboard_manager.add_backboard(user_uuid, user_id, course_id, lesson_name, root_path=f'/home/{user_id}/{course_id}/{chapter_name}/{lesson_name}')
+        chatmanager.init(user_uuid, user_uuid2ase_client[user_uuid], 
+                        fmd,   fmdp, fsp, course_id, chapter_name, lesson_name, max_iter=5, app=current_app, socketio=self)
+        backboard_manager.add_backboard(user_uuid, user_id, course_id,
+                                         lesson_name, root_path=f'/home/{user_id}/{course_id}/{chapter_name}/{lesson_name}')
         chatmanager.bb = backboard_manager.get_backboard(user_uuid)
-        chatmanager.next_chapter()
+        # 如果有保存的进度，需要跳过已经完成的章节、无需清空代码、对话历史恢复
+        if continue_learn:
+            for _ in range(need_skip_chapters):
+                chatmanager.next_chapter()
+                emit('next_chapter', room=user_uuid, namespace='/agent')
+            # 恢复对话历史到前端 - 使用批量发送消息列表
+            if chatmanager.chat_historys:
+                emit('messages', chatmanager.chat_historys, room=user_uuid, namespace='/agent')
+        
         self.chatmanager = chatmanager
         self.ase_client = user_uuid2ase_client[user_uuid]
         user_uuid2ase_client[user_uuid].register_on_connect_entry(
-            callback=self.on_connect_to_ase,
+            callback=on_connect_to_ase,
             entry=(self, user_uuid2ase_client[user_uuid]),
-            init_data={'room':user_uuid}
+            init_data={'room':user_uuid, 'restart':chatmanager.restart}
         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='dialog',
-                                            callback=self.receive_ase_dialog,
+                                            callback=receive_ase_dialog,
                                             entry=self,               
                                             init_data={'room': user_uuid}          
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='dialog-hint',
-                                            callback=self.receive_ase_message_hint,
+                                            callback=receive_ase_message_hint,
                                             entry=self,
                                             init_data={'room': user_uuid}
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='voice_out',
-                                            callback=self.receive_ase_voice_out,
+                                            callback=receive_ase_voice_out,
                                             entry=self,
                                             init_data={'room': user_uuid}
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='judge',
-                                            callback=self.receive_ase_judge,
+                                            callback=receive_ase_judge,
                                             entry=self,               
                                             init_data={'room': user_uuid}          
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='next_chapter',
-                                            callback=self.receive_ase_next_chapter,
+                                            callback=receive_ase_next_chapter,
                                             entry=self,               
                                             init_data={'room': user_uuid}          
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='chapter_score',
-                                            callback=self.receive_ase_chapter_score,
+                                            callback=receive_ase_chapter_score,
                                             entry=(get_or_load_current_user(),chatmanager),
                                             init_data={'room': user_uuid}
                                         )            
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='process',
-                                            callback=self.receive_ase_process,
+                                            callback=receive_ase_process,
                                             entry=self,
                                             init_data={'room': user_uuid}
                                         )
         user_uuid2ase_client[user_uuid].register_route_with_entry(
                                             route='paste_detected',
-                                            callback=self.receive_ase_paste_detected,
+                                            callback=receive_ase_paste_detected,
                                             entry=self,
                                             init_data={'room': user_uuid}
                                         )
@@ -140,10 +210,8 @@ class AgentNamespace(Namespace):
         
     def on_language(self, language):
         ex = current_app.extensions
-        print(f"Language changed to: {language}")
 
     def on_message(self, data):
-        print(f"Message from client: {data}")
         ex = current_app.extensions
         chatmanager = ex["user_uuid2chatmanager"]
         uuid = session.get('user_uuid')
@@ -153,14 +221,11 @@ class AgentNamespace(Namespace):
         if data['type'] == 'text':
             res = user_uuid2ase_client[uuid].send_text('dialog', data['data'])
             chatmanager[uuid].chat_historys.append({'role': 'user', 'content': data['data']})
-            print(f"Send text to route 'dialog' success: {res}")
 
         if data['type'] == 'function': # 在这里 前端会发送允许执行的function与参数
-            print("function_call", data['data'])
             d = data['data']
             res = chatmanager[uuid].function_call(d['data']['name'], d['data'].get('args', {}))
             d['data'] = res.to_dict()
-            print("function_call_res", d['data'])
             emit(d['route'], d, room=uuid, namespace='/agent')
             chatmanager[uuid].chat_historys.append({'role': 'user', 'content': data['data']})
             user_uuid2ase_client[uuid].send_text(d['route'], data['data'])
@@ -171,64 +236,9 @@ class AgentNamespace(Namespace):
         uuid = session.get('user_uuid')
         user_uuid2ase_client = ex["user_uuid2ase_client"]
         res = user_uuid2ase_client[uuid].send_voice('voice_in', voice_data['data'])
-        print(f"Send voicce to route 'voice_in' success: {res}")
-        
-    def on_connect_to_ase(client_entry: HSAEngineClient, namespace_entry, init_data):
-        '''
-        此时刚刚建立好aseclient连接，并向前端发送打开code-server-like指令。
-        '''
-        print(f"on_connect_to_ase {client_entry}, {namespace_entry}, {init_data}")
-        namespace_entry, ase_client = namespace_entry
-        namespace_entry.emit('open-iframe',"", room=init_data['room'], namespace='/agent')
-        ase_client.chatmanager.load_next_chapter()
-        ase_client.send_text("chapter-start", "")
-        ase_client.send_text("clear","")
-        namespace_entry.emit('message', "Multi-Agents服务已连接", room=init_data['room'], namespace='/agent')
-
-    #接受消息回来直接让message监听发送
-    def receive_ase_paste_detected(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        print("receive_ase_paste_detected", data)
-        client_entry.chatmanager.chat_historys.append({'role': 'assistant', 'content': data['data']})
-        namespace_entry.emit('message', data['data'], room=init_data['room'], namespace='/agent')
-
-    def receive_ase_dialog(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        print("receive_ase_dialog", data)
-        client_entry.chatmanager.chat_historys.append({'role': 'assistant', 'content': data['data']})
-        namespace_entry.emit('message', data['data'], room=init_data['room'], namespace='/agent')
-
-    def receive_ase_message_hint(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        print("receive_ase_message_hint", data)
-        namespace_entry.emit('message-hint', data['data'], room=init_data['room'], namespace='/agent')
-
-    #接受语音信息
-    def receive_ase_voice_out(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        namespace_entry.emit('voiceMessage', data['data'], room=init_data['room'], namespace='/agent')
-
-    def receive_ase_process(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        namespace_entry.emit('process', data['data'], room=init_data['room'], namespace='/agent')
-
-    def receive_ase_judge(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        print("receive_ase_judge", data)
-        namespace_entry.emit('request_function', data, room=init_data['room'], namespace='/agent')  # data 是一个列表 /dict也支持
-
-    def receive_ase_next_chapter(client_entry: HSAEngineClient, namespace_entry: Namespace, data, init_data):
-        print("receive_ase_next_chapter", data)
-        namespace_entry.emit('request_function',data, room=init_data['room'], namespace='/agent')  # data 是一个列表 /dict也支持
-
-    def receive_ase_chapter_score(client_entry: HSAEngineClient, user_and_manager, data, init_data):
-        print("load_next_chapter")
-        user, chatmanager = user_and_manager
-        if len(chatmanager.scores) >= chatmanager.chapter_chain_now:
-            chatmanager.scores[chatmanager.chapter_chain_now - 1] = data.get('data', None)
-        else: chatmanager.scores.append(data.get('data', None))
-        user.set_course_progress(chatmanager.chat_historys, chatmanager.scores, chatmanager.material_id, chatmanager.chapter_name, chatmanager.lesson_name)
-        chatmanager.load_next_chapter()
-        time.sleep(0.5)
-        chatmanager.ase_client.send_text("chapter-start", "")
 
 
     def on_initiative(self,data): # 主动call
-        print("User active function call")
         ex = current_app.extensions
         uuid = session.get('user_uuid')
         manager = ex["user_uuid2chatmanager"][uuid]
@@ -241,10 +251,32 @@ class AgentNamespace(Namespace):
 
 
     def on_disconnect(self,data):
+        self.app.logger.info(f'AgentNamespace client disconnected, session user_uuid: {session.get("user_uuid", "unknown")}')
         ex = current_app.extensions
         uuid = session.get('user_uuid')
-        user_uuid2chatmanager = ex["user_uuid2chatmanager"]
-        user_uuid2chatmanager[uuid].disconnect(uuid)
+        user_uuid2chatmanager = ex.get("user_uuid2chatmanager", {})
+        
+        # 保存学习进度到MongoDB
+        try:
+            # 获取用户ID
+            uuid2username = ex.get("uuid2username", {})
+            user_id = uuid2username.get(uuid, "unknown")
+            self.app.logger.debug(f"get user's dialog his user_id={user_id}")
+            # 调用保存学习进度功能
+            chatmanager = user_uuid2chatmanager.get(uuid)
+            if chatmanager:
+                save_result = save_learning_progress(chatmanager, user_id)
+            
+        except Exception as e:
+            self.app.logger.error(f"保存学习进度时发生异常: {str(e)}")
+        
+        # 执行原有的断开连接逻辑
+        if uuid in user_uuid2chatmanager:
+            user_uuid2chatmanager[uuid].disconnect(uuid)
+        
+        # 离开房间
+        if uuid:
+            leave_room(uuid, namespace='/agent')
 
-        print("VSCode client disconnected")
-        print("Disconnect reason:"+str(data))
+        self.app.logger.info("VSCode client disconnected")
+        self.app.logger.info(f"Disconnect reason: {str(data)}")

Html/apps/static/cdnback/css/xterm.css

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2014 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * https://github.com/chjj/term.js
+ * @license MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ *   The original design remains. The terminal itself
+ *   has been extended to include xterm CSI codes, among
+ *   other features.
+ */
+
+/**
+ *  Default styles for xterm.js
+ */
+
+.xterm {
+    cursor: text;
+    position: relative;
+    user-select: none;
+    -ms-user-select: none;
+    -webkit-user-select: none;
+}
+
+.xterm.focus,
+.xterm:focus {
+    outline: none;
+}
+
+.xterm .xterm-helpers {
+    position: absolute;
+    top: 0;
+    /**
+     * The z-index of the helpers must be higher than the canvases in order for
+     * IMEs to appear on top.
+     */
+    z-index: 5;
+}
+
+.xterm .xterm-helper-textarea {
+    padding: 0;
+    border: 0;
+    margin: 0;
+    /* Move textarea out of the screen to the far left, so that the cursor is not visible */
+    position: absolute;
+    opacity: 0;
+    left: -9999em;
+    top: 0;
+    width: 0;
+    height: 0;
+    z-index: -5;
+    /** Prevent wrapping so the IME appears against the textarea at the correct position */
+    white-space: nowrap;
+    overflow: hidden;
+    resize: none;
+}
+
+.xterm .composition-view {
+    /* TODO: Composition position got messed up somewhere */
+    background: #000;
+    color: #FFF;
+    display: none;
+    position: absolute;
+    white-space: nowrap;
+    z-index: 1;
+}
+
+.xterm .composition-view.active {
+    display: block;
+}
+
+.xterm .xterm-viewport {
+    /* On OS X this is required in order for the scroll bar to appear fully opaque */
+    background-color: #000;
+    overflow-y: scroll;
+    cursor: default;
+    position: absolute;
+    right: 0;
+    left: 0;
+    top: 0;
+    bottom: 0;
+}
+
+.xterm .xterm-screen {
+    position: relative;
+}
+
+.xterm .xterm-screen canvas {
+    position: absolute;
+    left: 0;
+    top: 0;
+}
+
+.xterm .xterm-scroll-area {
+    visibility: hidden;
+}
+
+.xterm-char-measure-element {
+    display: inline-block;
+    visibility: hidden;
+    position: absolute;
+    top: 0;
+    left: -9999em;
+    line-height: normal;
+}
+
+.xterm.enable-mouse-events {
+    /* When mouse events are enabled (eg. tmux), revert to the standard pointer cursor */
+    cursor: default;
+}
+
+.xterm.xterm-cursor-pointer,
+.xterm .xterm-cursor-pointer {
+    cursor: pointer;
+}
+
+.xterm.column-select.focus {
+    /* Column selection mode */
+    cursor: crosshair;
+}
+
+.xterm .xterm-accessibility:not(.debug),
+.xterm .xterm-message {
+    position: absolute;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    z-index: 10;
+    color: transparent;
+    pointer-events: none;
+}
+
+.xterm .xterm-accessibility-tree:not(.debug) *::selection {
+  color: transparent;
+}
+
+.xterm .xterm-accessibility-tree {
+  user-select: text;
+  white-space: pre;
+}
+
+.xterm .live-region {
+    position: absolute;
+    left: -9999px;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+}
+
+.xterm-dim {
+    /* Dim should not apply to background, so the opacity of the foreground color is applied
+     * explicitly in the generated class and reset to 1 here */
+    opacity: 1 !important;
+}
+
+.xterm-underline-1 { text-decoration: underline; }
+.xterm-underline-2 { text-decoration: double underline; }
+.xterm-underline-3 { text-decoration: wavy underline; }
+.xterm-underline-4 { text-decoration: dotted underline; }
+.xterm-underline-5 { text-decoration: dashed underline; }
+
+.xterm-overline {
+    text-decoration: overline;
+}
+
+.xterm-overline.xterm-underline-1 { text-decoration: overline underline; }
+.xterm-overline.xterm-underline-2 { text-decoration: overline double underline; }
+.xterm-overline.xterm-underline-3 { text-decoration: overline wavy underline; }
+.xterm-overline.xterm-underline-4 { text-decoration: overline dotted underline; }
+.xterm-overline.xterm-underline-5 { text-decoration: overline dashed underline; }
+
+.xterm-strikethrough {
+    text-decoration: line-through;
+}
+
+.xterm-screen .xterm-decoration-container .xterm-decoration {
+	z-index: 6;
+	position: absolute;
+}
+
+.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer {
+	z-index: 7;
+}
+
+.xterm-decoration-overview-ruler {
+    z-index: 8;
+    position: absolute;
+    top: 0;
+    right: 0;
+    pointer-events: none;
+}
+
+.xterm-decoration-top {
+    z-index: 2;
+    position: relative;
+}

Html/apps/static/cdnback/js/addons/fit/fit.js

@@ -0,0 +1,51 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.fit = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function proposeGeometry(term) {
+    if (!term.element.parentElement) {
+        return null;
+    }
+    var parentElementStyle = window.getComputedStyle(term.element.parentElement);
+    var parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height'));
+    var parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')));
+    var elementStyle = window.getComputedStyle(term.element);
+    var elementPadding = {
+        top: parseInt(elementStyle.getPropertyValue('padding-top')),
+        bottom: parseInt(elementStyle.getPropertyValue('padding-bottom')),
+        right: parseInt(elementStyle.getPropertyValue('padding-right')),
+        left: parseInt(elementStyle.getPropertyValue('padding-left'))
+    };
+    var elementPaddingVer = elementPadding.top + elementPadding.bottom;
+    var elementPaddingHor = elementPadding.right + elementPadding.left;
+    var availableHeight = parentElementHeight - elementPaddingVer;
+    var availableWidth = parentElementWidth - elementPaddingHor - term._core.viewport.scrollBarWidth;
+    var geometry = {
+        cols: Math.floor(availableWidth / term._core.renderer.dimensions.actualCellWidth),
+        rows: Math.floor(availableHeight / term._core.renderer.dimensions.actualCellHeight)
+    };
+    return geometry;
+}
+exports.proposeGeometry = proposeGeometry;
+function fit(term) {
+    var geometry = proposeGeometry(term);
+    if (geometry) {
+        if (term.rows !== geometry.rows || term.cols !== geometry.cols) {
+            term._core.renderer.clear();
+            term.resize(geometry.cols, geometry.rows);
+        }
+    }
+}
+exports.fit = fit;
+function apply(terminalConstructor) {
+    terminalConstructor.prototype.proposeGeometry = function () {
+        return proposeGeometry(this);
+    };
+    terminalConstructor.prototype.fit = function () {
+        fit(this);
+    };
+}
+exports.apply = apply;
+
+},{}]},{},[1])(1)
+});
+//# sourceMappingURL=fit.js.map

Html/apps/static/cdnback/js/addons/fullscreen/fullscreen.js

@@ -0,0 +1,27 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.fullscreen = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function toggleFullScreen(term, fullscreen) {
+    var fn;
+    if (typeof fullscreen === 'undefined') {
+        fn = (term.element.classList.contains('fullscreen')) ? 'remove' : 'add';
+    }
+    else if (!fullscreen) {
+        fn = 'remove';
+    }
+    else {
+        fn = 'add';
+    }
+    term.element.classList[fn]('fullscreen');
+}
+exports.toggleFullScreen = toggleFullScreen;
+function apply(terminalConstructor) {
+    terminalConstructor.prototype.toggleFullScreen = function (fullscreen) {
+        toggleFullScreen(this, fullscreen);
+    };
+}
+exports.apply = apply;
+
+},{}]},{},[1])(1)
+});
+//# sourceMappingURL=fullscreen.js.map

Html/apps/static/cdnback/js/addons/search/search.js

@@ -0,0 +1,126 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.search = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var SearchHelper = (function () {
+    function SearchHelper(_terminal) {
+        this._terminal = _terminal;
+    }
+    SearchHelper.prototype.findNext = function (term) {
+        if (!term || term.length === 0) {
+            return false;
+        }
+        var result;
+        var startRow = this._terminal._core.buffer.ydisp;
+        if (this._terminal._core.selectionManager.selectionEnd) {
+            startRow = this._terminal._core.selectionManager.selectionEnd[1];
+        }
+        for (var y = startRow + 1; y < this._terminal._core.buffer.ybase + this._terminal.rows; y++) {
+            result = this._findInLine(term, y);
+            if (result) {
+                break;
+            }
+        }
+        if (!result) {
+            for (var y = 0; y < startRow; y++) {
+                result = this._findInLine(term, y);
+                if (result) {
+                    break;
+                }
+            }
+        }
+        return this._selectResult(result);
+    };
+    SearchHelper.prototype.findPrevious = function (term) {
+        if (!term || term.length === 0) {
+            return false;
+        }
+        var result;
+        var startRow = this._terminal._core.buffer.ydisp;
+        if (this._terminal._core.selectionManager.selectionStart) {
+            startRow = this._terminal._core.selectionManager.selectionStart[1];
+        }
+        for (var y = startRow - 1; y >= 0; y--) {
+            result = this._findInLine(term, y);
+            if (result) {
+                break;
+            }
+        }
+        if (!result) {
+            for (var y = this._terminal._core.buffer.ybase + this._terminal.rows - 1; y > startRow; y--) {
+                result = this._findInLine(term, y);
+                if (result) {
+                    break;
+                }
+            }
+        }
+        return this._selectResult(result);
+    };
+    SearchHelper.prototype._findInLine = function (term, y) {
+        var lowerStringLine = this._terminal._core.buffer.translateBufferLineToString(y, true).toLowerCase();
+        var lowerTerm = term.toLowerCase();
+        var searchIndex = lowerStringLine.indexOf(lowerTerm);
+        if (searchIndex >= 0) {
+            var line = this._terminal._core.buffer.lines.get(y);
+            for (var i = 0; i < searchIndex; i++) {
+                var charData = line[i];
+                var char = charData[1];
+                if (char.length > 1) {
+                    searchIndex -= char.length - 1;
+                }
+                var charWidth = charData[2];
+                if (charWidth === 0) {
+                    searchIndex++;
+                }
+            }
+            return {
+                term: term,
+                col: searchIndex,
+                row: y
+            };
+        }
+    };
+    SearchHelper.prototype._selectResult = function (result) {
+        if (!result) {
+            return false;
+        }
+        this._terminal._core.selectionManager.setSelection(result.col, result.row, result.term.length);
+        this._terminal.scrollLines(result.row - this._terminal._core.buffer.ydisp);
+        return true;
+    };
+    return SearchHelper;
+}());
+exports.SearchHelper = SearchHelper;
+
+},{}],2:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var SearchHelper_1 = require("./SearchHelper");
+function findNext(terminal, term) {
+    var addonTerminal = terminal;
+    if (!addonTerminal.__searchHelper) {
+        addonTerminal.__searchHelper = new SearchHelper_1.SearchHelper(addonTerminal);
+    }
+    return addonTerminal.__searchHelper.findNext(term);
+}
+exports.findNext = findNext;
+function findPrevious(terminal, term) {
+    var addonTerminal = terminal;
+    if (!addonTerminal.__searchHelper) {
+        addonTerminal.__searchHelper = new SearchHelper_1.SearchHelper(addonTerminal);
+    }
+    return addonTerminal.__searchHelper.findPrevious(term);
+}
+exports.findPrevious = findPrevious;
+function apply(terminalConstructor) {
+    terminalConstructor.prototype.findNext = function (term) {
+        return findNext(this, term);
+    };
+    terminalConstructor.prototype.findPrevious = function (term) {
+        return findPrevious(this, term);
+    };
+}
+exports.apply = apply;
+
+},{"./SearchHelper":1}]},{},[2])(2)
+});
+//# sourceMappingURL=search.js.map

Html/apps/static/cdnback/js/addons/webLinks/webLinks.js

@@ -0,0 +1,41 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.webLinks = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var protocolClause = '(https?:\\/\\/)';
+var domainCharacterSet = '[\\da-z\\.-]+';
+var negatedDomainCharacterSet = '[^\\da-z\\.-]+';
+var domainBodyClause = '(' + domainCharacterSet + ')';
+var tldClause = '([a-z\\.]{2,6})';
+var ipClause = '((\\d{1,3}\\.){3}\\d{1,3})';
+var localHostClause = '(localhost)';
+var portClause = '(:\\d{1,5})';
+var hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + '|' + localHostClause + ')' + portClause + '?';
+var pathClause = '(\\/[\\/\\w\\.\\-%~]*)*';
+var queryStringHashFragmentCharacterSet = '[0-9\\w\\[\\]\\(\\)\\/\\?\\!#@$%&\'*+,:;~\\=\\.\\-]*';
+var queryStringClause = '(\\?' + queryStringHashFragmentCharacterSet + ')?';
+var hashFragmentClause = '(#' + queryStringHashFragmentCharacterSet + ')?';
+var negatedPathCharacterSet = '[^\\/\\w\\.\\-%]+';
+var bodyClause = hostClause + pathClause + queryStringClause + hashFragmentClause;
+var start = '(?:^|' + negatedDomainCharacterSet + ')(';
+var end = ')($|' + negatedPathCharacterSet + ')';
+var strictUrlRegex = new RegExp(start + protocolClause + bodyClause + end);
+function handleLink(event, uri) {
+    window.open(uri, '_blank');
+}
+function webLinksInit(term, handler, options) {
+    if (handler === void 0) { handler = handleLink; }
+    if (options === void 0) { options = {}; }
+    options.matchIndex = 1;
+    term.registerLinkMatcher(strictUrlRegex, handler, options);
+}
+exports.webLinksInit = webLinksInit;
+function apply(terminalConstructor) {
+    terminalConstructor.prototype.webLinksInit = function (handler, options) {
+        webLinksInit(this, handler, options);
+    };
+}
+exports.apply = apply;
+
+},{}]},{},[1])(1)
+});
+//# sourceMappingURL=webLinks.js.map

Html/apps/static/css/desktop.css

@@ -107,13 +107,7 @@
         .btn-group-toggle .btn {
             padding: 5px 10px;
         }
-        #leftSidebar, .vscode-web, #rightSidebar {
-            height: 100%;
-            overflow: auto;
-          }
-        
-
-          /* 主容器，使用 grid 布局 */
+        /* 主容器，使用 grid 布局 */
         #maxcontainer {
             display: grid;
             grid-template-columns: 2fr 5px 3fr 5px 2fr; /* 默认宽度比例 */
@@ -122,7 +116,20 @@
         
         /* 各区域基础样式 */
         .sidebar {
-            overflow: auto; /* 确保内容可以滚动 */
+            display: flex;
+            flex-direction: column;
+            overflow: hidden; /* 隐藏溢出内容，让内部元素单独滚动 */
+        }
+        
+        /* 左侧边栏样式 */
+        #leftSidebar {
+            height: 100%;
+        }
+        
+        /* 中间和右侧边栏样式 */
+        .vscode-web, #rightSidebar {
+            height: 100%;
+            overflow: auto;
         }
         
         .vscode-web {
@@ -162,55 +169,75 @@
 
 
 
+/* Markdown内容区域样式 */
+#markdown-content {
+    flex: 1; /* 占满剩余空间 */
+    overflow-y: auto; /* 只有内容区域可以垂直滚动 */
+    overflow-x: hidden; /* 隐藏水平滚动条 */
+}
+
+/* 设置进度条容器样式 */
+#markdown-content-process {
+    display: flex;
+    align-items: flex-end; /* 让进度条靠底部对齐 */
+    padding: 0 10px 10px 10px; /* 添加底部内边距，调整与底部的距离 */
+    box-sizing: border-box;
+    flex-shrink: 0; /* 防止进度条被压缩 */
+}
+
 /* 设置每个子框的基本样式 */
 .progress-box {
-    height: 100%;  /* 高度为 100%，撑满容器 */
+    width: 100%;  /* 宽度为 100%，撑满容器 */
     display: flex;
     flex-direction: row;  /* 使子框横向排列 */
     justify-content: flex-start;
+    gap: 2px; /* 进度条之间的间距 */
+    margin-bottom: 0; /* 移除底部边距 */
 }
 
 .progress-title {
-    height: 60px;
-    text-align: center;
-    line-height: 60px;
-    margin-right: 2px;
-    border: 1px solid #ddd;
-    transition: background-color 0.3s ease;
+    height: 8px; /* 更细的进度条 */
+    flex: 1; /* 均匀分配宽度 */
+    border-radius: 4px; /* 圆角设计，更扁平化 */
+    transition: all 0.3s ease; /* 平滑过渡效果 */
     position: relative;
-    
-    /* 新增以下属性实现文字溢出省略 */
-    white-space: nowrap;  /* 防止文字换行 */
-    overflow: hidden;     /* 隐藏溢出内容 */
-    text-overflow: ellipsis;  /* 溢出部分显示为省略号 */
+    cursor: pointer;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.1); /* 轻微阴影，增加层次感 */
+    overflow: visible; /* 允许文字溢出 */
 }
 
+/* 颜色方案：已学习为蓝色，当前学习为绿色，未学习为白色 */
+.blue {
+    background-color: #007bff; /* 蓝色 - 已学习 */
+}
 
 .green {
-    background-color: green;
-    color: white;
+    background-color: #28a745; /* 绿色 - 当前学习 */
 }
 
 .white {
-    background-color: white;
-    color: black;
+    background-color: #e9ecef; /* 浅灰色 - 未学习，比纯白色更美观 */
 }
 
-.progress-box > .progress-title:last-child {
-    margin-bottom: 0; /* 防止最后一个子框出现多余的间距 */
+/* 进度条悬停效果 */
+.progress-title:hover {
+    transform: translateY(-1px); /* 轻微上浮效果 */
+    box-shadow: 0 2px 5px rgba(0,0,0,0.2); /* 增强阴影 */
 }
 
 /* 进度条详细信息的样式 */
 #progress-detail {
     position: absolute;
-    top: 0;
-    left: 0;
     display: none;
     padding: 10px;
-    background-color: rgba(0, 0, 0, 0.7);
+    background-color: rgba(0, 0, 0, 0.8);
     color: white;
-    border-radius: 5px;
+    border-radius: 6px;
     max-width: 200px;
+    font-size: 14px;
+    z-index: 1000;
+    pointer-events: none; /* 防止干扰鼠标事件 */
+    box-shadow: 0 2px 10px rgba(0,0,0,0.3); /* 增强阴影 */
 }
 
 .button {

Html/apps/static/css/helpTip.css

@@ -0,0 +1,51 @@
+/* HelpTip 组件样式 */
+
+/* 问号图标样式 */
+.help-icon {
+  display: inline-block;
+  margin-left: 8px;
+  color: #888;
+  font-weight: bold;
+  cursor: help;
+  font-size: 14px;
+  line-height: 1;
+  transition: color 0.2s ease;
+}
+
+.help-icon:hover {
+  color: #4CAF50;
+}
+
+/* 全局提示框样式（挂在 body 下） */
+.tooltip-portal {
+  position: fixed;   /* 不受父级 overflow 影响 */
+  left: 0;
+  top: 0;
+  z-index: 999999;   /* 足够高，覆盖所有元素 */
+  display: none;
+  opacity: 0;
+  transition: opacity 0.08s linear;
+
+  background: rgba(0, 0, 0, 0.9);
+  color: #fff;
+  padding: 6px 10px;
+  border-radius: 6px;
+  font-size: 13px;
+  line-height: 1.4;
+  pointer-events: none; /* 鼠标穿透，避免闪烁 */
+  white-space: pre-wrap; /* 支持换行符 */
+  max-width: 300px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.25);
+  word-wrap: break-word;
+}
+
+/* 提示框显示状态 */
+.tooltip-portal.show {
+  display: block;
+  opacity: 1;
+}
+
+/* 提示框动画效果 */
+.tooltip-portal.fade {
+  transition: opacity 0.2s ease;
+}

Html/apps/static/css/lesson.css

@@ -1,35 +1,3 @@
-/* 问号图标 */
-.help-icon {
-  display: inline-block;
-  margin-left: 8px;
-  color: #888;
-  font-weight: bold;
-  cursor: help;
-}
-.help-icon:hover { color: #4CAF50; }
-
-/* Portal Tooltip（挂在 body 下） */
-.tooltip-portal {
-  position: fixed;   /* 不受父级 overflow 影响 */
-  left: 0; top: 0;
-  z-index: 999999;   /* 足够高，覆盖侧栏等 */
-  display: none;
-  opacity: 0;
-  transition: opacity .08s linear;
-
-  background: rgba(0,0,0,.9);
-  color: #fff;
-  padding: 6px 10px;
-  border-radius: 6px;
-  font-size: 13px;
-  line-height: 1.4;
-  pointer-events: none; /* 鼠标穿透，避免闪烁 */
-  white-space: nowrap;
-  box-shadow: 0 4px 12px rgba(0,0,0,.25);
-}
-
-
-
 .add-step-btn, .add-phase-btn {
   background-color: #4CAF50;
   color: white;

Html/apps/static/css/navbar.css

@@ -3,13 +3,28 @@
     background: linear-gradient(135deg, var(--primary-blue), var(--accent-blue));
     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
     padding: 0.8rem 1rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
 }
 
 .navbar .logo h1 {
     color: rgb(245, 245, 245);
-    
-    font-size: 24px;
+    font-size: 18px;
     font-weight: bold;
+    margin: 0;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 300px;
+}
+
+.navbar-links {
+    display: flex;
+    justify-content: center;
+    flex: 1;
+    margin: 0 20px;
 }
 
 .navbar-links a {
@@ -69,4 +84,41 @@
 /* 下拉浮框  hover 显示 */
 .dropdown:hover .dropdown-content {
     display: block;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+    .navbar {
+        flex-direction: column;
+        gap: 1rem;
+    }
+    
+    .navbar-links {
+        margin: 0;
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 0.5rem;
+    }
+    
+    .navbar-links a {
+        margin: 0 0.75rem;
+        font-size: 16px;
+    }
+    
+    .navbar .logo h1 {
+        font-size: 16px;
+        max-width: 250px;
+    }
+}
+
+@media (max-width: 480px) {
+    .navbar .logo h1 {
+        font-size: 14px;
+        max-width: 200px;
+    }
+    
+    .navbar-links a {
+        margin: 0 0.5rem;
+        font-size: 14px;
+    }
 }

Html/apps/static/css/teacherboard.css

@@ -60,6 +60,7 @@
     border-radius: 8px;
     box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
     cursor: pointer;
+    position: relative; /* 添加相对定位 */
 }
 
 .course-image {
@@ -81,6 +82,27 @@
 .course-description {
     font-size: 14px;
     color: #555;
+    margin-bottom: 10px;
+    display: -webkit-box; /* 使用-webkit-box实现文本截断 */
+    -webkit-line-clamp: 3; /* 限制显示3行 */
+    -webkit-box-orient: vertical; /* 垂直排列 */
+    overflow: hidden; /* 隐藏溢出内容 */
+    text-overflow: ellipsis; /* 用省略号表示截断 */
+}
+
+/* 课程日期信息 */
+.course-date {
+    position: absolute; /* 绝对定位到底部 */
+    bottom: 10px; /* 距离底部10px */
+    left: 0; /* 左对齐 */
+    right: 0; /* 右对齐 */
+    padding: 10px; /* 内边距 */
+    background-color: white; /* 白色背景 */
+    border-radius: 5px; /* 圆角 */
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* 阴影 */
+    font-size: 12px; /* 字体大小 */
+    color: #666; /* 字体颜色 */
+    line-height: 1.5; /* 行高 */
 }
 
 /* 课程目录弹出框 */
@@ -159,11 +181,14 @@
 /* 浮窗内容 */
 .modal-content {
     background-color: #fff;
-    margin: 15% auto;
+    margin: 10% auto; /* 修改为10%以缩小顶部距离 */
     padding: 20px;
     border-radius: 10px;
-    width: 40%;
-    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    width: 80%; /* 修改为80%以适应小屏幕 */
+    max-width: 600px; /* 设置最大宽度 */
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0 1);
+    overflow-y: auto; /* 添加垂直滚动条 */
+    max-height: 80vh; /* 设置最大高度 */
 }
 
 /* 按钮样式 */
@@ -205,7 +230,34 @@ label {
     margin-top: 20px; /* 上方间距 */
 }
 
+/* 选择课程或新建课程的下拉框 */
+.course-selection-container {
+    margin: 10px 0;
+    font-size: 16px;
+}
 
+#course-selection {
+    width: 100%; /* 占满一行 */
+    padding: 12px; /* 增加内边距 */
+    font-size: 16px; /* 调整字体大小 */
+    margin: 10px 0; /* 上下留间距 */
+    border: 2px solid #ccc; /* 边框 */
+    border-radius: 8px; /* 圆角边框 */
+    background-color: #f9f9f9; /* 背景色 */
+    transition: border 0.3s ease, box-shadow 0.3s ease; /* 添加过渡效果 */
+}
+
+/* 鼠标悬停时下拉框的效果 */
+#course-selection:hover {
+    border-color: #4CAF50; /* 悬停时的边框颜色 */
+    box-shadow: 0 0 10px rgba(76, 175, 80, 0.5); /* 悬停时的阴影效果 */
+}
+
+/* 下拉框选中项的样式 */
+#course-selection option {
+    padding: 10px;
+    font-size: 16px;
+}
 
 /* 添加课程按钮样式 */
 .add-course-button {
@@ -433,6 +485,20 @@ label[for="course-description"] {
     cursor: pointer;
 }
 
+.delete-course-btn {
+    background-color: #e74c3c;
+    color: white;
+    padding: 10px;
+    border-radius: 5px;
+    cursor: pointer;
+    width: 100%;
+    margin-top: 10px;
+}
+
+.delete-course-btn:hover {
+    background-color: #c0392b;
+}
+
 /* 编辑弹窗 */
 .edit-modal {
     display: none;

Html/apps/static/js/chatbox.js

@@ -2,6 +2,57 @@
 var socket;
 let system_message_idx = 0
 const activeApprovals = {};
+let chatManager; // 全局聊天管理器实例
+
+// 聊天消息管理器 - 更现代的数据结构
+class ChatMessageManager {
+    constructor() {
+        this.chatbox = document.getElementById('chatbox');
+        this.messageTemplate = {
+            user: `<div class="chat-message user-message"><b>你:</b> {{content}}</div>`,
+            assistant: `<div><b>华实君:</b></div><div class="chat-message server-message"> {{content}}</div>`
+        };
+    }
+
+    // 渲染单个消息
+    renderMessage(message) {
+        let html;
+        let content;
+
+        // 处理不同的数据格式
+        if (typeof message === 'string') {
+            // 旧格式：直接字符串
+            content = marked.parse(message);
+            html = this.messageTemplate.assistant.replace('{{content}}', content);
+        } else if (typeof message === 'object' && message !== null) {
+            // 新格式：{role, content} 对象
+            content = marked.parse(message.content);
+            if (message.role === 'user') {
+                html = this.messageTemplate.user.replace('{{content}}', content);
+            } else {
+                html = this.messageTemplate.assistant.replace('{{content}}', content);
+            }
+        }
+
+        if (html) {
+            const messageDiv = document.createElement('div');
+            messageDiv.innerHTML = html;
+            this.chatbox.appendChild(messageDiv);
+            this.scrollToBottom();
+        }
+    }
+
+    // 渲染多条消息（用于恢复历史）
+    renderMessages(messages) {
+        messages.forEach(message => this.renderMessage(message));
+    }
+
+    // 滚动到底部
+    scrollToBottom() {
+        this.chatbox.scrollTop = this.chatbox.scrollHeight;
+    }
+}
+
 // 清理过期的批准记录
 function cleanupExpiredApprovals() {
   const now = Date.now();
@@ -24,6 +75,10 @@ document.addEventListener('DOMContentLoaded', function () {
             folder: data.folder
         }
     });
+
+    // 初始化聊天消息管理器
+    chatManager = new ChatMessageManager();
+
     socket.on('connect', function () {
         console.log('Connected to server');
         socket.emit('login',JSON.stringify(data));
@@ -38,12 +93,13 @@ document.addEventListener('DOMContentLoaded', function () {
         input.value += data;
     });
     socket.on('message', function (data) {
-        // 显示服务器的回复消息
-        const serverMessage = document.createElement('div');
-        serverMessage.innerHTML = `<div><b>华实君:</b></div><div class="chat-message server-message"> ${marked.parse(data)}</div>`;
-        document.getElementById('chatbox').appendChild(serverMessage);
-        // 滚动到最新消息
-        document.getElementById('chatbox').scrollTop = document.getElementById('chatbox').scrollHeight;
+        // 显示服务器的回复消息 - 单个消息
+        chatManager.renderMessage(data);
+    });
+    
+    socket.on('messages', function (data) {
+        // 显示服务器发送的消息列表 - 用于恢复对话历史
+        chatManager.renderMessages(data);
     });
     socket.on('message-hint', function(data){
         console.log('get message-hint');
@@ -90,7 +146,7 @@ document.addEventListener('DOMContentLoaded', function () {
                 }
 
                 const approveButton = document.createElement('button');
-                approveButton.innerHTML = '<i class="fas fa-check-circle-check"></i>';
+                approveButton.innerHTML = '<i class="bi bi-check-circle-fill"></i>';
                 approveButton.data = element;
                 approveButton.className = 'approve-button';
                 approveButton.onclick = function (event) {
@@ -105,29 +161,7 @@ document.addEventListener('DOMContentLoaded', function () {
                 document.getElementById('chatbox').appendChild(requestMessage);
                 document.getElementById('chatbox').scrollTop = document.getElementById('chatbox').scrollHeight;
             }
-            // for (let i = 0; i < data.length; i++) {
-            //     const element = data[i]
-            //     const requestMessage = document.createElement('div');
-            //     requestMessage.className = 'chat-message server-message';
-            //     const approveButton = document.createElement('button');
-            //     approveButton.innerText = '批准';
-            //     approveButton.data = element;
-            //     approveButton.style.width = '100%';
-            //     approveButton.style.borderRadius = '4px';
-            //     approveButton.onclick = function(event) {
-            //         console.log(element)
-            //         socket.emit('message', JSON.stringify({type:'function', data:element}));
-            //         event.currentTarget.disabled = true;
-            //         event.currentTarget.style.backgroundColor = 'gray';
-            //         event.currentTarget.style.color = 'white'; // 可选：设置文字颜色为白色，以便更清晰地显示
-            //         event.currentTarget.style.border = 'none'; // 可选：去掉边框
-            //     };
-            //     // 将按钮添加到消息气泡中
-            //     requestMessage.innerHTML = `<b>Function:</b> ${element.name}(${JSON.stringify(element.arguments)})<br>`;
-            //     requestMessage.appendChild(approveButton);
-            //     document.getElementById('chatbox').appendChild(requestMessage);
-            //     document.getElementById('chatbox').scrollTop = document.getElementById('chatbox').scrollHeight;
-            // }
+
         } catch (error) {
             console.log(error)
         }
@@ -232,142 +266,19 @@ function sendMessage() {
     const input = document.getElementById('messageInput').value;
     if (input.trim() === '') return;
 
-    // 使用 marked.js 解析 markdown
-    const markdownHtml = marked.parse(input);
-
-    // 显示用户发送的消息
-    const userMessage = document.createElement('div');
-    userMessage.innerHTML = `<div class="chat-message user-message"><b>你:</b> ${markdownHtml}</div>`;
-    document.getElementById('chatbox').appendChild(userMessage);
-
     // 发送消息到服务器
     socket.emit('message', JSON.stringify({ data: input, type: 'text' }));
 
+    // 使用聊天管理器显示用户消息
+    chatManager.renderMessage({ role: 'user', content: input });
+
     // 清空输入框
     document.getElementById('messageInput').value = '';
-
-    // 滚动到最新消息
-    document.getElementById('chatbox').scrollTop = document.getElementById('chatbox').scrollHeight;
 }
 
-// let voice_stream = null;
-// let audio_chunks = [];
-// let isRecording = false;
-// let recordingInterval = null;
-// //鼠标点击终止事件
-// function handleMouseClick(event) {
-//     event.stopPropagation();
-//     stopRecording();
-// }
-// //发送语音
-// const startAudioRecording = async () => {
-//   try {
-//     const stream = await navigator.mediaDevices.getUserMedia({ 
-//       audio: {
-//         sampleRate: 16000,
-//         channelCount: 1,
-//         echoCancellation: true,
-//         noiseSuppression: true
-//       }
-//     });
-//     const mediaRecorder = new MediaRecorder(stream);
-//     const audioContext = new AudioContext({
-//       sampleRate: 16000
-//     });
-    
-//     // Load the AudioWorklet
-//     await audioContext.audioWorklet.addModule('/static/js/audio-processor.js');
-    
-//     const source = audioContext.createMediaStreamSource(stream);
-//     const workletNode = new AudioWorkletNode(audioContext, 'audio-processor');
-//     let audioChunks = [];
-    
-//     workletNode.port.onmessage = (e) => {
-//       audioChunks.push(new Float32Array(e.data));
-      
-//       if (audioChunks.length >= 16) {
-//         // 合并所有音频块
-//         const totalLength = audioChunks.reduce((acc, chunk) => acc + chunk.length, 0);
-//         const mergedData = new Float32Array(totalLength);
-//         let offset = 0;
-//         for (const chunk of audioChunks) {
-//           mergedData.set(chunk, offset);
-//           offset += chunk.length;
-//         }
-        
-//         const audioMessage = {
-//           id: window.data.user_uuid,
-//           type: 'audio',
-//           data: mergedData,
-//           sampleRate: 16000,
-//           timestamp: Date.now()
-//         };
-//         socket.emit('voice', audioMessage);
-//         console.log("voice sended")
-//         audioChunks = [];
-//       }
-//     };
-    
-//     source.connect(workletNode);
-//     workletNode.connect(audioContext.destination);
-    
-//     mediaRecorder.value = {
-//       stop: () => {
-//         source.disconnect();
-//         workletNode.disconnect();
-//         stream.getTracks().forEach(track => track.stop());
-//         audioContext.close();
-//       }
-//     }
-    
-//     isRecording.value = true;
-//   } catch (error) {
-//     console.error('Error starting audio recording:', error);
-//   }
-// };
-// function sendVoiceMessage() {
-//     startAudioRecording()
-//     //变换录音中图标
-//     document.getElementById('recordIcon').className = 'bi bi-record-circle';
-//     document.addEventListener('click', handleMouseClick);
-// }
 
-// //停止录音
-// function stopRecording() {
-//     if (!isRecording) return;
-//     isRecording = false;
-//     //取消监听
-//     document.removeEventListener('click', handleMouseClick);
-//     //取消定时器
-//     if (recordingInterval) {
-//         clearInterval(recordingInterval);
-//         recordingInterval = null;
-//     }
-//     //变换图标
-//     document.getElementById('recordIcon').className = 'bi bi-mic';
-//     //发送剩下的数据
-//     if (audio_chunks.length > 0) {
-//         const merged_data = new Uint8Array(audio_chunks.reduce((acc, chunk) => acc + chunk.length, 0));
-//         let offset = 0;
-//         for (const chunk of audio_chunks) {
-//             merged_data.set(new Uint8Array(chunk), offset);
-//             offset += chunk.length;
-//         }
-//         socket.emit('VoiceMessage', merged_data, { binary: true });
-//         audio_chunks = [];
-//     }
-//     overlay.style.display = 'none';
-//     //关闭音频流
-//     if (voice_stream) {
-//         voice_stream.stop_stream();
-//         voice_stream.close();
-//         voice_stream = null;
-//     }
-//     if (p) {
-//         p.terminate();
-//         p = null;
-//     }
-// }
+
+
 
 
 //语音这一块//
@@ -513,14 +424,11 @@ window.addEventListener('beforeunload', () => {
 
 let currentChapterIndex = -1;
 function next_chapter(data) {
-    // 获取所有的 h3 元素
-    var iframe = document.getElementById('markdown-content-iframe');
-
-    // 访问 iframe 的文档对象
-    var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
-    var titles = []
-    var h3Elements = iframeDocument.querySelectorAll('h3');
-    console.log("h3Elements next")
+    var container = document.getElementById('markdown-content-container');
+    var titles = [];
+    var h3Elements = container.querySelectorAll('h3');
+    console.log("h3Elements next");
+    
     if (currentChapterIndex >= h3Elements.length) {
         return; // 如果已经到了最后一个章节，则不进行任何操作
     }
@@ -528,7 +436,7 @@ function next_chapter(data) {
     // 隐藏当前章节及其后的内容
     for (let i = 0; i < h3Elements.length; i++) {
         h3Elements[i].style.display = 'none';
-        titles.push(h3Elements[i].innerText)
+        titles.push(h3Elements[i].innerText);
         let nextSibling = h3Elements[i].nextElementSibling;
         while (nextSibling && nextSibling.tagName !== 'H3') {
             nextSibling.style.display = 'none';
@@ -558,48 +466,31 @@ function generateProgressBar(N, idx, titles) {
     const progressBox = document.createElement('div');
     progressBox.className = 'progress-box';
 
-    // 获取详细信息容器
-    const detailBox = document.getElementById('progress-detail');
-
-    // 根据N值动态调整每个进度节点的宽度
-    const nodeWidth = 100 / N;  // 每个节点的宽度为 100% / N
-
     // 根据N值生成子框并设置颜色
     for (let i = 0; i < N; i++) {
         const titleBox = document.createElement('div');
         titleBox.className = 'progress-title';
 
-        // 设置进度条的颜色
+        // 设置进度条的颜色：已学习为蓝色，当前学习为绿色，未学习为白色
         if (i < idx) {
-            titleBox.classList.add('green'); // 已完成部分
+            titleBox.classList.add('blue'); // 已完成部分 - 蓝色
+        } else if (i === idx) {
+            titleBox.classList.add('green'); // 当前正在学习 - 绿色
         } else {
-            titleBox.classList.add('white'); // 未完成部分
+            titleBox.classList.add('white'); // 未完成部分 - 白色
         }
 
-        // 设置每个子框的标题
-        titleBox.innerHTML = titles[i] || `Step ${i + 1}`;
+        // 移除进度条上的文字，因为现在进度条很细
+        titleBox.innerHTML = '';
 
-        // 设置每个进度节点的宽度
-        titleBox.style.width = `${nodeWidth}%`;
-
-        // 监听鼠标移入事件来显示详情
-        titleBox.addEventListener('mouseenter', function () {
-            detailBox.innerHTML = `Step ${i + 1}: ${titles[i] || "No title"}`;// - Additional details here...`;
-            detailBox.style.display = 'block';
-            // 根据进度条位置显示详情
-            const rect = titleBox.getBoundingClientRect();
-            detailBox.style.top = `${rect.top + window.scrollY - 100}px`;  // 微调位置
-            detailBox.style.left = `${rect.left + window.scrollX + rect.width / 2 - detailBox.offsetWidth / 2}px`;
-        });
-
-        // 监听鼠标移出事件来隐藏详情
-        titleBox.addEventListener('mouseleave', function () {
-            detailBox.style.display = 'none';
-        });
+        // 使用attachImmediateTooltip函数，使提示框跟随鼠标移动
+        const tooltipText = `Step ${i + 1}: ${titles[i] || "No title"}`;
+        attachImmediateTooltip(titleBox, tooltipText);
 
         progressBox.appendChild(titleBox);
     }
 
     // 将生成的进度条添加到容器中
     container.appendChild(progressBox);
+
 }

Html/apps/static/js/helpTip.js

@@ -0,0 +1,58 @@
+// helpTip.js - 全局tooltip功能，可在不同页面复用
+
+// 在页面里复用一个全局 tooltip 节点
+let __globalTooltip;
+
+// 确保tooltip节点存在
+function ensureTooltip() {
+  if (!__globalTooltip) {
+    __globalTooltip = document.createElement('div');
+    __globalTooltip.className = 'tooltip-portal';
+    document.body.appendChild(__globalTooltip);
+  }
+  return __globalTooltip;
+}
+
+// 绑定到任意图标：移入→显示；移动→跟随；移出→隐藏
+function attachImmediateTooltip(anchorEl, text) {
+  const tip = ensureTooltip();
+  let shown = false;
+
+  function show(e) {
+    tip.textContent = text;
+    tip.style.display = 'block';
+    tip.style.opacity = '1';
+    position(e);
+    shown = true;
+  }
+  
+  function position(e) {
+    // 以鼠标位置为准
+    const padding = 8;
+    const tipRect = tip.getBoundingClientRect();
+    let x = e.clientX + 12;
+    let y = e.clientY - tipRect.height - 12;
+
+    // 简易防出界
+    const vw = window.innerWidth, vh = window.innerHeight;
+    if (x + tipRect.width + padding > vw) x = vw - tipRect.width - padding;
+    if (y < padding) y = e.clientY + 16; // 放到下面
+
+    tip.style.left = `${x}px`;
+    tip.style.top  = `${y}px`;
+  }
+  
+  function hide() {
+    tip.style.opacity = '0';
+    // 用小延迟避免闪烁
+    setTimeout(() => { if (!shown) return; tip.style.display = 'none'; }, 100);
+    shown = false;
+  }
+
+  anchorEl.addEventListener('mouseenter', show);
+  anchorEl.addEventListener('mousemove', position);
+  anchorEl.addEventListener('mouseleave', hide);
+}
+
+// 导出函数，供其他文件使用
+window.attachImmediateTooltip = attachImmediateTooltip;

Html/apps/static/js/lesson.js

@@ -4,60 +4,6 @@ window.addEventListener('load', ()=>{
     editLesson(window.material.material_id, window.chapter.chapter_name, window.lesson.lesson_name);
 });
 
-// 在页面里复用一个全局 tooltip 节点
-let __globalTooltip;
-function ensureTooltip() {
-  if (!__globalTooltip) {
-    __globalTooltip = document.createElement('div');
-    __globalTooltip.className = 'tooltip-portal';
-    document.body.appendChild(__globalTooltip);
-  }
-  return __globalTooltip;
-}
-
-// 绑定到任意图标：移入→显示；移动→跟随；移出→隐藏
-function attachImmediateTooltip(anchorEl, text) {
-  const tip = ensureTooltip();
-  let shown = false;
-
-  function show(e) {
-    tip.textContent = text;
-    tip.style.display = 'block';
-    tip.style.opacity = '1';
-    position(e);
-    shown = true;
-  }
-  function position(e) {
-    // 以鼠标位置为准（也可用 anchorEl.getBoundingClientRect()）
-    const padding = 8;
-    const tipRect = tip.getBoundingClientRect();
-    let x = e.clientX + 12;
-    let y = e.clientY - tipRect.height - 12;
-
-    // 简易防出界
-    const vw = window.innerWidth, vh = window.innerHeight;
-    if (x + tipRect.width + padding > vw) x = vw - tipRect.width - padding;
-    if (y < padding) y = e.clientY + 16; // 放到下面
-
-    tip.style.left = `${x}px`;
-    tip.style.top  = `${y}px`;
-  }
-  function hide() {
-    tip.style.opacity = '0';
-    // 用小延迟避免闪烁
-    setTimeout(() => { if (!shown) return; tip.style.display = 'none'; }, 100);
-    shown = false;
-  }
-
-  anchorEl.addEventListener('mouseenter', show);
-  anchorEl.addEventListener('mousemove', position);
-  anchorEl.addEventListener('mouseleave', hide);
-}
-
-// 你的 renderOutline 里调用：
-// if (outline.theme) addThemeWithHelp(tree, outline.theme);
-
-
 
 
 
@@ -196,6 +142,7 @@ function parseHeadings(mdText) {
     help.className = 'help-icon';
     help.textContent = ' ?';
     li.appendChild(help);
+
     // 新增：铅笔编辑按钮
     const editBtn = createEditButton(() => {
       openTitleEditor({

Html/apps/static/js/render-desktop-markdown.js

@@ -0,0 +1,116 @@
+// 动态加载 Markdown 文件
+function loadMarkdown(course_id, chapter_name, lesson_name) {
+    fetch(`/${course_id}-${chapter_name}-${lesson_name}-markdown`)
+    .then(response => response.json())
+    .then(data => {
+        if (data.markdown_content) {
+            // 使用 marked 解析 Markdown 内容
+            const html = marked.parse(data.markdown_content);
+            
+            // 创建包含 MathJax 支持的 HTML 结构
+            const markdownContainer = document.createElement('div');
+            markdownContainer.id = 'markdown-content-container';
+            markdownContainer.innerHTML = html;
+            
+            // 处理代码块，实现缩略显示
+            const codeBlocks = markdownContainer.querySelectorAll('pre code');
+            codeBlocks.forEach(codeBlock => {
+                const preBlock = codeBlock.parentElement;
+                
+                // 保存原始代码内容
+                const originalContent = preBlock.innerHTML;
+                
+                // 创建缩略提示元素
+                const codeHint = document.createElement('div');
+                codeHint.className = 'code-hint';
+                codeHint.innerHTML = '<div style="padding: 10px; background-color: #f5f5f5; border: 1px solid #ddd; border-radius: 4px; color: #666; font-size: 14px; text-align: center;">💡 代码已放置在代码区中，点击展开查看</div>';
+                
+                // 创建展开/折叠按钮
+                const toggleButton = document.createElement('button');
+                toggleButton.className = 'toggle-code';
+                toggleButton.innerHTML = '展开代码';
+                toggleButton.style.cssText = 'margin: 5px; padding: 5px 10px; background-color: #007bff; color: white; border: none; border-radius: 3px; cursor: pointer; font-size: 12px;';
+                
+                // 添加到提示元素中
+                codeHint.appendChild(toggleButton);
+                
+                // 替换原始代码块为提示
+                preBlock.innerHTML = '';
+                preBlock.appendChild(codeHint);
+                
+                // 保存原始代码，用于切换
+                preBlock.dataset.originalContent = originalContent;
+                preBlock.dataset.isExpanded = 'false';
+                
+                // 添加切换事件
+                toggleButton.addEventListener('click', () => {
+                    if (preBlock.dataset.isExpanded === 'false') {
+                        // 展开代码
+                        preBlock.innerHTML = preBlock.dataset.originalContent;
+                        toggleButton.innerHTML = '折叠代码';
+                        preBlock.appendChild(toggleButton);
+                        preBlock.dataset.isExpanded = 'true';
+                        // 如果MathJax已加载，重新排版
+                        if (typeof MathJax !== 'undefined') {
+                            MathJax.typesetPromise([preBlock]);
+                        }
+                    } else {
+                        // 折叠代码
+                        preBlock.innerHTML = '';
+                        preBlock.appendChild(codeHint.cloneNode(true));
+                        preBlock.appendChild(toggleButton.cloneNode(true));
+                        preBlock.dataset.isExpanded = 'false';
+                        // 重新添加事件监听
+                        const newToggleButton = preBlock.querySelector('.toggle-code');
+                        newToggleButton.addEventListener('click', arguments.callee);
+                    }
+                });
+            });
+            
+            // 清空内容容器并添加渲染后的内容
+            const contentElement = document.getElementById('markdown-content');
+            contentElement.innerHTML = '';
+            contentElement.appendChild(markdownContainer);
+            
+            // 配置并加载 MathJax
+            if (typeof MathJax === 'undefined') {
+                // 动态加载 MathJax
+                const script = document.createElement('script');
+                script.src = '/static/cdnback/js/tex-mml-chtml.js';
+                script.async = true;
+                script.onload = function() {
+                    MathJax.config = {
+                        tex: {
+                            inlineMath: [['$', '$'], ['\\(', '\\)']]
+                        },
+                        svg: {
+                            fontCache: 'global'
+                        }
+                    };
+                    MathJax.typesetPromise([markdownContainer]);
+                    // 初始化课程进度
+                    next_chapter();
+                };
+                document.head.appendChild(script);
+            } else {
+                // MathJax 已加载，直接排版
+                MathJax.typesetPromise([markdownContainer]);
+                // 初始化课程进度
+                next_chapter();
+            }
+        } else {
+            console.error('Markdown file not found');
+        }
+    })
+    .catch(error => {
+        console.error('Error loading markdown:', error);
+    });
+}
+
+// 文档加载完成后初始化
+document.addEventListener('DOMContentLoaded', function() {
+    // 从全局变量获取课程信息
+    if (window.appData) {
+        loadMarkdown(window.appData.course_id, window.appData.chapter_name, window.appData.lesson_name);
+    }
+});

Html/apps/static/js/teacherboard.js

@@ -292,13 +292,50 @@ function closeAddCourseModal() {
     document.getElementById('add-course-modal').style.display = 'none';
 }
 
+// 显示删除课程确认弹窗
+function showDeleteCourseConfirmation() {
+    if (!material_id) {
+        alert('无法删除课程：未找到课程ID');
+        return;
+    }
+    
+    if (confirm('确定要删除这个课程吗？此操作无法撤销！')) {
+        deleteCourse(material_id);
+    }
+}
+
+// 删除课程
+function deleteCourse(courseId) {
+    fetch(`/materials/${courseId}`, {
+        method: 'DELETE',
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.message) {
+            alert(data.message);
+            if (data.success) {
+                // 关闭侧边栏并刷新页面
+                closeCourseDetails();
+                location.reload();
+            }
+        }
+    })
+    .catch(error => {
+        console.error('删除课程时出错:', error);
+        alert('删除课程失败，请稍后再试！');
+    });
+}
+
 function onTeacherboardPageLoad(){
 // 提交表单处理
 document.getElementById('add-course-form').addEventListener('submit', function(event) {
     event.preventDefault();
 
     const courseName = document.getElementById('course-name').value;
-    const courseSelection = document.getElementById('course-selection').value;
+    const courseSelection = document.getElementById('course-selection').value; // 获取选择值
     const coverImage = document.getElementById('cover-preview').src;
     const courseDescription = document.getElementById('course-description').value;
     // 构建发送的数据
@@ -312,7 +349,7 @@ document.getElementById('add-course-form').addEventListener('submit', function(e
     // 如果选择了已有课程，可以通过 courseSelection 传递课程ID（根据需要修改）
     if (courseSelection !== 'new') {
         // 如果是修改已有课程，设置相关的章节信息或其他数据
-        data.chapters = ["Chapter 1", "Chapter 2"]; // 示例章节信息
+        data.chapters = ["Chapter 1", "Chapter 2"];
     }
 
     // 发送 POST 请求到 /create_material

Html/apps/templates/code-like-desktop.html

@@ -8,6 +8,7 @@
     </style>
     <link rel="stylesheet" href="/static/css/desktop.css">
     <link rel="stylesheet" href="/static/css/chatbox_approve_icon.css">
+    <link rel="stylesheet" href="/static/css/helpTip.css">
     <script>
         document.cookie = "vscode-tkn=44edc269-6f88-46ab-9790-dc253f66ac36; path=/; SameSite=None; Secure";
     </script>
@@ -85,6 +86,22 @@
                     folder:"{{workspace_path}}"
                 }
             </script>
+            <script>
+                // 检测页面刷新事件
+                window.addEventListener('beforeunload', function(e) {
+                    // 这里不弹出提示，只在页面刷新时执行跳转
+                    // 但是beforeunload中不能直接跳转，所以我们需要在页面加载时检测是否是刷新
+                });
+                
+                // 检测是否是页面刷新
+                if (performance.navigation.type === 1 || performance.getEntriesByType("navigation")[0].type === "reload") {
+                    // 是刷新操作，跳转到确认页面
+                    const course_id = "{{course_id}}";
+                    const chapter_name = "{{chapter_name}}";
+                    const lesson_name = "{{lesson_name}}";
+                    window.location.href = `/desktop_nouser/${course_id}/${chapter_name}/${lesson_name}`;
+                }
+            </script>
         </div>
     </div>
 
@@ -124,9 +141,7 @@
         </div>
     </div>
     <script src="/static/js/process_show_floating_window.js"></script>
-
-
-
+    <script src="/static/js/helpTip.js"></script>
     <script src="/static/js/chatbox.js"></script>
     
     <script>
@@ -177,7 +192,6 @@
 
 
 
-
         // 使用 fetch 发送请求到 Flask 服务器，获取 session 信息
         fetch('/get_session', {
             method: 'GET',
@@ -214,31 +228,6 @@
         }
 
         
-    // 动态加载 Markdown 文件
-    function loadMarkdown(course_id, chapter_name, lesson_name) {
-        fetch(`/${course_id}-${chapter_name}-${lesson_name}-markdown`)
-        .then(response => response.json())
-        .then(data => {
-            if (data.html_url) {
-                document.getElementById('markdown-content').innerHTML = `<iframe id="markdown-content-iframe" src="${data.html_url}"style="width: 100%;height: 100%;"></iframe>`;
-                document.getElementById('markdown-content-iframe').addEventListener('load', function() {
-                    // 在这里执行你想要的操作
-                    console.log('Iframe has finished loading');
-                    next_chapter();
-                });
-            } else {
-                console.error('Markdown file not found');
-            }
-        })
-        .catch(error => {
-            console.error('Error loading markdown:', error);
-        });
-    }
-    document.addEventListener('DOMContentLoaded', function() {
-        loadMarkdown('{{course_id}}','{{chapter_name}}','{{lesson_name}}');
-    });
-
-
 // 侧边工具栏切换
         const sidebarTools = document.getElementById('sidebarTools');
         const toggleButton = document.getElementById('toggleButton');
@@ -254,5 +243,7 @@
         });
 
     </script>
+    <!-- 引入 Markdown 渲染脚本 -->
+    <script src="/static/js/render-desktop-markdown.js"></script>
 </body>
 </html>

Html/apps/templates/confirm_load_history.html

@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>确认加载历史数据</title>
+    <link rel="stylesheet" href="/static/cdnback/bootstrap.min.css">
+    <style>
+        body {
+            background-color: #f8f9fa;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            margin: 0;
+        }
+        .confirm-container {
+            background: white;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            padding: 30px;
+            max-width: 500px;
+            width: 100%;
+            text-align: center;
+        }
+        h1 {
+            color: #343a40;
+            margin-bottom: 20px;
+        }
+        p {
+            color: #6c757d;
+            margin-bottom: 30px;
+            font-size: 16px;
+        }
+        .btn-group {
+            display: flex;
+            gap: 15px;
+            justify-content: center;
+            margin-top: 20px;
+        }
+        .btn {
+            padding: 10px 30px;
+            font-size: 16px;
+            border-radius: 5px;
+        }
+        .btn-primary {
+            background-color: #007bff;
+            border: none;
+        }
+        .btn-primary:hover {
+            background-color: #0056b3;
+        }
+        .btn-secondary {
+            background-color: #6c757d;
+            border: none;
+        }
+        .btn-secondary:hover {
+            background-color: #545b62;
+        }
+    </style>
+</head>
+<body>
+    <div class="confirm-container">
+        {% if is_course_finished %}
+            <h1>重新学习确认</h1>
+            <p>您已经完成了该课程的学习，是否要重新开始学习？</p>
+            <div class="btn-group">
+                <a href="{{ url_for('vscode.desktop', user_uuid=user_uuid, course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name, load_history='false') }}" class="btn btn-primary">
+                    重新开始学习
+                </a>
+            </div>
+        {% else %}
+            <h1>加载历史数据确认</h1>
+            <p>您即将进入学习环境，是否需要加载您之前的对话历史记录和学习进度数据？</p>
+            <div class="btn-group">
+                <a href="{{ url_for('vscode.desktop', user_uuid=user_uuid, course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name, load_history='true') }}" class="btn btn-primary">
+                    是，加载历史数据
+                </a>
+                <a href="{{ url_for('vscode.desktop', user_uuid=user_uuid, course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name, load_history='false') }}" class="btn btn-secondary">
+                    否，重新开始
+                </a>
+            </div>
+        {% endif %}
+    </div>
+</body>
+</html>

Html/apps/templates/course.html

@@ -46,7 +46,7 @@
             </div>
         </div>
     </div>
-         {% include 'foot.html' %}
+         {% include 'footer-brief.html' %}
 </body>
 <script>
     var course_id = "{{course_id}}";

Html/apps/templates/dashboard.html

@@ -13,7 +13,6 @@
 </head>
 <body>
     {% include 'navbar.html' %}  <!-- 引入navbar.html -->
-    {% include 'learning-path.html' %} <!-- 引入learning-path.html -->
             <section class="search-section">
             <div class="container">
                 <div class="row justify-content-center">
@@ -81,7 +80,7 @@
         </div>
     </div>
 
-     {% include 'foot.html' %}
+     {% include 'footer-brief.html' %}
 
     <script src="/static/js/dashboard.js"></script>
     <script>

Html/apps/templates/footer-brief.html

@@ -0,0 +1,11 @@
+<link rel="stylesheet" href="/static/css/footer.css">
+<footer class="hs-footer">
+  <div class="footer-main">
+
+  <div class="footer-bottom">
+    <div class="footer-bottom-right">
+      <span>© 2025 华实学伴. 保留所有权利</span>
+      <a href="https://beian.miit.gov.cn" target="_blank">沪ICP备2025142149号</a>
+    </div>
+  </div>
+</footer>

Html/apps/templates/index.html

@@ -80,7 +80,7 @@
     </main>
 
 
-  {% include 'foot.html' %}
+  {% include 'footer-brief.html' %}
 </body>
 <script>
     window.appData = {

Html/apps/templates/lesson.html

@@ -8,6 +8,7 @@
     <link rel="stylesheet" href="/static/css/teacherboard.css">
     <link rel="stylesheet" href="/static/css/dashboard.css">
     <link rel="stylesheet" href="/static/css/lesson.css">
+    <link rel="stylesheet" href="/static/css/helpTip.css">
     <link rel="stylesheet" href="/static/css/teacher_course_setting.css">
     <link rel="stylesheet" href="/static/css/lesson_setting.css">
     <link rel="stylesheet" href="/static/css/modelinput.css">
@@ -100,6 +101,7 @@
     <script src="/static/js/teacherboard.js"></script>
     <script src="/static/js/teacher_course_setting.js"></script>
     <script src="/static/js/lesson_markdown.js"></script>
+    <script src="/static/js/helpTip.js"></script>
     <script src="/static/js/lesson.js"></script>
 
     <script>

Html/apps/templates/navbar.html

@@ -1,7 +1,6 @@
-<link rel="stylesheet" href="/static/css/navbar.css">
-
     <link rel="stylesheet" href="/static/cdnback/all.min.css">
     <link rel="stylesheet" href="/static/css/dashboard.css">
+    <link rel="stylesheet" href="/static/css/navbar.css">
 <header class="navbar">
     <div class="logo">
         <h1>华实学伴：教学练评一体的虚拟助教</h1>

Html/apps/templates/teacherboard.html

@@ -65,7 +65,7 @@
             </div>
         </ul>
         <button class="add-chapter-btn" onclick="showInputForNewChapter()">新增章节</button>
-        
+        <button class="delete-course-btn" onclick="showDeleteCourseConfirmation()">删除课程</button>
     </div>
 
     <!-- 编辑章节或课时弹窗 -->
@@ -90,9 +90,9 @@
             <div class="cover-image-container">
                 <div id="cover-image" class="cover-image-placeholder">
                     <span class="plus-sign">+</span>
-                    <input type="file" id="cover-image-input" style="display: none;" accept="image/*" />
+                    <input type="file" id="cover-image-input" style="display: none;" accept="image/*" /> 
                 </div>
-                <img id="cover-preview" src="" alt="封面预览" style="display: none;" />
+                <img id="cover-preview" src="" alt="封面预览" style="display: none;" /> 
             </div>
             
             <form id="add-course-form">
@@ -100,8 +100,8 @@
                 <label for="course-selection">从课程创建或新建课程：</label>
                 <select id="course-selection">
                     <option value="new">新建课程</option>
-                    {% for course in courses %}
-                        <option value="{{ course.id }}">{{ course.name }}</option>
+                    {% for course in materials %}
+                        <option value="{{ course._id }}">{{ course.name }}</option>
                     {% endfor %}
                 </select>
                 <br><br>
@@ -121,6 +121,6 @@
     <script src="/static/js/course_current.js"></script>
     <script src="/static/js/teacherboard.js"></script>
     <script src="/static/js/teacher_course_setting.js"></script>
-     {% include 'foot.html' %}
+     {% include 'footer-brief.html' %}
 </body>
 </html>

Html/apps/utils/chapterUtil.py

@@ -156,7 +156,6 @@ def load_chapters(markdown, markdown_prompt, score_prompt):
 
     chapter_chain = []
     No = 1
-    print (chapter_dict)
     for chapter_name in chapter_sequence:
         chapter_chain.append(Chapter(  No, CHAPTER_LATTER, chapter_name, chapter_dict[chapter_name]["markdown"], chapter_dict[chapter_name]["markdown_prompt"], chapter_dict[chapter_name]["score_prompt"],chapter_dict[chapter_name]["require_tools"]))
         No+=1

Html/apps/utils/json_serializer.py

@@ -0,0 +1,58 @@
+import json
+from datetime import datetime, date, time
+from bson import ObjectId
+from typing import Any, Dict, List, Union
+
+
+class JSONEncoder(json.JSONEncoder):
+    """
+    通用JSON编码器，处理常见的非JSON序列化类型
+    
+    支持的特殊类型：
+    - datetime: 转换为ISO格式字符串
+    - date: 转换为ISO格式字符串
+    - time: 转换为ISO格式字符串
+    - ObjectId: 转换为字符串
+    - 其他不可序列化类型: 转换为字符串表示
+    """
+    
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, (datetime, date, time)):
+            return obj.isoformat()
+        elif isinstance(obj, ObjectId):
+            return str(obj)
+        elif isinstance(obj, bytes):
+            return obj.decode('utf-8', errors='replace')
+        elif isinstance(obj, (set, frozenset)):
+            return list(obj)
+        elif hasattr(obj, '__dict__'):
+            return obj.__dict__
+        else:
+            return str(obj)
+
+
+def json_serialize(obj: Any) -> str:
+    """
+    通用JSON序列化函数，处理常见的非JSON序列化类型
+    
+    参数：
+    - obj: 要序列化的对象
+    
+    返回：
+    - str: JSON字符串
+    """
+    return json.dumps(obj, cls=JSONEncoder, ensure_ascii=False)
+
+
+def json_serialize_dict(obj: Any) -> Dict:
+    """
+    通用JSON序列化函数，将对象转换为可JSON序列化的字典
+    
+    参数：
+    - obj: 要序列化的对象
+    
+    返回：
+    - Dict: 可JSON序列化的字典
+    """
+    json_str = json_serialize(obj)
+    return json.loads(json_str)

Html/apps/views/markdown.py

@@ -14,17 +14,8 @@ bp = Blueprint("markdown", __name__)
 def convert_md(course_id, chapter_name, lesson_name):
     print(f"convert_md: {course_id}, {chapter_name}, {lesson_name}")
     md_file = load_markdown_file(course_id, chapter_name, lesson_name)
-    # 配置Markdown解析器，启用数学公式支持
-    md = MarkdownIt()
-    md.use(texmath.texmath_plugin)  # 添加数学公式插件
-    # 转换markdown为html（包含公式标记）
-    html = md.render(md_file)
-    # 包装样式时添加MathJax支持，用于在浏览器中渲染公式
-    html_with_styles = wrap_with_styles(html)
-    # 保存HTML文件到static
-    html_output_path = os.path.join(current_app.config["STATIC_DIR"], f"{course_id}-{chapter_name}-{lesson_name}.html")
-    save_html(html_with_styles, html_output_path)
-    return jsonify({"html_url": f"/static/{course_id}-{chapter_name}-{lesson_name}.html"})
+    # 直接返回Markdown源文件内容，不进行服务器端渲染
+    return jsonify({"markdown_content": md_file})
 
 # 提供静态文件访问
 @bp.route("/static/<path:filename>")

Html/apps/views/material.py

@@ -1,4 +1,5 @@
 from flask import Blueprint, request, jsonify, current_app, session, render_template, session
+from bson import ObjectId
 from ..services.course_service import create_material, update_material, get_materials_by_teacher, load_material, get_materials_by_teacher_dict, add_material_chapter, add_material_chapter_lesson, delete_material_chapter_lesson, reorder_material_structure, rename_material_structure
 from ..auth.decorators import require_role
 from ..services.cos_service import upload_file
@@ -37,24 +38,60 @@ def create_new_material():
     material_id = create_material(teacher_id, material_name, description, chapters, image_url)
     return jsonify({"message": "教材创建成功", "material_id": material_id}), 201
 
-@bp.route('/materials/<material_id>', methods=['GET'])
+@bp.route('/materials/<material_id>', methods=['GET', 'PUT', 'DELETE'])
 @require_role(roles="teacher")
-def get_material(material_id):
-    if material_id is None:
-        return jsonify({"message": "教材名称不能为空"}), 400
-    material = load_material(material_id)
-    print(material)
-    return jsonify( material.model_dump()), 200
+def handle_material(material_id):
 
-
-@bp.route('/materials/<material_id>', methods=['PUT'])
-@require_role(roles="teacher")
-def update_existing_material(material_id):
-    data = request.get_json()
-    chapters = data.get('chapters')
-    if update_material(material_id, chapters):
-        return jsonify({"message": "教材更新成功"}), 200
-    return jsonify({"message": "教材未找到"}), 404
+    if request.method == 'GET':
+        if material_id is None:
+            return jsonify({"message": "教材名称不能为空"}), 400
+        material = load_material(material_id)
+        print(material)
+        return jsonify(material.model_dump()), 200
+    
+    elif request.method == 'PUT':
+        data = request.get_json()
+        chapters = data.get('chapters')
+        if update_material(material_id, chapters):
+            return jsonify({"message": "教材更新成功"}), 200
+        else:
+            return jsonify({"message": "教材更新失败"}), 500
+    
+    elif request.method == 'DELETE':
+        # 获取当前教师信息
+        teacher_uuid = session.get("user_uuid")
+        teacher_id = current_app.extensions["uuid2username"][teacher_uuid]
+        
+        # 检查材料是否存在，并且是否为当前教师创建
+        mongo = current_app.extensions["mongo"]
+        print(f"尝试删除课程ID: {material_id}, 当前教师ID: {teacher_id}")
+        try:
+            material = mongo.db.materials.find_one({'_id': ObjectId(material_id)})
+            print(f"找到的材料: {material}")
+            
+            if not material:
+                return jsonify({"message": "课程不存在", "success": False}), 404
+            
+            # 验证是否为当前教师创建的课程
+            if material.get('teacher_id') != teacher_id:
+                return jsonify({"message": "权限不足，无法删除他人课程", "success": False}), 403
+                
+        except Exception as e:
+            print(f"查询材料时出错: {e}")
+            return jsonify({"message": f"查询课程时出错: {str(e)}", "success": False}), 500
+        
+        # 执行删除操作
+        try:
+            result = mongo.db.materials.delete_one({'_id': ObjectId(material_id), 'teacher_id': teacher_id})
+            print(f"删除操作结果: {result.deleted_count}")
+        except Exception as e:
+            print(f"删除材料时出错: {e}")
+            return jsonify({"message": f"删除课程时出错: {str(e)}", "success": False}), 500
+        
+        if result.deleted_count > 0:
+            return jsonify({"message": "课程删除成功", "success": True}), 200
+        else:
+            return jsonify({"message": "删除失败", "success": False}), 500
 
 @bp.route('/materials/addchapter/<material_id>', methods=['POST'])
 @require_role(roles="teacher")

Html/apps/views/vscode.py

@@ -6,6 +6,7 @@ from ..services.backboard_service import realtime_response
 from ..extension_ase.ase_client.manager import ChatManager
 import subprocess
 from ..auth.decorators import require_role
+from ..services.course_service import load_learning_progress
 
 bp = Blueprint("vscode", __name__)
 
@@ -17,6 +18,16 @@ def desktop(user_uuid, course_id, chapter_name, lesson_name):
     userid_recorder = current_app.extensions["userid_recorder"]
     if "user_uuid" not in session:
         return redirect(url_for("auth.login"))
+    
+    # 检查是否有 load_history 参数
+    load_history_str = request.args.get('load_history')
+    if load_history_str is None:
+        # 如果没有参数，跳转到确认页面
+        return redirect(url_for("vscode.desktop_nouser", course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name))
+    
+    # 将字符串转换为布尔值
+    load_history = load_history_str.lower() == 'true'
+    
     # 全局映射
     user_id = uuid2username[user_uuid]
     userid_recorder[f"{user_id}&{course_id}"] = session["user_uuid"]
@@ -58,8 +69,7 @@ def desktop(user_uuid, course_id, chapter_name, lesson_name):
 
 
 
-    chatmanager = ChatManager()
-    print(f"now user uuid {user_uuid}")
+    chatmanager = ChatManager(restart=not load_history)
     current_app.extensions["user_uuid2chatmanager"][user_uuid] = chatmanager
     code_server_port = 10000 + int(uuid.uuid4().int % 10000)
     # chatmanager.start_code_server(user_uuid, user_id, path_dir, code_server_port)
@@ -136,11 +146,38 @@ def desktop(user_uuid, course_id, chapter_name, lesson_name):
     )
 
 @bp.route("/desktop_nouser/<course_id>/<chapter_name>/<lesson_name>")
+@require_role
 def desktop_nouser(course_id, chapter_name, lesson_name):
     if "user_uuid" not in session:
         return redirect(url_for("auth.login"))  # 如果你有 auth 蓝图
+    
     user_uuid = session["user_uuid"]
-    return redirect(url_for("vscode.desktop", user_uuid=user_uuid, course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name))
+    uuid2username = current_app.extensions["uuid2username"]
+    user_id = uuid2username[user_uuid]
+    
+    # 检查是否有学习记录
+    progress_result = load_learning_progress(user_id, course_id, chapter_name, lesson_name)
+    
+    if not progress_result["exists"]:
+        # 没有学习记录，直接跳转到学习页面，不显示确认加载历史的页面
+        return redirect(url_for("vscode.desktop", user_uuid=user_uuid, course_id=course_id, chapter_name=chapter_name, lesson_name=lesson_name, load_history="false"))
+    
+    # 获取学习记录数据
+    progress_data = progress_result["data"]
+    chapter_chain_now = progress_data.get("chapter_chain_now", -1)
+    chapter_chain_length = progress_data.get("chapter_chain_length", 0)
+    
+    # 检查是否已经学完所有章节
+    is_course_finished = chapter_chain_now >= chapter_chain_length - 1
+    
+    return render_template(
+        "confirm_load_history.html",
+        user_uuid=user_uuid,
+        course_id=course_id,
+        chapter_name=chapter_name,
+        lesson_name=lesson_name,
+        is_course_finished=is_course_finished
+    )
 
 @bp.route("/vscode_data", methods=["POST"])
 def vscode_data():

Html/backboardManager.py

@@ -43,13 +43,22 @@ class Backboard:
         f"- File tree: {self.file_tree}{endl}")
         # f"- Activated file content (current editing 10 lines): {endl}"
     def add_history(self, realtime_action):
-        if(realtime_action['type']=='config'):return
-        if len(self.history)!=0:
-            if (self.history[-1]['type']=='fileEdit'):
-                if(self.history[-1]['filePath'] == realtime_action['filePath']):
+        # 检查必要的键是否存在，避免KeyError
+        if realtime_action.get('type') == 'config':
+            return
+        if len(self.history) > 0 and realtime_action.get('type') == 'fileEdit':
+            # 安全地获取filePath，并进行比较
+            current_file_path = realtime_action.get('filePath')
+            # 检查最近的历史记录是否包含filePath
+            if current_file_path and self.history[-1].get('filePath') == current_file_path:
+                # 安全地更新content，只有当content存在时才更新
+                if 'content' in realtime_action:
                     self.history[-1]['content'] = realtime_action['content']
-                    return
+                return
         self.history.append(realtime_action)
+        # 限制历史记录的数量
+        if len(self.history) > 500:  # 假设最多保留500条记录
+            self.history.pop(0)  # 移除最旧的记录
 
 
     def get_deltatime_mmss(self, start_time, end_time):

Html/config.ini

@@ -5,9 +5,9 @@ api_key = sk-aMpnWklN2IbsK44d1kNpy6YOP9bk1pdPJjFeEmbb0a5ytEFf
 model=gpt-4.1-nano
 
 [VSCODE_WEB]
-url = https://hsamooc.com
+url = https://hsamooc.cn
 [CODE_LIKE]
-url = https://hsamooc.com/vsc-like
+url = /vsc-like
 #http://asengine.net:8282
 [VSCODE_WEB_PATH]
 is_wsl = true
@@ -27,5 +27,6 @@ bucket = hsamooc-cdn-1374354408
 region = ap-guangzhou
 
 [ASE_ENGINE]
-url = https://asengine.net
+url = https://test.asengine.net
 namespace = /socket.io/7100eebf7a909e1ee3f4e06766f512f0358ecb6ac51d5434c17d31dd70890dc1
+url_token = 7100eebf7a909e1ee3f4e06766f512f0358ecb6ac51d5434c17d31dd70890dc1

Html/test_datetime_serialization.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+from datetime import datetime
+
+# Add the project root to the Python path
+sys.path.insert(0, '/Users/cakecai/Documents/gitea/hsa/Html')
+
+# Test the JSON serializer
+try:
+    from apps.utils.json_serializer import json_serialize, json_serialize_dict, JSONEncoder
+    import json
+    
+    # Create a test dictionary with datetime object
+    test_data = {
+        "user_id": "test_user",
+        "material_id": "test_course",
+        "chapter_name": "test_chapter",
+        "lesson_name": "test_lesson",
+        "chat_historys": [],
+        "scores": [],
+        "chapter_chain_now": None,
+        "updated_at": datetime.now()
+    }
+    
+    print("Testing datetime serialization...")
+    print(f"Original data: {test_data}")
+    print(f"Type of updated_at: {type(test_data['updated_at'])}")
+    
+    # Test json_serialize function
+    json_str = json_serialize(test_data)
+    print(f"\nSerialized JSON string: {json_str}")
+    
+    # Test json_serialize_dict function
+    serialized_dict = json_serialize_dict(test_data)
+    print(f"\nSerialized dictionary: {serialized_dict}")
+    print(f"Type of updated_at in serialized dict: {type(serialized_dict['updated_at'])}")
+    
+    # Test direct json.dumps with custom encoder
+    json_str2 = json.dumps(test_data, cls=JSONEncoder, ensure_ascii=False)
+    print(f"\nDirect json.dumps with custom encoder: {json_str2}")
+    
+    # Verify it can be parsed back
+    parsed = json.loads(json_str)
+    print(f"\nParsed back from JSON: {parsed}")
+    
+    print("\n✅ All tests passed! datetime objects can be correctly serialized to JSON.")
+    
+except Exception as e:
+    print(f"\n❌ Test failed with error: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)

Html/test_progress.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+
+# Add the project root to the Python path
+sys.path.insert(0, '/Users/cakecai/Documents/gitea/hsa/Html')
+
+from flask import Flask
+from flask_pymongo import PyMongo
+
+# Create a minimal Flask app for testing
+app = Flask(__name__)
+app.config['MONGO_URI'] = 'mongodb://localhost:27017/test_db'
+mongo = PyMongo(app)
+
+# Register the mongo extension with the app
+app.extensions = {'mongo': mongo}
+
+# Import the function to test
+with app.app_context():
+    from apps.services.course_services.learning_progess_process import load_learning_progress
+    
+    # Test with non-existent record
+    print("Testing with non-existent record:")
+    result = load_learning_progress("test_user", "test_course", "test_chapter", "test_lesson")
+    print(f"Result: {result}")
+    print(f"Exists: {result['exists']}")
+    print(f"Data keys: {list(result['data'].keys())}")
+    print(f"Message: {result['message']}")
+    print("\n")
+    
+    # Test that default values are correctly set
+    print("Testing default values:")
+    print(f"Chat historys: {result['data']['chat_historys']}")
+    print(f"Scores: {result['data']['scores']}")
+    print(f"Chapter chain now: {result['data']['chapter_chain_now']}")
+    print(f"Updated at: {result['data']['updated_at']}")
+    print("\n")
+    
+    print("Test completed successfully!")

code-server-like/templates/index.html

@@ -4,17 +4,17 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Cloud IDE</title>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.34.0/min/vs/editor/editor.main.css">
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.5.1/socket.io.min.js"></script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/xterm/5.5.0/xterm.css" />
+    <link rel="stylesheet" href="static/cdnback/css/editor/editor.main.css">
+    <script src="static/cdnback/socket.io.min.js"></script>
+    <link rel="stylesheet" href="static/cdnback/all.min.css">
+    <link rel="stylesheet" href="static/cdnback/css/xterm.css" />
     <!-- <script src="https://cdnjs.cloudflare.com/ajax/libs/xterm/5.5.0/xterm.js"></script> -->
-    <script src="https://unpkg.com/xterm@3.6.0/dist/xterm.js"></script>
-    <script src="https://unpkg.com/xterm@3.6.0/dist/addons/fit/fit.js"></script>
-    <script src="https://unpkg.com/xterm@3.6.0/dist/addons/webLinks/webLinks.js"></script>
-    <script src="https://unpkg.com/xterm@3.6.0/dist/addons/fullscreen/fullscreen.js"></script>
-    <script src="https://unpkg.com/xterm@3.6.0/dist/addons/search/search.js"></script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+    <script src="static/cdnback/js/xterm.js"></script>
+    <script src="static/cdnback/js/addons/fit/fit.js"></script>
+    <script src="static/cdnback/js/addons/webLinks/webLinks.js"></script>
+    <script src="static/cdnback/js/addons/fullscreen/fullscreen.js"></script>
+    <script src="static/cdnback/js/addons/search/search.js"></script>
+    <link rel="stylesheet" href="static/cdnback/all.min.css">
 
     <link rel="stylesheet" href="/vsc-like/static/css/index.css">
     <link rel="stylesheet" href="/vsc-like/static/css/notification.css">
@@ -148,12 +148,14 @@
                     });
 
                     // 防抖处理非粘贴的编辑操作
-                    const content = changes.text;
+                    // 确保始终使用完整的编辑器内容而非仅变更部分
+                    const fullContent = editor.getValue();
                     debounceSendToServer({
                         type: 'fileEdit',
                         filePath: filePath,
-                        content: content,
+                        content: fullContent,
                         config: code_like_config,
+                        timestamp: new Date().getTime() // 添加时间戳以便追踪
                     }, 5000
                 );
                 // saveFile