ADD file via upload

README.md

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

doc/README.md

@@ -0,0 +1 @@
+基于Python的Hello World

src/comments/admin.py

@@ -1,56 +1,59 @@
+#zjy 评论模块的Django Admin配置
+#zjy 自定义评论在Django后台的管理界面
+
 from django.contrib import admin
 from django.urls import reverse
 from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 
 
-# 批量禁用评论（将 is_enable 设为 False）
+#zjy 批量禁用评论（将 is_enable 设为 False）
 def disable_commentstatus(modeladmin, request, queryset):
     queryset.update(is_enable=False)
 
 
-# 批量启用评论（将 is_enable 设为 True）
+#zjy 批量启用评论（将 is_enable 设为 True）
 def enable_commentstatus(modeladmin, request, queryset):
     queryset.update(is_enable=True)
 
 
-# 定义动作名称，在 Django Admin 批量操作菜单中显示的文字
+#zjy 定义动作名称，在 Django Admin 批量操作菜单中显示的文字
 disable_commentstatus.short_description = _('Disable comments')
 enable_commentstatus.short_description = _('Enable comments')
 
 
 class CommentAdmin(admin.ModelAdmin):
-    # 每页显示评论数量
+    #zjy 每页显示评论数量
     list_per_page = 20
 
-    # 在评论列表中显示哪些字段
+    #zjy 在评论列表中显示哪些字段
     list_display = (
         'id',
-        'body',             # 评论正文
-        'link_to_userinfo', # 用户信息（带链接）
-        'link_to_article',  # 所属文章（带链接）
-        'is_enable',        # 是否启用
-        'creation_time'     # 创建时间
+        'body',             #zjy 评论正文
+        'link_to_userinfo', #zjy 用户信息（带链接）
+        'link_to_article',  #zjy 所属文章（带链接）
+        'is_enable',        #zjy 是否启用
+        'creation_time'     #zjy 创建时间
     )
 
-    # 可以点击哪些字段进入编辑页面
+    #zjy 可以点击哪些字段进入编辑页面
     list_display_links = ('id', 'body', 'is_enable')
 
-    # 过滤器（后台右侧筛选功能）
+    #zjy 过滤器（后台右侧筛选功能）
     list_filter = ('is_enable',)
 
-    # 排除不需要在后台编辑的字段（自动时间字段不应手动修改）
+    #zjy 排除不需要在后台编辑的字段（自动时间字段不应手动修改）
     exclude = ('creation_time', 'last_modify_time')
 
-    # 批量操作按钮
+    #zjy 批量操作按钮
     actions = [disable_commentstatus, enable_commentstatus]
 
-    # 显示用户信息，并可点击跳转到用户编辑页面
+    #zjy 显示用户信息，并可点击跳转到用户编辑页面
     def link_to_userinfo(self, obj):
-        # 获取目标 admin change 页面的 URL 路径
+        #zjy 获取目标 admin change 页面的 URL 路径
         info = (obj.author._meta.app_label, obj.author._meta.model_name)
         link = reverse('admin:%s_%s_change' % info, args=(obj.author.id,))
-        # 显示用户昵称，若无昵称显示 email
+        #zjy 显示用户昵称，若无昵称显示 email
         return format_html(
             '<a href="{}">{}</a>'.format(
                 link,
@@ -58,12 +61,12 @@ class CommentAdmin(admin.ModelAdmin):
             )
         )
 
-    # 显示所属文章，并可点击跳转到文章编辑页面
+    #zjy 显示所属文章，并可点击跳转到文章编辑页面
     def link_to_article(self, obj):
         info = (obj.article._meta.app_label, obj.article._meta.model_name)
         link = reverse('admin:%s_%s_change' % info, args=(obj.article.id,))
         return format_html('<a href="{}">{}</a>'.format(link, obj.article.title))
 
-    # 设置在后台列表中显示的列标题
+    #zjy 设置在后台列表中显示的列标题
     link_to_userinfo.short_description = _('User')
     link_to_article.short_description = _('Article')

src/comments/apps.py

@@ -0,0 +1,13 @@
+#zjy 评论模块的应用配置
+#zjy 定义评论应用的配置信息
+
+from django.apps import AppConfig
+
+
+class CommentsConfig(AppConfig):
+    #zjy 指定该 App 在项目中的名称（即所在目录名）
+    name = 'comments'
+
+    #zjy （可选）可以在这里做初始化操作，如引入 signals
+    # def ready(self):
+    #     import comments.signals

src/comments/forms.py

@@ -0,0 +1,24 @@
+#zjy 评论模块的表单定义
+#zjy 定义评论提交的表单验证规则
+
+from django import forms
+from django.forms import ModelForm
+
+from .models import Comment
+
+
+class CommentForm(ModelForm):
+    #zjy 用于存储父评论的 ID（实现评论回复功能）
+    #zjy 该字段不会显示到页面中（HiddenInput），允许为空（一级评论时为空）
+    parent_comment_id = forms.IntegerField(
+        widget=forms.HiddenInput, 
+        required=False
+    )
+
+    class Meta:
+        #zjy 指定该表单操作的模型为 Comment
+        model = Comment
+        
+        #zjy 只允许用户输入评论内容（body）
+        #zjy 其他字段（如 author、article、parent_comment）将在视图中自动赋值
+        fields = ['body']

src/comments/models.py

@@ -0,0 +1,74 @@
+#zjy 评论模块的数据模型定义
+#zjy 定义了Comment模型，用于存储博客文章的评论信息，支持多级回复功能
+
+from django.conf import settings
+from django.db import models
+from django.utils.timezone import now
+from django.utils.translation import gettext_lazy as _
+
+from blog.models import Article
+
+
+class Comment(models.Model):
+    #zjy 评论正文，限制最大输入长度 300，使用 TextField 以便输入多行内容
+    body = models.TextField('正文', max_length=300)
+
+    #zjy 评论创建时间，默认使用 timezone.now（可自动获取当前时区时间）
+    creation_time = models.DateTimeField(
+        _('creation time'),
+        default=now
+    )
+
+    #zjy 评论最后修改时间，通常用于编辑评论功能，但如果不编辑也会保持不变
+    last_modify_time = models.DateTimeField(
+        _('last modify time'),
+        default=now
+    )
+
+    #zjy 评论作者，关联到用户模型，用户删除时，对应评论也一并删除
+    author = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        verbose_name=_('author'),
+        on_delete=models.CASCADE
+    )
+
+    #zjy 评论所属文章，关联到 Article 模型，文章被删除时，其下所有评论也被删除
+    article = models.ForeignKey(
+        Article,
+        verbose_name=_('article'),
+        on_delete=models.CASCADE
+    )
+
+    #zjy 父评论，用于构建"评论回复"树结构
+    #zjy 若为空 → 表示为一级评论；不为空 → 表示为某条评论的子评论
+    parent_comment = models.ForeignKey(
+        'self',                    #zjy 自关联
+        verbose_name=_('parent comment'),
+        blank=True,                #zjy 表单中允许为空
+        null=True,                 #zjy 数据库允许为 null
+        on_delete=models.CASCADE   #zjy 父评论删除时，子评论也被删除
+    )
+
+    #zjy 是否启用评论（常用于需要审核评论是否展示）
+    #zjy 默认为 False → 新评论不会立刻显示，需要管理员审核启用
+    is_enable = models.BooleanField(
+        _('enable'),
+        default=False,
+        blank=False,
+        null=False
+    )
+
+    class Meta:
+        #zjy 默认按 id 倒序排列 → 新评论显示在前
+        ordering = ['-id']
+
+        #zjy Django Admin 后台显示的模型名称
+        verbose_name = _('comment')
+        verbose_name_plural = verbose_name
+
+        #zjy latest() 方法依据 id 获取最新对象
+        get_latest_by = 'id'
+
+    def __str__(self):
+        #zjy 后台及 shell 打印对象时显示评论内容
+        return self.body

src/comments/tests.py

@@ -1,3 +1,6 @@
+#zjy 评论模块的测试用例
+#zjy 测试评论的提交、审核、显示和邮件通知等功能
+
 from django.test import Client, RequestFactory, TransactionTestCase
 from django.urls import reverse
 
@@ -9,27 +12,23 @@ from djangoblog.utils import get_max_articleid_commentid
 
 
 class CommentsTest(TransactionTestCase):
-    """
-    评论相关功能测试类
-    使用 TransactionTestCase 允许测试包含事务的数据库操作
-    """
+    #zjy 评论相关功能测试类
+    #zjy 使用 TransactionTestCase 允许测试包含事务的数据库操作
 
     def setUp(self):
-        """
-        测试初始化工作：
-        - 创建请求客户端
-        - 配置博客系统为“评论需要审核”
-        - 创建一个超级管理员用户（用于登录发表评论）
-        """
+        #zjy 测试初始化工作：
+        #zjy - 创建请求客户端
+        #zjy - 配置博客系统为"评论需要审核"
+        #zjy - 创建一个超级管理员用户（用于登录发表评论）
         self.client = Client()
         self.factory = RequestFactory()
 
         from blog.models import BlogSettings
         value = BlogSettings()
-        value.comment_need_review = True   # 开启评论审核，提交的评论默认不显示
+        value.comment_need_review = True   #zjy 开启评论审核，提交的评论默认不显示
         value.save()
 
-        # 创建可登录的超级管理员用户
+        #zjy 创建可登录的超级管理员用户
         self.user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
@@ -37,28 +36,24 @@ class CommentsTest(TransactionTestCase):
         )
 
     def update_article_comment_status(self, article):
-        """
-        将文章下所有评论改为 is_enable=True
-        模拟管理员审核通过评论（使评论显示）
-        """
+        #zjy 将文章下所有评论改为 is_enable=True
+        #zjy 模拟管理员审核通过评论（使评论显示）
         comments = article.comment_set.all()
         for comment in comments:
             comment.is_enable = True
             comment.save()
 
     def test_validate_comment(self):
-        """
-        测试评论提交、审核、评论树解析等功能流程
-        """
-        # 登录用户
+        #zjy 测试评论提交、审核、评论树解析等功能流程
+        #zjy 登录用户
         self.client.login(username='liangliangyy1', password='liangliangyy1')
 
-        # 创建分类
+        #zjy 创建分类
         category = Category()
         category.name = "categoryccc"
         category.save()
 
-        # 创建文章
+        #zjy 创建文章
         article = Article()
         article.title = "nicetitleccc"
         article.body = "nicecontentccc"
@@ -68,22 +63,22 @@ class CommentsTest(TransactionTestCase):
         article.status = 'p'
         article.save()
 
-        # 文章评论提交 URL
+        #zjy 文章评论提交 URL
         comment_url = reverse('comments:postcomment', kwargs={'article_id': article.id})
 
-        # 用户提交第一条评论
+        #zjy 用户提交第一条评论
         response = self.client.post(comment_url, {'body': '123ffffffffff'})
-        self.assertEqual(response.status_code, 302)  # 正常应重定向（提交成功）
+        self.assertEqual(response.status_code, 302)  #zjy 正常应重定向（提交成功）
 
-        # 因为评论需要审核，未批准前评论数为 0
+        #zjy 因为评论需要审核，未批准前评论数为 0
         article = Article.objects.get(pk=article.pk)
         self.assertEqual(len(article.comment_list()), 0)
 
-        # 模拟管理员审核评论
+        #zjy 模拟管理员审核评论
         self.update_article_comment_status(article)
         self.assertEqual(len(article.comment_list()), 1)
 
-        # 提交第二条评论
+        #zjy 提交第二条评论
         response = self.client.post(comment_url, {'body': '123ffffffffff'})
         self.assertEqual(response.status_code, 302)
 
@@ -91,7 +86,7 @@ class CommentsTest(TransactionTestCase):
         self.update_article_comment_status(article)
         self.assertEqual(len(article.comment_list()), 2)
 
-        # 回复第一条评论（测试 parent_comment 功能）
+        #zjy 回复第一条评论（测试 parent_comment 功能）
         parent_comment_id = article.comment_list()[0].id
 
         response = self.client.post(comment_url, {
@@ -110,27 +105,27 @@ class CommentsTest(TransactionTestCase):
         })
         self.assertEqual(response.status_code, 302)
 
-        # 通过审核
+        #zjy 通过审核
         self.update_article_comment_status(article)
 
-        # 再次获取文章
+        #zjy 再次获取文章
         article = Article.objects.get(pk=article.pk)
         self.assertEqual(len(article.comment_list()), 3)
 
-        # 测试评论树解析
+        #zjy 测试评论树解析
         comment = Comment.objects.get(id=parent_comment_id)
         tree = parse_commenttree(article.comment_list(), comment)
-        self.assertEqual(len(tree), 1)  # 第一条评论应当有 1 个子评论
+        self.assertEqual(len(tree), 1)  #zjy 第一条评论应当有 1 个子评论
 
-        # 渲染评论组件标签是否正常返回
+        #zjy 渲染评论组件标签是否正常返回
         data = show_comment_item(comment, True)
         self.assertIsNotNone(data)
 
-        # 测试工具函数获取最大文章/评论 id
+        #zjy 测试工具函数获取最大文章/评论 id
         s = get_max_articleid_commentid()
         self.assertIsNotNone(s)
 
-        # 测试发送评论邮件通知（若配置邮件服务则会成功）
+        #zjy 测试发送评论邮件通知（若配置邮件服务则会成功）
         from comments.utils import send_comment_email
         send_comment_email(comment)
     send_comment_email(comment)

src/comments/utils.py

@@ -1,3 +1,6 @@
+#zjy 评论模块的工具函数
+#zjy 提供评论相关的辅助功能，如邮件通知
+
 import logging
 
 from django.utils.translation import gettext_lazy as _
@@ -9,20 +12,19 @@ logger = logging.getLogger(__name__)
 
 
 def send_comment_email(comment):
-    """
-    当用户发表评论后，给评论者发送邮件通知；
-    如果该评论是回复别人的，则同时给被回复的用户发送提醒邮件。
-    """
-    # 获取当前站点域名
+    #zjy 当用户发表评论后，给评论者发送邮件通知；
+    #zjy 如果该评论是回复别人的，则同时给被回复的用户发送提醒邮件。
+    
+    #zjy 获取当前站点域名
     site = get_current_site().domain
 
-    # 邮件主题
+    #zjy 邮件主题
     subject = _('Thanks for your comment')
 
-    # 构造文章访问 URL（以便用户点进查看）
+    #zjy 构造文章访问 URL（以便用户点进查看）
     article_url = f"https://{site}{comment.article.get_absolute_url()}"
 
-    # 给评论者自己发送的邮件内容
+    #zjy 给评论者自己发送的邮件内容
     html_content = _("""<p>Thank you very much for your comments on this site</p>
                     You can visit <a href="%(article_url)s" rel="bookmark">%(article_title)s</a>
                     to review your comments,
@@ -34,16 +36,16 @@ def send_comment_email(comment):
                         'article_title': comment.article.title
                     }
 
-    # 收件人 = 评论的作者本人
+    #zjy 收件人 = 评论的作者本人
     tomail = comment.author.email
 
-    # 发送邮件
+    #zjy 发送邮件
     send_email([tomail], subject, html_content)
 
     try:
-        # 如果该评论存在父评论（说明是回复行为）
+        #zjy 如果该评论存在父评论（说明是回复行为）
         if comment.parent_comment:
-            # 给被回复的人发送通知邮件
+            #zjy 给被回复的人发送通知邮件
             html_content = _("""Your comment on <a href="%(article_url)s" rel="bookmark">%(article_title)s</a><br/> has 
                    received a reply. <br/> %(comment_body)s
                     <br/>   
@@ -56,12 +58,12 @@ def send_comment_email(comment):
                         'article_title': comment.article.title,
                         'comment_body': comment.parent_comment.body
                     }
-            # 父评论的作者邮箱
+            #zjy 父评论的作者邮箱
             tomail = comment.parent_comment.author.email
 
-            # 向被回复者发送邮件
+            #zjy 向被回复者发送邮件
             send_email([tomail], subject, html_content)
 
     except Exception as e:
-        # 出现错误则记录日志，但不影响评论正常流程
+        #zjy 出现错误则记录日志，但不影响评论正常流程
         logger.error(e)

src/comments/views.py

@@ -0,0 +1,44 @@
+#zjy 评论模块的视图处理
+#zjy 处理评论的提交和显示逻辑
+
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.http import HttpResponseRedirect
+from django.shortcuts import get_object_or_404
+from django.views.generic import View
+
+from blog.models import Article
+from .models import Comment
+from .forms import CommentForm
+
+
+class CommentPostView(LoginRequiredMixin, View):
+    #zjy 负责处理评论提交
+    #zjy 使用类视图方式处理POST请求
+
+    def post(self, request, article_id):
+        #zjy 获取目标文章
+        article = get_object_or_404(Article, pk=article_id)
+
+        form = CommentForm(request.POST)
+        if form.is_valid():
+            #zjy 获取评论内容
+            body = form.cleaned_data['body'].strip()
+            parent_id = form.cleaned_data.get('parent_comment_id')
+
+            comment = Comment()
+            comment.article = article
+            comment.author = request.user
+            comment.body = body
+
+            #zjy 判断是否是子评论（回复）
+            if parent_id:
+                try:
+                    parent_comment = Comment.objects.get(id=parent_id)
+                    comment.parent_comment = parent_comment
+                except Comment.DoesNotExist:
+                    pass
+
+            comment.save()
+
+        #zjy 评论成功后返回文章页面
+        return HttpResponseRedirect(article.get_absolute_url())

src/main.py

@@ -1,32 +1 @@
-def is_prime(n):
-    """判断一个数是否为质数"""
-    if n <= 1:
-        return False
-    if n == 2:
-        return True
-    if n % 2 == 0:
-        return False
-    for i in range(3, int(n**0.5) + 1, 2):
-        if n % i == 0:
-            return False
-    return True
-
-def print_first_n_primes(n):
-    """打印前n个质数"""
-    count = 0
-    num = 2
-    primes = []
-    
-    while count < n:
-        if is_prime(num):
-            primes.append(num)
-            count += 1
-        num += 1
-    
-    # 打印结果，每10个一行
-    for i in range(0, len(primes), 10):
-        print(", ".join(map(str, primes[i:i+10])))
-
-# 输出前100位质数
-print("前100位质数为:")
-print_first_n_primes(100)
+print("Hello World")

src/代码注释/accounts/admin.py

@@ -1,87 +0,0 @@
-# 导入Django表单基类
-from django import forms
-# 导入Django内置的用户管理员类，用于扩展自定义用户的admin配置
-from django.contrib.auth.admin import UserAdmin
-# 导入Django内置的用户修改表单，用于扩展自定义用户的修改表单
-from django.contrib.auth.forms import UserChangeForm
-# 导入Django内置的用户名字段类，用于自定义用户名字段验证
-from django.contrib.auth.forms import UsernameField
-# 导入翻译工具，用于实现字段名称的国际化
-from django.utils.translation import gettext_lazy as _
-
-# 注册模型时需要导入自定义的用户模型
-from .models import BlogUser
-
-
-class BlogUserCreationForm(forms.ModelForm):
-    """自定义用户创建表单，用于在admin站点添加新用户时使用"""
-    # 密码字段，使用密码输入框（输入内容隐藏），标签支持国际化
-    password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput)
-    # 确认密码字段，用于验证两次输入的密码是否一致
-    password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput)
-
-    class Meta:
-        # 关联的模型为自定义的BlogUser
-        model = BlogUser
-        # 创建用户时需要填写的字段（这里仅指定email，其他字段可默认或后续补充）
-        fields = ('email',)
-
-    def clean_password2(self):
-        """验证两次输入的密码是否一致"""
-        # 获取清洗后的密码1和密码2
-        password1 = self.cleaned_data.get("password1")
-        password2 = self.cleaned_data.get("password2")
-        # 如果两次密码都存在且不一致，抛出验证错误
-        if password1 and password2 and password1 != password2:
-            raise forms.ValidationError(_("passwords do not match"))
-        return password2
-
-    def save(self, commit=True):
-        """保存用户，将密码加密处理，并设置创建来源"""
-        # 调用父类的save方法，先不提交到数据库（commit=False）
-        user = super().save(commit=False)
-        # 对密码进行加密处理（Django内置的密码哈希方法）
-        user.set_password(self.cleaned_data["password1"])
-        # 如果需要提交到数据库
-        if commit:
-            # 设置用户的创建来源为'adminsite'（表示通过admin站点创建）
-            user.source = 'adminsite'
-            user.save()
-        return user
-
-
-class BlogUserChangeForm(UserChangeForm):
-    """自定义用户修改表单，用于在admin站点编辑用户信息时使用"""
-    class Meta:
-        # 关联的模型为BlogUser
-        model = BlogUser
-        # 显示所有字段（可根据需要指定具体字段）
-        fields = '__all__'
-        # 指定用户名字段的处理类为UsernameField（提供内置验证）
-        field_classes = {'username': UsernameField}
-
-    def __init__(self, *args, **kwargs):
-        """初始化方法，调用父类的初始化逻辑"""
-        super().__init__(*args, **kwargs)
-
-
-class BlogUserAdmin(UserAdmin):
-    """自定义用户管理员类，用于在admin站点配置BlogUser的展示和操作"""
-    # 指定修改用户时使用的表单
-    form = BlogUserChangeForm
-    # 指定添加用户时使用的表单
-    add_form = BlogUserCreationForm
-    # 列表页展示的字段
-    list_display = (
-        'id',          # 用户ID
-        'nickname',    # 昵称
-        'username',    # 用户名
-        'email',       # 邮箱
-        'last_login',  # 最后登录时间
-        'date_joined', # 注册时间
-        'source'       # 创建来源
-    )
-    # 列表页中可点击跳转详情页的字段
-    list_display_links = ('id', 'username')
-    # 列表页的排序方式（按ID降序，即最新创建的用户在前）
-    ordering = ('-id',)

