Update app.py

app.py

@@ -1,913 +1,3 @@
-# #!/usr/bin/env python
-# # -*- coding: utf-8 -*-
-# from flask import Flask, request, make_response
-# import hashlib
-# import time
-# import xml.etree.ElementTree as ET
-# import os
-# import json
-# from openai import OpenAI
-# from dotenv import load_dotenv
-# from markdown import markdown
-# import re
-# import threading
-# import logging
-# from datetime import datetime
-
-# # 配置日志记录
-# logging.basicConfig(
-#     level=logging.INFO,
-#     format='%(asctime)s - %(levelname)s - %(message)s',
-#     handlers=[
-#         logging.FileHandler('wechat_service.log'),
-#         logging.StreamHandler()
-#     ]
-# )
-
-# # 加载环境变量
-# load_dotenv()
-
-# app = Flask(__name__)
-
-# # 基础配置
-# TOKEN = os.getenv('TOKEN')
-# API_KEY = os.getenv("API_KEY")
-# BASE_URL = os.getenv("OPENAI_BASE_URL")
-# client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
-
-# class UserSession:
-#     def __init__(self):
-#         self.messages = [{"role": "system", "content": "You are a helpful assistant."}]
-#         self.pending_parts = []
-#         self.last_active = time.time()
-
-# class SessionManager:
-#     def __init__(self):
-#         self.sessions = {}
-#         self.session_timeout = 3600  # 1小时会话超时
-#         self._lock = threading.Lock()
-
-#     def get_session(self, user_id):
-#         with self._lock:
-#             if user_id not in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-#             session = self.sessions[user_id]
-#             session.last_active = time.time()
-#             return session
-
-#     def clear_session(self, user_id):
-#         with self._lock:
-#             if user_id in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-
-#     def cleanup_expired_sessions(self):
-#         with self._lock:
-#             current_time = time.time()
-#             expired_users = [
-#                 user_id for user_id, session in self.sessions.items()
-#                 if current_time - session.last_active > self.session_timeout
-#             ]
-#             for user_id in expired_users:
-#                 del self.sessions[user_id]
-#                 logging.info(f"已清理过期会话: {user_id}")
-
-# session_manager = SessionManager()
-
-# def convert_markdown_to_wechat(md_text):
-#     """将Markdown转换为微信友好的文本格式"""
-#     md_text = re.sub(r'^# (.*?)$', r'【标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^## (.*?)$', r'【子标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)
-#     md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)
-#     md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'```(.*?)```', r'【代码】\n\1\n【代码结束】', md_text, flags=re.DOTALL)
-#     md_text = re.sub(r'^> (.*?)$', r'▎\1', md_text, flags=re.MULTILINE)
-#     return md_text
-
-# def verify_wechat(request):
-#     """验证微信服务器请求"""
-#     data = request.args
-#     signature = data.get('signature')
-#     timestamp = data.get('timestamp')
-#     nonce = data.get('nonce')
-#     echostr = data.get('echostr')
-    
-#     temp = [timestamp, nonce, TOKEN]
-#     temp.sort()
-#     temp = ''.join(temp)
-    
-#     if hashlib.sha1(temp.encode('utf8')).hexdigest() == signature:
-#         return echostr
-#     return 'error', 403
-
-# def parse_xml_message(xml_content):
-#     """解析微信XML消息"""
-#     root = ET.fromstring(xml_content)
-#     return {
-#         'content': root.find('Content').text,
-#         'from_user': root.find('FromUserName').text,
-#         'to_user': root.find('ToUserName').text,
-#         'msg_id': root.find('MsgId').text,
-#         'create_time': root.find('CreateTime').text
-#     }
-
-# def generate_response_xml(to_user, from_user, content):
-#     """生成回复的XML消息"""
-#     response_content = convert_markdown_to_wechat(content)
-#     xml_template = '''
-#     <xml>
-#         <ToUserName><![CDATA[%s]]></ToUserName>
-#         <FromUserName><![CDATA[%s]]></FromUserName>
-#         <CreateTime>%s</CreateTime>
-#         <MsgType><![CDATA[text]]></MsgType>
-#         <Content><![CDATA[%s]]></Content>
-#     </xml>
-#     '''
-#     response = make_response(
-#         xml_template % (to_user, from_user, str(int(time.time())), response_content)
-#     )
-#     response.content_type = 'application/xml'
-#     return response
-
-# def get_openai_response(messages, timeout=30):
-#     """获取OpenAI API响应"""
-#     try:
-#         response = client.chat.completions.create(
-#             model="gpt-4o-mini",
-#             messages=messages,
-#             timeout=timeout
-#         )
-#         return response.choices[0].message.content
-#     except Exception as e:
-#         logging.error(f"OpenAI API错误: {str(e)}")
-#         return "抱歉，我暂时无法回答，请稍后再试。"
-
-# def split_message(message, max_length=500):
-#     """将长消息分段"""
-#     return [message[i:i+max_length] for i in range(0, len(message), max_length)]
-
-# def append_status_message(content, has_pending_parts=False):
-#     """添加状态提示信息"""
-#     status_message = "\n\n-------------------\n"
-#     if has_pending_parts:
-#         status_message += "当前消息已截断，发送’继续‘查看后续内容\n"
-#     status_message += "发送’新对话‘开始新的对话"
-#     return content + status_message
-
-# @app.route('/api/wx', methods=['GET', 'POST'])
-# def wechatai():
-#     if request.method == 'GET':
-#         return verify_wechat(request)
-    
-#     try:
-#         message_data = parse_xml_message(request.data)
-#         user_content = message_data['content']
-#         from_user = message_data['from_user']
-#         to_user = message_data['to_user']
-        
-#         logging.info(f"收到用户({from_user})消息: {user_content}")
-        
-#         session = session_manager.get_session(from_user)
-
-#         if user_content.strip() == '新对话':
-#             session_manager.clear_session(from_user)
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message("已开始新的对话。请描述您的问题。")
-#             )
-
-#         if user_content.strip() == '继续':
-#             if session.pending_parts:
-#                 next_part = session.pending_parts.pop(0)
-#                 has_more = bool(session.pending_parts)
-#                 return generate_response_xml(
-#                     from_user,
-#                     to_user,
-#                     append_status_message(next_part, has_more)
-#                 )
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message("没有更多内容了。请继续您的问题。")
-#             )
-
-#         session.messages.append({"role": "user", "content": user_content})
-#         response = get_openai_response(session.messages)
-#         session.messages.append({"role": "assistant", "content": response})
-
-#         if len(response) > 500:
-#             parts = split_message(response)
-#             first_part = parts.pop(0)
-#             session.pending_parts = parts
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message(first_part, True)
-#             )
-        
-#         return generate_response_xml(
-#             from_user,
-#             to_user,
-#             append_status_message(response)
-#         )
-
-#     except Exception as e:
-#         logging.error(f"处理请求时出错: {str(e)}")
-#         return generate_response_xml(
-#             message_data['from_user'],
-#             message_data['to_user'],
-#             append_status_message("抱歉，系统暂时出现问题，请稍后重试。")
-#         )
-
-# def cleanup_sessions():
-#     """定期清理过期会话"""
-#     while True:
-#         time.sleep(3600)
-#         session_manager.cleanup_expired_sessions()
-
-# if __name__ == '__main__':
-#     # 启动清理线程
-#     cleanup_thread = threading.Thread(target=cleanup_sessions, daemon=True)
-#     cleanup_thread.start()
-    
-#     app.run(host='0.0.0.0', port=7860, debug=True)
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# from flask import Flask, request, make_response
-# import hashlib
-# import time
-# import xml.etree.ElementTree as ET
-# import os
-# import json
-# from openai import OpenAI
-# from dotenv import load_dotenv
-# from markdown import markdown
-# import re
-# import threading
-# import logging
-# from datetime import datetime
-# import asyncio
-# from concurrent.futures import ThreadPoolExecutor
-# import queue
-# import uuid
-
-# # 配置日志记录
-# logging.basicConfig(
-#     level=logging.INFO,
-#     format='%(asctime)s - %(levelname)s - %(message)s',
-#     handlers=[
-#         logging.FileHandler('wechat_service.log'),
-#         logging.StreamHandler()
-#     ]
-# )
-
-# # 加载环境变量
-# load_dotenv()
-
-# app = Flask(__name__)
-
-# # 基础配置
-# TOKEN = os.getenv('TOKEN')
-# API_KEY = os.getenv("API_KEY")
-# BASE_URL = os.getenv("OPENAI_BASE_URL")
-# client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
-
-# # 创建线程池
-# executor = ThreadPoolExecutor(max_workers=10)
-
-# def convert_markdown_to_wechat(md_text):
-#     """将Markdown转换为微信友好的文本格式"""
-#     if not md_text:
-#         return md_text
-        
-#     # 处理标题
-#     md_text = re.sub(r'^# (.*?)$', r'【标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^## (.*?)$', r'【子标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^### (.*?)$', r'【小标题】\1', md_text, flags=re.MULTILINE)
-    
-#     # 处理强调语法
-#     md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)  # 粗体
-#     md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)      # 斜体
-#     md_text = re.sub(r'`(.*?)`', r'「\1」', md_text)        # 行内代码
-    
-#     # 处理列表
-#     md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)  # 无序列表
-#     md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)  # 有序列表
-    
-#     # 处理代码块
-#     md_text = re.sub(r'```[\w]*\n(.*?)```', r'【代码开始】\n\1\n【代码结束】', md_text, flags=re.DOTALL)
-    
-#     # 处理引用
-#     md_text = re.sub(r'^> (.*?)$', r'▎\1', md_text, flags=re.MULTILINE)
-    
-#     # 处理分隔线
-#     md_text = re.sub(r'^-{3,}$', r'—————————', md_text, flags=re.MULTILINE)
-    
-#     # 处理链接
-#     md_text = re.sub(r'\[(.*?)\]\((.*?)\)', r'\1（\2）', md_text)
-    
-#     # 净化处理：去除多余的空行
-#     md_text = re.sub(r'\n{3,}', '\n\n', md_text)
-    
-#     return md_text
-
-# class AsyncResponse:
-#     def __init__(self):
-#         self.status = "processing"  # processing, completed, failed
-#         self.result = None
-#         self.error = None
-
-# class UserSession:
-#     def __init__(self):
-#         self.messages = [{"role": "system", "content": "You are a helpful assistant."}]
-#         self.pending_parts = []
-#         self.last_active = time.time()
-#         self.current_task = None  # 存储当前正在处理的任务ID
-#         self.response_queue = {}  # 存储异步响应
-
-# class SessionManager:
-#     def __init__(self):
-#         self.sessions = {}
-#         self.session_timeout = 3600  # 1小时会话超时
-#         self._lock = threading.Lock()
-
-#     def get_session(self, user_id):
-#         with self._lock:
-#             if user_id not in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-#             session = self.sessions[user_id]
-#             session.last_active = time.time()
-#             return session
-
-#     def clear_session(self, user_id):
-#         with self._lock:
-#             if user_id in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-                
-#     def cleanup_expired_sessions(self):
-#         with self._lock:
-#             current_time = time.time()
-#             expired_users = [
-#                 user_id for user_id, session in self.sessions.items()
-#                 if current_time - session.last_active > self.session_timeout
-#             ]
-#             for user_id in expired_users:
-#                 del self.sessions[user_id]
-#                 logging.info(f"已清理过期会话: {user_id}")
-
-# session_manager = SessionManager()
-
-# def verify_wechat(request):
-#     """验证微信服务器请求"""
-#     data = request.args
-#     signature = data.get('signature')
-#     timestamp = data.get('timestamp')
-#     nonce = data.get('nonce')
-#     echostr = data.get('echostr')
-    
-#     temp = [timestamp, nonce, TOKEN]
-#     temp.sort()
-#     temp = ''.join(temp)
-    
-#     if hashlib.sha1(temp.encode('utf8')).hexdigest() == signature:
-#         return echostr
-#     return 'error', 403
-
-# def parse_xml_message(xml_content):
-#     """解析微信XML消息"""
-#     root = ET.fromstring(xml_content)
-#     return {
-#         'content': root.find('Content').text,
-#         'from_user': root.find('FromUserName').text,
-#         'to_user': root.find('ToUserName').text,
-#         'msg_id': root.find('MsgId').text,
-#         'create_time': root.find('CreateTime').text
-#     }
-
-# def generate_response_xml(to_user, from_user, content):
-#     """生成回复的XML消息"""
-#     formatted_content = convert_markdown_to_wechat(content)
-#     xml_template = '''
-#     <xml>
-#         <ToUserName><![CDATA[%s]]></ToUserName>
-#         <FromUserName><![CDATA[%s]]></FromUserName>
-#         <CreateTime>%s</CreateTime>
-#         <MsgType><![CDATA[text]]></MsgType>
-#         <Content><![CDATA[%s]]></Content>
-#     </xml>
-#     '''
-#     response = make_response(
-#         xml_template % (to_user, from_user, str(int(time.time())), formatted_content)
-#     )
-#     response.content_type = 'application/xml'
-#     return response
-
-# def process_long_running_task(messages):
-#     """处理耗时任务"""
-#     try:
-#         response = client.chat.completions.create(
-#             model="gpt-4o-mini",
-#             messages=messages,
-#             timeout=60
-#         )
-#         return response.choices[0].message.content
-#     except Exception as e:
-#         logging.error(f"API调用错误: {str(e)}")
-#         raise
-
-# def handle_async_task(session, task_id, messages):
-#     """异步任务处理函数"""
-#     try:
-#         result = process_long_running_task(messages)
-#         session.response_queue[task_id].status = "completed"
-#         session.response_queue[task_id].result = result
-#     except Exception as e:
-#         session.response_queue[task_id].status = "failed"
-#         session.response_queue[task_id].error = str(e)
-
-# def generate_initial_response():
-#     """生成初始响应消息"""
-#     return "您的��求正在处理中，请稍后回复’查询‘获取结果。"
-
-# def split_message(message, max_length=500):
-#     """将长消息分段"""
-#     return [message[i:i+max_length] for i in range(0, len(message), max_length)]
-
-# def append_status_message(content, has_pending_parts=False, is_processing=False):
-#     """添加状态提示信息"""
-#     status_message = "\n\n-------------------\n"
-#     if is_processing:
-#         status_message += "您的请求正在处理中，请回复’查询‘获取结果\n"
-#     elif has_pending_parts:
-#         status_message += "当前消息已截断，发送’继续‘查看后续内容\n"
-#     status_message += "发送‘新对话’开始新的对话"
-#     return content + status_message
-
-# @app.route('/api/wx', methods=['GET', 'POST'])
-# def wechatai():
-#     if request.method == 'GET':
-#         return verify_wechat(request)
-    
-#     try:
-#         message_data = parse_xml_message(request.data)
-#         user_content = message_data['content'].strip()
-#         from_user = message_data['from_user']
-#         to_user = message_data['to_user']
-        
-#         logging.info(f"收到用户({from_user})消息: {user_content}")
-#         session = session_manager.get_session(from_user)
-
-#         # 处理特殊命令
-#         if user_content == '新对话':
-#             session_manager.clear_session(from_user)
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message("已开始新的对话。请描述您的问题。")
-#             )
-
-#         if user_content == '继续':
-#             if session.pending_parts:
-#                 next_part = session.pending_parts.pop(0)
-#                 has_more = bool(session.pending_parts)
-#                 return generate_response_xml(
-#                     from_user,
-#                     to_user,
-#                     append_status_message(next_part, has_more)
-#                 )
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message("没有更多内容了。请继续您的问题。")
-#             )
-
-#         if user_content == '查询':
-#             if session.current_task:
-#                 task_response = session.response_queue.get(session.current_task)
-#                 if task_response:
-#                     if task_response.status == "completed":
-#                         response = task_response.result
-#                         # 清理完成的任务
-#                         del session.response_queue[session.current_task]
-#                         session.current_task = None
-                        
-#                         # 处理长消息
-#                         if len(response) > 500:
-#                             parts = split_message(response)
-#                             first_part = parts.pop(0)
-#                             session.pending_parts = parts
-#                             return generate_response_xml(
-#                                 from_user,
-#                                 to_user,
-#                                 append_status_message(first_part, True)
-#                             )
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message(response)
-#                         )
-#                     elif task_response.status == "failed":
-#                         error_message = "处理过程中出现错误，请重新提问。"
-#                         # 清理失败的任务
-#                         del session.response_queue[session.current_task]
-#                         session.current_task = None
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message(error_message)
-#                         )
-#                     else:
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message("正在处理中，请稍后再次查询。", is_processing=True)
-#                         )
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message("没有正在处理的请求。")
-#             )
-
-#         # 处理新的用户消息
-#         session.messages.append({"role": "user", "content": user_content})
-        
-#         # 创建新的异步任务
-#         task_id = str(uuid.uuid4())
-#         session.current_task = task_id
-#         session.response_queue[task_id] = AsyncResponse()
-        
-#         # 启动异步处理
-#         executor.submit(handle_async_task, session, task_id, session.messages.copy())
-        
-#         # 返回初始响应
-#         return generate_response_xml(
-#             from_user,
-#             to_user,
-#             append_status_message(generate_initial_response(), is_processing=True)
-#         )
-
-#     except Exception as e:
-#         logging.error(f"处理请求时出错: {str(e)}")
-#         return generate_response_xml(
-#             message_data['from_user'],
-#             message_data['to_user'],
-#             append_status_message("抱歉，系统暂时出现问题，请稍后重试。")
-#         )
-
-# def cleanup_sessions():
-#     """定期清理过期会话"""
-#     while True:
-#         time.sleep(3600)  # 每小时清理一次
-#         try:
-#             session_manager.cleanup_expired_sessions()
-#         except Exception as e:
-#             logging.error(f"清理会话时出错: {str(e)}")
-
-# if __name__ == '__main__':
-#     # 启动清理线程
-#     cleanup_thread = threading.Thread(target=cleanup_sessions, daemon=True)
-#     cleanup_thread.start()
-    
-#     # 启动Flask应用
-#     app.run(host='0.0.0.0', port=7860, debug=True)
-# #!/usr/bin/env python
-# # -*- coding: utf-8 -*-
-# from flask import Flask, request, make_response
-# import hashlib
-# import time
-# import xml.etree.ElementTree as ET
-# import os
-# import json
-# from openai import OpenAI
-# from dotenv import load_dotenv
-# from markdown import markdown
-# import re
-# import threading
-# import logging
-# from datetime import datetime
-# import asyncio
-# from concurrent.futures import ThreadPoolExecutor
-# import queue
-# import uuid
-
-# # 配置日志记录
-# logging.basicConfig(
-#     level=logging.INFO,
-#     format='%(asctime)s - %(levelname)s - %(message)s',
-#     handlers=[
-#         logging.FileHandler('wechat_service.log'),
-#         logging.StreamHandler()
-#     ]
-# )
-
-# # 加载环境变量
-# load_dotenv()
-
-# app = Flask(__name__)
-
-# # 基础配置
-# TOKEN = os.getenv('TOKEN')
-# API_KEY = os.getenv("API_KEY")
-# BASE_URL = os.getenv("OPENAI_BASE_URL")
-# client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
-
-# # 创建线程池
-# executor = ThreadPoolExecutor(max_workers=10)
-
-# def convert_markdown_to_wechat(md_text):
-#     """将Markdown转换为微信友好的文本格式"""
-#     if not md_text:
-#         return md_text
-        
-#     # 处理标题
-#     md_text = re.sub(r'^# (.*?)$', r'【标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^## (.*?)$', r'【子标题】\1', md_text, flags=re.MULTILINE)
-#     md_text = re.sub(r'^### (.*?)$', r'【小标题】\1', md_text, flags=re.MULTILINE)
-    
-#     # 处理强调语法
-#     md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)  # 粗体
-#     md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)      # 斜体
-#     md_text = re.sub(r'`(.*?)`', r'「\1」', md_text)        # 行内代码
-    
-#     # 处理列表
-#     md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)  # 无序列表
-#     md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)  # 有序列表
-    
-#     # 处理代码块
-#     md_text = re.sub(r'```[\w]*\n(.*?)```', r'【代码开始】\n\1\n【代码结束】', md_text, flags=re.DOTALL)
-    
-#     # 处理引用
-#     md_text = re.sub(r'^> (.*?)$', r'▎\1', md_text, flags=re.MULTILINE)
-    
-#     # 处理分隔线
-#     md_text = re.sub(r'^-{3,}$', r'—————————', md_text, flags=re.MULTILINE)
-    
-#     # 处理链接
-#     md_text = re.sub(r'\[(.*?)\]\((.*?)\)', r'\1（\2）', md_text)
-    
-#     # 净化处理：去除多余的空行
-#     md_text = re.sub(r'\n{3,}', '\n\n', md_text)
-    
-#     return md_text
-
-# class AsyncResponse:
-#     def __init__(self):
-#         self.status = "processing"  # processing, completed, failed
-#         self.result = None
-#         self.error = None
-
-# class UserSession:
-#     def __init__(self):
-#         self.messages = [{"role": "system", "content": "You are a helpful assistant."}]
-#         self.pending_parts = []
-#         self.last_active = time.time()
-#         self.current_task = None
-#         self.response_queue = {}
-
-# class SessionManager:
-#     def __init__(self):
-#         self.sessions = {}
-#         self.session_timeout = 3600
-#         self._lock = threading.Lock()
-
-#     def get_session(self, user_id):
-#         with self._lock:
-#             if user_id not in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-#             session = self.sessions[user_id]
-#             session.last_active = time.time()
-#             return session
-
-#     def clear_session(self, user_id):
-#         with self._lock:
-#             if user_id in self.sessions:
-#                 self.sessions[user_id] = UserSession()
-                
-#     def cleanup_expired_sessions(self):
-#         with self._lock:
-#             current_time = time.time()
-#             expired_users = [
-#                 user_id for user_id, session in self.sessions.items()
-#                 if current_time - session.last_active > self.session_timeout
-#             ]
-#             for user_id in expired_users:
-#                 del self.sessions[user_id]
-#                 logging.info(f"已清理过期会话: {user_id}")
-
-# session_manager = SessionManager()
-
-# def verify_wechat(request):
-#     """验证微信服务器请求"""
-#     data = request.args
-#     signature = data.get('signature')
-#     timestamp = data.get('timestamp')
-#     nonce = data.get('nonce')
-#     echostr = data.get('echostr')
-    
-#     temp = [timestamp, nonce, TOKEN]
-#     temp.sort()
-#     temp = ''.join(temp)
-    
-#     if hashlib.sha1(temp.encode('utf8')).hexdigest() == signature:
-#         return echostr
-#     return 'error', 403
-
-# def parse_xml_message(xml_content):
-#     """解析微信XML消息"""
-#     root = ET.fromstring(xml_content)
-#     return {
-#         'content': root.find('Content').text,
-#         'from_user': root.find('FromUserName').text,
-#         'to_user': root.find('ToUserName').text,
-#         'msg_id': root.find('MsgId').text,
-#         'create_time': root.find('CreateTime').text
-#     }
-
-# def generate_response_xml(to_user, from_user, content):
-#     """生成回复的XML消息"""
-#     formatted_content = convert_markdown_to_wechat(content)
-#     xml_template = '''
-#     <xml>
-#         <ToUserName><![CDATA[%s]]></ToUserName>
-#         <FromUserName><![CDATA[%s]]></FromUserName>
-#         <CreateTime>%s</CreateTime>
-#         <MsgType><![CDATA[text]]></MsgType>
-#         <Content><![CDATA[%s]]></Content>
-#     </xml>
-#     '''
-#     response = make_response(
-#         xml_template % (to_user, from_user, str(int(time.time())), formatted_content)
-#     )
-#     response.content_type = 'application/xml'
-#     return response
-
-# def process_long_running_task(messages):
-#     """处理耗时任务"""
-#     try:
-#         response = client.chat.completions.create(
-#             model="gpt-4o-mini",
-#             messages=messages,
-#             timeout=60
-#         )
-#         return response.choices[0].message.content
-#     except Exception as e:
-#         logging.error(f"API调用错误: {str(e)}")
-#         raise
-
-# def handle_async_task(session, task_id, messages):
-#     """异步任务处理函数"""
-#     try:
-#         result = process_long_running_task(messages)
-#         session.response_queue[task_id].status = "completed"
-#         session.response_queue[task_id].result = result
-#     except Exception as e:
-#         session.response_queue[task_id].status = "failed"
-#         session.response_queue[task_id].error = str(e)
-
-# def generate_initial_response():
-#     """生成初始响应消息"""
-#     return "您的请求正在处理中"
-
-# def split_message(message, max_length=500):
-#     """将长消息分段"""
-#     return [message[i:i+max_length] for i in range(0, len(message), max_length)]
-
-# def append_status_message(content, has_pending_parts=False, is_processing=False):
-#     """添加状态提示信息"""
-#     status_message = "\n\n-------------------"
-#     if is_processing:
-#         status_message += "\n请回复'查询'获取结果"
-#     elif has_pending_parts:
-#         status_message += "\n当前消息已截断，发送'继续'查看后续内容"
-#     status_message += "\n发送'新对话'开始新的对话"
-#     return content + status_message
-
-# @app.route('/api/wx', methods=['GET', 'POST'])
-# def wechatai():
-#     if request.method == 'GET':
-#         return verify_wechat(request)
-    
-#     try:
-#         message_data = parse_xml_message(request.data)
-#         user_content = message_data['content'].strip()
-#         from_user = message_data['from_user']
-#         to_user = message_data['to_user']
-        
-#         logging.info(f"收到用户({from_user})消息: {user_content}")
-#         session = session_manager.get_session(from_user)
-
-#         if user_content == '新对话':
-#             session_manager.clear_session(from_user)
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message('已开始新的对话。请描述您的问题。')
-#             )
-
-#         if user_content == '继续':
-#             if session.pending_parts:
-#                 next_part = session.pending_parts.pop(0)
-#                 has_more = bool(session.pending_parts)
-#                 return generate_response_xml(
-#                     from_user,
-#                     to_user,
-#                     append_status_message(next_part, has_more)
-#                 )
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message('没有更多内容了。请继续您的问题。')
-#             )
-
-#         if user_content == '查询':
-#             if session.current_task:
-#                 task_response = session.response_queue.get(session.current_task)
-#                 if task_response:
-#                     if task_response.status == "completed":
-#                         response = task_response.result
-#                         del session.response_queue[session.current_task]
-#                         session.current_task = None
-                        
-#                         if len(response) > 500:
-#                             parts = split_message(response)
-#                             first_part = parts.pop(0)
-#                             session.pending_parts = parts
-#                             return generate_response_xml(
-#                                 from_user,
-#                                 to_user,
-#                                 append_status_message(first_part, True)
-#                             )
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message(response)
-#                         )
-#                     elif task_response.status == "failed":
-#                         error_message = '处理过程中出现错误，请重新提问。'
-#                         del session.response_queue[session.current_task]
-#                         session.current_task = None
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message(error_message)
-#                         )
-#                     else:
-#                         return generate_response_xml(
-#                             from_user,
-#                             to_user,
-#                             append_status_message('正在处理中，请稍后再次查询。', is_processing=True)
-#                         )
-#             return generate_response_xml(
-#                 from_user,
-#                 to_user,
-#                 append_status_message('没有正在处理的请求。')
-#             )
-
-#         session.messages.append({"role": "user", "content": user_content})
-        
-#         task_id = str(uuid.uuid4())
-#         session.current_task = task_id
-#         session.response_queue[task_id] = AsyncResponse()
-        
-#         executor.submit(handle_async_task, session, task_id, session.messages.copy())
-        
-#         return generate_response_xml(
-#             from_user,
-#             to_user,
-#             append_status_message(generate_initial_response(), is_processing=True)
-#         )
-
-#     except Exception as e:
-#         logging.error(f"处理请求时出错: {str(e)}")
-#         return generate_response_xml(
-#             message_data['from_user'],
-#             message_data['to_user'],
-#             append_status_message('抱歉，系统暂时出现问题，请稍后重试。')
-#         )
-
-# def cleanup_sessions():
-#     """定期清理过期会话"""
-#     while True:
-#         time.sleep(3600)
-#         try:
-#             session_manager.cleanup_expired_sessions()
-#         except Exception as e:
-#             logging.error(f"清理会话时出错: {str(e)}")
-
-# if __name__ == '__main__':
-#     cleanup_thread = threading.Thread(target=cleanup_sessions, daemon=True)
-#     cleanup_thread.start()
-    
-#     app.run(host='0.0.0.0', port=7860, debug=True)
-#下面这个代码解决的是响应查询时重复回应的情况
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# 
-#下面这个代码是告诉用户超时后就需要重新回答了
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 from flask import Flask, request, make_response
 import hashlib
 import time
