注释

src/DjangoBlog-master/servermanager/MemcacheStorage.py

@@ -1,39 +1,39 @@
-# MemcacheStorage.py
+#zxx MemcacheStorage.py
 from werobot.session import SessionStorage
 from werobot.utils import json_loads, json_dumps
 
-from djangoblog.utils import cache  # 导入Django缓存工具
+from djangoblog.utils import cache  #zxx 导入Django缓存工具
 
 
 class MemcacheStorage(SessionStorage):
-    # 基于Memcache的会话存储实现
+    #zxx 基于Memcache的会话存储实现
     def __init__(self, prefix='ws_'):
-        self.prefix = prefix  # 缓存键前缀
-        self.cache = cache  # Django缓存实例
+        self.prefix = prefix  #zxx 缓存键前缀
+        self.cache = cache  #zxx Django缓存实例
 
     @property
     def is_available(self):
-        # 检查Memcache是否可用
+        #zxx 检查Memcache是否可用
         value = "1"
         self.set('checkavaliable', value=value)
         return value == self.get('checkavaliable')
 
     def key_name(self, s):
-        # 生成完整的缓存键名
+        #zxx 生成完整的缓存键名
         return '{prefix}{s}'.format(prefix=self.prefix, s=s)
 
     def get(self, id):
-        # 从缓存获取会话数据
+        #zxx 从缓存获取会话数据
         id = self.key_name(id)
-        session_json = self.cache.get(id) or '{}'  # 如果不存在返回空字典的JSON
-        return json_loads(session_json)  # 解析JSON字符串为Python对象
+        session_json = self.cache.get(id) or '{}'  #zxx 如果不存在返回空字典的JSON
+        return json_loads(session_json)  #zxx 解析JSON字符串为Python对象
 
     def set(self, id, value):
-        # 设置会话数据到缓存
+        #zxx 设置会话数据到缓存
         id = self.key_name(id)
-        self.cache.set(id, json_dumps(value))  # 将Python对象序列化为JSON字符串存储
+        self.cache.set(id, json_dumps(value))  #zxx 将Python对象序列化为JSON字符串存储
 
     def delete(self, id):
-        # 删除会话数据
+        #zxx 删除会话数据
         id = self.key_name(id)
-        self.cache.delete(id)  # 从缓存中删除
+        self.cache.delete(id)  #zxx 从缓存中删除

src/DjangoBlog-master/servermanager/admin.py

@@ -1,17 +1,17 @@
-# admin.py
+#zxx admin.py
 from django.contrib import admin
-# Register your models here.
+#zxx Register your models here.
 
 
 class CommandsAdmin(admin.ModelAdmin):
-    # 命令模型的后台管理配置
-    list_display = ('title', 'command', 'describe')  # 列表页显示的字段
+    #zxx 命令模型的后台管理配置
+    list_display = ('title', 'command', 'describe')  #zxx 列表页显示的字段
 
 
 class EmailSendLogAdmin(admin.ModelAdmin):