src/代码注释/accounts/apps.py

@@ -1,12 +0,0 @@
-# 从Django的apps模块导入AppConfig类，用于定义应用的配置信息
-from django.apps import AppConfig
-
-
-class AccountsConfig(AppConfig):
-    """
-    accounts应用的配置类，用于设置应用的基本信息
-
-    继承自Django的AppConfig，通过此类可以配置应用的名称、默认自动生成的主键类型等元数据
-    """
-    # 定义应用的名称，Django通过此名称识别该应用，与项目settings.py中INSTALLED_APPS里的配置对应
-    name = 'accounts'

src/代码注释/accounts/forms.py

@@ -1,153 +0,0 @@
-# 导入Django表单基类
-from django import forms
-# 导入Django用户模型工具及密码验证功能
-from django.contrib.auth import get_user_model, password_validation
-# 导入Django内置的认证表单（登录、用户创建）
-from django.contrib.auth.forms import AuthenticationForm, UserCreationForm
-# 导入Django验证错误类，用于自定义表单验证
-from django.core.exceptions import ValidationError
-# 导入Django表单控件，用于自定义输入框样式
-from django.forms import widgets
-# 导入翻译工具，实现字段名称/提示的国际化
-from django.utils.translation import gettext_lazy as _
-# 导入自定义工具类（可能用于验证码验证等）
-from . import utils
-# 导入自定义用户模型
-from .models import BlogUser
-
-
-class LoginForm(AuthenticationForm):
-    """自定义登录表单，继承自Django内置的AuthenticationForm"""
-    def __init__(self, *args, **kwargs):
-        """初始化方法，重写父类初始化逻辑以自定义表单控件样式"""
-        super(LoginForm, self).__init__(*args, **kwargs)
-        # 自定义用户名字段的输入控件：设置占位符和CSS类
-        self.fields['username'].widget = widgets.TextInput(
-            attrs={'placeholder': "username", "class": "form-control"})
-        # 自定义密码字段的输入控件：使用密码输入框，设置占位符和CSS类
-        self.fields['password'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "password", "class": "form-control"})
-
-
-class RegisterForm(UserCreationForm):
-    """自定义注册表单，继承自Django内置的UserCreationForm"""
-    def __init__(self, *args, **kwargs):
-        """初始化方法，重写父类初始化逻辑以自定义表单控件样式"""
-        super(RegisterForm, self).__init__(*args, **kwargs)
-
-        # 自定义用户名字段控件：文本输入框，设置占位符和CSS类
-        self.fields['username'].widget = widgets.TextInput(
-            attrs={'placeholder': "username", "class": "form-control"})
-        # 自定义邮箱字段控件：邮箱输入框，设置占位符和CSS类
-        self.fields['email'].widget = widgets.EmailInput(
-            attrs={'placeholder': "email", "class": "form-control"})
-        # 自定义密码1字段控件：密码输入框，设置占位符和CSS类
-        self.fields['password1'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "password", "class": "form-control"})
-        # 自定义密码2字段控件：密码输入框（确认密码），设置占位符和CSS类
-        self.fields['password2'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "repeat password", "class": "form-control"})
-
-    def clean_email(self):
-        """自定义邮箱验证：检查邮箱是否已被注册"""
-        email = self.cleaned_data['email']
-        # 如果该邮箱已存在于用户表中，抛出验证错误
-        if get_user_model().objects.filter(email=email).exists():
-            raise ValidationError(_("email already exists"))
-        return email
-
-    class Meta:
-        # 关联的用户模型（通过get_user_model获取项目配置的用户模型）
-        model = get_user_model()
-        # 注册表单需填写的字段：用户名和邮箱
-        fields = ("username", "email")
-
-
-class ForgetPasswordForm(forms.Form):
-    """忘记密码表单，用于用户重置密码（包含密码重置、邮箱验证、验证码验证）"""
-    # 新密码字段：标签国际化，使用密码输入框，设置CSS类和占位符
-    new_password1 = forms.CharField(
-        label=_("New password"),
-        widget=forms.PasswordInput(
-            attrs={
-                "class": "form-control",
-                'placeholder': _("New password")
-            }
-        ),
-    )
-
-    # 确认新密码字段：标签为“确认密码”，使用密码输入框，设置样式
-    new_password2 = forms.CharField(
-        label="确认密码",
-        widget=forms.PasswordInput(
-            attrs={
-                "class": "form-control",
-                'placeholder': _("Confirm password")
-            }
-        ),
-    )
-
-    # 邮箱字段：用于验证用户身份，使用文本输入框，设置样式
-    email = forms.EmailField(
-        label='邮箱',
-        widget=forms.TextInput(
-            attrs={
-                'class': 'form-control',
-                'placeholder': _("Email")
-            }
-        ),
-    )
-
-    # 验证码字段：用于验证用户真实性，使用文本输入框，设置样式
-    code = forms.CharField(
-        label=_('Code'),
-        widget=forms.TextInput(
-            attrs={
-                'class': 'form-control',
-                'placeholder': _("Code")
-            }
-        ),
-    )
-
-    def clean_new_password2(self):
-        """验证两次输入的新密码是否一致，并验证密码强度"""
-        password1 = self.data.get("new_password1")  # 获取第一次输入的密码
-        password2 = self.data.get("new_password2")  # 获取第二次输入的密码
-        # 如果两次密码都存在且不一致，抛出验证错误
-        if password1 and password2 and password1 != password2:
-            raise ValidationError(_("passwords do not match"))
-        # 使用Django内置密码验证器验证密码强度（如长度、复杂度等）
-        password_validation.validate_password(password2)
-        return password2
-
-    def clean_email(self):
-        """验证邮箱是否已注册（存在于用户表中）"""
-        user_email = self.cleaned_data.get("email")
-        # 如果该邮箱不存在于BlogUser表中，抛出验证错误
-        if not BlogUser.objects.filter(
-                email=user_email
-        ).exists():
-            # 注意：此处提示可能暴露邮箱是否注册，可根据需求修改
-            raise ValidationError(_("email does not exist"))
-        return user_email
-
-    def clean_code(self):
-        """验证验证码是否有效（调用自定义工具类的verify方法）"""
-        code = self.cleaned_data.get("code")
-        # 调用utils.verify验证邮箱和验证码是否匹配，返回错误信息（若有）
-        error = utils.verify(
-            email=self.cleaned_data.get("email"),
-            code=code,
-        )
-        # 如果验证失败（有错误信息），抛出验证错误
-        if error:
-            raise ValidationError(error)
-        return code
-
-
-class ForgetPasswordCodeForm(forms.Form):
-    """获取忘记密码验证码的表单，用于提交邮箱以发送验证码"""
-    # 邮箱字段：用于指定需要发送验证码的邮箱，标签国际化
-    email = forms.EmailField(
-        label=_('Email'),
-    )

src/代码注释/accounts/migrations/0001_initial.py

@@ -1,77 +0,0 @@
-# Generated by Django 4.1.7 on 2023-03-02 07:14
-# 以上注释为Django自动生成，标识该迁移文件由Django 4.1.7版本在2023-03-02 07:14生成
-
-# 导入Django内置的用户模型相关模块
-import django.contrib.auth.models
-# 导入Django内置的用户验证器
-import django.contrib.auth.validators
-# 从django.db导入迁移和模型相关类
-from django.db import migrations, models
-# 导入Django的时区工具
-import django.utils.timezone
-
-
-# 定义迁移类，继承自migrations.Migration
-class Migration(migrations.Migration):
-
-    # 标识这是初始迁移（首次创建模型的迁移）
-    initial = True
-
-    # 依赖的其他迁移文件，这里依赖auth应用的0012_alter_user_first_name_max_length迁移
-    dependencies = [
-        ('auth', '0012_alter_user_first_name_max_length'),
-    ]
-
-    # 迁移操作列表，包含要执行的数据库操作
-    operations = [
-        # 创建BlogUser模型的迁移操作
-        migrations.CreateModel(
-            name='BlogUser',  # 模型名称
-            fields=[  # 模型字段定义列表
-                # 自增主键字段，BigAutoField适用于大数据量场景
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                # 密码字段，最大长度128，显示名称为'password'
-                ('password', models.CharField(max_length=128, verbose_name='password')),
-                # 最后登录时间字段，可为空且允许空白，显示名称为'last login'
-                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
-                # 是否为超级用户字段，默认False，包含帮助文本和显示名称
-                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
-                # 用户名字段，包含错误信息、帮助文本、最大长度150、唯一约束、验证器和显示名称
-                ('username', models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username')),
-                # 名字段，允许空白，最大长度150，显示名称为'first name'
-                ('first_name', models.CharField(blank=True, max_length=150, verbose_name='first name')),
-                # 姓字段，允许空白，最大长度150，显示名称为'last name'
-                ('last_name', models.CharField(blank=True, max_length=150, verbose_name='last name')),
-                # 邮箱字段，允许空白，最大长度254，显示名称为'email address'
-                ('email', models.EmailField(blank=True, max_length=254, verbose_name='email address')),
-                # 是否为管理员（可登录admin站点），默认False，包含帮助文本和显示名称
-                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
-                # 是否激活字段，默认True，包含帮助文本（建议通过此选项禁用账户而非删除）和显示名称
-                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
-                # 加入日期字段，默认值为当前时区时间，显示名称为'date joined'
-                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
-                # 自定义昵称字段，允许空白，最大长度100，显示名称为'昵称'
-                ('nickname', models.CharField(blank=True, max_length=100, verbose_name='昵称')),
-                # 自定义创建时间字段，默认值为当前时区时间，显示名称为'创建时间'
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                # 自定义最后修改时间字段，默认值为当前时区时间，显示名称为'修改时间'
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-                # 自定义创建来源字段，允许空白，最大长度100，显示名称为'创建来源'
-                ('source', models.CharField(blank=True, max_length=100, verbose_name='创建来源')),
-                # 与auth.Group的多对多关系，用于用户组权限管理，包含帮助文本、关联名称和显示名称
-                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
-                # 与auth.Permission的多对多关系，用于用户单独权限管理，包含帮助文本、关联名称和显示名称
-                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
-            ],
-            options={  # 模型的元数据配置
-                'verbose_name': '用户',  # 模型的单数显示名称
-                'verbose_name_plural': '用户',  # 模型的复数显示名称
-                'ordering': ['-id'],  # 排序方式：按id降序
-                'get_latest_by': 'id',  # 获取最新记录的依据字段：id
-            },
-            managers=[  # 模型的管理器配置
-                # 使用Django内置的UserManager作为模型的管理器
-                ('objects', django.contrib.auth.models.UserManager()),
-            ],
-        ),
-    ]

src/代码注释/accounts/migrations/0002_alter_bloguser_options_remove_bloguser_created_time_and_more.py

@@ -1,68 +0,0 @@
-# Generated by Django 4.2.5 on 2023-09-06 13:13
-# 以上注释为Django自动生成，标识该迁移文件由Django 4.2.5版本在2023-09-06 13:13生成
-
-# 从django.db导入迁移和模型相关类，用于定义数据库迁移操作
-from django.db import migrations, models
-# 导入Django的时区工具，用于处理时间字段的默认值
-import django.utils.timezone
-
-
-# 定义迁移类，继承自migrations.Migration，用于描述数据库结构的变更
-class Migration(migrations.Migration):
-
-    # 依赖的其他迁移文件：依赖于accounts应用的0001_initial迁移
-    # 表示当前迁移需要在0001_initial迁移执行之后才能运行
-    dependencies = [
-        ('accounts', '0001_initial'),
-    ]
-
-    # 迁移操作列表，包含一系列对数据库模型的修改操作
-    operations = [
-        # 修改BlogUser模型的元数据配置
-        migrations.AlterModelOptions(
-            name='bloguser',  # 目标模型名称
-            # 新的元数据选项：
-            # get_latest_by：指定通过id字段获取最新记录
-            # ordering：按id降序排序
-            # verbose_name/verbose_name_plural：模型的显示名称（单数和复数）改为'user'
-            options={'get_latest_by': 'id', 'ordering': ['-id'], 'verbose_name': 'user', 'verbose_name_plural': 'user'},
-        ),
-        # 从BlogUser模型中移除'created_time'字段
-        migrations.RemoveField(
-            model_name='bloguser',  # 目标模型名称
-            name='created_time',  # 要移除的字段名
-        ),
-        # 从BlogUser模型中移除'last_mod_time'字段
-        migrations.RemoveField(
-            model_name='bloguser',  # 目标模型名称
-            name='last_mod_time',  # 要移除的字段名
-        ),
-        # 向BlogUser模型添加'creation_time'字段
-        migrations.AddField(
-            model_name='bloguser',  # 目标模型名称
-            name='creation_time',  # 新增字段名
-            # 字段类型为DateTimeField，默认值为当前时区时间，显示名称为'creation time'
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        # 向BlogUser模型添加'last_modify_time'字段
-        migrations.AddField(
-            model_name='bloguser',  # 目标模型名称
-            name='last_modify_time',  # 新增字段名
-            # 字段类型为DateTimeField，默认值为当前时区时间，显示名称为'last modify time'
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='last modify time'),
-        ),
-        # 修改BlogUser模型的'nickname'字段属性
-        migrations.AlterField(
-            model_name='bloguser',  # 目标模型名称
-            name='nickname',  # 要修改的字段名
-            # 字段仍为CharField，允许空白，最大长度100，显示名称改为'nick name'
-            field=models.CharField(blank=True, max_length=100, verbose_name='nick name'),
-        ),
-        # 修改BlogUser模型的'source'字段属性
-        migrations.AlterField(
-            model_name='bloguser',  # 目标模型名称
-            name='source',  # 要修改的字段名
-            # 字段仍为CharField，允许空白，最大长度100，显示名称改为'create source'
-            field=models.CharField(blank=True, max_length=100, verbose_name='create source'),
-        ),
-    ]

src/代码注释/accounts/models.py

@@ -1,64 +0,0 @@
-# 导入Django内置的抽象用户模型，用于扩展自定义用户功能（包含基础用户名、密码等字段）
-from django.contrib.auth.models import AbstractUser
-# 导入Django模型相关类，用于定义数据库表结构
-from django.db import models
-# 导入reverse函数，用于通过URL名称生成对应的URL路径
-from django.urls import reverse
-# 导入now函数，用于获取当前时区的时间（作为字段默认值）
-from django.utils.timezone import now
-# 导入翻译工具，用于实现模型字段名称的国际化
-from django.utils.translation import gettext_lazy as _
-# 导入自定义工具函数get_current_site，用于获取当前站点的域名信息
-from djangoblog.utils import get_current_site
-
-
-class BlogUser(AbstractUser):
-    """
-    自定义用户模型，继承自Django的AbstractUser
-    扩展了内置用户模型，增加了昵称、创建时间、修改时间、创建来源等自定义字段
-    """
-    # 昵称字段：支持国际化标签，最大长度100，允许空白（不强制填写）
-    nickname = models.CharField(_('nick name'), max_length=100, blank=True)
-    # 创建时间字段：支持国际化标签，默认值为当前时间（调用now函数）
-    creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间字段：支持国际化标签，默认值为当前时间
-    last_modify_time = models.DateTimeField(_('last modify time'), default=now)
-    # 创建来源字段：记录用户创建的渠道（如adminsite、frontend等），支持国际化标签，允许空白
-    source = models.CharField(_('create source'), max_length=100, blank=True)
-
-    def get_absolute_url(self):
-        """
-        定义模型实例的绝对URL（标准Django方法）
-        通过URL名称'blog:author_detail'生成用户详情页的URL，参数为用户名
-        """
-        return reverse(
-            'blog:author_detail', kwargs={
-                'author_name': self.username})  # kwargs传递URL所需的用户名参数
-
-    def __str__(self):
-        """
-        定义模型实例的字符串表示
-        当打印或引用用户实例时，返回用户的邮箱地址（便于识别）
-        """
-        return self.email
-
-    def get_full_url(self):
-        """
-        生成用户详情页的完整URL（包含站点域名）
-        结合当前站点域名和get_absolute_url生成的相对路径，组成完整链接
-        """
-        # 获取当前站点的域名（如www.example.com）
-        site = get_current_site().domain
-        # 拼接域名和相对路径，形成完整URL（使用HTTPS协议）
-        url = "https://{site}{path}".format(site=site,
-                                            path=self.get_absolute_url())
-        return url
-
-    class Meta:
-        """
-        模型的元数据配置，用于定义模型的显示和行为规则
-        """
-        ordering = ['-id']  # 数据查询时的默认排序：按ID降序（最新创建的用户在前）
-        verbose_name = _('user')  # 模型的单数显示名称（支持国际化）
-        verbose_name_plural = verbose_name  # 模型的复数显示名称（与单数一致，避免英文复数变形问题）
-        get_latest_by = 'id'  # 获取"最新记录"时的依据字段：按ID判断（ID最大的为最新）

src/代码注释/accounts/tests.py

@@ -1,276 +0,0 @@
-# 导入Django测试所需的核心类：Client模拟HTTP请求、RequestFactory创建请求对象、TestCase测试基类
-from django.test import Client, RequestFactory, TestCase
-# 导入reverse通过URL名称生成路径，用于测试中定位接口
-from django.urls import reverse
-# 导入timezone处理时间相关字段，用于创建测试数据
-from django.utils import timezone
-# 导入翻译工具，用于处理国际化文本（测试中未直接使用，但保持原导入）
-from django.utils.translation import gettext_lazy as _
-
-# 导入需要测试的自定义模型：用户模型、文章模型、分类模型
-from accounts.models import BlogUser
-from blog.models import Article, Category
-# 导入项目工具函数（如获取当前站点、加密、缓存操作等）
-from djangoblog.utils import *
-# 导入当前模块的工具函数（如验证码处理）
-from . import utils
-
-
-# 定义账户相关测试类，继承Django的TestCase（提供测试框架支持）
-class AccountTest(TestCase):
-    def setUp(self):
-        """
-        测试初始化方法，在每个测试方法执行前自动调用
-        用于创建共用的测试对象，避免代码重复
-        """
-        # 创建测试客户端，用于模拟用户发送HTTP请求
-        self.client = Client()
-        # 创建请求工厂，用于生成原始请求对象（按需使用）
-        self.factory = RequestFactory()
-        # 创建普通测试用户，用户名test、邮箱admin@admin.com、密码12345678
-        self.blog_user = BlogUser.objects.create_user(
-            username="test",
-            email="admin@admin.com",
-            password="12345678"
-        )
-        # 定义测试用的新密码，后续忘记密码测试中使用
-        self.new_test = "xxx123--="
-
-    def test_validate_account(self):
-        """测试账户基础功能：超级用户创建、登录验证、admin访问、内容创建与管理"""
-        # 获取当前站点域名（测试中未实际使用，保持原逻辑）
-        site = get_current_site().domain
-        # 创建超级用户（拥有admin管理权限）
-        user = BlogUser.objects.create_superuser(
-            email="liangliangyy1@gmail.com",
-            username="liangliangyy1",
-            password="qwer!@#$ggg")
-        # 通过用户名查询刚创建的超级用户，验证创建成功
-        testuser = BlogUser.objects.get(username='liangliangyy1')
-
-        # 使用测试客户端模拟超级用户登录
-        loginresult = self.client.login(
-            username='liangliangyy1',
-            password='qwer!@#$ggg')
-        # 断言登录成功（返回True）
-        self.assertEqual(loginresult, True)
-        # 模拟访问admin后台页面
-        response = self.client.get('/admin/')
-        # 断言admin页面访问成功（状态码200）
-        self.assertEqual(response.status_code, 200)
-
-        # 创建测试分类：设置名称、创建时间、修改时间并保存
-        category = Category()
-        category.name = "categoryaaa"
-        category.creation_time = timezone.now()
-        category.last_modify_time = timezone.now()
-        category.save()
-
-        # 创建测试文章：关联作者（超级用户）和分类，设置标题、内容、类型、状态并保存
-        article = Article()
-        article.title = "nicetitleaaa"
-        article.body = "nicecontentaaa"
-        article.author = user
-        article.category = category
-        article.type = 'a'  # 假设'a'代表普通文章类型
-        article.status = 'p'  # 假设'p'代表已发布状态
-        article.save()
-
-        # 模拟访问文章的admin管理页面（通过文章模型的get_admin_url方法获取路径）
-        response = self.client.get(article.get_admin_url())
-        # 断言文章管理页面访问成功（状态码200）
-        self.assertEqual(response.status_code, 200)
-
-    def test_validate_register(self):
-        """测试用户注册流程：注册请求、注册后用户存在性、邮箱验证、登录与权限升级、内容管理"""
-        # 注册前断言：邮箱为user123@user.com的用户不存在（初始状态）
-        self.assertEquals(
-            0, len(
-                BlogUser.objects.filter(
-                    email='user123@user.com')))
-        # 模拟发送注册请求：向account:register接口提交用户名、邮箱、两次一致的密码
-        response = self.client.post(reverse('account:register'), {
-            'username': 'user1233',
-            'email': 'user123@user.com',
-            'password1': 'password123!q@wE#R$T',
-            'password2': 'password123!q@wE#R$T',
-        })
-        # 注册后断言：邮箱为user123@user.com的用户存在（注册成功）
-        self.assertEquals(
-            1, len(
-                BlogUser.objects.filter(
-                    email='user123@user.com')))
-
-        # 获取刚注册的用户，生成邮箱验证链接（使用项目加密逻辑生成签名）
-        user = BlogUser.objects.filter(email='user123@user.com')[0]
-        sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))  # 双重SHA256加密签名
-        path = reverse('accounts:result')  # 验证结果页的URL路径
-        url = '{path}?type=validation&id={id}&sign={sign}'.format(
-            path=path, id=user.id, sign=sign)  # 拼接完整验证URL
-        # 模拟访问邮箱验证链接
-        response = self.client.get(url)
-        # 断言验证页面访问成功（状态码200）
-        self.assertEqual(response.status_code, 200)
-
-        # 模拟刚注册的用户登录
-        self.client.login(username='user1233', password='password123!q@wE#R$T')
-        # 升级用户权限为超级用户（便于测试admin功能）
-        user = BlogUser.objects.filter(email='user123@user.com')[0]
-        user.is_superuser = True  # 设为超级用户
-        user.is_staff = True  # 允许登录admin
-        user.save()
-        # 删除侧边栏缓存（项目自定义缓存操作，测试中保持原逻辑）
-        delete_sidebar_cache()
-
-        # 创建测试分类（用于后续创建文章）
-        category = Category()
-        category.name = "categoryaaa"
-        category.creation_time = timezone.now()
-        category.last_modify_time = timezone.now()
-        category.save()
-
-        # 创建测试文章（关联升级权限后的用户）
-        article = Article()
-        article.category = category
-        article.title = "nicetitle333"
-        article.body = "nicecontentttt"
-        article.author = user
-        article.type = 'a'
-        article.status = 'p'
-        article.save()
-
-        # 模拟访问文章的admin管理页面
-        response = self.client.get(article.get_admin_url())
-        self.assertEqual(response.status_code, 200)
-
-        # 模拟用户登出
-        response = self.client.get(reverse('account:logout'))
-        # 断言登出请求响应正常（允许301/302重定向或200成功）
-        self.assertIn(response.status_code, [301, 302, 200])
-
-        # 登出后尝试访问文章admin页面（应被拒绝或重定向）
-        response = self.client.get(article.get_admin_url())
-        self.assertIn(response.status_code, [301, 302, 200])
-
-        # 模拟使用错误密码登录（密码不匹配）
-        response = self.client.post(reverse('account:login'), {
-            'username': 'user1233',
-            'password': 'password123'
-        })
-        # 断言登录请求响应正常（无论成功失败，状态码合法）
-        self.assertIn(response.status_code, [301, 302, 200])
-
-        # 错误登录后尝试访问文章admin页面（应被拒绝或重定向）
-        response = self.client.get(article.get_admin_url())
-        self.assertIn(response.status_code, [301, 302, 200])
-
-    def test_verify_email_code(self):
-        """测试邮箱验证码验证逻辑：正确验证码验证成功，错误邮箱验证失败"""
-        # 定义测试邮箱和生成随机验证码
-        to_email = "admin@admin.com"
-        code = generate_code()  # 调用工具函数生成验证码
-        # 存储验证码（关联邮箱，用于后续验证）
-        utils.set_code(to_email, code)
-        # 发送验证邮件（测试中仅执行流程，不实际校验邮件发送结果）
-        utils.send_verify_email(to_email, code)
-
-        # 验证1：使用正确的邮箱和验证码，断言无错误返回（验证成功）
-        err = utils.verify("admin@admin.com", code)
-        self.assertEqual(err, None)
-
-        # 验证2：使用错误的邮箱（与存储的验证码不匹配），断言返回错误信息（字符串类型）
-        err = utils.verify("admin@123.com", code)
-        self.assertEqual(type(err), str)
-
-    def test_forget_password_email_code_success(self):
-        """测试获取忘记密码验证码的成功场景：提交正确邮箱，返回成功响应"""
-        # 模拟向account:forget_password_code接口提交正确邮箱
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict(email="admin@admin.com")
-        )
-        # 断言请求成功（状态码200）且返回内容为"ok"（表示验证码发送成功）
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.content.decode("utf-8"), "ok")
-
-    def test_forget_password_email_code_fail(self):
-        """测试获取忘记密码验证码的失败场景：无邮箱、邮箱格式错误"""
-        # 失败场景1：不提交邮箱（空数据）
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict()
-        )
-        # 断言返回"错误的邮箱"（参数缺失）
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
-
-        # 失败场景2：提交格式错误的邮箱（admin@com不符合标准格式）
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict(email="admin@com")
-        )
-        # 断言返回"错误的邮箱"（格式校验失败）
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
-
-    def test_forget_password_email_success(self):
-        """测试忘记密码重置成功场景：提交正确验证码和新密码，密码修改生效"""
-        # 生成验证码并关联测试用户的邮箱（模拟用户已获取验证码）
-        code = generate_code()
-        utils.set_code(self.blog_user.email, code)
-        # 构造忘记密码重置请求数据：新密码（两次一致）、用户邮箱、正确验证码
-        data = dict(
-            new_password1=self.new_test,
-            new_password2=self.new_test,
-            email=self.blog_user.email,
-            code=code,
-        )
-        # 模拟发送密码重置请求
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-        # 断言重置成功（重定向到结果页，状态码302）
-        self.assertEqual(resp.status_code, 302)
-
-        # 验证密码是否真的修改成功：查询用户并校验新密码
-        blog_user = BlogUser.objects.filter(
-            email=self.blog_user.email,
-        ).first()  # 获取用户实例
-        self.assertNotEqual(blog_user, None)  # 断言用户存在
-        # 使用check_password方法验证新密码是否匹配（Django内置密码校验，自动处理哈希）
-        self.assertEqual(blog_user.check_password(data["new_password1"]), True)
-
-    def test_forget_password_email_not_user(self):
-        """测试忘记密码重置失败场景：使用不存在的邮箱"""
-        # 构造请求数据：新密码、不存在的邮箱、任意验证码
-        data = dict(
-            new_password1=self.new_test,
-            new_password2=self.new_test,
-            email="123@123.com",
-            code="123456",
-        )
-        # 模拟发送密码重置请求
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-        # 断言请求响应正常（页面返回错误提示，状态码200）
-        self.assertEqual(resp.status_code, 200)
-
-    def test_forget_password_email_code_error(self):
-        """测试忘记密码重置失败场景：验证码错误"""
-        # 生成正确验证码并关联用户邮箱，但请求时提交错误验证码
-        code = generate_code()
-        utils.set_code(self.blog_user.email, code)
-        data = dict(
-            new_password1=self.new_test,
-            new_password2=self.new_test,
-            email=self.blog_user.email,
-            code="111111",  # 错误的验证码
-        )
-        # 模拟发送密码重置请求
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-        # 断言请求响应正常（页面返回验证码错误提示，状态码200）
-        self.assertEqual(resp.status_code, 200)