@@ -925,8 +15,12 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import queue
 import uuid
+import base64
+from Crypto.Cipher import AES
+import struct
+import random
+import string
 
-# 配置日志记录
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -936,30 +30,75 @@ logging.basicConfig(
     ]
 )
 
-# 加载环境变量
 load_dotenv()
 
 app = Flask(__name__)
 
-# 基础配置
 TOKEN = os.getenv('TOKEN')
+ENCODING_AES_KEY = os.getenv('ENCODING_AES_KEY')
+APPID = os.getenv('APPID')
 API_KEY = os.getenv("API_KEY")
 BASE_URL = os.getenv("OPENAI_BASE_URL")
-client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
 
-# 创建线程池
+client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
 executor = ThreadPoolExecutor(max_workers=10)
 
+class WeChatCrypto:
+    def __init__(self, key, app_id):
+        self.key = base64.b64decode(key + '=')
+        self.app_id = app_id
+
+    def encrypt(self, text):
+        # 生成随机16字节字符串
+        random_str = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
+        text_bytes = text.encode('utf-8')
+        
+        # 构造明文字符串
+        msg_len = struct.pack('>I', len(text_bytes))
+        message = random_str.encode('utf-8') + msg_len + text_bytes + self.app_id.encode('utf-8')
+        
+        # 补位
+        pad_len = 32 - (len(message) % 32)
+        message += chr(pad_len).encode('utf-8') * pad_len
+        
+        # 加密
+        cipher = AES.new(self.key, AES.MODE_CBC, self.key[:16])
+        encrypted = cipher.encrypt(message)
+        return base64.b64encode(encrypted).decode('utf-8')
+
+    def decrypt(self, encrypted_text):
+        # Base64解码
+        encrypted_data = base64.b64decode(encrypted_text)
+        
+        # 解密
+        cipher = AES.new(self.key, AES.MODE_CBC, self.key[:16])
+        decrypted = cipher.decrypt(encrypted_data)
+        
+        # 获取填充长度
+        pad_len = decrypted[-1]
+        if not isinstance(pad_len, int):
+            pad_len = ord(pad_len)
+        content = decrypted[16:-pad_len]
+        
+        # 获取消息长度
+        msg_len = struct.unpack('>I', content[:4])[0]
+        xml_content = content[4:msg_len + 4].decode('utf-8')
+        app_id = content[msg_len + 4:].decode('utf-8')
+        
+        if app_id != self.app_id:
+            raise ValueError('Invalid AppID')
+            
+        return xml_content
+
 class AsyncResponse:
     def __init__(self):