-    # 邮件发送日志的后台管理配置
-    list_display = ('title', 'emailto', 'send_result', 'creation_time')  # 列表页显示的字段
-    readonly_fields = (  # 只读字段，不能编辑
+    #zxx 邮件发送日志的后台管理配置
+    list_display = ('title', 'emailto', 'send_result', 'creation_time')  #zxx 列表页显示的字段
+    readonly_fields = (  #zxx 只读字段，不能编辑
         'title',
         'emailto',
         'send_result',
@@ -19,5 +19,5 @@ class EmailSendLogAdmin(admin.ModelAdmin):
         'content')
 
     def has_add_permission(self, request):
-        # 禁止在后台添加新的邮件日志记录
+        #zxx 禁止在后台添加新的邮件日志记录
         return False

src/DjangoBlog-master/servermanager/api/blogapi.py

@@ -1,37 +1,37 @@
-# blogapi.py
 from haystack.query import SearchQuerySet
 
 from blog.models import Article, Category
 
 
 class BlogApi:
-    """博客API类，提供博客文章的搜索和查询功能"""
+    """zxx博客API类，提供博客文章的搜索和查询功能"""
 
     def __init__(self):
-        # 初始化搜索查询集
+        # zxx初始化搜索查询集
         self.searchqueryset = SearchQuerySet()
         self.searchqueryset.auto_query('')
-        # 设置最大返回结果数量
+        # zxx设置最大返回结果数量
         self.__max_takecount__ = 8
 
     def search_articles(self, query):
         """
+        zxx
         搜索文章
         :param query: 搜索查询字符串
         :return: 搜索结果的查询集（最多8条）
         """
-        # 使用Haystack进行自动查询
+        # zxx使用Haystack进行自动查询
         sqs = self.searchqueryset.auto_query(query)
-        sqs = sqs.load_all()  # 加载所有相关数据
-        return sqs[:self.__max_takecount__]  # 返回前8条结果
+        sqs = sqs.load_all()  # zxx加载所有相关数据
+        return sqs[:self.__max_takecount__]  #zxx 返回前8条结果
 
     def get_category_lists(self):
-        """获取所有分类列表"""
+        """zxx获取所有分类列表"""
         return Category.objects.all()
 
     def get_category_articles(self, categoryname):
         """
-        获取指定分类下的文章
+        zxx获取指定分类下的文章
         :param categoryname: 分类名称
         :return: 该分类下的文章列表（最多8篇）或None
         """
@@ -41,5 +41,5 @@ class BlogApi:
         return None
 
     def get_recent_articles(self):
-        """获取最近的文章列表（最多8篇）"""
+        """zxx获取最近的文章列表（最多8篇）"""
         return Article.objects.all()[:self.__max_takecount__]

src/DjangoBlog-master/servermanager/api/commonapi.py

@@ -7,68 +7,71 @@ from servermanager.models import commands
 
 logger = logging.getLogger(__name__)
 
-# 设置OpenAI API密钥，从环境变量中获取
+#zxx 设置OpenAI API密钥，从环境变量中获取
 openai.api_key = os.environ.get('OPENAI_API_KEY')
-# 如果设置了HTTP代理，则配置OpenAI使用代理
+#zxx 如果设置了HTTP代理，则配置OpenAI使用代理
 if os.environ.get('HTTP_PROXY'):
     openai.proxy = os.environ.get('HTTP_PROXY')
 
 
 class ChatGPT:
-    """ChatGPT API封装类，提供与GPT-3.5-turbo模型的对话功能"""
+    """zxxChatGPT API封装类，提供与GPT-3.5-turbo模型的对话功能"""
 
     @staticmethod
     def chat(prompt):
         """
+        zxx
         静态方法，向ChatGPT发送提示并获取回复
         :param prompt: 用户输入的提示文本
         :return: ChatGPT的回复内容或错误信息
         """
         try:
-            # 调用OpenAI ChatCompletion API创建对话完成
+            #zxx 调用OpenAI ChatCompletion API创建对话完成
             completion = openai.ChatCompletion.create(model="gpt-3.5-turbo",
                                                       messages=[{"role": "user", "content": prompt}])
-            # 返回第一个选择中的消息内容
+            #zxx 返回第一个选择中的消息内容
             return completion.choices[0].message.content
         except Exception as e:
-            # 记录错误日志并返回用户友好的错误信息
+            #zxx 记录错误日志并返回用户友好的错误信息
             logger.error(e)
             return "服务器出错了"
 
 
 class CommandHandler:
-    """命令处理器类，用于执行预定义的系统命令"""
+    """zxx命令处理器类，用于执行预定义的系统命令"""
 
     def __init__(self):
-        # 初始化时从数据库获取所有命令
+        #zxx 初始化时从数据库获取所有命令
         self.commands = commands.objects.all()
 
     def run(self, title):
         """
+        zxx
         运行命令
         :param title: 命令标题
         :return: 返回命令执行结果或帮助信息
         """
-        # 使用filter和lambda函数查找匹配的命令（不区分大小写）
+        #zxx 使用filter和lambda函数查找匹配的命令（不区分大小写）
         cmd = list(
             filter(
                 lambda x: x.title.upper() == title.upper(),
                 self.commands))
         if cmd:
-            # 如果找到命令，执行该命令
+            #zxx 如果找到命令，执行该命令
             return self.__run_command__(cmd[0].command)
         else:
-            # 未找到命令时返回帮助提示
+            #zxx 未找到命令时返回帮助提示
             return "未找到相关命令，请输入hepme获得帮助。"
 
     def __run_command__(self, cmd):
         """
+        zxx
         私有方法，实际执行系统命令
         :param cmd: 要执行的命令字符串
         :return: 命令执行结果或错误信息
         """
         try:
-            # 使用os.popen执行系统命令并读取结果
+            #zxx 使用os.popen执行系统命令并读取结果
             res = os.popen(cmd).read()
             return res
         except BaseException:
@@ -76,18 +79,19 @@ class CommandHandler:
 
     def get_help(self):
         """
+        zxx
         获取所有可用命令的帮助信息
         :return: 格式化的命令帮助字符串
         """
         rsp = ''
-        # 遍历所有命令，格式化输出命令标题和描述
+        #zxx 遍历所有命令，格式化输出命令标题和描述
         for cmd in self.commands:
             rsp += '{c}:{d}\n'.format(c=cmd.title, d=cmd.describe)
         return rsp
 
 
 if __name__ == '__main__':
-    # 测试代码：创建ChatGPT实例并测试对话功能
+    #zxx 测试代码：创建ChatGPT实例并测试对话功能
     chatbot = ChatGPT()
     prompt = "写一篇1000字关于AI的论文"
     print(chatbot.chat(prompt))

src/DjangoBlog-master/servermanager/apps.py

@@ -1,12 +1,12 @@
-# apps.py
+#zxx apps.py
 from django.apps import AppConfig
 
 
 class ServermanagerConfig(AppConfig):
-    # ServermanagerConfig 类继承自 Django 的 AppConfig 基类
-    # 这是 Django 应用的配置类，用于对 servermanager 应用进行配置
+    #zxx ServermanagerConfig 类继承自 Django 的 AppConfig 基类
+    #zxx 这是 Django 应用的配置类，用于对 servermanager 应用进行配置
 
     name = 'servermanager'
-    # name 属性指定了该配置类对应的 Django 应用的名称
-    # 这里的值是 'servermanager'，表示这个配置类用于配置名为 servermanager 的 Django 应用
-    # 这个名称应该与应用的目录名保持一致
+    #zxx name 属性指定了该配置类对应的 Django 应用的名称
+    #zxx 这里的值是 'servermanager'，表示这个配置类用于配置名为 servermanager 的 Django 应用
+    #zxx 这个名称应该与应用的目录名保持一致

src/DjangoBlog-master/servermanager/migrations/0001_initial.py

@@ -1,61 +1,61 @@
-# 0001_initial.py
-# 由Django 4.1.7于2023-03-02 07:14生成
+#zxx 0001_initial.py
+#zxx 由Django 4.1.7于2023-03-02 07:14生成
 
 from django.db import migrations, models
 
 
 class Migration(migrations.Migration):
 
-    initial = True  # 这是初始迁移文件
+    initial = True  #zxx 这是初始迁移文件
 
     dependencies = [
-        # 没有依赖项，因为这是第一个迁移
+        #zxx 没有依赖项，因为这是第一个迁移
     ]
 
     operations = [
-        # 创建commands模型表
+        #zxx 创建commands模型表
         migrations.CreateModel(
             name='commands',
             fields=[
-                # 主键ID，自增BigAutoField
+                #zxx 主键ID，自增BigAutoField
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                # 命令标题字段，最大长度300字符
+                #zxx 命令标题字段，最大长度300字符
                 ('title', models.CharField(max_length=300, verbose_name='命令标题')),
-                # 命令字段，最大长度2000字符
+                #zxx 命令字段，最大长度2000字符
                 ('command', models.CharField(max_length=2000, verbose_name='命令')),
-                # 命令描述字段，最大长度300字符
+                #zxx 命令描述字段，最大长度300字符
                 ('describe', models.CharField(max_length=300, verbose_name='命令描述')),
-                # 创建时间字段，自动设置为记录创建时间
+                #zxx 创建时间字段，自动设置为记录创建时间
                 ('created_time', models.DateTimeField(auto_now_add=True, verbose_name='创建时间')),
-                # 最后修改时间字段，自动更新为最后修改时间
+                #zxx 最后修改时间字段，自动更新为最后修改时间
                 ('last_mod_time', models.DateTimeField(auto_now=True, verbose_name='修改时间')),
             ],
             options={
-                'verbose_name': '命令',  # 单数显示名称
-                'verbose_name_plural': '命令',  # 复数显示名称
+                'verbose_name': '命令',  #zxx 单数显示名称
+                'verbose_name_plural': '命令',  #zxx 复数显示名称
             },
         ),
-        # 创建EmailSendLog模型表
+        #zxx 创建EmailSendLog模型表
         migrations.CreateModel(
             name='EmailSendLog',
             fields=[
-                # 主键ID，自增BigAutoField
+                #zxx 主键ID，自增BigAutoField
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                # 收件人字段，最大长度300字符
+                #zxx 收件人字段，最大长度300字符
                 ('emailto', models.CharField(max_length=300, verbose_name='收件人')),
-                # 邮件标题字段，最大长度2000字符
+                #zxx 邮件标题字段，最大长度2000字符
                 ('title', models.CharField(max_length=2000, verbose_name='邮件标题')),
-                # 邮件内容字段，文本类型
+                #zxx 邮件内容字段，文本类型
                 ('content', models.TextField(verbose_name='邮件内容')),
-                # 发送结果字段，布尔值，默认False
+                #zxx 发送结果字段，布尔值，默认False
                 ('send_result', models.BooleanField(default=False, verbose_name='结果')),
-                # 创建时间字段，自动设置为记录创建时间
+                #zxx 创建时间字段，自动设置为记录创建时间
                 ('created_time', models.DateTimeField(auto_now_add=True, verbose_name='创建时间')),
             ],
             options={
-                'verbose_name': '邮件发送log',  # 单数显示名称
-                'verbose_name_plural': '邮件发送log',  # 复数显示名称
-                'ordering': ['-created_time'],  # 按创建时间降序排列
+                'verbose_name': '邮件发送log',  #zxx 单数显示名称
+                'verbose_name_plural': '邮件发送log',  #zxx 复数显示名称
+                'ordering': ['-created_time'],  #zxx 按创建时间降序排列
             },
         ),
     ]

src/DjangoBlog-master/servermanager/migrations/0002_alter_emailsendlog_options_and_more.py

@@ -1,42 +1,42 @@
-# 0002_alter_emailsendlog_options_and_more.py
-# 由Django 4.2.5于2023-09-06 13:19生成
+#zxx 0002_alter_emailsendlog_options_and_more.py
+#zxx 由Django 4.2.5于2023-09-06 13:19生成
 
 from django.db import migrations
 
 
 class Migration(migrations.Migration):
 
-    # 依赖之前的初始迁移文件
+    #zxx 依赖之前的初始迁移文件
     dependencies = [
         ('servermanager', '0001_initial'),
     ]
 
     operations = [
-        # 修改EmailSendLog模型的选项配置
+        #zxx 修改EmailSendLog模型的选项配置
         migrations.AlterModelOptions(
             name='emailsendlog',
             options={
-                'ordering': ['-creation_time'],  # 修改排序字段为creation_time
-                'verbose_name': '邮件发送log',    # 保持单数显示名称不变
-                'verbose_name_plural': '邮件发送log',  # 保持复数显示名称不变
+                'ordering': ['-creation_time'],  #zxx 修改排序字段为creation_time
+                'verbose_name': '邮件发送log',    #zxx 保持单数显示名称不变
+                'verbose_name_plural': '邮件发送log',  #zxx 保持复数显示名称不变
             },
         ),
-        # 重命名commands模型的created_time字段为creation_time
+        #zxx 重命名commands模型的created_time字段为creation_time
         migrations.RenameField(
             model_name='commands',
-            old_name='created_time',    # 原字段名
-            new_name='creation_time',   # 新字段名
+            old_name='created_time',    #zxx 原字段名
+            new_name='creation_time',   #zxx 新字段名
         ),
-        # 重命名commands模型的last_mod_time字段为last_modify_time
+        #zxx 重命名commands模型的last_mod_time字段为last_modify_time
         migrations.RenameField(
             model_name='commands',
-            old_name='last_mod_time',    # 原字段名
-            new_name='last_modify_time', # 新字段名
+            old_name='last_mod_time',    #zxx 原字段名
+            new_name='last_modify_time', #zxx 新字段名
         ),
-        # 重命名EmailSendLog模型的created_time字段为creation_time
+        #zxx 重命名EmailSendLog模型的created_time字段为creation_time
         migrations.RenameField(
             model_name='emailsendlog',
-            old_name='created_time',    # 原字段名
-            new_name='creation_time',   # 新字段名
+            old_name='created_time',    #zxx 原字段名
+            new_name='creation_time',   #zxx 新字段名
         ),
     ]

src/DjangoBlog-master/servermanager/models.py

@@ -1,30 +1,30 @@
-# models.py
+#zxx models.py
 from django.db import models
 
 
-# Create your models here.
+#zxx Create your models here.
 class commands(models.Model):
-    # 命令模型，用于存储可执行的系统命令
+    #zxx 命令模型，用于存储可执行的系统命令
     title = models.CharField('命令标题', max_length=300)
     command = models.CharField('命令', max_length=2000)
     describe = models.CharField('命令描述', max_length=300)
-    creation_time = models.DateTimeField('创建时间', auto_now_add=True)  # 自动设置创建时间
-    last_modify_time = models.DateTimeField('修改时间', auto_now=True)  # 自动更新修改时间
+    creation_time = models.DateTimeField('创建时间', auto_now_add=True)  #zxx 自动设置创建时间
+    last_modify_time = models.DateTimeField('修改时间', auto_now=True)  #zxx 自动更新修改时间
 
     def __str__(self):
         return self.title
 
     class Meta:
         verbose_name = '命令'
-        verbose_name_plural = verbose_name  # 复数形式显示名称
+        verbose_name_plural = verbose_name  #zxx 复数形式显示名称
 
 
 class EmailSendLog(models.Model):
-    # 邮件发送日志模型
+    #zxx 邮件发送日志模型
     emailto = models.CharField('收件人', max_length=300)
     title = models.CharField('邮件标题', max_length=2000)
     content = models.TextField('邮件内容')
-    send_result = models.BooleanField('结果', default=False)  # 发送结果
+    send_result = models.BooleanField('结果', default=False)  #zxx 发送结果
     creation_time = models.DateTimeField('创建时间', auto_now_add=True)
 
     def __str__(self):
@@ -33,4 +33,4 @@ class EmailSendLog(models.Model):
     class Meta:
         verbose_name = '邮件发送log'
         verbose_name_plural = verbose_name
-        ordering = ['-creation_time']  # 按创建时间降序排列
+        ordering = ['-creation_time']  #zxx 按创建时间降序排列

src/DjangoBlog-master/servermanager/robot.py

@@ -1,4 +1,4 @@
-# robot.py
+#zxx robot.py
 import logging
 import os
 import re
@@ -14,11 +14,11 @@ from servermanager.api.blogapi import BlogApi
 from servermanager.api.commonapi import ChatGPT, CommandHandler
 from .MemcacheStorage import MemcacheStorage
 
-# 创建微信机器人实例，使用环境变量中的token或默认值
+#zxx 创建微信机器人实例，使用环境变量中的token或默认值
 robot = WeRoBot(token=os.environ.get('DJANGO_WEROBOT_TOKEN')
                       or 'lylinux', enable_session=True)
 
-# 配置会话存储，优先使用Memcache，否则使用文件存储
+#zxx 配置会话存储，优先使用Memcache，否则使用文件存储
 memstorage = MemcacheStorage()
 if memstorage.is_available:
     robot.config['SESSION_STORAGE'] = memstorage
@@ -27,28 +27,28 @@ else:
         os.remove(os.path.join(settings.BASE_DIR, 'werobot_session'))
     robot.config['SESSION_STORAGE'] = FileStorage(filename='werobot_session')
 
-# 初始化API处理器
+#zxx 初始化API处理器
 blogapi = BlogApi()
 cmd_handler = CommandHandler()
 logger = logging.getLogger(__name__)
 
 
 def convert_to_article_reply(articles, message):
-    # 将文章列表转换为微信图文回复格式
+    #zxx 将文章列表转换为微信图文回复格式
     reply = ArticlesReply(message=message)
     from blog.templatetags.blog_tags import truncatechars_content
     for post in articles:
-        # 从文章内容中提取图片URL
+        #zxx 从文章内容中提取图片URL
         imgs = re.findall(r'(?:http\:|https\:)?\/\/.*\.(?:png|jpg)', post.body)
         imgurl = ''
         if imgs:
             imgurl = imgs[0]
-        # 创建图文消息条目
+        #zxx 创建图文消息条目
         article = Article(
             title=post.title,
-            description=truncatechars_content(post.body),  # 截断文章内容作为描述
-            img=imgurl,  # 文章封面图
-            url=post.get_full_url()  # 文章完整URL
+            description=truncatechars_content(post.body),  #zxx 截断文章内容作为描述
+            img=imgurl,  #zxx 文章封面图
+            url=post.get_full_url()  #zxx 文章完整URL
         )
         reply.add_article(article)
     return reply
@@ -56,9 +56,9 @@ def convert_to_article_reply(articles, message):
 
 @robot.filter(re.compile(r"^\?.*"))
 def search(message, session):
-    # 搜索文章功能，以?开头触发
+    #zxx 搜索文章功能，以?开头触发
     s = message.content
-    searchstr = str(s).replace('?', '')  # 去除问号得到搜索关键词
+    searchstr = str(s).replace('?', '')  #zxx 去除问号得到搜索关键词
     result = blogapi.search_articles(searchstr)
     if result:
         articles = list(map(lambda x: x.object, result))
@@ -70,7 +70,7 @@ def search(message, session):
 
 @robot.filter(re.compile(r'^category\s*$', re.I))
 def category(message, session):
-    # 获取所有分类目录
+    #zxx 获取所有分类目录
     categorys = blogapi.get_category_lists()
     content = ','.join(map(lambda x: x.name, categorys))
     return '所有文章分类目录：' + content
@@ -78,7 +78,7 @@ def category(message, session):
 
 @robot.filter(re.compile(r'^recent\s*$', re.I))
 def recents(message, session):
-    # 获取最新文章
+    #zxx 获取最新文章
     articles = blogapi.get_recent_articles()
     if articles:
         reply = convert_to_article_reply(articles, message)
@@ -89,7 +89,7 @@ def recents(message, session):
 
 @robot.filter(re.compile('^help$', re.I))
 def help(message, session):
-    # 帮助信息
+    #zxx 帮助信息
     return '''欢迎关注!
             默认会与图灵机器人聊天~~
         你可以通过下面这些命令来获得信息
@@ -112,71 +112,71 @@ def help(message, session):
 
 @robot.filter(re.compile(r'^weather\:.*$', re.I))
 def weather(message, session):
-    # 天气查询功能（建设中）
+    #zxx 天气查询功能（建设中）
     return "建设中..."
 
 
 @robot.filter(re.compile(r'^idcard\:.*$', re.I))
 def idcard(message, session):
-    # 身份证查询功能（建设中）
+    #zxx 身份证查询功能（建设中）
     return "建设中..."
 
 
 @robot.handler
 def echo(message, session):
-    # 默认消息处理器
+    #zxx 默认消息处理器
     handler = MessageHandler(message, session)
     return handler.handler()
 
 
 class MessageHandler:
-    # 消息处理器类，处理用户会话状态和命令执行
+    #zxx 消息处理器类，处理用户会话状态和命令执行
     def __init__(self, message, session):
         userid = message.source
         self.message = message
         self.session = session
         self.userid = userid
         try:
-            # 从会话中获取用户信息
+            #zxx 从会话中获取用户信息
             info = session[userid]
             self.userinfo = jsonpickle.decode(info)
         except Exception as e:
-            # 如果会话不存在，创建新的用户信息
+            #zxx 如果会话不存在，创建新的用户信息
             userinfo = WxUserInfo()
             self.userinfo = userinfo
 
     @property
     def is_admin(self):
-        # 检查用户是否为管理员
+        #zxx 检查用户是否为管理员
         return self.userinfo.isAdmin
 
     @property
     def is_password_set(self):
-        # 检查管理员密码是否已验证
+        #zxx 检查管理员密码是否已验证
         return self.userinfo.isPasswordSet
 
     def save_session(self):
-        # 保存用户信息到会话
+        #zxx 保存用户信息到会话
         info = jsonpickle.encode(self.userinfo)
         self.session[self.userid] = info
 
     def handler(self):
-        # 主要消息处理逻辑
+        #zxx 主要消息处理逻辑
         info = self.message.content
 
-        # 管理员退出处理
+        #zxx 管理员退出处理
         if self.userinfo.isAdmin and info.upper() == 'EXIT':
             self.userinfo = WxUserInfo()
             self.save_session()
             return "退出成功"
 
-        # 进入管理员模式
+        #zxx 进入管理员模式
         if info.upper() == 'ADMIN':
             self.userinfo.isAdmin = True
             self.save_session()
             return "输入管理员密码"
 
-        # 管理员密码验证
+        #zxx 管理员密码验证
         if self.userinfo.isAdmin and not self.userinfo.isPasswordSet:
             passwd = settings.WXADMIN
             if settings.TESTING:
@@ -194,7 +194,7 @@ class MessageHandler:
                 self.save_session()
                 return "验证失败，请重新输入管理员密码:"
 
-        # 管理员命令执行
+        #zxx 管理员命令执行
         if self.userinfo.isAdmin and self.userinfo.isPasswordSet:
             if self.userinfo.Command != '' and info.upper() == 'Y':
                 return cmd_handler.run(self.userinfo.Command)
@@ -205,14 +205,14 @@ class MessageHandler:
                 self.save_session()
                 return "确认执行: " + info + " 命令?"
 
-        # 默认使用ChatGPT回复
+        #zxx 默认使用ChatGPT回复
         return ChatGPT.chat(info)
 
 
 class WxUserInfo():
-    # 微信用户信息类，存储用户会话状态
+    #zxx 微信用户信息类，存储用户会话状态
     def __init__(self):
-        self.isAdmin = False  # 是否为管理员
-        self.isPasswordSet = False  # 密码是否已验证
-        self.Count = 0  # 密码尝试次数
-        self.Command = ''  # 待执行的命令
+        self.isAdmin = False  #zxx 是否为管理员
+        self.isPasswordSet = False  #zxx 密码是否已验证
+        self.Count = 0  #zxx 密码尝试次数
+        self.Command = ''  #zxx 待执行的命令

src/DjangoBlog-master/servermanager/tests.py

@@ -1,4 +1,4 @@
-# tests.py
+#zxx tests.py
 from django.test import Client, RequestFactory, TestCase
 from django.utils import timezone
 from werobot.messages.messages import TextMessage
@@ -11,34 +11,34 @@ from .robot import MessageHandler, CommandHandler
 from .robot import search, category, recents
 
 
-# Create your tests here.
+#zxx Create your tests here.
 class ServerManagerTest(TestCase):
     def setUp(self):
-        # 初始化测试客户端和请求工厂
+        #zxx 初始化测试客户端和请求工厂
         self.client = Client()
         self.factory = RequestFactory()
 
     def test_chat_gpt(self):
-        # 测试ChatGPT功能
+        #zxx 测试ChatGPT功能
         content = ChatGPT.chat("你好")
-        self.assertIsNotNone(content)  # 断言回复内容不为空
+        self.assertIsNotNone(content)  #zxx 断言回复内容不为空
 
     def test_validate_comment(self):
-        # 创建超级用户用于测试
+        #zxx 创建超级用户用于测试
         user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
             password="liangliangyy1")
 
-        # 登录用户
+        #zxx 登录用户
         self.client.login(username='liangliangyy1', password='liangliangyy1')
 
-        # 创建分类
+        #zxx 创建分类
         c = Category()
         c.name = "categoryccc"
         c.save()
 
-        # 创建文章
+        #zxx 创建文章
         article = Article()
         article.title = "nicetitleccc"
         article.body = "nicecontentccc"
@@ -48,37 +48,37 @@ class ServerManagerTest(TestCase):
         article.status = 'p'
         article.save()
 
-        # 测试搜索功能
+        #zxx 测试搜索功能
         s = TextMessage([])
         s.content = "nice"
         rsp = search(s, None)
 
-        # 测试分类功能
+        #zxx 测试分类功能
         rsp = category(None, None)
         self.assertIsNotNone(rsp)
 
-        # 测试最近文章功能
+        #zxx 测试最近文章功能
         rsp = recents(None, None)
         self.assertTrue(rsp != '暂时还没有文章')
 
-        # 创建测试命令
+        #zxx 创建测试命令
         cmd = commands()
         cmd.title = "test"
         cmd.command = "ls"
         cmd.describe = "test"
         cmd.save()
 
-        # 测试命令执行
+        #zxx 测试命令执行
         cmdhandler = CommandHandler()
         rsp = cmdhandler.run('test')
         self.assertIsNotNone(rsp)
 
-        # 测试消息处理器
+        #zxx 测试消息处理器
         s.source = 'u'
         s.content = 'test'
         msghandler = MessageHandler(s, {})
 
-        # 测试各种消息处理场景
+        #zxx 测试各种消息处理场景
         msghandler.handler()
         s.content = 'y'
         msghandler.handler()

src/DjangoBlog-master/servermanager/urls.py

@@ -1,10 +1,10 @@
 from django.urls import path
 from werobot.contrib.django import make_view
 
-from .robot import robot  # 导入微信机器人实例
+from .robot import robot  #zxx 导入微信机器人实例
 
-app_name = "servermanager"  # 定义应用命名空间
+app_name = "servermanager"  #zxx 定义应用命名空间
 urlpatterns = [
-    # 配置微信机器人路由，所有发送到robot的请求都由微信机器人处理
+    #zxx 配置微信机器人路由，所有发送到robot的请求都由微信机器人处理
     path(r'robot', make_view(robot)),
 ]

src/DjangoBlog-master/servermanager/views.py

@@ -1 +1 @@
-# Create your views here.
+# zxxCreate your views here.