src/代码注释/accounts/urls.py

@@ -1,45 +0,0 @@
-# 导入Django的URL路径定义工具：path用于精确路径匹配，re_path支持正则表达式匹配
-from django.urls import path
-from django.urls import re_path
-
-# 导入当前应用（accounts）的视图模块，包含登录、注册等业务逻辑处理
-from . import views
-# 导入当前应用的自定义登录表单，用于登录页面的表单渲染和验证
-from .forms import LoginForm
-
-# 定义应用的命名空间为"accounts"，避免不同应用间URL名称冲突
-app_name = "accounts"
-
-# URL路由配置列表，映射URL路径到对应的视图
-urlpatterns = [
-    # 1. 登录页面URL
-    re_path(r'^login/$',  # 正则匹配路径：以"login/"开头并结束（即精确匹配"/login/"）
-            views.LoginView.as_view(success_url='/'),  # 关联LoginView视图，登录成功后重定向到网站根路径（"/"）
-            name='login',  # URL的命名，用于模板或视图中通过reverse('accounts:login')生成路径
-            kwargs={'authentication_form': LoginForm}),  # 传递参数：指定登录使用自定义的LoginForm表单
-
-    # 2. 注册页面URL
-    re_path(r'^register/$',  # 正则匹配路径：精确匹配"/register/"
-            views.RegisterView.as_view(success_url="/"),  # 关联RegisterView视图，注册成功后重定向到网站根路径
-            name='register'),  # URL命名，用于反向生成注册页面路径
-
-    # 3. 登出功能URL
-    re_path(r'^logout/$',  # 正则匹配路径：精确匹配"/logout/"
-            views.LogoutView.as_view(),  # 关联LogoutView视图，处理登出逻辑（默认登出后重定向到登录页）
-            name='logout'),  # URL命名，用于反向生成登出路径
-
-    # 4. 账户操作结果页URL（如登录/注册/密码重置后的结果提示）
-    path(r'account/result.html',  # 精确路径匹配：固定路径"/account/result.html"
-         views.account_result,  # 关联普通函数视图account_result，处理结果页渲染
-         name='result'),  # URL命名，用于反向生成结果页路径
-
-    # 5. 忘记密码页面URL（密码重置表单页）
-    re_path(r'^forget_password/$',  # 正则匹配路径：精确匹配"/forget_password/"
-            views.ForgetPasswordView.as_view(),  # 关联ForgetPasswordView视图，处理密码重置表单逻辑
-            name='forget_password'),  # URL命名，用于反向生成忘记密码页面路径
-
-    # 6. 获取忘记密码验证码的URL（发送验证码到邮箱）
-    re_path(r'^forget_password_code/$',  # 正则匹配路径：精确匹配"/forget_password_code/"
-            views.ForgetPasswordEmailCode.as_view(),  # 关联ForgetPasswordEmailCode视图，处理发送验证码逻辑
-            name='forget_password_code'),  # URL命名，用于反向生成获取验证码的路径
-]

src/代码注释/accounts/user_login_backend.py

@@ -1,53 +0,0 @@
-# 导入Django的用户模型工具，用于获取项目配置的用户模型（支持自定义用户模型）
-from django.contrib.auth import get_user_model
-# 导入Django内置的模型认证后端基类，用于扩展自定义认证逻辑
-from django.contrib.auth.backends import ModelBackend
-
-
-class EmailOrUsernameModelBackend(ModelBackend):
-    """
-    自定义认证后端，继承自Django的ModelBackend
-    功能：允许用户使用用户名或邮箱地址进行登录验证
-    """
-
-    def authenticate(self, request, username=None, password=None, **kwargs):
-        """
-        重写认证方法，实现用户名/邮箱登录逻辑
-        :param request: 请求对象
-        :param username: 登录时输入的标识（可能是用户名或邮箱）
-        :param password: 登录密码
-        :param kwargs: 其他关键字参数
-        :return: 验证成功返回用户对象，失败返回None
-        """
-        # 判断输入的"username"是否包含@符号，若包含则视为邮箱登录
-        if '@' in username:
-            # 构建查询条件：使用email字段匹配
-            kwargs = {'email': username}
-        else:
-            # 否则视为用户名登录，构建查询条件：使用username字段匹配
-            kwargs = {'username': username}
-
-        try:
-            # 根据构建的条件查询用户（使用项目配置的用户模型）
-            user = get_user_model().objects.get(**kwargs)
-            # 验证查询到的用户密码是否正确（Django内置的密码校验，自动处理哈希对比）
-            if user.check_password(password):
-                # 密码正确，返回用户对象
-                return user
-        except get_user_model().DoesNotExist:
-            # 若用户不存在（查询失败），返回None表示认证失败
-            return None
-
-    def get_user(self, username):
-        """
-        重写获取用户的方法，根据用户主键获取用户对象
-        （Django认证系统会调用此方法获取已认证用户的详细信息）
-        :param username: 实际为用户的主键（pk）
-        :return: 存在则返回用户对象，不存在返回None
-        """
-        try:
-            # 根据主键查询用户
-            return get_user_model().objects.get(pk=username)
-        except get_user_model().DoesNotExist:
-            # 用户不存在，返回None
-            return None

src/代码注释/accounts/utils.py

@@ -1,81 +0,0 @@
-# 导入类型提示模块，用于定义函数参数和返回值的类型（增强代码可读性和类型检查）
-import typing
-# 导入timedelta，用于定义时间间隔（此处用于设置验证码有效期）
-from datetime import timedelta
-
-# 导入Django缓存模块，用于临时存储验证码（避免数据库频繁读写）
-from django.core.cache import cache
-# 导入Django翻译工具：gettext用于实时翻译字符串，gettext_lazy用于延迟翻译（适合定义常量时使用）
-from django.utils.translation import gettext
-from django.utils.translation import gettext_lazy as _
-
-# 导入项目自定义的发送邮件工具函数，用于实际发送验证码邮件
-from djangoblog.utils import send_email
-
-# 定义验证码的有效期：5分钟（全局常量，所有验证码共用此有效期）
-_code_ttl = timedelta(minutes=5)
-
-
-def send_verify_email(to_mail: str, code: str, subject: str = _("Verify Email")):
-    """
-    发送密码重置验证邮件，将验证码通过邮件发送给指定邮箱
-
-    Args:
-        to_mail: 接收邮件的目标邮箱地址（字符串类型）
-        code: 生成的验证码（字符串类型，用于后续验证）
-        subject: 邮件主题，默认值为"Verify Email"（支持国际化，可根据语言设置自动翻译）
-    """
-    # 构造邮件的HTML内容：包含验证码和有效期提示，使用国际化翻译，通过%(code)s格式化插入验证码
-    html_content = _(
-        "You are resetting the password, the verification code is：%(code)s, valid within 5 minutes, please keep it "
-        "properly") % {'code': code}
-    # 调用自定义的send_email函数发送邮件：参数为收件人列表、邮件主题、邮件内容
-    send_email([to_mail], subject, html_content)
-
-
-def verify(email: str, code: str) -> typing.Optional[str]:
-    """
-    验证用户输入的验证码是否有效（与缓存中存储的验证码对比）
-
-    Args:
-        email: 用户提交的邮箱地址（用于匹配缓存中对应的验证码）
-        code: 用户输入的验证码（需要验证的字符串）
-
-    Return:
-        验证失败时返回错误提示字符串（如"Verification code error"），验证成功时返回None
-
-    Note:
-        原代码注释说明：当前错误处理方式不合理，建议通过raise抛出异常替代返回错误字符串，
-        避免调用方需要额外处理返回的错误信息，使错误处理更符合Python规范
-    """
-    # 从缓存中获取该邮箱对应的验证码（调用get_code函数）
-    cache_code = get_code(email)
-    # 对比用户输入的验证码与缓存中的验证码，不一致则返回错误提示
-    if cache_code != code:
-        return gettext("Verification code error")
-
-
-def set_code(email: str, code: str):
-    """
-    将邮箱与对应的验证码存储到Django缓存中，并设置过期时间（使用全局的_code_ttl）
-
-    Args:
-        email: 作为缓存键（key）的邮箱地址（确保每个邮箱的验证码唯一）
-        code: 作为缓存值（value）的验证码（需要存储的字符串）
-    """
-    # 调用cache.set存储数据：key=email，value=code，timeout=_code_ttl.seconds（有效期转换为秒数）
-    cache.set(email, code, _code_ttl.seconds)
-
-
-def get_code(email: str) -> typing.Optional[str]:
-    """
-    根据邮箱地址从Django缓存中获取对应的验证码
-
-    Args:
-        email: 用于查询的缓存键（key），即目标邮箱地址
-
-    Return:
-        缓存中存在该邮箱对应的验证码时返回字符串类型的验证码，不存在或过期时返回None
-    """
-    # 调用cache.get获取缓存值：key=email，不存在则返回None
-    return cache.get(email)

src/代码注释/accounts/views.py