-        self.status = "processing"  # processing, completed, failed
+        self.status = "processing"
         self.result = None
         self.error = None
-        self.create_time = time.time()  # 任务创建时间
-        self.timeout = 3600  # 任务超时时间（1小时）
+        self.create_time = time.time()
+        self.timeout = 3600
 
     def is_expired(self):
-        """检查任务是否过期"""
         return time.time() - self.create_time > self.timeout
 
 class UserSession:
@@ -969,14 +108,12 @@ class UserSession:
         self.last_active = time.time()
         self.current_task = None
         self.response_queue = {}
-        self.session_timeout = 3600  # 会话超时时间（1小时）
+        self.session_timeout = 3600
 
     def is_expired(self):
-        """检查会话是否过期"""
         return time.time() - self.last_active > self.session_timeout
 
     def cleanup_expired_tasks(self):
-        """清理过期的任务"""
         expired_tasks = [
             task_id for task_id, response in self.response_queue.items()
             if response.is_expired()
@@ -990,6 +127,7 @@ class SessionManager:
     def __init__(self):
         self.sessions = {}
         self._lock = threading.Lock()
+        self.crypto = WeChatCrypto(ENCODING_AES_KEY, APPID)
 
     def get_session(self, user_id):
         with self._lock:
@@ -997,9 +135,9 @@ class SessionManager:
             if user_id in self.sessions:
                 session = self.sessions[user_id]
                 if session.is_expired():
-                    session = UserSession()  # 创建新会话
+                    session = UserSession()
                 else:
-                    session.cleanup_expired_tasks()  # 清理过期任务
+                    session.cleanup_expired_tasks()
             else:
                 session = UserSession()
             session.last_active = current_time
@@ -1025,88 +163,98 @@ class SessionManager:
 session_manager = SessionManager()
 
 def convert_markdown_to_wechat(md_text):
-    """将Markdown转换为微信友好的文本格式"""
     if not md_text:
         return md_text
         
-    # 处理标题
     md_text = re.sub(r'^# (.*?)$', r'【标题】\1', md_text, flags=re.MULTILINE)
     md_text = re.sub(r'^## (.*?)$', r'【子标题】\1', md_text, flags=re.MULTILINE)
     md_text = re.sub(r'^### (.*?)$', r'【小标题】\1', md_text, flags=re.MULTILINE)
-    
-    # 处理强调语法
-    md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)  # 粗体
-    md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)      # 斜体
-    md_text = re.sub(r'`(.*?)`', r'「\1」', md_text)        # 行内代码
-    
-    # 处理列表
-    md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)  # 无序列表
-    md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)  # 有序列表
-    
-    # 处理代码块
+    md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)
+    md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)
+    md_text = re.sub(r'`(.*?)`', r'「\1」', md_text)
+    md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)
+    md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)
     md_text = re.sub(r'```[\w]*\n(.*?)```', r'【代码开始】\n\1\n【代码结束】', md_text, flags=re.DOTALL)