@@ -1,330 +0,0 @@
-# 导入日志模块，用于记录视图操作中的关键信息（如请求类型、用户状态等）
-import logging
-# 导入Django国际化翻译工具，用于视图中文本的多语言支持
-from django.utils.translation import gettext_lazy as _
-# 导入Django项目配置，用于获取SECRET_KEY等全局设置
-from django.conf import settings
-# 导入Django认证相关模块：auth处理登录逻辑，REDIRECT_FIELD_NAME定义重定向参数名，get_user_model获取自定义用户模型
-from django.contrib import auth
-from django.contrib.auth import REDIRECT_FIELD_NAME
-from django.contrib.auth import get_user_model
-from django.contrib.auth import logout  # 登出功能函数
-# 导入Django内置认证表单，用于登录表单的基础验证
-from django.contrib.auth.forms import AuthenticationForm
-# 导入密码哈希工具，用于生成加密后的密码（忘记密码功能中更新密码时使用）
-from django.contrib.auth.hashers import make_password
-# 导入DjangoHTTP响应类：重定向、403禁止访问、基础响应
-from django.http import HttpResponseRedirect, HttpResponseForbidden
-from django.http.request import HttpRequest
-from django.http.response import HttpResponse
-# 导入Django快捷函数：get_object_or_404（获取对象不存在时返回404）、render（渲染模板）
-from django.shortcuts import get_object_or_404
-from django.shortcuts import render
-# 导入reverse函数，通过URL名称生成路径（避免硬编码路径）
-from django.urls import reverse
-# 导入Django视图装饰器：method_decorator（为类视图方法添加装饰器）、never_cache（禁止缓存）、csrf_protect（CSRF保护）、sensitive_post_parameters（保护敏感POST参数）
-from django.utils.decorators import method_decorator
-from django.utils.http import url_has_allowed_host_and_scheme  # 验证重定向地址是否安全
-# 导入Django类视图基类：View（基础视图类）、FormView（处理表单的视图类）、RedirectView（处理重定向的视图类）
-from django.views import View
-from django.views.decorators.cache import never_cache
-from django.views.decorators.csrf import csrf_protect
-from django.views.decorators.debug import sensitive_post_parameters
-from django.views.generic import FormView, RedirectView
-
-# 导入项目自定义工具函数：发送邮件、SHA256加密、获取当前站点、生成验证码、删除侧边栏缓存
-from djangoblog.utils import send_email, get_sha256, get_current_site, generate_code, delete_sidebar_cache
-# 导入当前应用（accounts）的工具函数（验证码相关操作）
-from . import utils
-# 导入当前应用的自定义表单：注册、登录、忘记密码、获取忘记密码验证码的表单
-from .forms import RegisterForm, LoginForm, ForgetPasswordForm, ForgetPasswordCodeForm
-# 导入当前应用的自定义用户模型
-from .models import BlogUser
-
-# 创建日志记录器，用于记录当前视图模块的日志
-logger = logging.getLogger(__name__)
-
-
-# Create your views here.
-
-class RegisterView(FormView):
-    """
-    处理用户注册的类视图，继承自FormView（专门处理表单提交的视图基类）
-    功能：展示注册表单、验证表单数据、创建未激活用户、发送邮箱验证链接、跳转注册结果页
-    """
-    form_class = RegisterForm  # 关联的表单类：自定义的RegisterForm
-    template_name = 'account/registration_form.html'  # 渲染的模板文件路径
-
-    @method_decorator(csrf_protect)
-    def dispatch(self, *args, **kwargs):
-        """
-        重写dispatch方法，为视图添加CSRF保护装饰器
-        dispatch是类视图的入口方法，所有请求（GET/POST）都会先经过此方法
-        """
-        return super(RegisterView, self).dispatch(*args, **kwargs)
-
-    def form_valid(self, form):
-        """
-        表单数据验证通过后执行的逻辑（用户提交的注册信息合法时）
-        """
-        if form.is_valid():
-            # 1. 创建用户但不立即提交到数据库（commit=False），后续手动设置额外字段
-            user = form.save(False)
-            # 2. 设置用户初始状态：未激活（需邮箱验证后激活）、注册来源为"Register"
-            user.is_active = False
-            user.source = 'Register'
-            # 3. 提交用户数据到数据库
-            user.save(True)
-
-            # 4. 生成邮箱验证链接：包含当前站点域名、验证路径、用户ID、加密签名
-            site = get_current_site().domain  # 获取当前站点域名（如www.example.com）
-            # 双重SHA256加密：使用SECRET_KEY+用户ID生成签名，防止链接被篡改
-            sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
-            # 开发环境（DEBUG=True）下，站点域名替换为本地地址（127.0.0.1:8000）
-            if settings.DEBUG:
-                site = '127.0.0.1:8000'
-            # 获取验证结果页的路径（通过URL名称反向生成）
-            path = reverse('account:result')
-            # 拼接完整的邮箱验证链接
-            url = "http://{site}{path}?type=validation&id={id}&sign={sign}".format(
-                site=site, path=path, id=user.id, sign=sign)
-
-            # 5. 构造验证邮件内容（包含验证链接）
-            content = """
-                            <p>请点击下面链接验证您的邮箱</p>
-
-                            <a href="{url}" rel="bookmark">{url}</a>
-
-                            再次感谢您！
-                            <br />
-                            如果上面链接无法打开，请将此链接复制至浏览器。
-                            {url}
-                            """.format(url=url)
-            # 6. 发送验证邮件到用户注册邮箱
-            send_email(
-                emailto=[user.email],  # 收件人列表
-                title='验证您的电子邮箱',  # 邮件标题
-                content=content  # 邮件HTML内容
-            )
-
-            # 7. 重定向到注册结果页（携带注册成功的类型和用户ID参数）
-            url = reverse('accounts:result') + '?type=register&id=' + str(user.id)
-            return HttpResponseRedirect(url)
-        else:
-            # 表单验证失败（如用户名已存在、邮箱格式错误），重新渲染表单并显示错误信息
-            return self.render_to_response({'form': form})
-
-
-class LogoutView(RedirectView):
-    """
-    处理用户登出的类视图，继承自RedirectView（专门处理重定向的视图基类）
-    功能：执行登出逻辑、删除侧边栏缓存、重定向到登录页
-    """
-    url = '/login/'  # 登出后默认重定向的目标路径（登录页）
-
-    @method_decorator(never_cache)
-    def dispatch(self, request, *args, **kwargs):
-        """
-        重写dispatch方法，添加禁止缓存装饰器
-        避免浏览器缓存登出页面，防止用户后退到已登出的页面
-        """
-        return super(LogoutView, self).dispatch(request, *args, **kwargs)
-
-    def get(self, request, *args, **kwargs):
-        """
-        处理GET请求（用户访问登出URL时）
-        """
-        # 1. 执行Django内置的登出函数，清除用户的session信息
-        logout(request)
-        # 2. 删除侧边栏缓存（可能存储了用户相关信息，登出后需更新）
-        delete_sidebar_cache()
-        # 3. 调用父类的get方法，执行重定向到登录页
-        return super(LogoutView, self).get(request, *args, **kwargs)
-
-
-class LoginView(FormView):
-    """
-    处理用户登录的类视图，继承自FormView
-    功能：展示登录表单、验证登录信息、处理"记住我"功能、重定向到目标页面
-    """
-    form_class = LoginForm  # 关联的表单类：自定义的LoginForm
-    template_name = 'account/login.html'  # 渲染的登录模板路径
-    success_url = '/'  # 登录成功后的默认重定向路径（网站根目录）
-    redirect_field_name = REDIRECT_FIELD_NAME  # 重定向参数名（默认是"next"）
-    login_ttl = 2626560  # 记住登录状态的有效期（秒），约等于一个月
-
-    @method_decorator(sensitive_post_parameters('password'))
-    @method_decorator(csrf_protect)
-    @method_decorator(never_cache)
-    def dispatch(self, request, *args, **kwargs):
-        """
-        重写dispatch方法，添加三个装饰器：
-        1. sensitive_post_parameters('password')：保护密码参数，不在错误日志中显示
-        2. csrf_protect：开启CSRF保护，防止跨站请求伪造
-        3. never_cache：禁止缓存登录页面，确保每次访问都是最新状态
-        """
-        return super(LoginView, self).dispatch(request, *args, **kwargs)
-
-    def get_context_data(self, **kwargs):
-        """
-        扩展上下文数据，将重定向地址（next参数）传递到模板中
-        模板中可根据该参数决定登录成功后跳转到哪里
-        """
-        # 从GET请求中获取重定向地址（如访问需要登录的页面时，会携带next参数）
-        redirect_to = self.request.GET.get(self.redirect_field_name)
-        # 如果没有重定向地址，默认设置为网站根目录
-        if redirect_to is None:
-            redirect_to = '/'
-        # 将重定向地址添加到上下文
-        kwargs['redirect_to'] = redirect_to
-        # 调用父类方法，返回完整的上下文数据
-        return super(LoginView, self).get_context_data(**kwargs)
-
-    def form_valid(self, form):
-        """
-        表单数据验证通过后执行的逻辑（用户提交的登录信息合法时）
-        注意：此处重新初始化了AuthenticationForm，用于Django内置的登录验证
-        """
-        # 用请求的POST数据和request对象初始化Django内置的认证表单
-        form = AuthenticationForm(data=self.request.POST, request=self.request)
-
-        if form.is_valid():
-            # 1. 登录成功，删除侧边栏缓存（可能存储了未登录状态的内容）
-            delete_sidebar_cache()
-            # 2. 记录重定向参数名到日志（用于调试）
-            logger.info(self.redirect_field_name)
-
-            # 3. 执行Django内置的登录函数，将用户信息存入session
-            auth.login(self.request, form.get_user())
-            # 4. 处理"记住我"功能：如果用户勾选了"remember"，设置session有效期
-            if self.request.POST.get("remember"):
-                self.request.session.set_expiry(self.login_ttl)
-            # 5. 调用父类的form_valid方法，执行重定向到成功页面
-            return super(LoginView, self).form_valid(form)
-        else:
-            # 表单验证失败（如用户名不存在、密码错误），重新渲染表单并显示错误
-            return self.render_to_response({'form': form})
-
-    def get_success_url(self):
-        """
-        自定义登录成功后的重定向地址
-        优先使用POST请求中的"next"参数（如果合法），否则使用默认的success_url
-        """
-        # 从POST请求中获取重定向地址（用户登录时提交的next参数）
-        redirect_to = self.request.POST.get(self.redirect_field_name)
-        # 验证重定向地址是否安全（是否属于当前站点，防止恶意重定向）
-        if not url_has_allowed_host_and_scheme(
-                url=redirect_to, allowed_hosts=[self.request.get_host()]):
-            # 不安全的地址，使用默认的成功重定向路径
-            redirect_to = self.success_url
-        return redirect_to
-
-
-def account_result(request):
-    """
-    处理账户操作结果的函数视图（注册成功提示、邮箱验证结果）
-    功能：根据URL参数（type和id）展示不同的结果信息，激活用户邮箱
-    """
-    # 从GET请求中获取操作类型（register/validation）和用户ID
-    type = request.GET.get('type')
-    id = request.GET.get('id')
-
-    # 根据用户ID查询用户，不存在则返回404页面
-    user = get_object_or_404(get_user_model(), id=id)
-    # 记录操作类型到日志
-    logger.info(type)
-
-    # 如果用户已激活（is_active=True），直接重定向到根目录（无需再展示结果）
-    if user.is_active:
-        return HttpResponseRedirect('/')
-
-    # 如果操作类型合法（属于register或validation），处理对应的逻辑
-    if type and type in ['register', 'validation']:
-        if type == 'register':
-            # 1. 注册成功场景：展示注册成功提示，告知用户验证邮件已发送
-            content = '''
-    恭喜您注册成功，一封验证邮件已经发送到您的邮箱，请验证您的邮箱后登录本站。
-    '''
-            title = '注册成功'
-        else:
-            # 2. 邮箱验证场景：验证签名是否合法，合法则激活用户
-            # 重新生成签名（用于与请求中的sign参数对比）
-            c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
-            # 从GET请求中获取签名参数
-            sign = request.GET.get('sign')
-            # 如果签名不匹配（链接被篡改），返回403禁止访问
-            if sign != c_sign:
-                return HttpResponseForbidden()
-            # 签名匹配，激活用户（设置is_active=True）并保存
-            user.is_active = True
-            user.save()
-            # 展示验证成功提示
-            content = '''
-            恭喜您已经成功的完成邮箱验证，您现在可以使用您的账号来登录本站。
-            '''
-            title = '验证成功'
-        # 渲染结果页面，传递标题和内容
-        return render(request, 'account/result.html', {
-            'title': title,
-            'content': content
-        })
-    else:
-        # 操作类型不合法，重定向到根目录
-        return HttpResponseRedirect('/')
-
-
-class ForgetPasswordView(FormView):
-    """
-    处理忘记密码的类视图，继承自FormView
-    功能：展示忘记密码表单、验证表单数据（验证码、邮箱、密码）、更新用户密码
-    """
-    form_class = ForgetPasswordForm  # 关联的表单类：自定义的ForgetPasswordForm
-    template_name = 'account/forget_password.html'  # 渲染的忘记密码模板路径
-
-    def form_valid(self, form):
-        """
-        表单数据验证通过后执行的逻辑（验证码、邮箱、密码均合法时）
-        """
-        if form.is_valid():
-            # 1. 根据表单中的邮箱查询对应的用户
-            blog_user = BlogUser.objects.filter(email=form.cleaned_data.get("email")).get()
-            # 2. 用新密码（加密处理）更新用户密码
-            blog_user.password = make_password(form.cleaned_data["new_password2"])
-            # 3. 保存密码更新结果到数据库
-            blog_user.save()
-            # 4. 重定向到登录页（密码重置成功后需重新登录）
-            return HttpResponseRedirect('/login/')
-        else:
-            # 表单验证失败（如验证码错误、密码不一致），重新渲染表单并显示错误
-            return self.render_to_response({'form': form})
-
-
-class ForgetPasswordEmailCode(View):
-    """
-    处理发送忘记密码验证码的类视图，继承自基础View类
-    功能：接收邮箱、验证邮箱格式、生成验证码、发送验证邮件、存储验证码到缓存
-    """
-
-    def post(self, request: HttpRequest):
-        """
-        处理POST请求（用户提交邮箱以获取验证码时）
-        """
-        # 1. 用请求的POST数据初始化验证码表单
-        form = ForgetPasswordCodeForm(request.POST)
-        # 2. 验证表单（主要验证邮箱格式是否合法）
-        if not form.is_valid():
-            # 表单验证失败（邮箱格式错误），返回"错误的邮箱"响应
-            return HttpResponse("错误的邮箱")
-
-        # 3. 表单验证通过，获取清洗后的邮箱地址
-        to_email = form.cleaned_data["email"]
-
-        # 4. 生成随机验证码
-        code = generate_code()
-        # 5. 发送验证码邮件到用户邮箱（调用utils中的send_verify_email函数）
-        utils.send_verify_email(to_email, code)
-        # 6. 将验证码存储到缓存（关联邮箱，设置有效期）
-        utils.set_code(to_email, code)
-
-        # 7. 发送成功，返回"ok"响应
-        return HttpResponse("ok")

src/代码注释/blog/admin.py

@@ -1,204 +0,0 @@
-# 导入Django表单模块，用于创建自定义表单
-from django import forms
-# 导入Django admin模块，用于配置后台管理界面
-from django.contrib import admin
-# 导入Django用户模型获取工具，兼容自定义用户模型场景
-from django.contrib.auth import get_user_model
-# 导入Django URL反向解析模块，用于生成后台管理页面的链接
-from django.urls import reverse
-# 导入Django HTML格式化工具，用于在后台显示自定义HTML内容（如链接）
-from django.utils.html import format_html
-# 导入Django国际化翻译工具，用于实现后台文字的多语言支持
-from django.utils.translation import gettext_lazy  as _
-
-# 注册自定义模型到admin后台的标识注释（固定写法）
-# Register your models here.
-# 从当前应用的models.py文件中导入Article模型（文章模型）
-from .models import Article
-
-
-# 自定义Article模型的列表页过滤器，继承自Django内置的SimpleListFilter
-class ArticleListFilter(admin.SimpleListFilter):
-    # 过滤器在后台页面显示的标题（支持国际化），这里是“作者”
-    title = _("author")
-    # 过滤器对应的URL参数名，用于URL中传递过滤条件（如?author=1）
-    parameter_name = 'author'
-
-    # 定义过滤器的选项列表，返回（值, 显示文本）格式的元组
-    def lookups(self, request, model_admin):
-        # 1. 从Article模型中获取所有文章的作者，用set去重（避免同一作者多次出现）
-        # 2. 转换为list便于遍历，map函数提取每篇文章的author字段
-        authors = list(set(map(lambda x: x.author, Article.objects.all())))
-        # 遍历去重后的作者列表，生成过滤器选项
-        for author in authors:
-            # 选项值为作者ID（用于数据库查询），显示文本为作者用户名（支持国际化）
-            yield (author.id, _(author.username))
-
-    # 根据过滤器选择的参数，过滤文章查询集（queryset）
-    def queryset(self, request, queryset):
-        # 获取当前过滤器选中的参数值（即作者ID）
-        id = self.value()
-        # 如果有选中的作者ID，返回该作者的所有文章
-        if id:
-            return queryset.filter(author__id__exact=id)
-        # 如果未选中任何作者，返回全部文章查询集
-        else:
-            return queryset
-
-
-# 自定义Article模型的表单类，继承自Django内置的ModelForm
-class ArticleForm(forms.ModelForm):
-    # 注释：此处原本计划使用AdminPagedownWidget富文本编辑器渲染body字段，暂未启用
-    # body = forms.CharField(widget=AdminPagedownWidget())
-
-    # 表单元数据配置类，用于关联模型与字段
-    class Meta:
-        # 关联的模型为Article（表示该表单用于操作Article模型数据）
-        model = Article
-        # 表单包含模型的所有字段（__all__为通配符，也可指定具体字段列表）
-        fields = '__all__'
-
-
-# 自定义批量操作函数：将选中的文章状态设为“已发布”（假设status='p'代表发布）
-def makr_article_publish(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将status字段设为'p'
-    queryset.update(status='p')
-
-
-# 自定义批量操作函数：将选中的文章状态设为“草稿”（假设status='d'代表草稿）
-def draft_article(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将status字段设为'd'
-    queryset.update(status='d')
-
-
-# 自定义批量操作函数：关闭选中文章的评论功能（假设comment_status='c'代表关闭）
-def close_article_commentstatus(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将comment_status字段设为'c'
-    queryset.update(comment_status='c')
-
-
-# 自定义批量操作函数：开启选中文章的评论功能（假设comment_status='o'代表开启）
-def open_article_commentstatus(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将comment_status字段设为'o'
-    queryset.update(comment_status='o')
-
-
-# 为批量操作函数设置后台显示名称（支持国际化），显示在“动作”下拉菜单中
-makr_article_publish.short_description = _('Publish selected articles')  # “发布选中的文章”
-draft_article.short_description = _('Draft selected articles')  # “将选中的文章设为草稿”
-close_article_commentstatus.short_description = _('Close article comments')  # “关闭选中文章的评论”
-open_article_commentstatus.short_description = _('Open article comments')  # “开启选中文章的评论”
-
-
-# 自定义Article模型的Admin配置类，继承自Django内置的ModelAdmin
-class ArticlelAdmin(admin.ModelAdmin):
-    # 后台列表页每页显示的文章数量，这里是20条/页
-    list_per_page = 20
-    # 后台列表页的搜索框配置，支持搜索文章的“内容（body）”和“标题（title）”字段
-    search_fields = ('body', 'title')
-    # 后台添加/编辑文章时使用的自定义表单，即上面定义的ArticleForm
-    form = ArticleForm
-    # 后台列表页显示的字段列表，按顺序展示
-    list_display = (
-        'id',  # 文章ID
-        'title',  # 文章标题
-        'author',  # 文章作者
-        'link_to_category',  # 自定义字段：文章分类（带跳转链接）
-        'creation_time',  # 文章创建时间
-        'views',  # 文章浏览量
-        'status',  # 文章状态（发布/草稿等）
-        'type',  # 文章类型（如原创/转载等，需在Article模型中定义）
-        'article_order'  # 文章排序权重（用于自定义排序）
-    )
-    # 后台列表页中，点击哪些字段可以跳转到文章编辑页
-    list_display_links = ('id', 'title')
-    # 后台列表页的过滤器配置，包含自定义的作者过滤器和内置字段过滤器
-    list_filter = (ArticleListFilter, 'status', 'type', 'category', 'tags')
-    # 多对多字段（tags标签）的编辑界面样式，使用水平选择框（默认是垂直）
-    filter_horizontal = ('tags',)
-    # 后台添加/编辑文章时，隐藏的字段（不允许管理员手动修改）
-    exclude = ('creation_time', 'last_modify_time')
-    # 是否显示“在站点上查看”按钮（跳转到文章的前台页面）
-    view_on_site = True
-    # 后台列表页的批量操作功能列表，关联上面定义的4个批量操作函数
-    actions = [
-        makr_article_publish,
-        draft_article,
-        close_article_commentstatus,
-        open_article_commentstatus]
-
-    # 自定义列表页字段：显示文章分类，并添加跳转到分类编辑页的链接
-    def link_to_category(self, obj):
-        # 1. 获取文章分类（obj.category）的模型元数据（应用名、模型名）
-        # 2. 用于生成admin后台分类编辑页的URL
-        info = (obj.category._meta.app_label, obj.category._meta.model_name)
-        # 3. 反向解析分类编辑页的URL，参数为分类ID（obj.category.id）
-        link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,))
-        # 4. 生成HTML链接，显示分类名称，点击跳转到分类编辑页
-        return format_html(u'<a href="%s">%s</a>' % (link, obj.category.name))
-
-    # 自定义字段“link_to_category”在后台列表页的显示标题（支持国际化）
-    link_to_category.short_description = _('category')
-
-    # 重写获取表单的方法，自定义作者字段（author）的可选值
-    def get_form(self, request, obj=None, **kwargs):
-        # 1. 先调用父类的get_form方法，获取默认表单
-        form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs)
-        # 2. 限制作者字段的可选范围：仅显示超级用户（is_superuser=True）
-        form.base_fields['author'].queryset = get_user_model(
-        ).objects.filter(is_superuser=True)
-        # 3. 返回修改后的表单
-        return form
-
-    # 重写保存模型的方法（此处未修改逻辑，仅保留父类功能，便于后续扩展）
-    def save_model(self, request, obj, form, change):
-        # 调用父类的save_model方法，完成默认的保存逻辑（如更新时间、权限验证等）
-        super(ArticlelAdmin, self).save_model(request, obj, form, change)
-
-    # 重写“在站点上查看”的链接地址，跳转到文章的前台完整URL
-    def get_view_on_site_url(self, obj=None):
-        # 如果有具体的文章对象（obj不为空），调用文章模型的get_full_url方法获取前台URL
-        if obj:
-            url = obj.get_full_url()
-            return url
-        # 如果没有文章对象（如在列表页顶部的“查看站点”按钮），返回当前站点的域名
-        else:
-            # 从自定义工具模块导入获取当前站点的函数（需确保djangoblog.utils存在）
-            from djangoblog.utils import get_current_site
-            # 获取当前站点的域名（如www.example.com）
-            site = get_current_site().domain
-            return site
-
-
-# 自定义Tag模型（标签模型）的Admin配置类（假设Tag模型在models.py中定义）
-class TagAdmin(admin.ModelAdmin):
-    # 后台添加/编辑标签时，隐藏的字段（不允许手动修改）
-    exclude = ('slug', 'last_mod_time', 'creation_time')
-
-
-# 自定义Category模型（分类模型）的Admin配置类（假设Category模型在models.py中定义）
-class CategoryAdmin(admin.ModelAdmin):
-    # 后台分类列表页显示的字段：分类名称、父分类、排序索引
-    list_display = ('name', 'parent_category', 'index')
-    # 后台添加/编辑分类时，隐藏的字段（不允许手动修改）
-    exclude = ('slug', 'last_mod_time', 'creation_time')
-
-
-# 自定义Links模型（友情链接模型）的Admin配置类（假设Links模型在models.py中定义）
-class LinksAdmin(admin.ModelAdmin):
-    # 后台添加/编辑友情链接时，隐藏的字段（不允许手动修改）
-    exclude = ('last_mod_time', 'creation_time')
-
-
-# 自定义SideBar模型（侧边栏模型）的Admin配置类（假设SideBar模型在models.py中定义）
-class SideBarAdmin(admin.ModelAdmin):
-    # 后台侧边栏列表页显示的字段：名称、内容、是否启用、排序序号
-    list_display = ('name', 'content', 'is_enable', 'sequence')
-    # 后台添加/编辑侧边栏时，隐藏的字段（不允许手动修改）
-    exclude = ('last_mod_time', 'creation_time')
-
-
-# 自定义BlogSettings模型（博客设置模型）的Admin配置类（假设BlogSettings模型在models.py中定义）
-class BlogSettingsAdmin(admin.ModelAdmin):
-    # 空配置，使用ModelAdmin的默认功能（如需自定义可后续添加字段）
-    pass

src/代码注释/blog/apps.py

@@ -1,9 +0,0 @@
-# 导入Django的AppConfig类，该类用于定义单个Django应用的配置信息
-from django.apps import AppConfig
-
-
-# 定义当前应用（blog）的配置类，继承自Django提供的AppConfig基类
-class BlogConfig(AppConfig):
-    # 配置当前应用的唯一标识名称（即应用目录名），Django通过该名称识别和管理应用
-    # 这里'blog'表示当前配置对应的是名为'blog'的Django应用
-    name = 'blog'

src/代码注释/blog/context_processors.py

@@ -1,204 +0,0 @@
-# 导入Django表单模块，用于创建自定义表单
-from django import forms
-# 导入Django admin模块，用于配置后台管理界面
-from django.contrib import admin
-# 导入Django用户模型获取工具，兼容自定义用户模型场景
-from django.contrib.auth import get_user_model
-# 导入Django URL反向解析模块，用于生成后台管理页面的链接
-from django.urls import reverse
-# 导入Django HTML格式化工具，用于在后台显示自定义HTML内容（如链接）
-from django.utils.html import format_html
-# 导入Django国际化翻译工具，用于实现后台文字的多语言支持
-from django.utils.translation import gettext_lazy  as _
-
-# 注册自定义模型到admin后台的标识注释（固定写法）
-# Register your models here.
-# 从当前应用的models.py文件中导入Article模型（文章模型）
-from .models import Article
-
-
-# 自定义Article模型的列表页过滤器，继承自Django内置的SimpleListFilter
-class ArticleListFilter(admin.SimpleListFilter):
-    # 过滤器在后台页面显示的标题（支持国际化），这里是“作者”
-    title = _("author")
-    # 过滤器对应的URL参数名，用于URL中传递过滤条件（如?author=1）
-    parameter_name = 'author'
-
-    # 定义过滤器的选项列表，返回（值, 显示文本）格式的元组
-    def lookups(self, request, model_admin):
-        # 1. 从Article模型中获取所有文章的作者，用set去重（避免同一作者多次出现）
-        # 2. 转换为list便于遍历，map函数提取每篇文章的author字段
-        authors = list(set(map(lambda x: x.author, Article.objects.all())))
-        # 遍历去重后的作者列表，生成过滤器选项
-        for author in authors:
-            # 选项值为作者ID（用于数据库查询），显示文本为作者用户名（支持国际化）
-            yield (author.id, _(author.username))
-
-    # 根据过滤器选择的参数，过滤文章查询集（queryset）
-    def queryset(self, request, queryset):
-        # 获取当前过滤器选中的参数值（即作者ID）
-        id = self.value()
-        # 如果有选中的作者ID，返回该作者的所有文章
-        if id:
-            return queryset.filter(author__id__exact=id)
-        # 如果未选中任何作者，返回全部文章查询集
-        else:
-            return queryset
-
-
-# 自定义Article模型的表单类，继承自Django内置的ModelForm
-class ArticleForm(forms.ModelForm):
-    # 注释：此处原本计划使用AdminPagedownWidget富文本编辑器渲染body字段，暂未启用
-    # body = forms.CharField(widget=AdminPagedownWidget())
-
-    # 表单元数据配置类，用于关联模型与字段
-    class Meta:
-        # 关联的模型为Article（表示该表单用于操作Article模型数据）
-        model = Article
-        # 表单包含模型的所有字段（__all__为通配符，也可指定具体字段列表）
-        fields = '__all__'
-
-
-# 自定义批量操作函数：将选中的文章状态设为“已发布”（假设status='p'代表发布）
-def makr_article_publish(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将status字段设为'p'
-    queryset.update(status='p')
-
-
-# 自定义批量操作函数：将选中的文章状态设为“草稿”（假设status='d'代表草稿）
-def draft_article(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将status字段设为'd'
-    queryset.update(status='d')
-
-
-# 自定义批量操作函数：关闭选中文章的评论功能（假设comment_status='c'代表关闭）
-def close_article_commentstatus(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将comment_status字段设为'c'
-    queryset.update(comment_status='c')
-
-
-# 自定义批量操作函数：开启选中文章的评论功能（假设comment_status='o'代表开启）
-def open_article_commentstatus(modeladmin, request, queryset):
-    # 批量更新选中的文章查询集，将comment_status字段设为'o'
-    queryset.update(comment_status='o')
-
-
-# 为批量操作函数设置后台显示名称（支持国际化），显示在“动作”下拉菜单中
-makr_article_publish.short_description = _('Publish selected articles')  # “发布选中的文章”
-draft_article.short_description = _('Draft selected articles')  # “将选中的文章设为草稿”
-close_article_commentstatus.short_description = _('Close article comments')  # “关闭选中文章的评论”
-open_article_commentstatus.short_description = _('Open article comments')  # “开启选中文章的评论”
-
-
-# 自定义Article模型的Admin配置类，继承自Django内置的ModelAdmin
-class ArticlelAdmin(admin.ModelAdmin):
-    # 后台列表页每页显示的文章数量，这里是20条/页
-    list_per_page = 20
-    # 后台列表页的搜索框配置，支持搜索文章的“内容（body）”和“标题（title）”字段
-    search_fields = ('body', 'title')
-    # 后台添加/编辑文章时使用的自定义表单，即上面定义的ArticleForm
-    form = ArticleForm
-    # 后台列表页显示的字段列表，按顺序展示
-    list_display = (
-        'id',  # 文章ID
-        'title',  # 文章标题
-        'author',  # 文章作者
-        'link_to_category',  # 自定义字段：文章分类（带跳转链接）
-        'creation_time',  # 文章创建时间
-        'views',  # 文章浏览量
-        'status',  # 文章状态（发布/草稿等）
-        'type',  # 文章类型（如原创/转载等，需在Article模型中定义）
-        'article_order'  # 文章排序权重（用于自定义排序）
-    )
-    # 后台列表页中，点击哪些字段可以跳转到文章编辑页
-    list_display_links = ('id', 'title')
-    # 后台列表页的过滤器配置，包含自定义的作者过滤器和内置字段过滤器
-    list_filter = (ArticleListFilter, 'status', 'type', 'category', 'tags')
-    # 多对多字段（tags标签）的编辑界面样式，使用水平选择框（默认是垂直）
-    filter_horizontal = ('tags',)
-    # 后台添加/编辑文章时，隐藏的字段（不允许管理员手动修改）
-    exclude = ('creation_time', 'last_modify_time')
-    # 是否显示“在站点上查看”按钮（跳转到文章的前台页面）
-    view_on_site = True
-    # 后台列表页的批量操作功能列表，关联上面定义的4个批量操作函数
-    actions = [
-        makr_article_publish,
-        draft_article,
-        close_article_commentstatus,
-        open_article_commentstatus]
-
-    # 自定义列表页字段：显示文章分类，并添加跳转到分类编辑页的链接
-    def link_to_category(self, obj):
-        # 1. 获取文章分类（obj.category）的模型元数据（应用名、模型名）
-        # 2. 用于生成admin后台分类编辑页的URL
-        info = (obj.category._meta.app_label, obj.category._meta.model_name)
-        # 3. 反向解析分类编辑页的URL，参数为分类ID（obj.category.id）
-        link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,))
-        # 4. 生成HTML链接，显示分类名称，点击跳转到分类编辑页
-        return format_html(u'<a href="%s">%s</a>' % (link, obj.category.name))
-
-    # 自定义字段“link_to_category”在后台列表页的显示标题（支持国际化）
-    link_to_category.short_description = _('category')
-
-    # 重写获取表单的方法，自定义作者字段（author）的可选值
-    def get_form(self, request, obj=None, **kwargs):
-        # 1. 先调用父类的get_form方法，获取默认表单
-        form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs)
-        # 2. 限制作者字段的可选范围：仅显示超级用户（is_superuser=True）
-        form.base_fields['author'].queryset = get_user_model(
-        ).objects.filter(is_superuser=True)
-        # 3. 返回修改后的表单
-        return form
-
-    # 重写保存模型的方法（此处未修改逻辑，仅保留父类功能，便于后续扩展）
-    def save_model(self, request, obj, form, change):
-        # 调用父类的save_model方法，完成默认的保存逻辑（如更新时间、权限验证等）
-        super(ArticlelAdmin, self).save_model(request, obj, form, change)
-
-    # 重写“在站点上查看”的链接地址，跳转到文章的前台完整URL
-    def get_view_on_site_url(self, obj=None):
-        # 如果有具体的文章对象（obj不为空），调用文章模型的get_full_url方法获取前台URL
-        if obj:
-            url = obj.get_full_url()
-            return url
-        # 如果没有文章对象（如在列表页顶部的“查看站点”按钮），返回当前站点的域名
-        else:
-            # 从自定义工具模块导入获取当前站点的函数（需确保djangoblog.utils存在）
-            from djangoblog.utils import get_current_site
-            # 获取当前站点的域名（如www.example.com）
-            site = get_current_site().domain
-            return site
-
-
-# 自定义Tag模型（标签模型）的Admin配置类（假设Tag模型在models.py中定义）
-class TagAdmin(admin.ModelAdmin):
-    # 后台添加/编辑标签时，隐藏的字段（不允许手动修改）
-    exclude = ('slug', 'last_mod_time', 'creation_time')
-
-
-# 自定义Category模型（分类模型）的Admin配置类（假设Category模型在models.py中定义）
-class CategoryAdmin(admin.ModelAdmin):
-    # 后台分类列表页显示的字段：分类名称、父分类、排序索引
-    list_display = ('name', 'parent_category', 'index')
-    # 后台添加/编辑分类时，隐藏的字段（不允许手动修改）
-    exclude = ('slug', 'last_mod_time', 'creation_time')
-
-
-# 自定义Links模型（友情链接模型）的Admin配置类（假设Links模型在models.py中定义）
-class LinksAdmin(admin.ModelAdmin):
-    # 后台添加/编辑友情链接时，隐藏的字段（不允许手动修改）
-    exclude = ('last_mod_time', 'creation_time')
-
-
-# 自定义SideBar模型（侧边栏模型）的Admin配置类（假设SideBar模型在models.py中定义）
-class SideBarAdmin(admin.ModelAdmin):
-    # 后台侧边栏列表页显示的字段：名称、内容、是否启用、排序序号
-    list_display = ('name', 'content', 'is_enable', 'sequence')
-    # 后台添加/编辑侧边栏时，隐藏的字段（不允许手动修改）
-    exclude = ('last_mod_time', 'creation_time')
-
-
-# 自定义BlogSettings模型（博客设置模型）的Admin配置类（假设BlogSettings模型在models.py中定义）
-class BlogSettingsAdmin(admin.ModelAdmin):
-    # 空配置，使用ModelAdmin的默认功能（如需自定义可后续添加字段）
-    pass

src/代码注释/blog/documents.py

@@ -1,277 +0,0 @@
-# 导入Python内置time模块，用于生成唯一ID（时间戳毫秒级）
-import time
-
-# 导入Elasticsearch客户端模块，用于直接操作Elasticsearch服务（如创建管道、删除索引）
-import elasticsearch.client
-# 导入Django配置模块，用于读取项目中的Elasticsearch配置（settings.py中）
-from django.conf import settings
-# 从elasticsearch-dsl库导入核心组件：
-# Document：Elasticsearch文档模型基类（类似Django的Model）
-# InnerDoc：嵌套文档基类（用于存储结构化子数据，如地理位置、用户代理信息）
-# 字段类型：Date(日期)、Integer(整数)、Long(长整数)、Text(可分词文本)、Object(对象类型)、GeoPoint(地理坐标)、Keyword(不可分词文本)、Boolean(布尔值)
-from elasticsearch_dsl import Document, InnerDoc, Date, Integer, Long, Text, Object, GeoPoint, Keyword, Boolean
-# 导入elasticsearch-dsl的连接管理模块，用于建立与Elasticsearch服务的连接
-from elasticsearch_dsl.connections import connections
-
-# 从当前应用（blog）的models.py导入Article模型，用于将文章数据同步到Elasticsearch
-from blog.models import Article
-
-# 判断项目是否启用Elasticsearch：检查settings.py中是否配置了ELASTICSEARCH_DSL
-ELASTICSEARCH_ENABLED = hasattr(settings, 'ELASTICSEARCH_DSL')
-
-# 如果启用了Elasticsearch，执行以下初始化操作
-if ELASTICSEARCH_ENABLED:
-    # 建立与Elasticsearch服务的连接：从settings中读取配置的主机地址（如['http://localhost:9200']）
-    connections.create_connection(
-        hosts=[settings.ELASTICSEARCH_DSL['default']['hosts']])
-    # 导入Elasticsearch原生客户端，用于执行更底层的操作（如创建索引、删除索引）
-    from elasticsearch import Elasticsearch
-
-    # 初始化Elasticsearch原生客户端，传入服务地址
-    es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
-    # 导入Elasticsearch的IngestClient（数据处理管道客户端），用于创建数据预处理管道
-    from elasticsearch.client import IngestClient
-
-    # 初始化IngestClient，绑定到上面创建的Elasticsearch客户端
-    c = IngestClient(es)
-    try:
-        # 尝试获取名为'geoip'的数据处理管道（用于解析IP地址对应的地理位置）
-        c.get_pipeline('geoip')
-    # 如果管道不存在（捕获NotFoundError异常），则创建该管道
-    except elasticsearch.exceptions.NotFoundError:
-        # 创建'geoip'管道：定义数据处理逻辑，通过geoip处理器解析IP地址
-        c.put_pipeline('geoip', body='''{
-              "description" : "Add geoip info",  // 管道描述：添加地理位置信息
-              "processors" : [                  // 处理器列表：定义数据处理步骤
-                {
-                  "geoip" : {                    // geoip处理器：Elasticsearch内置，用于解析IP
-                    "field" : "ip"               // 待解析的字段：文档中的'ip'字段
-                  }
-                }
-              ]
-            }''')
-
-
-# 定义GeoIp嵌套文档类（InnerDoc）：存储IP地址解析后的地理位置信息
-class GeoIp(InnerDoc):
-    continent_name = Keyword()       # 洲名（Keyword类型：不可分词，适合精确查询/排序）
-    country_iso_code = Keyword()     # 国家ISO代码（如CN、US，Keyword类型）
-    country_name = Keyword()         # 国家名称（Keyword类型）
-    location = GeoPoint()            # 地理坐标（经纬度，GeoPoint类型：支持地理位置查询）
-
-
-# 定义UserAgentBrowser嵌套文档类：存储用户代理（UA）中的浏览器信息
-class UserAgentBrowser(InnerDoc):
-    Family = Keyword()               # 浏览器家族（如Chrome、Firefox，Keyword类型）
-    Version = Keyword()              # 浏览器版本（如120.0，Keyword类型）
-
-
-# 定义UserAgentOS嵌套文档类：存储用户代理中的操作系统信息，继承自UserAgentBrowser（结构一致）
-class UserAgentOS(UserAgentBrowser):
-    pass  # 直接继承父类字段，无需额外定义
-
-
-# 定义UserAgentDevice嵌套文档类：存储用户代理中的设备信息
-class UserAgentDevice(InnerDoc):
-    Family = Keyword()               # 设备家族（如iPhone、Windows，Keyword类型）
-    Brand = Keyword()                # 设备品牌（如Apple、Huawei，Keyword类型）
-    Model = Keyword()                # 设备型号（如iPhone 15，Keyword类型）
-
-
-# 定义UserAgent嵌套文档类：存储完整的用户代理信息（包含浏览器、OS、设备）
-class UserAgent(InnerDoc):
-    browser = Object(UserAgentBrowser, required=False)  # 浏览器信息（Object类型：关联UserAgentBrowser）
-    os = Object(UserAgentOS, required=False)            # 操作系统信息（Object类型：关联UserAgentOS）
-    device = Object(UserAgentDevice, required=False)    # 设备信息（Object类型：关联UserAgentDevice）
-    string = Text()                                     # 完整UA字符串（Text类型：可分词，支持模糊查询）
-    is_bot = Boolean()                                  # 是否为爬虫（Boolean类型：true/false）
-
-
-# 定义ElapsedTimeDocument文档类：Elasticsearch中的"性能监控"文档模型（记录请求耗时、访问信息）
-class ElapsedTimeDocument(Document):
-    url = Keyword()                  # 访问URL（Keyword类型：精确匹配，不分词）
-    time_taken = Long()              # 请求耗时（毫秒，Long类型：支持大范围数值存储）
-    log_datetime = Date()            # 日志记录时间（Date类型：支持时间范围查询）
-    ip = Keyword()                   # 访问IP地址（Keyword类型：精确匹配）
-    geoip = Object(GeoIp, required=False)  # 地理位置信息（Object类型：关联GeoIp嵌套文档，非必填）
-    useragent = Object(UserAgent, required=False)  # 用户代理信息（Object类型：关联UserAgent嵌套文档，非必填）
-
-    # 定义文档对应的Elasticsearch索引配置
-    class Index:
-        name = 'performance'         # 索引名称：Elasticsearch中存储性能数据的索引名
-        settings = {                 # 索引设置
-            "number_of_shards": 1,   # 分片数：1个（小型索引无需多分片）
-            "number_of_replicas": 0  # 副本数：0个（开发/小型场景无需副本，节省资源）
-        }
-
-    # 定义文档元数据（兼容Elasticsearch旧版本，doc_type在7.x后已废弃，此处保留兼容）
-    class Meta:
-        doc_type = 'ElapsedTime'     # 文档类型：标识索引中的文档类别
-
-
-# 定义ElaspedTimeDocumentManager类：ElapsedTimeDocument的管理类（封装索引创建、数据插入等操作）
-class ElaspedTimeDocumentManager:
-    # 静态方法：创建性能监控索引（如果不存在）
-    @staticmethod
-    def build_index():
-        # 导入Elasticsearch原生客户端
-        from elasticsearch import Elasticsearch
-        # 初始化客户端，读取settings中的Elasticsearch地址
-        client = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
-        # 检查名为'performance'的索引是否已存在
-        res = client.indices.exists(index="performance")
-        # 如果索引不存在，初始化ElapsedTimeDocument（创建索引及映射）
-        if not res:
-            ElapsedTimeDocument.init()
-
-    # 静态方法：删除性能监控索引
-    @staticmethod
-    def delete_index():
-        from elasticsearch import Elasticsearch
-        es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
-        # 删除'performance'索引，忽略400（请求错误）和404（索引不存在）异常
-        es.indices.delete(index='performance', ignore=[400, 404])
-
-    # 静态方法：创建性能监控文档（插入一条访问耗时记录）
-    @staticmethod
-    def create(url, time_taken, log_datetime, useragent, ip):
-        # 确保索引已创建（调用build_index方法）
-        ElaspedTimeDocumentManager.build_index()
-        # 初始化UserAgent嵌套文档对象
-        ua = UserAgent()
-        # 赋值浏览器信息：从传入的useragent对象中提取浏览器家族和版本
-        ua.browser = UserAgentBrowser()
-        ua.browser.Family = useragent.browser.family
-        ua.browser.Version = useragent.browser.version_string
-
-        # 赋值操作系统信息：从传入的useragent对象中提取OS家族和版本
-        ua.os = UserAgentOS()
-        ua.os.Family = useragent.os.family
-        ua.os.Version = useragent.os.version_string
-
-        # 赋值设备信息：从传入的useragent对象中提取设备家族、品牌、型号
-        ua.device = UserAgentDevice()
-        ua.device.Family = useragent.device.family
-        ua.device.Brand = useragent.device.brand
-        ua.device.Model = useragent.device.model
-        # 赋值完整UA字符串和是否为爬虫的标识
-        ua.string = useragent.ua_string
-        ua.is_bot = useragent.is_bot
-
-        # 初始化ElapsedTimeDocument文档对象，设置字段值
-        doc = ElapsedTimeDocument(
-            meta={
-                'id': int(round(time.time() * 1000))  # 文档ID：毫秒级时间戳（确保唯一）
-            },
-            url=url,                  # 访问URL
-            time_taken=time_taken,    # 请求耗时（毫秒）
-            log_datetime=log_datetime,# 记录时间
-            useragent=ua,             # 用户代理信息（嵌套文档）
-            ip=ip)                    # 访问IP
-        # 保存文档到Elasticsearch，并指定使用'geoip'管道预处理（解析IP地址）
-        doc.save(pipeline="geoip")
-
-
-# 定义ArticleDocument文档类：Elasticsearch中的"文章"文档模型（用于文章搜索）
-class ArticleDocument(Document):
-    # 文章内容：Text类型，使用ik_max_word分词器（分词更细，适合全文搜索），搜索时用ik_smart（分词更粗，提升效率）
-    body = Text(analyzer='ik_max_word', search_analyzer='ik_smart')
-    # 文章标题：同上，支持中文分词搜索
-    title = Text(analyzer='ik_max_word', search_analyzer='ik_smart')
-    # 作者信息：Object类型，包含昵称（可分词）和ID（整数）
-    author = Object(properties={
-        'nickname': Text(analyzer='ik_max_word', search_analyzer='ik_smart'),
-        'id': Integer()
-    })
-    # 分类信息：Object类型，包含分类名称（可分词）和ID（整数）
-    category = Object(properties={
-        'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'),
-        'id': Integer()
-    })
-    # 标签信息：Object类型（数组），每个标签包含名称（可分词）和ID（整数）
-    tags = Object(properties={
-        'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'),
-        'id': Integer()
-    })
-
-    pub_time = Date()                # 发布时间（Date类型：支持按时间排序/筛选）
-    status = Text()                  # 文章状态（如'p'=发布，'d'=草稿，Text类型）
-    comment_status = Text()          # 评论状态（如'o'=开启，'c'=关闭，Text类型）
-    type = Text()                    # 文章类型（如'p'=页面，'a'=普通文章，Text类型）
-    views = Integer()                # 浏览量（Integer类型：支持数值排序）
-    article_order = Integer()        # 排序权重（Integer类型：用于自定义文章排序）
-
-    # 定义文档对应的Elasticsearch索引配置
-    class Index:
-        name = 'blog'                # 索引名称：存储文章数据的索引名
-        settings = {                 # 索引设置
-            "number_of_shards": 1,   # 分片数：1个（小型博客无需多分片）
-            "number_of_replicas": 0  # 副本数：0个（开发/小型场景节省资源）
-        }
-
-    # 文档元数据（兼容旧版本Elasticsearch的doc_type）
-    class Meta:
-        doc_type = 'Article'         # 文档类型：标识为文章类文档
-
-
-# 定义ArticleDocumentManager类：ArticleDocument的管理类（封装文章索引的创建、重建、更新等操作）
-class ArticleDocumentManager():
-    # 构造方法：实例化管理类时自动创建文章索引（如果不存在）
-    def __init__(self):
-        self.create_index()
-
-    # 实例方法：创建文章索引（调用ArticleDocument的init方法，生成索引和字段映射）
-    def create_index(self):
-        ArticleDocument.init()
-
-    # 实例方法：删除文章索引
-    def delete_index(self):
-        from elasticsearch import Elasticsearch
-        es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
-        # 删除'blog'索引，忽略400和404异常
-        es.indices.delete(index='blog', ignore=[400, 404])
-
-    # 实例方法：将Django的Article模型对象列表转换为Elasticsearch的ArticleDocument列表
-    def convert_to_doc(self, articles):
-        # 列表推导式：遍历每篇文章，构建对应的ArticleDocument
-        return [
-            ArticleDocument(
-                meta={'id': article.id},  # 文档ID与Django Article模型ID一致（便于关联）
-                body=article.body,        # 文章内容
-                title=article.title,      # 文章标题
-                author={                  # 作者信息：从Article模型的author字段提取
-                    'nickname': article.author.username,
-                    'id': article.author.id
-                },
-                category={                # 分类信息：从Article模型的category字段提取
-                    'name': article.category.name,
-                    'id': article.category.id
-                },
-                tags=[                    # 标签信息：遍历Article模型的tags多对多字段，提取每个标签的名称和ID
-                    {'name': t.name, 'id': t.id} for t in article.tags.all()
-                ],
-                pub_time=article.pub_time,          # 发布时间
-                status=article.status,              # 文章状态
-                comment_status=article.comment_status,  # 评论状态
-                type=article.type,                  # 文章类型
-                views=article.views,                # 浏览量
-                article_order=article.article_order  # 排序权重
-            ) for article in articles]
-
-    # 实例方法：重建文章索引（全量同步文章数据到Elasticsearch）
-    def rebuild(self, articles=None):
-        # 确保索引已创建（初始化索引和映射）
-        ArticleDocument.init()
-        # 如果传入了articles参数，则同步指定文章；否则同步所有文章（Article.objects.all()）
-        articles = articles if articles else Article.objects.all()
-        # 将Django Article对象转换为Elasticsearch文档列表
-        docs = self.convert_to_doc(articles)
-        # 遍历文档列表，逐个保存到Elasticsearch
-        for doc in docs:
-            doc.save()
-
-    # 实例方法：批量更新Elasticsearch中的文章文档
-    def update_docs(self, docs):
-        # 遍历文档列表，逐个保存（已存在的文档会执行更新操作）
-        for doc in docs:
-            doc.save()