-    
-    # 处理引用
     md_text = re.sub(r'^> (.*?)$', r'▎\1', md_text, flags=re.MULTILINE)
-    
-    # 处理分隔线
     md_text = re.sub(r'^-{3,}$', r'—————————', md_text, flags=re.MULTILINE)
-    
-    # 处理链接
     md_text = re.sub(r'\[(.*?)\]\((.*?)\)', r'\1（\2）', md_text)
-    
-    # 净化处理：去除多余的空行
     md_text = re.sub(r'\n{3,}', '\n\n', md_text)
     
     return md_text
 
-def verify_wechat(request):
-    """验证微信服务器请求"""
-    data = request.args
-    signature = data.get('signature')
-    timestamp = data.get('timestamp')
-    nonce = data.get('nonce')
-    echostr = data.get('echostr')
-    
-    temp = [timestamp, nonce, TOKEN]
-    temp.sort()
-    temp = ''.join(temp)
-    
-    if hashlib.sha1(temp.encode('utf8')).hexdigest() == signature:
-        return echostr
-    return 'error', 403
+def verify_signature(signature, timestamp, nonce, token):
+    items = [token, timestamp, nonce]
+    items.sort()
+    temp_str = ''.join(items)
+    hash_sha1 = hashlib.sha1(temp_str.encode('utf-8')).hexdigest()
+    return hash_sha1 == signature
+
+def verify_msg_signature(msg_signature, timestamp, nonce, token, encrypt_msg):
+    items = [token, timestamp, nonce, encrypt_msg]
+    items.sort()
+    temp_str = ''.join(items)
+    hash_sha1 = hashlib.sha1(temp_str.encode('utf-8')).hexdigest()
+    return hash_sha1 == msg_signature
 
 def parse_xml_message(xml_content):