src/代码注释/blog/forms.py

@@ -1,38 +0,0 @@
-# 导入Python内置logging模块，用于记录搜索相关日志（如搜索关键词）
-import logging
-
-# 导入Django表单基础模块，用于创建自定义表单字段
-from django import forms
-# 从Haystack库导入基础搜索表单类SearchForm，Haystack是Django的搜索引擎集成框架
-from haystack.forms import SearchForm
-
-# 创建日志记录器，日志名称与当前模块一致（__name__），便于定位日志来源（区分其他模块日志）
-logger = logging.getLogger(__name__)
-
-
-# 定义自定义搜索表单类BlogSearchForm，继承自Haystack提供的SearchForm（基础搜索表单）
-# 作用：扩展Haystack默认搜索表单，添加自定义字段和搜索逻辑
-class BlogSearchForm(SearchForm):
-    # 定义搜索输入字段：querydata（搜索关键词字段）
-    # required=True：表示该字段为必填项，用户必须输入关键词才能提交搜索
-    # CharField：单行文本输入框，适合接收搜索关键词
-    querydata = forms.CharField(required=True)
-
-    # 重写父类的search方法，自定义搜索逻辑（保留父类核心功能，添加日志记录）
-    def search(self):
-        # 1. 调用父类（SearchForm）的search方法，执行Haystack默认搜索流程
-        # 父类会自动处理索引查询、关键词匹配等核心逻辑，返回搜索结果集（SearchQuerySet对象）
-        datas = super(BlogSearchForm, self).search()
-
-        # 2. 验证表单数据是否合法（根据字段定义的规则，如required=True）
-        if not self.is_valid():
-            # 若表单数据不合法（如未输入关键词），调用父类的no_query_found方法返回默认空结果
-            return self.no_query_found()
-
-        # 3. 若表单验证通过，获取清理后的搜索关键词（cleaned_data是Django表单验证后的安全数据字典）
-        if self.cleaned_data['querydata']:
-            # 记录搜索日志：将用户输入的关键词写入日志（便于统计热门搜索、排查问题）
-            logger.info(self.cleaned_data['querydata'])
-
-        # 4. 返回搜索结果集（datas），该结果集会传递给搜索结果页面模板进行渲染
-        return datas

src/代码注释/blog/management/commands/build_index.py

@@ -1,18 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from blog.documents import ElapsedTimeDocument, ArticleDocumentManager, ElaspedTimeDocumentManager, \
-    ELASTICSEARCH_ENABLED
-
-
-# TODO 参数化
-class Command(BaseCommand):
-    help = 'build search index'
-
-    def handle(self, *args, **options):
-        if ELASTICSEARCH_ENABLED:
-            ElaspedTimeDocumentManager.build_index()
-            manager = ElapsedTimeDocument()
-            manager.init()
-            manager = ArticleDocumentManager()
-            manager.delete_index()
-            manager.rebuild()

src/代码注释/blog/management/commands/build_search_words.py

@@ -1,13 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from blog.models import Tag, Category
-
-
-# TODO 参数化
-class Command(BaseCommand):
-    help = 'build search words'
-
-    def handle(self, *args, **options):
-        datas = set([t.name for t in Tag.objects.all()] +
-                    [t.name for t in Category.objects.all()])
-        print('\n'.join(datas))

src/代码注释/blog/management/commands/clear_cache.py

@@ -1,11 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from djangoblog.utils import cache
-
-
-class Command(BaseCommand):
-    help = 'clear the whole cache'
-
-    def handle(self, *args, **options):
-        cache.clear()
-        self.stdout.write(self.style.SUCCESS('Cleared cache\n'))

src/代码注释/blog/management/commands/create_testdata.py

@@ -1,40 +0,0 @@
-from django.contrib.auth import get_user_model
-from django.contrib.auth.hashers import make_password
-from django.core.management.base import BaseCommand
-
-from blog.models import Article, Tag, Category
-
-
-class Command(BaseCommand):
-    help = 'create test datas'
-
-    def handle(self, *args, **options):
-        user = get_user_model().objects.get_or_create(
-            email='test@test.com', username='测试用户', password=make_password('test!q@w#eTYU'))[0]
-
-        pcategory = Category.objects.get_or_create(
-            name='我是父类目', parent_category=None)[0]
-
-        category = Category.objects.get_or_create(
-            name='子类目', parent_category=pcategory)[0]
-
-        category.save()
-        basetag = Tag()
-        basetag.name = "标签"
-        basetag.save()
-        for i in range(1, 20):
-            article = Article.objects.get_or_create(
-                category=category,
-                title='nice title ' + str(i),
-                body='nice content ' + str(i),
-                author=user)[0]
-            tag = Tag()
-            tag.name = "标签" + str(i)
-            tag.save()
-            article.tags.add(tag)
-            article.tags.add(basetag)
-            article.save()
-
-        from djangoblog.utils import cache
-        cache.clear()
-        self.stdout.write(self.style.SUCCESS('created test datas \n'))

src/代码注释/blog/management/commands/ping_baidu.py

@@ -1,50 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from djangoblog.spider_notify import SpiderNotify
-from djangoblog.utils import get_current_site
-from blog.models import Article, Tag, Category
-
-site = get_current_site().domain
-
-
-class Command(BaseCommand):
-    help = 'notify baidu url'
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            'data_type',
-            type=str,
-            choices=[
-                'all',
-                'article',
-                'tag',
-                'category'],
-            help='article : all article,tag : all tag,category: all category,all: All of these')
-
-    def get_full_url(self, path):
-        url = "https://{site}{path}".format(site=site, path=path)
-        return url
-
-    def handle(self, *args, **options):
-        type = options['data_type']
-        self.stdout.write('start get %s' % type)
-
-        urls = []
-        if type == 'article' or type == 'all':
-            for article in Article.objects.filter(status='p'):
-                urls.append(article.get_full_url())
-        if type == 'tag' or type == 'all':
-            for tag in Tag.objects.all():
-                url = tag.get_absolute_url()
-                urls.append(self.get_full_url(url))
-        if type == 'category' or type == 'all':
-            for category in Category.objects.all():
-                url = category.get_absolute_url()
-                urls.append(self.get_full_url(url))
-
-        self.stdout.write(
-            self.style.SUCCESS(
-                'start notify %d urls' %
-                len(urls)))
-        SpiderNotify.baidu_notify(urls)
-        self.stdout.write(self.style.SUCCESS('finish notify'))

src/代码注释/blog/management/commands/sync_user_avatar.py

@@ -1,47 +0,0 @@
-import requests
-from django.core.management.base import BaseCommand
-from django.templatetags.static import static
-
-from djangoblog.utils import save_user_avatar
-from oauth.models import OAuthUser
-from oauth.oauthmanager import get_manager_by_type
-
-
-class Command(BaseCommand):
-    help = 'sync user avatar'
-
-    def test_picture(self, url):
-        try:
-            if requests.get(url, timeout=2).status_code == 200:
-                return True
-        except:
-            pass
-
-    def handle(self, *args, **options):
-        static_url = static("../")
-        users = OAuthUser.objects.all()
-        self.stdout.write(f'开始同步{len(users)}个用户头像')
-        for u in users:
-            self.stdout.write(f'开始同步:{u.nickname}')
-            url = u.picture
-            if url:
-                if url.startswith(static_url):
-                    if self.test_picture(url):
-                        continue
-                    else:
-                        if u.metadata:
-                            manage = get_manager_by_type(u.type)
-                            url = manage.get_picture(u.metadata)
-                            url = save_user_avatar(url)
-                        else:
-                            url = static('blog/img/avatar.png')
-                else:
-                    url = save_user_avatar(url)
-            else:
-                url = static('blog/img/avatar.png')
-            if url:
-                self.stdout.write(
-                    f'结束同步:{u.nickname}.url:{url}')
-                u.picture = url
-                u.save()
-        self.stdout.write('结束同步')

src/代码注释/blog/middleware.py

@@ -1,79 +0,0 @@
-# 导入Python内置logging模块，用于记录中间件运行过程中的日志（如错误信息）
-import logging
-# 导入Python内置time模块，用于计算请求处理耗时（页面加载时间）
-import time
-
-# 导入ipware库的get_client_ip函数，用于获取请求客户端的真实IP地址（兼容多种部署场景）
-from ipware import get_client_ip
-# 导入user_agents库的parse函数，用于解析用户代理（UA）字符串，提取浏览器、设备、系统信息
-from user_agents import parse
-
-# 从当前应用的documents模块导入：
-# 1. ELASTICSEARCH_ENABLED：判断项目是否启用Elasticsearch（之前定义的全局变量）
-# 2. ElaspedTimeDocumentManager：性能监控文档管理类（用于将耗时数据存入Elasticsearch）
-from blog.documents import ELASTICSEARCH_ENABLED, ElaspedTimeDocumentManager
-
-# 创建日志记录器，日志名称与当前模块一致（__name__），便于定位日志来源（区分其他模块日志）
-logger = logging.getLogger(__name__)
-
-
-# 定义自定义中间件类OnlineMiddleware，遵循Django中间件接口规范
-# 作用：1. 计算请求处理耗时（页面加载时间）；2. 记录访问IP、设备信息到Elasticsearch；3. 替换页面中的加载时间占位符
-class OnlineMiddleware(object):
-    # 中间件初始化方法，接收get_response参数（Django 1.10+中间件必需参数，代表后续中间件/视图的响应流程）
-    def __init__(self, get_response=None):
-        # 保存get_response到实例属性，后续在__call__方法中调用，确保请求流程继续向下执行
-        self.get_response = get_response
-        # 调用父类（object）的初始化方法，确保基础类功能正常（Python 2/3兼容写法）
-        super().__init__()
-
-    # 中间件核心执行方法，处理每个请求的入口和出口（请求到达时执行前半部分，响应返回时执行后半部分）
-    def __call__(self, request):
-        ''' page render time '''  # 注释：该方法用于计算页面渲染耗时
-        # 记录请求开始时间（时间戳，单位：秒），作为耗时计算的起始点
-        start_time = time.time()
-        # 调用后续中间件/视图函数，获取响应对象（response），此时请求已完成业务处理
-        response = self.get_response(request)
-
-        # 从请求的META信息中获取用户代理（UA）字符串：
-        # HTTP_USER_AGENT是请求头中的字段，包含浏览器、设备、系统等信息，默认值为空字符串
-        http_user_agent = request.META.get('HTTP_USER_AGENT', '')
-        # 调用get_client_ip函数获取客户端真实IP：
-        # 返回值为元组（ip地址, 是否为代理IP），此处仅取IP地址（_忽略代理标记）
-        ip, _ = get_client_ip(request)
-        # 解析UA字符串：调用parse函数将原始UA字符串转换为结构化对象（可通过属性获取浏览器/设备/系统信息）
-        user_agent = parse(http_user_agent)
-
-        # 判断响应是否为非流式响应（流式响应如文件下载，无需处理加载时间和替换占位符）
-        if not response.streaming:
-            try:
-                # 计算请求处理总耗时：当前时间 - 开始时间（单位：秒）
-                cast_time = time.time() - start_time
-                # 如果启用了Elasticsearch，将性能数据存入Elasticsearch
-                if ELASTICSEARCH_ENABLED:
-                    # 耗时转换为毫秒（保留2位小数），更符合性能监控的常用单位
-                    time_taken = round((cast_time) * 1000, 2)
-                    # 获取请求的路径（如"/article/1/"），作为性能记录的URL标识
-                    url = request.path
-                    # 导入Django的timezone模块（延迟导入，避免循环导入问题），用于获取当前时间
-                    from django.utils import timezone
-                    # 调用ElaspedTimeDocumentManager的create方法，插入性能记录到Elasticsearch：
-                    # 包含URL、耗时、记录时间、用户代理信息、IP地址
-                    ElaspedTimeDocumentManager.create(
-                        url=url,
-                        time_taken=time_taken,
-                        log_datetime=timezone.now(),
-                        useragent=user_agent,
-                        ip=ip)
-                # 替换响应内容中的占位符：
-                # 将页面中的'<!!LOAD_TIMES!!>'字符串替换为实际耗时（保留前5个字符，如"0.321"）
-                # 注意：response.content是字节类型，需用str.encode将字符串耗时转换为字节
-                response.content = response.content.replace(
-                    b'<!!LOAD_TIMES!!>', str.encode(str(cast_time)[:5]))
-            # 捕获所有异常，避免中间件报错导致响应失败
-            except Exception as e:
-                # 记录异常日志：将错误信息写入日志，便于后续排查问题（如Elasticsearch连接失败、占位符替换失败）
-                logger.error("Error OnlineMiddleware: %s" % e)
-
-        # 返回处理后的响应对象，最终返回给客户端
-        return response

src/代码注释/blog/migrations/0001_initial.py

@@ -1,137 +0,0 @@
-# Generated by Django 4.1.7 on 2023-03-02 07:14
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-import django.utils.timezone
-import mdeditor.fields
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='BlogSettings',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('sitename', models.CharField(default='', max_length=200, verbose_name='网站名称')),
-                ('site_description', models.TextField(default='', max_length=1000, verbose_name='网站描述')),
-                ('site_seo_description', models.TextField(default='', max_length=1000, verbose_name='网站SEO描述')),
-                ('site_keywords', models.TextField(default='', max_length=1000, verbose_name='网站关键字')),
-                ('article_sub_length', models.IntegerField(default=300, verbose_name='文章摘要长度')),
-                ('sidebar_article_count', models.IntegerField(default=10, verbose_name='侧边栏文章数目')),
-                ('sidebar_comment_count', models.IntegerField(default=5, verbose_name='侧边栏评论数目')),
-                ('article_comment_count', models.IntegerField(default=5, verbose_name='文章页面默认显示评论数目')),
-                ('show_google_adsense', models.BooleanField(default=False, verbose_name='是否显示谷歌广告')),
-                ('google_adsense_codes', models.TextField(blank=True, default='', max_length=2000, null=True, verbose_name='广告内容')),
-                ('open_site_comment', models.BooleanField(default=True, verbose_name='是否打开网站评论功能')),
-                ('beiancode', models.CharField(blank=True, default='', max_length=2000, null=True, verbose_name='备案号')),
-                ('analyticscode', models.TextField(default='', max_length=1000, verbose_name='网站统计代码')),
-                ('show_gongan_code', models.BooleanField(default=False, verbose_name='是否显示公安备案号')),
-                ('gongan_beiancode', models.TextField(blank=True, default='', max_length=2000, null=True, verbose_name='公安备案号')),
-            ],
-            options={
-                'verbose_name': '网站配置',
-                'verbose_name_plural': '网站配置',
-            },
-        ),
-        migrations.CreateModel(
-            name='Links',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=30, unique=True, verbose_name='链接名称')),
-                ('link', models.URLField(verbose_name='链接地址')),
-                ('sequence', models.IntegerField(unique=True, verbose_name='排序')),
-                ('is_enable', models.BooleanField(default=True, verbose_name='是否显示')),
-                ('show_type', models.CharField(choices=[('i', '首页'), ('l', '列表页'), ('p', '文章页面'), ('a', '全站'), ('s', '友情链接页面')], default='i', max_length=1, verbose_name='显示类型')),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-            ],
-            options={
-                'verbose_name': '友情链接',
-                'verbose_name_plural': '友情链接',
-                'ordering': ['sequence'],
-            },
-        ),
-        migrations.CreateModel(
-            name='SideBar',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=100, verbose_name='标题')),
-                ('content', models.TextField(verbose_name='内容')),
-                ('sequence', models.IntegerField(unique=True, verbose_name='排序')),
-                ('is_enable', models.BooleanField(default=True, verbose_name='是否启用')),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-            ],
-            options={
-                'verbose_name': '侧边栏',
-                'verbose_name_plural': '侧边栏',
-                'ordering': ['sequence'],
-            },
-        ),
-        migrations.CreateModel(
-            name='Tag',
-            fields=[
-                ('id', models.AutoField(primary_key=True, serialize=False)),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-                ('name', models.CharField(max_length=30, unique=True, verbose_name='标签名')),
-                ('slug', models.SlugField(blank=True, default='no-slug', max_length=60)),
-            ],
-            options={
-                'verbose_name': '标签',
-                'verbose_name_plural': '标签',
-                'ordering': ['name'],
-            },
-        ),
-        migrations.CreateModel(
-            name='Category',
-            fields=[
-                ('id', models.AutoField(primary_key=True, serialize=False)),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-                ('name', models.CharField(max_length=30, unique=True, verbose_name='分类名')),
-                ('slug', models.SlugField(blank=True, default='no-slug', max_length=60)),
-                ('index', models.IntegerField(default=0, verbose_name='权重排序-越大越靠前')),
-                ('parent_category', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='blog.category', verbose_name='父级分类')),
-            ],
-            options={
-                'verbose_name': '分类',
-                'verbose_name_plural': '分类',
-                'ordering': ['-index'],
-            },
-        ),
-        migrations.CreateModel(
-            name='Article',
-            fields=[
-                ('id', models.AutoField(primary_key=True, serialize=False)),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-                ('title', models.CharField(max_length=200, unique=True, verbose_name='标题')),
-                ('body', mdeditor.fields.MDTextField(verbose_name='正文')),
-                ('pub_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='发布时间')),
-                ('status', models.CharField(choices=[('d', '草稿'), ('p', '发表')], default='p', max_length=1, verbose_name='文章状态')),
-                ('comment_status', models.CharField(choices=[('o', '打开'), ('c', '关闭')], default='o', max_length=1, verbose_name='评论状态')),
-                ('type', models.CharField(choices=[('a', '文章'), ('p', '页面')], default='a', max_length=1, verbose_name='类型')),
-                ('views', models.PositiveIntegerField(default=0, verbose_name='浏览量')),
-                ('article_order', models.IntegerField(default=0, verbose_name='排序,数字越大越靠前')),
-                ('show_toc', models.BooleanField(default=False, verbose_name='是否显示toc目录')),
-                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='作者')),
-                ('category', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='blog.category', verbose_name='分类')),
-                ('tags', models.ManyToManyField(blank=True, to='blog.tag', verbose_name='标签集合')),
-            ],
-            options={
-                'verbose_name': '文章',
-                'verbose_name_plural': '文章',
-                'ordering': ['-article_order', '-pub_time'],
-                'get_latest_by': 'id',
-            },
-        ),
-    ]

src/代码注释/blog/migrations/0002_blogsettings_global_footer_and_more.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.1.7 on 2023-03-29 06:08
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('blog', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='blogsettings',
-            name='global_footer',
-            field=models.TextField(blank=True, default='', null=True, verbose_name='公共尾部'),
-        ),
-        migrations.AddField(
-            model_name='blogsettings',
-            name='global_header',
-            field=models.TextField(blank=True, default='', null=True, verbose_name='公共头部'),
-        ),
-    ]

src/代码注释/blog/migrations/0003_blogsettings_comment_need_review.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.2.1 on 2023-05-09 07:45
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ('blog', '0002_blogsettings_global_footer_and_more'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='blogsettings',
-            name='comment_need_review',
-            field=models.BooleanField(default=False, verbose_name='评论是否需要审核'),
-        ),
-    ]

src/代码注释/blog/migrations/0004_rename_analyticscode_blogsettings_analytics_code_and_more.py

@@ -1,27 +0,0 @@
-# Generated by Django 4.2.1 on 2023-05-09 07:51
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ('blog', '0003_blogsettings_comment_need_review'),
-    ]
-
-    operations = [
-        migrations.RenameField(
-            model_name='blogsettings',
-            old_name='analyticscode',
-            new_name='analytics_code',
-        ),
-        migrations.RenameField(
-            model_name='blogsettings',
-            old_name='beiancode',
-            new_name='beian_code',
-        ),
-        migrations.RenameField(
-            model_name='blogsettings',
-            old_name='sitename',
-            new_name='site_name',
-        ),
-    ]

src/代码注释/blog/migrations/0005_alter_article_options_alter_category_options_and_more.py