-    """解析微信XML消息"""
     root = ET.fromstring(xml_content)
     return {
-        'content': root.find('Content').text,
+        'content': root.find('Content').text if root.find('Content') is not None else '',
         'from_user': root.find('FromUserName').text,
         'to_user': root.find('ToUserName').text,
-        'msg_id': root.find('MsgId').text,
-        'create_time': root.find('CreateTime').text
+        'msg_id': root.find('MsgId').text if root.find('MsgId') is not None else '',
+        'create_time': root.find('CreateTime').text,
+        'msg_type': root.find('MsgType').text
     }
 
-def generate_response_xml(to_user, from_user, content):
-    """生成回复的XML消息"""
+def generate_response_xml(to_user, from_user, content, encrypt_type='aes'):
     formatted_content = convert_markdown_to_wechat(content)
-    xml_template = '''
-    <xml>
-        <ToUserName><![CDATA[%s]]></ToUserName>
-        <FromUserName><![CDATA[%s]]></FromUserName>
-        <CreateTime>%s</CreateTime>
-        <MsgType><![CDATA[text]]></MsgType>
-        <Content><![CDATA[%s]]></Content>
-    </xml>
-    '''
-    response = make_response(
-        xml_template % (to_user, from_user, str(int(time.time())), formatted_content)
-    )
+    timestamp = str(int(time.time()))
+    nonce = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+    
+    if encrypt_type == 'aes':
+        xml_content = f'''
+        <xml>
+            <ToUserName><![CDATA[{to_user}]]></ToUserName>
+            <FromUserName><![CDATA[{from_user}]]></FromUserName>
+            <CreateTime>{timestamp}</CreateTime>
+            <MsgType><![CDATA[text]]></MsgType>
+            <Content><![CDATA[{formatted_content}]]></Content>
+        </xml>
+        '''
+        
+        # 加密消息内容
+        encrypted = session_manager.crypto.encrypt(xml_content)
+        
+        # 生成签名
+        signature_list = [TOKEN, timestamp, nonce, encrypted]
+        signature_list.sort()
+        msg_signature = hashlib.sha1(''.join(signature_list).encode('utf-8')).hexdigest()
+        
+        response_xml = f'''
+        <xml>
+            <Encrypt><![CDATA[{encrypted}]]></Encrypt>
+            <MsgSignature><![CDATA[{msg_signature}]]></MsgSignature>
+            <TimeStamp>{timestamp}</TimeStamp>
+            <Nonce><![CDATA[{nonce}]]></Nonce>
+        </xml>
+        '''
+    else:
+        response_xml = f'''
+        <xml>
+            <ToUserName><![CDATA[{to_user}]]></ToUserName>
+            <FromUserName><![CDATA[{from_user}]]></FromUserName>
+            <CreateTime>{timestamp}</CreateTime>
+            <MsgType><![CDATA[text]]></MsgType>
+            <Content><![CDATA[{formatted_content}]]></Content>
+        </xml>
+        '''
+    
+    response = make_response(response_xml)
     response.content_type = 'application/xml'
     return response
 
 def process_long_running_task(messages):