@@ -1,300 +0,0 @@
-# Generated by Django 4.2.5 on 2023-09-06 13:13
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-import django.utils.timezone
-import mdeditor.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('blog', '0004_rename_analyticscode_blogsettings_analytics_code_and_more'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='article',
-            options={'get_latest_by': 'id', 'ordering': ['-article_order', '-pub_time'], 'verbose_name': 'article', 'verbose_name_plural': 'article'},
-        ),
-        migrations.AlterModelOptions(
-            name='category',
-            options={'ordering': ['-index'], 'verbose_name': 'category', 'verbose_name_plural': 'category'},
-        ),
-        migrations.AlterModelOptions(
-            name='links',
-            options={'ordering': ['sequence'], 'verbose_name': 'link', 'verbose_name_plural': 'link'},
-        ),
-        migrations.AlterModelOptions(
-            name='sidebar',
-            options={'ordering': ['sequence'], 'verbose_name': 'sidebar', 'verbose_name_plural': 'sidebar'},
-        ),
-        migrations.AlterModelOptions(
-            name='tag',
-            options={'ordering': ['name'], 'verbose_name': 'tag', 'verbose_name_plural': 'tag'},
-        ),
-        migrations.RemoveField(
-            model_name='article',
-            name='created_time',
-        ),
-        migrations.RemoveField(
-            model_name='article',
-            name='last_mod_time',
-        ),
-        migrations.RemoveField(
-            model_name='category',
-            name='created_time',
-        ),
-        migrations.RemoveField(
-            model_name='category',
-            name='last_mod_time',
-        ),
-        migrations.RemoveField(
-            model_name='links',
-            name='created_time',
-        ),
-        migrations.RemoveField(
-            model_name='sidebar',
-            name='created_time',
-        ),
-        migrations.RemoveField(
-            model_name='tag',
-            name='created_time',
-        ),
-        migrations.RemoveField(
-            model_name='tag',
-            name='last_mod_time',
-        ),
-        migrations.AddField(
-            model_name='article',
-            name='creation_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        migrations.AddField(
-            model_name='article',
-            name='last_modify_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='modify time'),
-        ),
-        migrations.AddField(
-            model_name='category',
-            name='creation_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        migrations.AddField(
-            model_name='category',
-            name='last_modify_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='modify time'),
-        ),
-        migrations.AddField(
-            model_name='links',
-            name='creation_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        migrations.AddField(
-            model_name='sidebar',
-            name='creation_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        migrations.AddField(
-            model_name='tag',
-            name='creation_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='creation time'),
-        ),
-        migrations.AddField(
-            model_name='tag',
-            name='last_modify_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='modify time'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='article_order',
-            field=models.IntegerField(default=0, verbose_name='order'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='author',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='author'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='body',
-            field=mdeditor.fields.MDTextField(verbose_name='body'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='category',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='blog.category', verbose_name='category'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='comment_status',
-            field=models.CharField(choices=[('o', 'Open'), ('c', 'Close')], default='o', max_length=1, verbose_name='comment status'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='pub_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='publish time'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='show_toc',
-            field=models.BooleanField(default=False, verbose_name='show toc'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='status',
-            field=models.CharField(choices=[('d', 'Draft'), ('p', 'Published')], default='p', max_length=1, verbose_name='status'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='tags',
-            field=models.ManyToManyField(blank=True, to='blog.tag', verbose_name='tag'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='title',
-            field=models.CharField(max_length=200, unique=True, verbose_name='title'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='type',
-            field=models.CharField(choices=[('a', 'Article'), ('p', 'Page')], default='a', max_length=1, verbose_name='type'),
-        ),
-        migrations.AlterField(
-            model_name='article',
-            name='views',
-            field=models.PositiveIntegerField(default=0, verbose_name='views'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='article_comment_count',
-            field=models.IntegerField(default=5, verbose_name='article comment count'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='article_sub_length',
-            field=models.IntegerField(default=300, verbose_name='article sub length'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='google_adsense_codes',
-            field=models.TextField(blank=True, default='', max_length=2000, null=True, verbose_name='adsense code'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='open_site_comment',
-            field=models.BooleanField(default=True, verbose_name='open site comment'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='show_google_adsense',
-            field=models.BooleanField(default=False, verbose_name='show adsense'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='sidebar_article_count',
-            field=models.IntegerField(default=10, verbose_name='sidebar article count'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='sidebar_comment_count',
-            field=models.IntegerField(default=5, verbose_name='sidebar comment count'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='site_description',
-            field=models.TextField(default='', max_length=1000, verbose_name='site description'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='site_keywords',
-            field=models.TextField(default='', max_length=1000, verbose_name='site keywords'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='site_name',
-            field=models.CharField(default='', max_length=200, verbose_name='site name'),
-        ),
-        migrations.AlterField(
-            model_name='blogsettings',
-            name='site_seo_description',
-            field=models.TextField(default='', max_length=1000, verbose_name='site seo description'),
-        ),
-        migrations.AlterField(
-            model_name='category',
-            name='index',
-            field=models.IntegerField(default=0, verbose_name='index'),
-        ),
-        migrations.AlterField(
-            model_name='category',
-            name='name',
-            field=models.CharField(max_length=30, unique=True, verbose_name='category name'),
-        ),
-        migrations.AlterField(
-            model_name='category',
-            name='parent_category',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='blog.category', verbose_name='parent category'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='is_enable',
-            field=models.BooleanField(default=True, verbose_name='is show'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='last_mod_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='modify time'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='link',
-            field=models.URLField(verbose_name='link'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='name',
-            field=models.CharField(max_length=30, unique=True, verbose_name='link name'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='sequence',
-            field=models.IntegerField(unique=True, verbose_name='order'),
-        ),
-        migrations.AlterField(
-            model_name='links',
-            name='show_type',
-            field=models.CharField(choices=[('i', 'index'), ('l', 'list'), ('p', 'post'), ('a', 'all'), ('s', 'slide')], default='i', max_length=1, verbose_name='show type'),
-        ),
-        migrations.AlterField(
-            model_name='sidebar',
-            name='content',
-            field=models.TextField(verbose_name='content'),
-        ),
-        migrations.AlterField(
-            model_name='sidebar',
-            name='is_enable',
-            field=models.BooleanField(default=True, verbose_name='is enable'),
-        ),
-        migrations.AlterField(
-            model_name='sidebar',
-            name='last_mod_time',
-            field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='modify time'),
-        ),
-        migrations.AlterField(
-            model_name='sidebar',
-            name='name',
-            field=models.CharField(max_length=100, verbose_name='title'),
-        ),
-        migrations.AlterField(
-            model_name='sidebar',
-            name='sequence',
-            field=models.IntegerField(unique=True, verbose_name='order'),
-        ),
-        migrations.AlterField(
-            model_name='tag',
-            name='name',
-            field=models.CharField(max_length=30, unique=True, verbose_name='tag name'),
-        ),
-    ]

src/代码注释/blog/migrations/0006_alter_blogsettings_options.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.2.7 on 2024-01-26 02:41
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('blog', '0005_alter_article_options_alter_category_options_and_more'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='blogsettings',
-            options={'verbose_name': 'Website configuration', 'verbose_name_plural': 'Website configuration'},
-        ),
-    ]

src/代码注释/blog/models.py

@@ -1,515 +0,0 @@
-# 导入Python内置logging模块，用于记录模型操作相关日志（如缓存命中/设置、数据验证错误）
-import logging
-# 从abc模块导入abstractmethod装饰器，用于定义抽象方法（强制子类实现）
-from abc import abstractmethod
-
-# 导入Django配置模块，用于获取项目配置（如AUTH_USER_MODEL）
-from django.conf import settings
-# 导入Django数据验证异常类，用于自定义数据验证逻辑（如博客配置唯一性校验）
-from django.core.exceptions import ValidationError
-# 导入Django模型核心模块，用于定义数据模型（对应数据库表）
-from django.db import models
-# 导入Django URL反向解析模块，用于生成模型的绝对URL
-from django.urls import reverse
-# 导入Django时区工具，用于处理时间字段（确保时间戳一致性）
-from django.utils.timezone import now
-# 导入Django国际化翻译工具，用于模型字段/选项的多语言支持
-from django.utils.translation import gettext_lazy as _
-# 导入MDTextField字段（来自mdeditor库），用于支持Markdown格式的富文本编辑
-from mdeditor.fields import MDTextField
-# 导入uuslug库的slugify函数，用于将中文标题/名称转换为URL友好的slug（如"我的博客"→"wo-de-bo-ke"）
-from uuslug import slugify
-
-# 从自定义工具模块导入缓存相关工具：
-# 1. cache_decorator：缓存装饰器，用于缓存函数返回结果
-# 2. cache：缓存操作对象，用于直接读写缓存
-from djangoblog.utils import cache_decorator, cache
-# 从自定义工具模块导入获取当前站点信息的函数（用于生成完整URL）
-from djangoblog.utils import get_current_site
-
-# 创建日志记录器，日志名称与当前模块一致（__name__），便于定位日志来源
-logger = logging.getLogger(__name__)
-
-
-# 定义链接显示类型枚举类LinkShowType，继承自Django的TextChoices（枚举基类）
-# 作用：规范友情链接的显示位置选项，避免硬编码字符串
-class LinkShowType(models.TextChoices):
-    I = ('i', _('index'))  # 首页显示
-    L = ('l', _('list'))  # 列表页显示
-    P = ('p', _('post'))  # 文章详情页显示
-    A = ('a', _('all'))   # 所有页面显示
-    S = ('s', _('slide')) # 幻灯片区域显示
-
-
-# 定义抽象基础模型类BaseModel，继承自Django的models.Model
-# 作用：封装所有模型共有的字段和方法（如创建时间、修改时间、URL生成），避免代码重复
-# 注：abstract=True（Meta类中）表示该模型为抽象模型，不会生成数据库表，仅用于被子类继承
-class BaseModel(models.Model):
-    # 主键ID：自增整数类型（Django默认主键，此处显式定义以统一规范）
-    id = models.AutoField(primary_key=True)
-    # 创建时间：DateTimeField类型，默认值为当前时间（now()），支持国际化显示（_('creation time')）
-    creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间：DateTimeField类型，默认值为当前时间，用于记录数据更新时间
-    last_modify_time = models.DateTimeField(_('modify time'), default=now)
-
-    # 重写save方法，扩展保存逻辑（处理slug生成和浏览量更新优化）
-    def save(self, *args, **kwargs):
-        # 判断是否为Article模型的浏览量更新操作：
-        # 1. 实例是Article类的实例
-        # 2. save方法传入了update_fields参数
-        # 3. 仅更新views字段（浏览量）
-        is_update_views = isinstance(
-            self,
-            Article) and 'update_fields' in kwargs and kwargs['update_fields'] == ['views']
-        # 如果是浏览量单独更新，直接执行SQL更新（避免触发完整save流程，提升性能）
-        if is_update_views:
-            Article.objects.filter(pk=self.pk).update(views=self.views)
-        # 非浏览量更新场景，执行正常保存逻辑
-        else:
-            # 判断当前模型是否有slug字段（需要生成URL友好标识的模型，如Category、Tag）
-            if 'slug' in self.__dict__:
-                # 确定slug的生成源：优先取title字段（如Article），无则取name字段（如Category、Tag）
-                slug = getattr(
-                    self, 'title') if 'title' in self.__dict__ else getattr(
-                    self, 'name')
-                # 调用slugify函数生成slug，并赋值给当前实例的slug字段
-                setattr(self, 'slug', slugify(slug))
-            # 调用父类的save方法，完成数据入库（必须调用，否则数据不会保存）
-            super().save(*args, **kwargs)
-
-    # 生成模型实例的完整URL（含域名），用于前端跳转、SEO等场景
-    def get_full_url(self):
-        # 获取当前站点的域名（如"www.example.com"，通过get_current_site工具函数）
-        site = get_current_site().domain
-        # 拼接完整URL：协议（默认https）+ 域名 + 实例的相对URL（通过get_absolute_url获取）
-        url = "https://{site}{path}".format(site=site,
-                                            path=self.get_absolute_url())
-        return url
-
-    # 模型元数据配置
-    class Meta:
-        abstract = True  # 标记为抽象模型，不生成数据库表
-
-    # 定义抽象方法get_absolute_url，强制子类实现
-    # 作用：每个具体模型必须提供自己的相对URL生成逻辑（如文章详情页URL、分类页URL）
-    @abstractmethod
-    def get_absolute_url(self):
-        pass
-
-
-# 定义文章模型Article，继承自抽象基础模型BaseModel
-class Article(BaseModel):
-    """文章模型：存储博客文章/页面数据（如博客文章、关于页、联系页等）"""
-    # 文章状态选项：元组形式，每个元素为（存储值，显示文本），支持国际化
-    STATUS_CHOICES = (
-        ('d', _('Draft')),    # 'd'：草稿状态
-        ('p', _('Published')),# 'p'：已发布状态
-    )
-    # 评论状态选项：控制文章是否允许评论
-    COMMENT_STATUS = (
-        ('o', _('Open')),     # 'o'：开放评论
-        ('c', _('Close')),    # 'c'：关闭评论
-    )
-    # 文章类型选项：区分普通文章和独立页面
-    TYPE = (
-        ('a', _('Article')),  # 'a'：普通文章（如博客博文）
-        ('p', _('Page')),     # 'p'：独立页面（如关于页、隐私政策页）
-    )
-    # 文章标题：CharField类型，最大长度200，唯一约束（避免重复标题）
-    title = models.CharField(_('title'), max_length=200, unique=True)
-    # 文章内容：MDTextField类型，支持Markdown格式编辑（富文本）
-    body = MDTextField(_('body'))
-    # 发布时间：DateTimeField类型，必填，默认值为当前时间，用于控制文章发布时间点
-    pub_time = models.DateTimeField(
-        _('publish time'), blank=False, null=False, default=now)
-    # 文章状态：CharField类型，长度1，可选值为STATUS_CHOICES，默认已发布（'p'）
-    status = models.CharField(
-        _('status'),
-        max_length=1,
-        choices=STATUS_CHOICES,
-        default='p')
-    # 评论状态：CharField类型，长度1，可选值为COMMENT_STATUS，默认开放评论（'o'）
-    comment_status = models.CharField(
-        _('comment status'),
-        max_length=1,
-        choices=COMMENT_STATUS,
-        default='o')
-    # 文章类型：CharField类型，长度1，可选值为TYPE，默认普通文章（'a'）
-    type = models.CharField(_('type'), max_length=1, choices=TYPE, default='a')
-    # 浏览量：PositiveIntegerField类型（仅允许非负整数），默认0
-    views = models.PositiveIntegerField(_('views'), default=0)
-    # 作者：外键关联Django用户模型（settings.AUTH_USER_MODEL，兼容自定义用户模型）
-    # on_delete=models.CASCADE：用户被删除时，关联的文章也会被删除
-    author = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        verbose_name=_('author'),
-        blank=False,
-        null=False,
-        on_delete=models.CASCADE)
-    # 文章排序权重：IntegerField类型，默认0，用于自定义文章显示顺序（值越大越靠前）
-    article_order = models.IntegerField(
-        _('order'), blank=False, null=False, default=0)
-    # 是否显示目录：BooleanField类型，默认False，控制文章详情页是否显示TOC（目录）
-    show_toc = models.BooleanField(_('show toc'), blank=False, null=False, default=False)
-    # 分类：外键关联Category模型（自应用内的分类模型）
-    # on_delete=models.CASCADE：分类被删除时，关联的文章也会被删除
-    category = models.ForeignKey(
-        'Category',
-        verbose_name=_('category'),
-        on_delete=models.CASCADE,
-        blank=False,
-        null=False)
-    # 标签：多对多关联Tag模型（一篇文章可多个标签，一个标签可关联多篇文章），允许为空
-    tags = models.ManyToManyField('Tag', verbose_name=_('tag'), blank=True)
-
-    # 辅助方法：返回文章内容字符串（用于需要直接获取纯文本内容的场景）
-    def body_to_string(self):
-        return self.body
-
-    # 重写__str__方法，后台管理界面和打印实例时显示文章标题（友好显示）
-    def __str__(self):
-        return self.title
-
-    # 模型元数据配置
-    class Meta:
-        ordering = ['-article_order', '-pub_time']  # 默认排序：先按排序权重降序，再按发布时间降序
-        verbose_name = _('article')  # 模型单数显示名称（支持国际化）
-        verbose_name_plural = verbose_name  # 模型复数显示名称（与单数一致）
-        get_latest_by = 'id'  # 指定获取最新记录的字段（按ID降序）
-
-    # 实现抽象基类的get_absolute_url方法：生成文章的相对URL
-    def get_absolute_url(self):
-        # 反向解析'blog:detailbyid'路由，传递文章ID、发布年月日作为URL参数
-        return reverse('blog:detailbyid', kwargs={
-            'article_id': self.id,
-            'year': self.creation_time.year,
-            'month': self.creation_time.month,
-            'day': self.creation_time.day
-        })
-
-    # 缓存装饰器：缓存结果10小时（60*60*10秒），避免重复查询数据库
-    @cache_decorator(60 * 60 * 10)
-    # 获取文章分类的层级关系（如"技术→Python→Django"）
-    def get_category_tree(self):
-        # 调用分类模型的get_category_tree方法，获取当前文章分类的所有父级分类
-        tree = self.category.get_category_tree()
-        # 转换为（分类名称，分类URL）的元组列表，用于前端显示分类面包屑
-        names = list(map(lambda c: (c.name, c.get_absolute_url()), tree))
-        return names
-
-    # 重写save方法（此处仅调用父类方法，便于后续扩展自定义逻辑）
-    def save(self, *args, **kwargs):
-        super().save(*args, **kwargs)
-
-    # 文章浏览量递增方法：用于文章详情页访问时更新浏览量
-    def viewed(self):
-        self.views += 1  # 浏览量+1
-        # 仅更新views字段（通过update_fields参数优化，避免更新其他字段）
-        self.save(update_fields=['views'])
-
-    # 获取文章的评论列表（已启用的评论）
-    def comment_list(self):
-        # 定义缓存键：包含文章ID，确保不同文章的评论缓存不冲突
-        cache_key = 'article_comments_{id}'.format(id=self.id)
-        # 尝试从缓存获取评论列表
-        value = cache.get(cache_key)
-        if value:
-            # 缓存命中：记录日志，直接返回缓存的评论列表
-            logger.info('get article comments:{id}'.format(id=self.id))
-            return value
-        else:
-            # 缓存未命中：查询当前文章的已启用评论（按ID降序，最新评论在前）
-            comments = self.comment_set.filter(is_enable=True).order_by('-id')
-            # 将评论列表存入缓存，有效期100分钟（60*100秒）
-            cache.set(cache_key, comments, 60 * 100)
-            # 记录日志：缓存设置成功
-            logger.info('set article comments:{id}'.format(id=self.id))
-            return comments
-
-    # 生成文章在Django后台的编辑页URL（用于快速跳转到后台编辑）
-    def get_admin_url(self):
-        # 获取模型的元数据：（应用名，模型名）
-        info = (self._meta.app_label, self._meta.model_name)
-        # 反向解析admin的模型修改路由，传递文章主键
-        return reverse('admin:%s_%s_change' % info, args=(self.pk,))
-
-    # 缓存装饰器：缓存结果100分钟
-    @cache_decorator(expiration=60 * 100)
-    # 获取当前文章的下一篇文章（已发布状态，ID大于当前文章）
-    def next_article(self):
-        return Article.objects.filter(
-            id__gt=self.id, status='p').order_by('id').first()
-
-    # 缓存装饰器：缓存结果100分钟
-    @cache_decorator(expiration=60 * 100)
-    # 获取当前文章的前一篇文章（已发布状态，ID小于当前文章）
-    def prev_article(self):
-        return Article.objects.filter(id__lt=self.id, status='p').first()
-
-
-# 定义分类模型Category，继承自抽象基础模型BaseModel
-class Category(BaseModel):
-    """文章分类模型：存储博客文章的分类数据（支持层级分类，如父分类→子分类）"""
-    # 分类名称：CharField类型，最大长度30，唯一约束（避免重复分类名）
-    name = models.CharField(_('category name'), max_length=30, unique=True)
-    # 父分类：自关联外键（分类可作为其他分类的父分类），允许为空（顶级分类）
-    # on_delete=models.CASCADE：父分类被删除时，子分类也会被删除
-    parent_category = models.ForeignKey(
-        'self',
-        verbose_name=_('parent category'),
-        blank=True,
-        null=True,
-        on_delete=models.CASCADE)
-    # 分类slug：URL友好标识，默认值'no-slug'，用于生成分类页URL
-    slug = models.SlugField(default='no-slug', max_length=60, blank=True)
-    # 排序索引：IntegerField类型，默认0，用于控制分类显示顺序（值越大越靠前）
-    index = models.IntegerField(default=0, verbose_name=_('index'))
-
-    # 模型元数据配置
-    class Meta:
-        ordering = ['-index']  # 默认排序：按排序索引降序
-        verbose_name = _('category')  # 模型单数显示名称
-        verbose_name_plural = verbose_name  # 模型复数显示名称
-
-    # 实现抽象基类的get_absolute_url方法：生成分类的相对URL
-    def get_absolute_url(self):
-        # 反向解析'blog:category_detail'路由，传递分类slug作为参数
-        return reverse(
-            'blog:category_detail', kwargs={
-                'category_name': self.slug})
-
-    # 重写__str__方法，友好显示分类名称
-    def __str__(self):
-        return self.name
-
-    # 缓存装饰器：缓存结果10小时
-    @cache_decorator(60 * 60 * 10)
-    # 递归获取当前分类的所有父级分类（生成分类层级树，如子分类→父分类→顶级分类）
-    def get_category_tree(self):
-        """
-        递归获得分类目录的父级
-        :return: 分类实例列表（当前分类 + 所有父级分类）
-        """
-        categorys = []
-
-        # 内部递归函数：解析分类的父级
-        def parse(category):
-            categorys.append(category)  # 将当前分类加入列表
-            if category.parent_category:  # 如果存在父分类，继续递归
-                parse(category.parent_category)
-
-        parse(self)  # 从当前分类开始解析
-        return categorys
-
-    # 缓存装饰器：缓存结果10小时
-    @cache_decorator(60 * 60 * 10)
-    # 递归获取当前分类的所有子级分类（包括子分类的子分类）
-    def get_sub_categorys(self):
-        """
-        获得当前分类目录所有子集
-        :return: 分类实例列表（当前分类 + 所有子级分类）
-        """
-        categorys = []
-        all_categorys = Category.objects.all()  # 获取所有分类
-
-        # 内部递归函数：解析分类的子级
-        def parse(category):
-            if category not in categorys:  # 避免重复添加（防止循环引用）
-                categorys.append(category)
-            # 查询当前分类的直接子分类
-            childs = all_categorys.filter(parent_category=category)
-            for child in childs:  # 遍历子分类，递归解析
-                if category not in categorys:
-                    categorys.append(child)
-                parse(child)
-
-        parse(self)  # 从当前分类开始解析
-        return categorys
-
-
-# 定义标签模型Tag，继承自抽象基础模型BaseModel
-class Tag(BaseModel):
-    """文章标签模型：存储博客文章的标签数据（用于文章分类和搜索）"""
-    # 标签名称：CharField类型，最大长度30，唯一约束（避免重复标签名）
-    name = models.CharField(_('tag name'), max_length=30, unique=True)
-    # 标签slug：URL友好标识，默认值'no-slug'，用于生成标签页URL
-    slug = models.SlugField(default='no-slug', max_length=60, blank=True)
-
-    # 重写__str__方法，友好显示标签名称
-    def __str__(self):
-        return self.name
-
-    # 实现抽象基类的get_absolute_url方法：生成标签的相对URL
-    def get_absolute_url(self):
-        # 反向解析'blog:tag_detail'路由，传递标签slug作为参数
-        return reverse('blog:tag_detail', kwargs={'tag_name': self.slug})
-
-    # 缓存装饰器：缓存结果10小时
-    @cache_decorator(60 * 60 * 10)
-    # 获取当前标签关联的文章数量（去重，避免重复计数）
-    def get_article_count(self):
-        return Article.objects.filter(tags__name=self.name).distinct().count()
-
-    # 模型元数据配置
-    class Meta:
-        ordering = ['name']  # 默认排序：按标签名称升序
-        verbose_name = _('tag')  # 模型单数显示名称
-        verbose_name_plural = verbose_name  # 模型复数显示名称
-
-
-# 定义友情链接模型Links（未继承BaseModel，单独定义时间字段）
-class Links(models.Model):
-    """友情链接模型：存储博客的友情链接数据"""
-    # 链接名称：CharField类型，最大长度30，唯一约束（避免重复链接名）
-    name = models.CharField(_('link name'), max_length=30, unique=True)
-    # 链接URL：URLField类型，自动验证URL格式（如http://、https://）
-    link = models.URLField(_('link'))
-    # 排序序号：IntegerField类型，唯一约束（控制友情链接显示顺序，值越小越靠前）
-    sequence = models.IntegerField(_('order'), unique=True)
-    # 是否启用：BooleanField类型，默认True，控制是否在前端显示该链接
-    is_enable = models.BooleanField(
-        _('is show'), default=True, blank=False, null=False)
-    # 显示位置：CharField类型，长度1，可选值为LinkShowType枚举，默认首页显示（'i'）
-    show_type = models.CharField(
-        _('show type'),
-        max_length=1,
-        choices=LinkShowType.choices,
-        default=LinkShowType.I)
-    # 创建时间：DateTimeField类型，默认当前时间
-    creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间：DateTimeField类型，默认当前时间
-    last_mod_time = models.DateTimeField(_('modify time'), default=now)
-
-    # 模型元数据配置
-    class Meta:
-        ordering = ['sequence']  # 默认排序：按排序序号升序
-        verbose_name = _('link')  # 模型单数显示名称
-        verbose_name_plural = verbose_name  # 模型复数显示名称
-
-    # 重写__str__方法，友好显示链接名称
-    def __str__(self):
-        return self.name
-
-
-# 定义侧边栏模型SideBar（未继承BaseModel，单独定义时间字段）
-class SideBar(models.Model):
-    """侧边栏模型：存储博客侧边栏内容（支持自定义HTML内容，如公告、广告）"""
-    # 侧边栏标题：CharField类型，最大长度100
-    name = models.CharField(_('title'), max_length=100)
-    # 侧边栏内容：TextField类型，支持HTML文本（如公告、推荐文章列表）
-    content = models.TextField(_('content'))
-    # 排序序号：IntegerField类型，唯一约束（控制侧边栏显示顺序，值越小越靠前）
-    sequence = models.IntegerField(_('order'), unique=True)
-    # 是否启用：BooleanField类型，默认True，控制是否在前端显示该侧边栏
-    is_enable = models.BooleanField(_('is enable'), default=True)
-    # 创建时间：DateTimeField类型，默认当前时间
-    creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间：DateTimeField类型，默认当前时间
-    last_mod_time = models.DateTimeField(_('modify time'), default=now)
-
-    # 模型元数据配置
-    class Meta:
-        ordering = ['sequence']  # 默认排序：按排序序号升序
-        verbose_name = _('sidebar')  # 模型单数显示名称
-        verbose_name_plural = verbose_name  # 模型复数显示名称
-
-    # 重写__str__方法，友好显示侧边栏标题
-    def __str__(self):
-        return self.name
-
-
-# 定义博客配置模型BlogSettings
-class BlogSettings(models.Model):
-    """博客全局配置模型：存储博客的全局设置（如站点名称、SEO信息、备案号等）"""
-    # 站点名称：CharField类型，必填，默认空字符串
-    site_name = models.CharField(
-        _('site name'),
-        max_length=200,
-        null=False,
-        blank=False,
-        default='')
-    # 站点描述：TextField类型，必填，用于前端显示站点简介（如首页底部）
-    site_description = models.TextField(
-        _('site description'),
-        max_length=1000,
-        null=False,
-        blank=False,
-        default='')
-    # 站点SEO描述：TextField类型，必填，用于网页meta标签的description（提升搜索引擎排名）
-    site_seo_description = models.TextField(
-        _('site seo description'), max_length=1000, null=False, blank=False, default='')
-    # 站点关键词：TextField类型，必填，用于网页meta标签的keywords（提升搜索引擎排名）
-    site_keywords = models.TextField(
-        _('site keywords'),
-        max_length=1000,
-        null=False,
-        blank=False,
-        default='')
-    # 文章摘要长度：IntegerField类型，默认300，控制前端显示文章摘要的字符数
-    article_sub_length = models.IntegerField(_('article sub length'), default=300)
-    # 侧边栏文章数量：IntegerField类型，默认10，控制侧边栏显示的最新/热门文章数量
-    sidebar_article_count = models.IntegerField(_('sidebar article count'), default=10)
-    # 侧边栏评论数量：IntegerField类型，默认5，控制侧边栏显示的最新评论数量
-    sidebar_comment_count = models.IntegerField(_('sidebar comment count'), default=5)
-    # 文章页评论数量：IntegerField类型，默认5，控制文章详情页默认显示的评论数量
-    article_comment_count = models.IntegerField(_('article comment count'), default=5)
-    # 是否显示谷歌广告：BooleanField类型，默认False，控制是否在前端显示谷歌广告
-    show_google_adsense = models.BooleanField(_('show adsense'), default=False)
-    # 谷歌广告代码：TextField类型，可选，存储谷歌广告的HTML代码
-    google_adsense_codes = models.TextField(
-        _('adsense code'), max_length=2000, null=True, blank=True, default='')
-    # 是否开放全站评论：BooleanField类型，默认True，控制整个站点是否允许评论
-    open_site_comment = models.BooleanField(_('open site comment'), default=True)
-    # 公共头部代码：TextField类型，可选，存储全局头部的自定义HTML（如额外CSS、JS）
-    global_header = models.TextField("公共头部", null=True, blank=True, default='')
-    # 公共尾部代码：TextField类型，可选，存储全局尾部的自定义HTML（如备案信息、统计代码）
-    global_footer = models.TextField("公共尾部", null=True, blank=True, default='')
-    # 备案号：CharField类型，可选，存储网站ICP备案号（如"粤ICP备xxxx号"）
-    beian_code = models.CharField(
-        '备案号',
-        max_length=2000,
-        null=True,
-        blank=True,
-        default='')
-    # 网站统计代码：TextField类型，必填，存储统计工具的JS代码（如百度统计、谷歌分析）
-    analytics_code = models.TextField(
-        "网站统计代码",
-        max_length=1000,
-        null=False,
-        blank=False,
-        default='')
-    # 是否显示公安备案号：BooleanField类型，默认False，控制是否显示公安备案信息
-    show_gongan_code = models.BooleanField(
-        '是否显示公安备案号', default=False, null=False)
-    # 公安备案号：TextField类型，可选，存储公安备案号（如"粤公网安备xxxx号"）
-    gongan_beiancode = models.TextField(
-        '公安备案号',
-        max_length=2000,
-        null=True,
-        blank=True,
-        default='')
-    # 评论是否需要审核：BooleanField类型，默认False，控制用户提交的评论是否需管理员审核后显示
-    comment_need_review = models.BooleanField(
-        '评论是否需要审核', default=False, null=False)
-
-    # 模型元数据配置
-    class Meta:
-        verbose_name = _('Website configuration')  # 模型单数显示名称（网站配置）
-        verbose_name_plural = verbose_name  # 模型复数显示名称
-
-    # 重写__str__方法，友好显示站点名称
-    def __str__(self):
-        return self.site_name
-
-    # 自定义数据验证方法：确保博客配置只能有一条记录（全局唯一配置）
-    def clean(self):
-        # 排除当前实例ID后，查询是否已有其他配置记录
-        if BlogSettings.objects.exclude(id=self.id).count():
-            # 若存在其他记录，抛出验证错误（阻止保存）
-            raise ValidationError(_('There can only be one configuration'))
-
-    # 重写save方法：保存配置后清空缓存（确保前端能立即获取最新配置）
-    def save(self, *args, **kwargs):
-        super().save(*args, **kwargs)  # 调用父类save方法完成数据入库
-        from djangoblog.utils import cache  # 延迟导入缓存模块，避免循环导入
-        cache.clear()  # 清空所有缓存

src/代码注释/blog/search_indexes.py

@@ -1,28 +0,0 @@
-# 从Haystack库导入索引相关核心类：
-# 1. SearchIndex：搜索索引基类，定义搜索索引的核心结构（如搜索字段）
-# 2. Indexable：索引可访问性基类，要求子类实现get_model方法（指定关联的Django模型）
-from haystack import indexes
-
-# 从当前应用（blog）的models.py导入Article模型，用于将文章数据同步到搜索索引
-from blog.models import Article
-
-
-# 定义文章搜索索引类ArticleIndex，继承自SearchIndex（搜索索引核心）和Indexable（索引关联模型）
-# 作用：告诉Haystack如何构建Article模型的搜索索引，指定搜索字段、关联模型及索引数据范围
-class ArticleIndex(indexes.SearchIndex, indexes.Indexable):
-    # 定义核心搜索字段text：
-    # - document=True：标记该字段为Haystack的"文档字段"（全文搜索的核心字段，所有搜索都会基于该字段匹配）
-    # - use_template=True：指定使用模板来构建该字段的搜索内容（模板路径默认是 templates/search/indexes/blog/article_text.txt）
-    # 模板中可包含文章标题、正文、标签等需要被搜索的字段，Haystack会将这些内容整合为text字段用于搜索
-    text = indexes.CharField(document=True, use_template=True)
-
-    # 实现Indexable基类的强制方法：指定当前索引关联的Django模型
-    def get_model(self):
-        # 返回Article模型，告诉Haystack该索引是为Article模型构建的
-        return Article
-
-    # 定义索引查询集：指定哪些Article数据需要被纳入搜索索引
-    def index_queryset(self, using=None):
-        # using参数：指定使用的搜索引擎（如Elasticsearch、Whoosh），默认None使用配置的默认引擎
-        # 过滤条件：仅将状态为"已发布"（status='p'）的文章纳入索引，草稿文章不参与搜索
-        return self.get_model().objects.filter(status='p')

src/代码注释/blog/static/account/css/account.css

@@ -1,9 +0,0 @@
-.button {
-    border: none;
-    padding: 4px 80px;
-    text-align: center;
-    text-decoration: none;
-    display: inline-block;
-    font-size: 16px;
-    margin: 4px 2px;
-}

src/代码注释/blog/static/account/js/account.js

@@ -1,47 +0,0 @@
-let wait = 60;
-
-function time(o) {
-    if (wait == 0) {
-        o.removeAttribute("disabled");
-        o.value = "获取验证码";
-        wait = 60
-        return false
-    } else {
-        o.setAttribute("disabled", true);
-        o.value = "重新发送(" + wait + ")";
-        wait--;
-        setTimeout(function () {
-                time(o)
-            },
-            1000)
-    }
-}
-
-document.getElementById("btn").onclick = function () {
-    let id_email = $("#id_email")
-    let token = $("*[name='csrfmiddlewaretoken']").val()
-    let ts = this
-    let myErr = $("#myErr")
-    $.ajax(
-        {
-            url: "/forget_password_code/",
-            type: "POST",
-            data: {
-                "email": id_email.val(),
-                "csrfmiddlewaretoken": token
-            },
-            success: function (result) {
-                if (result != "ok") {
-                    myErr.remove()
-                    id_email.after("<ul className='errorlist' id='myErr'><li>" + result + "</li></ul>")
-                    return
-                }
-                myErr.remove()
-                time(ts)
-            },
-            error: function (e) {
-                alert("发送失败,请重试")
-            }
-        }
-    );
-}