-    """处理耗时任务"""
     try:
         response = client.chat.completions.create(
             model="gpt-4o-mini",
@@ -1119,7 +267,6 @@ def process_long_running_task(messages):
         raise
 
 def handle_async_task(session, task_id, messages):
-    """异步任务处理函数"""
     try:
         if task_id not in session.response_queue:
             return
@@ -1135,15 +282,12 @@ def handle_async_task(session, task_id, messages):
             session.response_queue[task_id].error = str(e)
 
 def generate_initial_response():
-    """生成初始响应消息"""
     return "您的请求正在处理中，请回复'查询'获取结果"
 
 def split_message(message, max_length=500):
-    """将长消息分段"""
     return [message[i:i+max_length] for i in range(0, len(message), max_length)]
 
 def append_status_message(content, has_pending_parts=False, is_processing=False):
-    """添加状态提示信息"""
     if "您的请求正在处理中" in content:
         return content + "\n\n-------------------\n发送'新对话'开始新的对话"
         
@@ -1158,10 +302,37 @@ def append_status_message(content, has_pending_parts=False, is_processing=False)
 @app.route('/api/wx', methods=['GET', 'POST'])
 def wechatai():
     if request.method == 'GET':
-        return verify_wechat(request)
+        signature = request.args.get('signature')
+        timestamp = request.args.get('timestamp')
+        nonce = request.args.get('nonce')
+        echostr = request.args.get('echostr')
+        
+        if verify_signature(signature, timestamp, nonce, TOKEN):
+            return echostr
+        return 'error', 403
     
     try:
-        message_data = parse_xml_message(request.data)
+        encrypt_type = request.args.get('encrypt_type', '')
+        
+        if encrypt_type == 'aes':
+            msg_signature = request.args.get('msg_signature')
+            timestamp = request.args.get('timestamp')
+            nonce = request.args.get('nonce')
+            
+            # 解析加密的XML
+            xml_tree = ET.fromstring(request.data)
+            encrypted_text = xml_tree.find('Encrypt').text
+            
+            # 验证消息签名
+            if not verify_msg_signature(msg_signature, timestamp, nonce, TOKEN, encrypted_text):
+                return 'Invalid signature', 403
+            
+            # 解密消息
+            decrypted_xml = session_manager.crypto.decrypt(encrypted_text)
+            message_data = parse_xml_message(decrypted_xml)
+        else:
+            message_data = parse_xml_message(request.data)
+        
         user_content = message_data['content'].strip()
         from_user = message_data['from_user']
         to_user = message_data['to_user']
@@ -1174,7 +345,8 @@ def wechatai():
             return generate_response_xml(
                 from_user,
                 to_user,
-                append_status_message('已开始新的对话。请描述您的问题。')
+                append_status_message('已开始新的对话。请描述您的问题。'),
+                encrypt_type
             )
 
         if user_content == '继续':
@@ -1184,12 +356,14 @@ def wechatai():
                 return generate_response_xml(
                     from_user,
                     to_user,
-                    append_status_message(next_part, has_more)
+                    append_status_message(next_part, has_more),
+                    encrypt_type
                 )
             return generate_response_xml(
                 from_user,
                 to_user,
-                append_status_message('没有更多内容了。请继续您的问题。')
+                append_status_message('没有更多内容了。请继续您的问题。'),
+                encrypt_type
             )
 
         if user_content == '查询':
@@ -1197,13 +371,13 @@ def wechatai():
                 task_response = session.response_queue.get(session.current_task)
                 if task_response:
                     if task_response.is_expired():
-                        # 处理过期任务
                         del session.response_queue[session.current_task]
                         session.current_task = None
                         return generate_response_xml(
                             from_user,
                             to_user,
-                            append_status_message('请求已过期，请重新提问。')
+                            append_status_message('请求已过期，请重新提问。'),
+                            encrypt_type
                         )
                         
                     if task_response.status == "completed":
@@ -1219,12 +393,14 @@ def wechatai():
                             return generate_response_xml(
                                 from_user,
                                 to_user,
-                                append_status_message(first_part, True)
+                                append_status_message(first_part, True),
+                                encrypt_type
                             )
                         return generate_response_xml(
                             from_user,
                             to_user,
-                            append_status_message(response)
+                            append_status_message(response),
+                            encrypt_type
                         )
                     elif task_response.status == "failed":
                         error_message = '处理过程中出现错误，请重新提问。'
@@ -1233,18 +409,21 @@ def wechatai():
                         return generate_response_xml(
                             from_user,
                             to_user,
-                            append_status_message(error_message)
+                            append_status_message(error_message),
+                            encrypt_type
                         )
                     else:
                         return generate_response_xml(
                             from_user,
                             to_user,
-                            append_status_message('正在处理中，请稍后再次查询。', is_processing=True)
+                            append_status_message('正在处理中，请稍后再次查询。', is_processing=True),
+                            encrypt_type
                         )
             return generate_response_xml(
                 from_user,
                 to_user,
-                append_status_message('没有正���处理的请求。')
+                append_status_message('没有正在处理的请求。'),
+                encrypt_type
             )
 
         session.messages.append({"role": "user", "content": user_content})
@@ -1258,7 +437,8 @@ def wechatai():
         return generate_response_xml(
             from_user,
             to_user,
-            append_status_message(generate_initial_response(), is_processing=True)
+            append_status_message(generate_initial_response(), is_processing=True),
+            encrypt_type
         )
 
     except Exception as e:
@@ -1266,11 +446,11 @@ def wechatai():
         return generate_response_xml(
             message_data['from_user'],
             message_data['to_user'],
-            append_status_message('抱歉，系统暂时出现问题，请稍后重试。')
+            append_status_message('抱歉，系统暂时出现问题，请稍后重试。'),
+            encrypt_type if 'encrypt_type' in locals() else ''
         )
 
 def cleanup_sessions():
-    """定期清理过期会话"""
     while True:
         time.sleep(3600)  # 每小时清理一次
         try:
@@ -1279,9 +459,7 @@ def cleanup_sessions():
             logging.error(f"清理会话时出错: {str(e)}")
 
 if __name__ == '__main__':
-    # 启动清理线程
     cleanup_thread = threading.Thread(target=cleanup_sessions, daemon=True)
     cleanup_thread.start()
     
-    # 启动Flask应用
     app.run(host='0.0.0.0', port=7860, debug=True)