添加自评表格

doc.gitkeep

@@ -1 +0,0 @@
-undefine

doc/.gitkeep

@@ -1 +0,0 @@
-This is for doc folder

doc/README.md

@@ -0,0 +1 @@
+# 文档目录 - 项目文档将存放于此

doc/Readme (2).txt

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# 显示脚本开始执行
+echo "脚本开始执行..."
+
+# 从键盘读取文件名
+read -p "请输入文件名: " filename
+
+# 检查文件是否存在
+if [ ! -e "$filename" ]; then
+    echo "错误：文件 '$filename' 不存在！"
+    exit 1
+fi
+
+echo "文件 '$filename' 存在"
+
+# 检查文件是否是符号链接
+if [ -L "$filename" ]; then
+    echo "检测到 '$filename' 是一个符号链接文件"
+    
+    # 获取文件名部分（不包括路径）
+    base_name=$(basename "$filename")
+    
+    # 移动文件到/tmp目录
+    echo "正在将 '$filename' 移动到 /tmp/$base_name"
+    mv "$filename" "/tmp/$base_name"
+    
+    # 检查移动是否成功
+    if [ $? -eq 0 ]; then
+        echo "移动成功！文件现在位于 /tmp/$base_name"
+    else
+        echo "移动失败！"
+        exit 1
+    fi
+else
+    echo "'$filename' 不是符号链接文件，不进行任何处理"
+fi
+
+echo "脚本执行完毕"
+exit 0

src.gitkeep

@@ -1 +0,0 @@
-undefined

src/DjangoBlog-master/accounts/admin.py

@@ -1,52 +1,80 @@
+# admin.py - Django后台管理配置文件
+
+# 导入Django表单模块
 from django import forms
+# 导入Django用户管理类
 from django.contrib.auth.admin import UserAdmin
+# 导入用户修改表单
 from django.contrib.auth.forms import UserChangeForm
+# 导入用户名字段
 from django.contrib.auth.forms import UsernameField
+# 导入国际化翻译函数
 from django.utils.translation import gettext_lazy as _
 
-# Register your models here.
+# 在这里注册模型
+# 导入自定义的用户模型
 from .models import BlogUser
 
 
+# 自定义用户创建表单
 class BlogUserCreationForm(forms.ModelForm):
+    # 密码字段1 - 用于输入密码
     password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput)
+    # 密码字段2 - 用于确认密码
     password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput)
 
     class Meta:
+        # 指定关联的模型
         model = BlogUser
+        # 表单包含的字段
         fields = ('email',)
 
+    # 清理密码确认字段的方法
     def clean_password2(self):
-        # Check that the two password entries match
+        # 从已清理的数据中获取两个密码字段的值
         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 the provided password in hashed format
+        # 调用父类的save方法但不立即提交到数据库
         user = super().save(commit=False)
+        # 设置哈希后的密码
         user.set_password(self.cleaned_data["password1"])
         if commit:
+            # 设置用户来源为管理员站点
             user.source = 'adminsite'
+            # 保存用户到数据库
             user.save()
         return user
 
 
+# 自定义用户修改表单
 class BlogUserChangeForm(UserChangeForm):
     class Meta:
+        # 指定关联的模型
         model = BlogUser
+        # 包含所有字段
         fields = '__all__'
+        # 字段类型映射
         field_classes = {'username': UsernameField}
 
+    # 初始化方法
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
 
+# 自定义用户管理类
 class BlogUserAdmin(UserAdmin):
+    # 指定修改表单
     form = BlogUserChangeForm
+    # 指定创建表单
     add_form = BlogUserCreationForm
+    # 列表页面显示的字段
     list_display = (
         'id',
         'nickname',
@@ -55,5 +83,7 @@ class BlogUserAdmin(UserAdmin):
         'last_login',
         'date_joined',
         'source')
+    # 列表中可点击链接的字段
     list_display_links = ('id', 'username')
-    ordering = ('-id',)
+    # 默认排序字段（按ID降序）
+    ordering = ('-id',)

src/DjangoBlog-master/accounts/apps.py

@@ -0,0 +1,10 @@
+# apps.py - Django应用程序配置文件
+
+# 导入Django应用配置基类
+from django.apps import AppConfig
+
+
+# 定义账户应用的配置类
+class AccountsConfig(AppConfig):
+    # 指定应用程序的完整Python路径
+    name = 'accounts'

src/DjangoBlog-master/accounts/forms.py

@@ -1,47 +1,71 @@
+# forms.py - Django表单定义文件
+
+# 导入Django表单模块
 from django import forms
+# 导入用户模型相关函数和表单类
 from django.contrib.auth import get_user_model, password_validation
 from django.contrib.auth.forms import AuthenticationForm, UserCreationForm
+# 导入验证错误异常
 from django.core.exceptions import ValidationError
+# 导入表单小部件
 from django.forms import widgets
+# 导入国际化翻译函数
 from django.utils.translation import gettext_lazy as _
+# 导入工具模块
 from . import utils
+# 导入用户模型
 from .models import BlogUser
 
 
+# 登录表单类
 class LoginForm(AuthenticationForm):
+    # 初始化方法，设置表单字段的样式和属性
     def __init__(self, *args, **kwargs):
         super(LoginForm, self).__init__(*args, **kwargs)
+        # 设置用户名字段的输入框样式
         self.fields['username'].widget = widgets.TextInput(
             attrs={'placeholder': "username", "class": "form-control"})
+        # 设置密码字段的输入框样式
         self.fields['password'].widget = widgets.PasswordInput(
             attrs={'placeholder': "password", "class": "form-control"})
 
 
+# 注册表单类
 class RegisterForm(UserCreationForm):
+    # 初始化方法，设置表单字段的样式和属性
     def __init__(self, *args, **kwargs):
         super(RegisterForm, self).__init__(*args, **kwargs)
-
+        # 设置用户名字段的输入框样式
         self.fields['username'].widget = widgets.TextInput(
             attrs={'placeholder': "username", "class": "form-control"})
+        # 设置邮箱字段的输入框样式
         self.fields['email'].widget = widgets.EmailInput(
             attrs={'placeholder': "email", "class": "form-control"})
+        # 设置密码字段的输入框样式
         self.fields['password1'].widget = widgets.PasswordInput(
             attrs={'placeholder': "password", "class": "form-control"})
+        # 设置确认密码字段的输入框样式
         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:
+        # 指定关联的用户模型
         model = get_user_model()
+        # 表单包含的字段
         fields = ("username", "email")
 
 
+# 忘记密码表单类
 class ForgetPasswordForm(forms.Form):
+    # 新密码字段
     new_password1 = forms.CharField(
         label=_("New password"),
         widget=forms.PasswordInput(
@@ -52,6 +76,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
+    # 确认新密码字段
     new_password2 = forms.CharField(
         label="确认密码",
         widget=forms.PasswordInput(
@@ -62,6 +87,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
+    # 邮箱字段
     email = forms.EmailField(
         label='邮箱',
         widget=forms.TextInput(
@@ -72,6 +98,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
+    # 验证码字段
     code = forms.CharField(
         label=_('Code'),
         widget=forms.TextInput(
@@ -82,17 +109,22 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
+    # 清理确认密码字段的方法
     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"))
+        # 验证密码强度
         password_validation.validate_password(password2)
 
         return password2
 
+    # 清理邮箱字段的方法，检查邮箱是否存在
     def clean_email(self):
         user_email = self.cleaned_data.get("email")
+        # 检查邮箱是否已注册
         if not BlogUser.objects.filter(
                 email=user_email
         ).exists():
@@ -100,8 +132,10 @@ class ForgetPasswordForm(forms.Form):
             raise ValidationError(_("email does not exist"))
         return user_email
 
+    # 清理验证码字段的方法
     def clean_code(self):
         code = self.cleaned_data.get("code")
+        # 验证邮箱和验证码是否匹配
         error = utils.verify(
             email=self.cleaned_data.get("email"),
             code=code,
@@ -111,7 +145,9 @@ class ForgetPasswordForm(forms.Form):
         return code
 
 
+# 获取忘记密码验证码表单类
 class ForgetPasswordCodeForm(forms.Form):
+    # 邮箱字段
     email = forms.EmailField(
         label=_('Email'),
-    )
+    )

src/DjangoBlog-master/accounts/models.py

@@ -1,35 +1,58 @@
+# models.py - Django数据模型定义文件
+
+# 导入Django内置的用户抽象基类
 from django.contrib.auth.models import AbstractUser
+# 导入Django数据库模型
 from django.db import models
+# 导入URL反向解析函数
 from django.urls import reverse
+# 导入时间相关函数
 from django.utils.timezone import now
+# 导入国际化翻译函数
 from django.utils.translation import gettext_lazy as _
+# 导入工具函数获取当前站点
 from djangoblog.utils import get_current_site
 
 
-# Create your models here.
+# 在这里创建模型
 
+# 博客用户模型，继承自Django的AbstractUser
 class BlogUser(AbstractUser):
+    # 昵称字段，最大长度100字符，允许为空
     nickname = models.CharField(_('nick name'), max_length=100, blank=True)
+    # 创建时间字段，默认值为当前时间
     creation_time = models.DateTimeField(_('creation time'), default=now)
+    # 最后修改时间字段，默认值为当前时间
     last_modify_time = models.DateTimeField(_('last modify time'), default=now)
+    # 用户来源字段，记录创建来源，最大长度100字符，允许为空
     source = models.CharField(_('create source'), max_length=100, blank=True)
 
+    # 获取用户绝对URL的方法
     def get_absolute_url(self):
         return reverse(
             'blog:author_detail', kwargs={
                 'author_name': self.username})
 
+    # 对象的字符串表示方法，返回邮箱地址
     def __str__(self):
         return self.email
 
+    # 获取完整URL的方法（包含域名）
     def get_full_url(self):
+        # 获取当前站点域名
         site = get_current_site().domain
+        # 构建完整的URL
         url = "https://{site}{path}".format(site=site,
                                             path=self.get_absolute_url())
         return url
 
+    # 模型的元数据配置
     class Meta:
+        # 默认按ID降序排列
         ordering = ['-id']
+        # 单数形式的显示名称
         verbose_name = _('user')
+        # 复数形式的显示名称（与单数相同）
         verbose_name_plural = verbose_name
-        get_latest_by = 'id'
+        # 指定获取最新对象的字段
+        get_latest_by = 'id'

src/DjangoBlog-master/accounts/tests.py

@@ -1,135 +1,186 @@
+# tests.py - Django测试用例文件
+
+# 导入Django测试相关模块
 from django.test import Client, RequestFactory, TestCase
+# 导入URL反向解析
 from django.urls import reverse
+# 导入时区相关功能
 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
 
 
-# Create your tests here.
+# 在这里创建测试用例
 
+# 账户测试类
 class AccountTest(TestCase):
+    # 测试前置设置方法
     def setUp(self):
+        # 创建测试客户端
         self.client = Client()
+        # 创建请求工厂
         self.factory = RequestFactory()
+        # 创建测试用户
         self.blog_user = BlogUser.objects.create_user(
             username="test",
             email="admin@admin.com",
             password="12345678"
         )
+        # 设置测试用的新密码
         self.new_test = "xxx123--="
 
+    # 测试账户验证功能
     def test_validate_account(self):
+        # 获取当前站点域名
         site = get_current_site().domain
+        # 创建超级用户
         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')
+        # 断言登录成功
         self.assertEqual(loginresult, True)
+        # 测试访问管理员页面
         response = self.client.get('/admin/')
         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'
-        article.status = 'p'
+        article.type = 'a'  # 文章类型
+        article.status = 'p'  # 发布状态
         article.save()
 
+        # 测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
         self.assertEqual(response.status_code, 200)
 
+    # 测试用户注册功能
     def test_validate_register(self):
+        # 断言邮箱不存在
         self.assertEquals(
             0, len(
                 BlogUser.objects.filter(
                     email='user123@user.com')))
+        # 发送注册请求
         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',
         })
+        # 断言用户创建成功
         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)))
         path = reverse('accounts:result')
+        # 构建验证URL
         url = '{path}?type=validation&id={id}&sign={sign}'.format(
             path=path, id=user.id, sign=sign)
+        # 测试验证页面
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
 
+        # 测试用户登录
         self.client.login(username='user1233', password='password123!q@wE#R$T')
         user = BlogUser.objects.filter(email='user123@user.com')[0]
+        # 设置用户为超级用户和管理员
         user.is_superuser = True
         user.is_staff = True
         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()
 
+        # 测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
         self.assertEqual(response.status_code, 200)
 
+        # 测试退出登录
         response = self.client.get(reverse('account:logout'))
         self.assertIn(response.status_code, [301, 302, 200])
 
+        # 测试退出后访问管理页面（应该重定向）
         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])
 
+        # 测试登录后访问管理页面
         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)
 
+        # 测试正确验证码
         err = utils.verify("admin@admin.com", code)
         self.assertEqual(err, None)
 
+        # 测试错误邮箱
         err = utils.verify("admin@123.com", code)
         self.assertEqual(type(err), str)
 
+    # 测试成功发送忘记密码验证码
     def test_forget_password_email_code_success(self):
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
@@ -139,33 +190,40 @@ class AccountTest(TestCase):
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp.content.decode("utf-8"), "ok")
 
+    # 测试发送忘记密码验证码失败情况
     def test_forget_password_email_code_fail(self):
+        # 测试空数据
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
             data=dict()
         )
         self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
 
+        # 测试错误邮箱格式
         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
         )
-        self.assertEqual(resp.status_code, 302)
+        self.assertEqual(resp.status_code, 302)  # 重定向响应
 
         # 验证用户密码是否修改成功
         blog_user = BlogUser.objects.filter(
@@ -174,6 +232,7 @@ class AccountTest(TestCase):
         self.assertNotEqual(blog_user, None)
         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,
@@ -188,7 +247,7 @@ class AccountTest(TestCase):
 
         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)
@@ -196,12 +255,11 @@ class AccountTest(TestCase):
             new_password1=self.new_test,
             new_password2=self.new_test,
             email=self.blog_user.email,
-            code="111111",
+            code="111111",  # 错误的验证码
         )
         resp = self.client.post(
             path=reverse("account:forget_password"),
             data=data
         )
 
-        self.assertEqual(resp.status_code, 200)
-
+        self.assertEqual(resp.status_code, 200)

src/DjangoBlog-master/accounts/urls.py

@@ -0,0 +1,54 @@
+# urls.py - Django URL路由配置文件
+
+# 导入Django URL路由相关函数
+from django.urls import path
+from django.urls import re_path
+
+# 导入当前应用的视图模块
+from . import views
+# 导入登录表单类
+from .forms import LoginForm
+
+# 定义应用命名空间（用于URL反向解析）
+app_name = "accounts"
+
+# URL模式列表 - 定义URL路径与视图的映射关系
+urlpatterns = [
+    # 登录URL - 使用正则表达式匹配路径
+    re_path(r'^login/$',
+            # 使用类视图，设置登录成功后跳转到首页
+            views.LoginView.as_view(success_url='/'),
+            name='login',  # URL名称，用于反向解析
+            # 传递额外参数，指定认证表单类
+            kwargs={'authentication_form': LoginForm}),
+    
+    # 注册URL - 使用正则表达式匹配路径
+    re_path(r'^register/$',
+            # 使用类视图，设置注册成功后跳转到首页
+            views.RegisterView.as_view(success_url="/"),
+            name='register'),  # URL名称，用于反向解析
+    
+    # 退出登录URL - 使用正则表达式匹配路径
+    re_path(r'^logout/$',
+            # 使用类视图
+            views.LogoutView.as_view(),
+            name='logout'),  # URL名称，用于反向解析
+    
+    # 账户操作结果页面URL - 使用path匹配精确路径
+    path(r'account/result.html',
+         # 使用函数视图
+         views.account_result,
+         name='result'),  # URL名称，用于反向解析
+    
+    # 忘记密码URL - 使用正则表达式匹配路径
+    re_path(r'^forget_password/$',
+            # 使用类视图
+            views.ForgetPasswordView.as_view(),
+            name='forget_password'),  # URL名称，用于反向解析
+    
+    # 获取忘记密码验证码URL - 使用正则表达式匹配路径
+    re_path(r'^forget_password_code/$',
+            # 使用类视图
+            views.ForgetPasswordEmailCode.as_view(),
+            name='forget_password_code'),  # URL名称，用于反向解析
+]

src/DjangoBlog-master/accounts/user_login_backend.py

@@ -0,0 +1,42 @@
+# user_login_backend.py - 自定义用户认证后端
+
+# 导入获取用户模型的函数
+from django.contrib.auth import get_user_model
+# 导入Django模型认证后端基类
+from django.contrib.auth.backends import ModelBackend
+
+
+# 自定义认证后端类，支持邮箱或用户名登录
+class EmailOrUsernameModelBackend(ModelBackend):
+    """
+    允许使用用户名或邮箱登录的自定义认证后端
+    """
+
+    # 用户认证方法
+    def authenticate(self, request, username=None, password=None, **kwargs):
+        # 判断输入的是邮箱还是用户名
+        if '@' in username:
+            # 如果包含@符号，按邮箱处理
+            kwargs = {'email': username}
+        else:
+            # 否则按用户名处理
+            kwargs = {'username': username}
+        
+        try:
+            # 根据用户名或邮箱获取用户
+            user = get_user_model().objects.get(**kwargs)
+            # 验证密码是否正确
+            if user.check_password(password):
+                return user  # 认证成功，返回用户对象
+        except get_user_model().DoesNotExist:
+            # 用户不存在，返回None
+            return None
+
+    # 根据用户ID获取用户的方法
+    def get_user(self, username):
+        try:
+            # 根据主键（用户ID）获取用户
+            return get_user_model().objects.get(pk=username)
+        except get_user_model().DoesNotExist:
+            # 用户不存在，返回None
+            return None

src/DjangoBlog-master/accounts/utils.py

@@ -0,0 +1,71 @@
+# utils.py - 工具函数模块，处理验证码相关功能
+
+# 导入类型提示模块
+import typing
+# 导入时间间隔类
+from datetime import timedelta
+
+# 导入Django缓存模块
+from django.core.cache import cache
+# 导入国际化翻译函数
+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: 接收邮箱地址
+        subject: 邮件主题，默认为"验证邮件"
+        code: 验证码
+    """
+    # 构建邮件HTML内容，包含验证码信息
+    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([to_mail], subject, html_content)
+
+
+def verify(email: str, code: str) -> typing.Optional[str]:
+    """验证验证码是否有效
+    Args:
+        email: 请求验证的邮箱地址
+        code: 用户输入的验证码
+    Return:
+        如果验证失败返回错误信息字符串，成功返回None
+    Note:
+        这里的错误处理不太合理，应该采用raise抛出异常
+        否则调用方也需要对error进行处理
+    """
+    # 从缓存中获取该邮箱对应的验证码
+    cache_code = get_code(email)
+    # 比较用户输入的验证码和缓存中的验证码
+    if cache_code != code:
+        return gettext("Verification code error")
+
+
+def set_code(email: str, code: str):
+    """设置验证码到缓存中
+    Args:
+        email: 邮箱地址，作为缓存的key
+        code: 验证码，作为缓存的value
+    """
+    # 将验证码存入缓存，设置过期时间为5分钟
+    cache.set(email, code, _code_ttl.seconds)
+
+
+def get_code(email: str) -> typing.Optional[str]:
+    """从缓存中获取验证码
+    Args:
+        email: 邮箱地址，作为缓存的key
+    Return:
+        返回验证码字符串，如果不存在则返回None
+    """
+    return cache.get(email)

src/DjangoBlog-master/accounts/views.py

@@ -1,59 +1,89 @@
+# views.py - Django视图文件，处理用户账户相关请求
+
+# 导入日志模块
 import logging
+# 导入国际化翻译函数
 from django.utils.translation import gettext_lazy as _
+# 导入Django设置
 from django.conf import settings
+# 导入Django认证相关模块
 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
 from django.contrib.auth.forms import AuthenticationForm
 from django.contrib.auth.hashers import make_password
+# 导入HTTP响应类
 from django.http import HttpResponseRedirect, HttpResponseForbidden
 from django.http.request import HttpRequest
 from django.http.response import HttpResponse
+# 导入快捷函数
 from django.shortcuts import get_object_or_404
 from django.shortcuts import render
+# 导入URL反向解析
 from django.urls import reverse
+# 导入方法装饰器
 from django.utils.decorators import method_decorator
 from django.utils.http import url_has_allowed_host_and_scheme
+# 导入基于类的视图
 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
 
+# 导入工具函数
 from djangoblog.utils import send_email, get_sha256, get_current_site, generate_code, delete_sidebar_cache
+# 导入当前应用的工具模块
 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):
+    # 指定使用的表单类
     form_class = RegisterForm
+    # 指定模板文件
     template_name = 'account/registration_form.html'
 
+    # 使用CSRF保护装饰器
     @method_decorator(csrf_protect)
     def dispatch(self, *args, **kwargs):
         return super(RegisterView, self).dispatch(*args, **kwargs)
 
+    # 表单验证通过后的处理
     def form_valid(self, form):
         if form.is_valid():
+            # 保存用户但不提交到数据库
             user = form.save(False)
+            # 设置用户为非激活状态（需要邮箱验证）
             user.is_active = False
+            # 设置用户来源
             user.source = 'Register'
+            # 保存用户到数据库
             user.save(True)
+            # 获取当前站点域名
             site = get_current_site().domain
+            # 生成验证签名
             sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
 
+            # 调试模式下使用本地地址
             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)
 
+            # 构建邮件内容
             content = """
                             <p>请点击下面链接验证您的邮箱</p>
 
@@ -64,6 +94,7 @@ class RegisterView(FormView):
                             如果上面链接无法打开，请将此链接复制至浏览器。
                             {url}
                             """.format(url=url)
+            # 发送验证邮件
             send_email(
                 emailto=[
                     user.email,
@@ -71,43 +102,59 @@ class RegisterView(FormView):
                 title='验证您的电子邮箱',
                 content=content)
 
+            # 重定向到结果页面
             url = reverse('accounts:result') + \
                   '?type=register&id=' + str(user.id)
             return HttpResponseRedirect(url)
         else:
+            # 表单验证失败，重新渲染表单
             return self.render_to_response({
                 'form': form
             })
 
 
+# 用户退出登录视图
 class LogoutView(RedirectView):
+    # 退出后重定向的URL
     url = '/login/'
 
+    # 禁用缓存
     @method_decorator(never_cache)
     def dispatch(self, request, *args, **kwargs):
         return super(LogoutView, self).dispatch(request, *args, **kwargs)
 
+    # 处理GET请求
     def get(self, request, *args, **kwargs):
+        # 执行退出登录操作
         logout(request)
+        # 清理侧边栏缓存
         delete_sidebar_cache()
         return super(LogoutView, self).get(request, *args, **kwargs)
 
 
+# 用户登录视图
 class LoginView(FormView):
+    # 指定使用的表单类
     form_class = LoginForm
+    # 指定模板文件
     template_name = 'account/login.html'
+    # 登录成功后的默认重定向URL
     success_url = '/'
+    # 重定向字段名
     redirect_field_name = REDIRECT_FIELD_NAME
-    login_ttl = 2626560  # 一个月的时间
+    # 登录会话有效期（一个月）
+    login_ttl = 2626560
 
+    # 使用多个装饰器保护敏感操作
     @method_decorator(sensitive_post_parameters('password'))
     @method_decorator(csrf_protect)
     @method_decorator(never_cache)
     def dispatch(self, request, *args, **kwargs):
-
         return super(LoginView, self).dispatch(request, *args, **kwargs)
 
+    # 获取上下文数据
     def get_context_data(self, **kwargs):
+        # 获取重定向URL
         redirect_to = self.request.GET.get(self.redirect_field_name)
         if redirect_to is None:
             redirect_to = '/'
@@ -115,26 +162,33 @@ class LoginView(FormView):
 
         return super(LoginView, self).get_context_data(**kwargs)
 
+    # 表单验证通过后的处理
     def form_valid(self, form):
         form = AuthenticationForm(data=self.request.POST, request=self.request)
 
         if form.is_valid():
+            # 清理侧边栏缓存
             delete_sidebar_cache()
+            # 记录日志
             logger.info(self.redirect_field_name)
 
+            # 执行登录操作
             auth.login(self.request, form.get_user())
+            # 如果用户选择"记住我"，设置会话有效期
             if self.request.POST.get("remember"):
                 self.request.session.set_expiry(self.login_ttl)
             return super(LoginView, self).form_valid(form)
-            # return HttpResponseRedirect('/')
         else:
+            # 表单验证失败，重新渲染表单
             return self.render_to_response({
                 'form': form
             })
 
+    # 获取登录成功后的重定向URL
     def get_success_url(self):
-
+        # 从POST数据中获取重定向URL
         redirect_to = self.request.POST.get(self.redirect_field_name)
+        # 检查URL是否安全
         if not url_has_allowed_host_and_scheme(
                 url=redirect_to, allowed_hosts=[
                     self.request.get_host()]):
@@ -142,63 +196,91 @@ class LoginView(FormView):
         return redirect_to
 
 
+# 账户操作结果页面视图函数
 def account_result(request):
+    # 获取操作类型和用户ID
     type = request.GET.get('type')
     id = request.GET.get('id')
 
+    # 获取用户对象，如果不存在返回404
     user = get_object_or_404(get_user_model(), id=id)
     logger.info(type)
+    # 如果用户已激活，重定向到首页
     if user.is_active:
         return HttpResponseRedirect('/')
+    # 处理注册和验证类型
     if type and type in ['register', 'validation']:
         if type == 'register':
+            # 注册成功页面内容
             content = '''
     恭喜您注册成功，一封验证邮件已经发送到您的邮箱，请验证您的邮箱后登录本站。
     '''
             title = '注册成功'
         else:
+            # 验证邮箱签名
             c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
             sign = request.GET.get('sign')
+            # 签名不匹配，返回403禁止访问
             if sign != c_sign:
                 return HttpResponseForbidden()
+            # 激活用户账户
             user.is_active = True
             user.save()
             content = '''
             恭喜您已经成功的完成邮箱验证，您现在可以使用您的账号来登录本站。
             '''
             title = '验证成功'
+        # 渲染结果页面
         return render(request, 'account/result.html', {
             'title': title,
             'content': content
         })
     else:
+        # 无效类型，重定向到首页
         return HttpResponseRedirect('/')
 
 
+# 忘记密码视图
 class ForgetPasswordView(FormView):
+    # 指定使用的表单类
     form_class = ForgetPasswordForm
+    # 指定模板文件
     template_name = 'account/forget_password.html'
 
+    # 表单验证通过后的处理
     def form_valid(self, form):
         if form.is_valid():
+            # 根据邮箱获取用户
             blog_user = BlogUser.objects.filter(email=form.cleaned_data.get("email")).get()
+            # 设置新密码（自动哈希）
             blog_user.password = make_password(form.cleaned_data["new_password2"])
+            # 保存用户
             blog_user.save()
+            # 重定向到登录页面
             return HttpResponseRedirect('/login/')
         else:
+            # 表单验证失败，重新渲染表单
             return self.render_to_response({'form': form})
 
 
+# 忘记密码验证码发送视图
 class ForgetPasswordEmailCode(View):
 
+    # 处理POST请求
     def post(self, request: HttpRequest):
+        # 初始化表单
         form = ForgetPasswordCodeForm(request.POST)
+        # 表单验证
         if not form.is_valid():
             return HttpResponse("错误的邮箱")
+        # 获取邮箱地址
         to_email = form.cleaned_data["email"]
 
+        # 生成验证码
         code = generate_code()
+        # 发送验证邮件
         utils.send_verify_email(to_email, code)
+        # 保存验证码到缓存
         utils.set_code(to_email, code)
 
-        return HttpResponse("ok")
+        return HttpResponse("ok")

src/DjangoBlog-master/blog/admin.py

@@ -17,18 +17,22 @@ class ArticleForm(forms.ModelForm):
         fields = '__all__'
 
 
+#xjh：管理员动作函数 - 发布选中的文章
 def makr_article_publish(modeladmin, request, queryset):
     queryset.update(status='p')
 
 
+#xjh：管理员动作函数 - 将选中的文章设为草稿
 def draft_article(modeladmin, request, queryset):
     queryset.update(status='d')
 
 
+#xjh：管理员动作函数 - 关闭文章评论
 def close_article_commentstatus(modeladmin, request, queryset):
     queryset.update(comment_status='c')
 
 
+#xjh：管理员动作函数 - 打开文章评论
 def open_article_commentstatus(modeladmin, request, queryset):
     queryset.update(comment_status='o')
 
@@ -40,6 +44,7 @@ open_article_commentstatus.short_description = _('Open article comments')
 
 
 class ArticlelAdmin(admin.ModelAdmin):
+    """xjh：文章模型的后台管理配置"""
     list_per_page = 20
     search_fields = ('body', 'title')
     form = ArticleForm
@@ -65,6 +70,7 @@ class ArticlelAdmin(admin.ModelAdmin):
         open_article_commentstatus]
 
     def link_to_category(self, obj):
+        """xjh：在文章列表显示分类链接"""
         info = (obj.category._meta.app_label, obj.category._meta.model_name)
         link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,))
         return format_html(u'<a href="%s">%s</a>' % (link, obj.category.name))
@@ -72,15 +78,18 @@ class ArticlelAdmin(admin.ModelAdmin):
     link_to_category.short_description = _('category')
 
     def get_form(self, request, obj=None, **kwargs):
+        """xjh：限制作者字段只能选择超级用户"""
         form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs)
         form.base_fields['author'].queryset = get_user_model(
         ).objects.filter(is_superuser=True)
         return form
 
     def save_model(self, request, obj, form, change):
+        """xjh：保存文章模型"""
         super(ArticlelAdmin, self).save_model(request, obj, form, change)
 
     def get_view_on_site_url(self, obj=None):
+        """xjh：获取文章在前台的URL"""
         if obj:
             url = obj.get_full_url()
             return url
@@ -91,22 +100,27 @@ class ArticlelAdmin(admin.ModelAdmin):
 
 
 class TagAdmin(admin.ModelAdmin):
+    """xjh：标签模型的后台管理配置"""
     exclude = ('slug', 'last_mod_time', 'creation_time')
 
 
 class CategoryAdmin(admin.ModelAdmin):
+    """xjh：分类模型的后台管理配置"""
     list_display = ('name', 'parent_category', 'index')
     exclude = ('slug', 'last_mod_time', 'creation_time')
 
 
 class LinksAdmin(admin.ModelAdmin):
+    """xjh：友情链接模型的后台管理配置"""
     exclude = ('last_mod_time', 'creation_time')
 
 
 class SideBarAdmin(admin.ModelAdmin):
+    """xjh：侧边栏模型的后台管理配置"""
     list_display = ('name', 'content', 'is_enable', 'sequence')
     exclude = ('last_mod_time', 'creation_time')
 
 
 class BlogSettingsAdmin(admin.ModelAdmin):
-    pass
+    """xjh：博客设置模型的后台管理配置"""
+    pass

src/DjangoBlog-master/blog/apps.py

@@ -2,4 +2,5 @@ from django.apps import AppConfig
 
 
 class BlogConfig(AppConfig):
-    name = 'blog'
+    """xjh：博客应用的配置类"""
+    name = 'blog'

src/DjangoBlog-master/blog/context_processors.py

@@ -9,6 +9,7 @@ logger = logging.getLogger(__name__)
 
 
 def seo_processor(requests):
+    """xjh：SEO上下文处理器，为模板提供SEO相关变量"""
     key = 'seo_processor'
     value = cache.get(key)
     if value:
@@ -16,6 +17,7 @@ def seo_processor(requests):
     else:
         logger.info('set processor cache.')
         setting = get_blog_setting()
+        #xjh：构建包含SEO和网站配置的上下文字典
         value = {
             'SITE_NAME': setting.site_name,
             'SHOW_GOOGLE_ADSENSE': setting.show_google_adsense,
@@ -39,5 +41,6 @@ def seo_processor(requests):
             "GLOBAL_FOOTER": setting.global_footer,
             "COMMENT_NEED_REVIEW": setting.comment_need_review,
         }
+        #xjh：缓存上下文数据10小时
         cache.set(key, value, 60 * 60 * 10)
-        return value
+        return value

src/DjangoBlog-master/blog/documents.py

@@ -7,9 +7,11 @@ from elasticsearch_dsl.connections import connections
 
 from blog.models import Article
 
+#xjh：检查是否启用了Elasticsearch
 ELASTICSEARCH_ENABLED = hasattr(settings, 'ELASTICSEARCH_DSL')
 
 if ELASTICSEARCH_ENABLED:
+    #xjh：创建Elasticsearch连接
     connections.create_connection(
         hosts=[settings.ELASTICSEARCH_DSL['default']['hosts']])
     from elasticsearch import Elasticsearch
@@ -21,6 +23,7 @@ if ELASTICSEARCH_ENABLED:
     try:
         c.get_pipeline('geoip')
     except elasticsearch.exceptions.NotFoundError:
+        #xjh：创建geoip处理管道，用于IP地址地理位置解析
         c.put_pipeline('geoip', body='''{
               "description" : "Add geoip info",
               "processors" : [
@@ -34,6 +37,7 @@ if ELASTICSEARCH_ENABLED:
 
 
 class GeoIp(InnerDoc):
+    """xjh：IP地理位置信息文档结构"""
     continent_name = Keyword()
     country_iso_code = Keyword()
     country_name = Keyword()
@@ -41,21 +45,25 @@ class GeoIp(InnerDoc):
 
 
 class UserAgentBrowser(InnerDoc):
+    """xjh：用户代理浏览器信息文档结构"""
     Family = Keyword()
     Version = Keyword()
 
 
 class UserAgentOS(UserAgentBrowser):
+    """xjh：用户代理操作系统信息文档结构"""
     pass
 
 
 class UserAgentDevice(InnerDoc):
+    """xjh：用户代理设备信息文档结构"""
     Family = Keyword()
     Brand = Keyword()
     Model = Keyword()
 
 
 class UserAgent(InnerDoc):
+    """xjh：完整的用户代理信息文档结构"""
     browser = Object(UserAgentBrowser, required=False)
     os = Object(UserAgentOS, required=False)
     device = Object(UserAgentDevice, required=False)
@@ -64,6 +72,7 @@ class UserAgent(InnerDoc):
 
 
 class ElapsedTimeDocument(Document):
+    """xjh：页面加载耗时记录文档"""
     url = Keyword()
     time_taken = Long()
     log_datetime = Date()
@@ -83,8 +92,10 @@ class ElapsedTimeDocument(Document):
 
 
 class ElaspedTimeDocumentManager:
+    """xjh：耗时文档管理器"""
     @staticmethod
     def build_index():
+        """xjh：构建性能索引"""
         from elasticsearch import Elasticsearch
         client = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
         res = client.indices.exists(index="performance")
@@ -93,12 +104,14 @@ class ElaspedTimeDocumentManager:
 
     @staticmethod
     def delete_index():
+        """xjh：删除性能索引"""
         from elasticsearch import Elasticsearch
         es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
         es.indices.delete(index='performance', ignore=[400, 404])
 
     @staticmethod
     def create(url, time_taken, log_datetime, useragent, ip):
+        """xjh：创建耗时记录"""
         ElaspedTimeDocumentManager.build_index()
         ua = UserAgent()
         ua.browser = UserAgentBrowser()
@@ -116,6 +129,7 @@ class ElaspedTimeDocumentManager:
         ua.string = useragent.ua_string
         ua.is_bot = useragent.is_bot
 
+        #xjh：使用当前时间戳作为文档ID
         doc = ElapsedTimeDocument(
             meta={
                 'id': int(
@@ -127,10 +141,11 @@ class ElaspedTimeDocumentManager:
             time_taken=time_taken,
             log_datetime=log_datetime,
             useragent=ua, ip=ip)
-        doc.save(pipeline="geoip")
+        doc.save(pipeline="geoip")  #xjh：保存文档并通过geoip管道处理
 
 
 class ArticleDocument(Document):
+    """xjh：文章搜索文档结构"""
     body = Text(analyzer='ik_max_word', search_analyzer='ik_smart')
     title = Text(analyzer='ik_max_word', search_analyzer='ik_smart')
     author = Object(properties={
@@ -165,19 +180,23 @@ class ArticleDocument(Document):
 
 
 class ArticleDocumentManager():
+    """xjh：文章文档管理器"""
 
     def __init__(self):
         self.create_index()
 
     def create_index(self):
+        """xjh：创建文章索引"""
         ArticleDocument.init()
 
     def delete_index(self):
+        """xjh：删除文章索引"""
         from elasticsearch import Elasticsearch
         es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts'])
         es.indices.delete(index='blog', ignore=[400, 404])
 
     def convert_to_doc(self, articles):
+        """xjh：将文章对象转换为搜索文档"""
         return [
             ArticleDocument(
                 meta={
@@ -202,6 +221,7 @@ class ArticleDocumentManager():
                 article_order=article.article_order) for article in articles]
 
     def rebuild(self, articles=None):
+        """xjh：重建文章索引"""
         ArticleDocument.init()
         articles = articles if articles else Article.objects.all()
         docs = self.convert_to_doc(articles)
@@ -209,5 +229,6 @@ class ArticleDocumentManager():
             doc.save()
 
     def update_docs(self, docs):
+        """xjh：更新文档"""
         for doc in docs:
-            doc.save()
+            doc.save()

src/DjangoBlog-master/blog/forms.py

@@ -7,13 +7,15 @@ logger = logging.getLogger(__name__)
 
 
 class BlogSearchForm(SearchForm):
+    """xjh：博客搜索表单"""
     querydata = forms.CharField(required=True)
 
     def search(self):
+        """xjh：执行搜索"""
         datas = super(BlogSearchForm, self).search()
         if not self.is_valid():
             return self.no_query_found()
 
         if self.cleaned_data['querydata']:
             logger.info(self.cleaned_data['querydata'])
-        return datas
+        return datas

src/DjangoBlog-master/blog/middleware.py

@@ -10,14 +10,16 @@ logger = logging.getLogger(__name__)
 
 
 class OnlineMiddleware(object):
+    """xjh：在线中间件，用于记录页面加载时间和用户访问信息"""
     def __init__(self, get_response=None):
         self.get_response = get_response
         super().__init__()
 
     def __call__(self, request):
-        ''' page render time '''
+        ''' xjh：页面渲染时间统计 '''
         start_time = time.time()
         response = self.get_response(request)
+        #xjh：获取用户IP和User-Agent信息
         http_user_agent = request.META.get('HTTP_USER_AGENT', '')
         ip, _ = get_client_ip(request)
         user_agent = parse(http_user_agent)
@@ -25,6 +27,7 @@ class OnlineMiddleware(object):
             try:
                 cast_time = time.time() - start_time
                 if ELASTICSEARCH_ENABLED:
+                    #xjh：记录页面加载耗时到Elasticsearch
                     time_taken = round((cast_time) * 1000, 2)
                     url = request.path
                     from django.utils import timezone
@@ -34,9 +37,10 @@ class OnlineMiddleware(object):
                         log_datetime=timezone.now(),
                         useragent=user_agent,
                         ip=ip)
+                #xjh：在页面内容中替换加载时间占位符
                 response.content = response.content.replace(
                     b'<!!LOAD_TIMES!!>', str.encode(str(cast_time)[:5]))
             except Exception as e:
                 logger.error("Error OnlineMiddleware: %s" % e)
 
-        return response
+        return response

src/DjangoBlog-master/blog/models.py

@@ -18,6 +18,7 @@ logger = logging.getLogger(__name__)
 
 
 class LinkShowType(models.TextChoices):
+    """xjh：链接显示类型选择"""
     I = ('i', _('index'))
     L = ('l', _('list'))
     P = ('p', _('post'))
@@ -26,17 +27,20 @@ class LinkShowType(models.TextChoices):
 
 
 class BaseModel(models.Model):
+    """xjh：基础模型类，包含公共字段"""
     id = models.AutoField(primary_key=True)
     creation_time = models.DateTimeField(_('creation time'), default=now)
     last_modify_time = models.DateTimeField(_('modify time'), default=now)
 
     def save(self, *args, **kwargs):
+        #xjh：特殊处理文章浏览量更新
         is_update_views = isinstance(
             self,
             Article) and 'update_fields' in kwargs and kwargs['update_fields'] == ['views']
         if is_update_views:
             Article.objects.filter(pk=self.pk).update(views=self.views)
         else:
+            #xjh：自动生成slug字段
             if 'slug' in self.__dict__:
                 slug = getattr(
                     self, 'title') if 'title' in self.__dict__ else getattr(
@@ -45,6 +49,7 @@ class BaseModel(models.Model):
             super().save(*args, **kwargs)
 
     def get_full_url(self):
+        """xjh：获取完整URL"""
         site = get_current_site().domain
         url = "https://{site}{path}".format(site=site,
                                             path=self.get_absolute_url())
@@ -55,11 +60,12 @@ class BaseModel(models.Model):
 
     @abstractmethod
     def get_absolute_url(self):
+        """xjh：抽象方法，获取绝对URL"""
         pass
 
 
 class Article(BaseModel):
-    """文章"""
+    """xjh：文章模型"""
     STATUS_CHOICES = (
         ('d', _('Draft')),
         ('p', _('Published')),
@@ -118,6 +124,7 @@ class Article(BaseModel):
         get_latest_by = 'id'
 
     def get_absolute_url(self):
+        """xjh：获取文章绝对URL"""
         return reverse('blog:detailbyid', kwargs={
             'article_id': self.id,
             'year': self.creation_time.year,
@@ -127,6 +134,7 @@ class Article(BaseModel):
 
     @cache_decorator(60 * 60 * 10)
     def get_category_tree(self):
+        """xjh：获取分类树"""
         tree = self.category.get_category_tree()
         names = list(map(lambda c: (c.name, c.get_absolute_url()), tree))
 
@@ -136,10 +144,12 @@ class Article(BaseModel):
         super().save(*args, **kwargs)
 
     def viewed(self):
+        """xjh：增加文章浏览量"""
         self.views += 1
         self.save(update_fields=['views'])
 
     def comment_list(self):
+        """xjh：获取文章评论列表"""
         cache_key = 'article_comments_{id}'.format(id=self.id)
         value = cache.get(cache_key)
         if value:
@@ -152,23 +162,24 @@ class Article(BaseModel):
             return comments
 
     def get_admin_url(self):
+        """xjh：获取文章管理后台URL"""
         info = (self._meta.app_label, self._meta.model_name)
         return reverse('admin:%s_%s_change' % info, args=(self.pk,))
 
     @cache_decorator(expiration=60 * 100)
     def next_article(self):
-        # 下一篇
+        """xjh：获取下一篇文章"""
         return Article.objects.filter(
             id__gt=self.id, status='p').order_by('id').first()
 
     @cache_decorator(expiration=60 * 100)
     def prev_article(self):
-        # 前一篇
+        """xjh：获取上一篇文章"""
         return Article.objects.filter(id__lt=self.id, status='p').first()
 
     def get_first_image_url(self):
         """
-        Get the first image url from article.body.
+        xjh：从文章内容中提取第一张图片URL
         :return:
         """
         match = re.search(r'!\[.*?\]\((.+?)\)', self.body)
@@ -178,7 +189,7 @@ class Article(BaseModel):
 
 
 class Category(BaseModel):
-    """文章分类"""
+    """xjh：文章分类模型"""
     name = models.CharField(_('category name'), max_length=30, unique=True)
     parent_category = models.ForeignKey(
         'self',
@@ -205,7 +216,7 @@ class Category(BaseModel):
     @cache_decorator(60 * 60 * 10)
     def get_category_tree(self):
         """
-        递归获得分类目录的父级
+        xjh：递归获得分类目录的父级
         :return:
         """
         categorys = []
@@ -221,7 +232,7 @@ class Category(BaseModel):
     @cache_decorator(60 * 60 * 10)
     def get_sub_categorys(self):
         """
-        获得当前分类目录所有子集
+        xjh：获得当前分类目录所有子集
         :return:
         """
         categorys = []
@@ -241,7 +252,7 @@ class Category(BaseModel):
 
 
 class Tag(BaseModel):
-    """文章标签"""
+    """xjh：文章标签模型"""
     name = models.CharField(_('tag name'), max_length=30, unique=True)
     slug = models.SlugField(default='no-slug', max_length=60, blank=True)
 
@@ -253,6 +264,7 @@ class Tag(BaseModel):
 
     @cache_decorator(60 * 60 * 10)
     def get_article_count(self):
+        """xjh：获取标签下的文章数量"""
         return Article.objects.filter(tags__name=self.name).distinct().count()
 
     class Meta:
@@ -262,7 +274,7 @@ class Tag(BaseModel):
 
 
 class Links(models.Model):
-    """友情链接"""
+    """xjh：友情链接模型"""
 
     name = models.CharField(_('link name'), max_length=30, unique=True)
     link = models.URLField(_('link'))
@@ -287,7 +299,7 @@ class Links(models.Model):
 
 
 class SideBar(models.Model):
-    """侧边栏,可以展示一些html内容"""
+    """xjh：侧边栏模型，可以展示一些html内容"""
     name = models.CharField(_('title'), max_length=100)
     content = models.TextField(_('content'))
     sequence = models.IntegerField(_('order'), unique=True)
@@ -305,7 +317,7 @@ class SideBar(models.Model):
 
 
 class BlogSettings(models.Model):
-    """blog的配置"""
+    """xjh：博客设置模型"""
     site_name = models.CharField(
         _('site name'),
         max_length=200,
@@ -367,10 +379,12 @@ class BlogSettings(models.Model):
         return self.site_name
 
     def clean(self):
+        """xjh：验证只能有一个博客配置实例"""
         if BlogSettings.objects.exclude(id=self.id).count():
             raise ValidationError(_('There can only be one configuration'))
 
     def save(self, *args, **kwargs):
+        """xjh：保存时清除缓存"""
         super().save(*args, **kwargs)
         from djangoblog.utils import cache
-        cache.clear()
+        cache.clear()

src/DjangoBlog-master/blog/search_indexes.py

@@ -4,10 +4,13 @@ from blog.models import Article
 
 
 class ArticleIndex(indexes.SearchIndex, indexes.Indexable):
+    """xjh：文章搜索索引配置"""
     text = indexes.CharField(document=True, use_template=True)
 
     def get_model(self):
+        """xjh：指定搜索模型"""
         return Article
 
     def index_queryset(self, using=None):
-        return self.get_model().objects.filter(status='p')
+        """xjh：指定索引查询集，只索引已发布的文章"""
+        return self.get_model().objects.filter(status='p')

src/DjangoBlog-master/blog/tests.py

@@ -20,11 +20,13 @@ from oauth.models import OAuthUser, OAuthConfig
 # Create your tests here.
 
 class ArticleTest(TestCase):
+    """xjh：文章相关测试用例"""
     def setUp(self):
         self.client = Client()
         self.factory = RequestFactory()
 
     def test_validate_article(self):
+        """xjh：测试文章相关功能"""
         site = get_current_site().domain
         user = BlogUser.objects.get_or_create(
             email="liangliangyy@gmail.com",
@@ -149,6 +151,7 @@ class ArticleTest(TestCase):
         self.client.get('/admin/admin/logentry/1/change/')
 
     def check_pagination(self, p, type, value):
+        """xjh：检查分页功能"""
         for page in range(1, p.num_pages + 1):
             s = load_pagination_info(p.page(page), type, value)
             self.assertIsNotNone(s)
@@ -160,6 +163,7 @@ class ArticleTest(TestCase):
                 self.assertEqual(response.status_code, 200)
 
     def test_image(self):
+        """xjh：测试图片上传和处理功能"""
         import requests
         rsp = requests.get(
             'https://www.python.org/static/img/python-logo.png')
@@ -183,10 +187,12 @@ class ArticleTest(TestCase):
             'https://www.python.org/static/img/python-logo.png')
 
     def test_errorpage(self):
+        """xjh：测试错误页面"""
         rsp = self.client.get('/eee')
         self.assertEqual(rsp.status_code, 404)
 
     def test_commands(self):
+        """xjh：测试管理命令"""
         user = BlogUser.objects.get_or_create(
             email="liangliangyy@gmail.com",
             username="liangliangyy")[0]
@@ -229,4 +235,4 @@ class ArticleTest(TestCase):
         call_command("create_testdata")
         call_command("clear_cache")
         call_command("sync_user_avatar")
-        call_command("build_search_words")
+        call_command("build_search_words")

src/DjangoBlog-master/blog/urls.py

@@ -5,58 +5,71 @@ from . import views
 
 app_name = "blog"
 urlpatterns = [
+    #xjh：首页
     path(
         r'',
         views.IndexView.as_view(),
         name='index'),
+    #xjh：首页分页
     path(
         r'page/<int:page>/',
         views.IndexView.as_view(),
         name='index_page'),
+    #xjh：文章详情页
     path(
         r'article/<int:year>/<int:month>/<int:day>/<int:article_id>.html',
         views.ArticleDetailView.as_view(),
         name='detailbyid'),
+    #xjh：分类目录页
     path(
         r'category/<slug:category_name>.html',
         views.CategoryDetailView.as_view(),
         name='category_detail'),
+    #xjh：分类目录分页
     path(
         r'category/<slug:category_name>/<int:page>.html',
         views.CategoryDetailView.as_view(),
         name='category_detail_page'),
+    #xjh：作者文章页
     path(
         r'author/<author_name>.html',
         views.AuthorDetailView.as_view(),
         name='author_detail'),
+    #xjh：作者文章分页
     path(
         r'author/<author_name>/<int:page>.html',
         views.AuthorDetailView.as_view(),
         name='author_detail_page'),
+    #xjh：标签文章页
     path(
         r'tag/<slug:tag_name>.html',
         views.TagDetailView.as_view(),
         name='tag_detail'),
+    #xjh：标签文章分页
     path(
         r'tag/<slug:tag_name>/<int:page>.html',
         views.TagDetailView.as_view(),
         name='tag_detail_page'),
+    #xjh：文章归档页（缓存1小时）
     path(
         'archives.html',
         cache_page(
             60 * 60)(
             views.ArchivesView.as_view()),
         name='archives'),
+    #xjh：友情链接页
     path(
         'links.html',
         views.LinkListView.as_view(),
         name='links'),
+    #xjh：文件上传接口
     path(
         r'upload',
         views.fileupload,
         name='upload'),
+    #xjh：清理缓存接口
     path(
         r'clean',
         views.clean_cache_view,
         name='clean'),
-]
+]

src/DjangoBlog-master/blog/views.py

@@ -25,6 +25,7 @@ logger = logging.getLogger(__name__)
 
 
 class ArticleListView(ListView):
+    """xjh：文章列表视图基类"""
     # template_name属性用于指定使用哪个模板进行渲染
     template_name = 'blog/article_index.html'
 
@@ -61,7 +62,7 @@ class ArticleListView(ListView):
 
     def get_queryset_from_cache(self, cache_key):
         '''
-        缓存页面数据
+        xjh：缓存页面数据
         :param cache_key: 缓存key
         :return:
         '''
@@ -77,7 +78,7 @@ class ArticleListView(ListView):
 
     def get_queryset(self):
         '''
-        重写默认，从缓存获取数据
+        xjh：重写默认，从缓存获取数据
         :return:
         '''
         key = self.get_queryset_cache_key()
@@ -91,7 +92,7 @@ class ArticleListView(ListView):
 
 class IndexView(ArticleListView):
     '''
-    首页
+    xjh：首页视图
     '''
     # 友情链接类型
     link_type = LinkShowType.I
@@ -107,7 +108,7 @@ class IndexView(ArticleListView):
 
 class ArticleDetailView(DetailView):
     '''
-    文章详情页面
+    xjh：文章详情页面视图
     '''
     template_name = 'blog/article_detail.html'
     model = Article
@@ -163,7 +164,7 @@ class ArticleDetailView(DetailView):
 
 class CategoryDetailView(ArticleListView):
     '''
-    分类目录列表
+    xjh：分类目录列表视图
     '''
     page_type = "分类目录归档"
 
@@ -202,7 +203,7 @@ class CategoryDetailView(ArticleListView):
 
 class AuthorDetailView(ArticleListView):
     '''
-    作者详情页
+    xjh：作者详情页视图
     '''
     page_type = '作者文章归档'
 
@@ -228,7 +229,7 @@ class AuthorDetailView(ArticleListView):
 
 class TagDetailView(ArticleListView):
     '''
-    标签列表页面
+    xjh：标签列表页面视图
     '''
     page_type = '分类标签归档'
 
@@ -260,7 +261,7 @@ class TagDetailView(ArticleListView):
 
 class ArchivesView(ArticleListView):
     '''
-    文章归档页面
+    xjh：文章归档页面视图
     '''
     page_type = '文章归档'
     paginate_by = None
@@ -276,6 +277,7 @@ class ArchivesView(ArticleListView):
 
 
 class LinkListView(ListView):
+    """xjh：友情链接列表视图"""
     model = Links
     template_name = 'blog/links_list.html'
 
@@ -284,6 +286,7 @@ class LinkListView(ListView):
 
 
 class EsSearchView(SearchView):
+    """xjh：Elasticsearch搜索视图"""
     def get_context(self):
         paginator, page = self.build_page()
         context = {
@@ -303,7 +306,7 @@ class EsSearchView(SearchView):
 @csrf_exempt
 def fileupload(request):
     """
-    该方法需自己写调用端来上传图片，该方法仅提供图床功能
+    xjh：文件上传接口，该方法需自己写调用端来上传图片，该方法仅提供图床功能
     :param request:
     :return:
     """
@@ -344,6 +347,7 @@ def page_not_found_view(
         request,
         exception,
         template_name='blog/error_page.html'):
+    """xjh：404页面处理视图"""
     if exception:
         logger.error(exception)
     url = request.get_full_path()
@@ -355,6 +359,7 @@ def page_not_found_view(
 
 
 def server_error_view(request, template_name='blog/error_page.html'):
+    """xjh：500页面处理视图"""
     return render(request,
                   template_name,
                   {'message': _('Sorry, the server is busy, please click the home page to see other?'),
@@ -366,6 +371,7 @@ def permission_denied_view(
         request,
         exception,
         template_name='blog/error_page.html'):
+    """xjh：403页面处理视图"""
     if exception:
         logger.error(exception)
     return render(
@@ -375,5 +381,6 @@ def permission_denied_view(
 
 
 def clean_cache_view(request):
+    """xjh：清理缓存视图"""
     cache.clear()
-    return HttpResponse('ok')
+    return HttpResponse('ok')

src/DjangoBlog-master/comments/admin.py

@@ -0,0 +1,47 @@
+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 _
+
+
+def disable_commentstatus(modeladmin, request, queryset):
+    queryset.update(is_enable=False)  # 杨智鑫：批量设置评论为禁用状态
+
+
+def enable_commentstatus(modeladmin, request, queryset):
+    queryset.update(is_enable=True)  # 杨智鑫：批量设置评论为启用状态
+
+
+disable_commentstatus.short_description = _('Disable comments')  # 杨智鑫：批量禁用评论
+enable_commentstatus.short_description = _('Enable comments')   # 杨智鑫：批量启用评论
+
+
+class CommentAdmin(admin.ModelAdmin):
+    list_per_page = 20
+    list_display = (
+        'id',
+        'body',
+        'link_to_userinfo',
+        'link_to_article',
+        'is_enable',
+        'creation_time')  # 杨智鑫：显示
+    list_display_links = ('id', 'body', 'is_enable')  # 杨智鑫：可点击
+    list_filter = ('is_enable',)  # 杨智鑫：过滤
+    exclude = ('creation_time', 'last_modify_time')  # 杨智鑫：不显示创建时间
+    actions = [disable_commentstatus, enable_commentstatus]  # 杨智鑫：批量操作
+
+    def link_to_userinfo(self, obj):
+        info = (obj.author._meta.app_label, obj.author._meta.model_name)  # 杨智鑫：获取用户信息
+        link = reverse('admin:%s_%s_change' % info, args=(obj.author.id,))  # 杨智鑫：获取用户信息
+        return format_html(
+            u'<a href="%s">%s</a>' %
+            (link, obj.author.nickname if obj.author.nickname else obj.author.email)) # 杨智鑫：获取用户信息
+
+    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(
+            u'<a href="%s">%s</a>' % (link, obj.article.title))  # 杨智鑫：获取文章信息
+
+    link_to_userinfo.short_description = _('User') # 杨智鑫：用户
+    link_to_article.short_description = _('Article')  # 杨智鑫：文章

src/DjangoBlog-master/comments/apps.py

@@ -2,4 +2,4 @@ from django.apps import AppConfig
 
 
 class CommentsConfig(AppConfig):
-    name = 'comments'
+    name = 'comments'   # 杨智鑫：应用名称

src/DjangoBlog-master/comments/forms.py

@@ -0,0 +1,13 @@
+from django import forms
+from django.forms import ModelForm
+
+from .models import Comment
+
+
+class CommentForm(ModelForm):
+    parent_comment_id = forms.IntegerField(
+        widget=forms.HiddenInput, required=False) # 杨智鑫：隐藏字段，用于处理回复评论的父评论ID
+
+    class Meta:
+        model = Comment # 杨智鑫：指定表单关联的模型
+        fields = ['body']  # 杨智鑫：表单只包含评论内容字段

src/DjangoBlog-master/comments/models.py

@@ -9,31 +9,31 @@ from blog.models import Article
 # Create your models here.
 
 class Comment(models.Model):
-    body = models.TextField('正文', max_length=300)
-    creation_time = models.DateTimeField(_('creation time'), default=now)
-    last_modify_time = models.DateTimeField(_('last modify time'), default=now)
+    body = models.TextField('正文', max_length=300)  # 杨智鑫：评论正文，最大长度300字符
+    creation_time = models.DateTimeField(_('creation time'), default=now)     # 杨智鑫：评论创建时间
+    last_modify_time = models.DateTimeField(_('last modify time'), default=now)  # 杨智鑫：最后修改时间
     author = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         verbose_name=_('author'),
-        on_delete=models.CASCADE)
+        on_delete=models.CASCADE) # 杨智鑫：关联用户模型，删除用户时级联删除评论
     article = models.ForeignKey(
         Article,
         verbose_name=_('article'),
-        on_delete=models.CASCADE)
+        on_delete=models.CASCADE) # 杨智鑫：关联文章模型，删除文章时级联删除评论
     parent_comment = models.ForeignKey(
         'self',
         verbose_name=_('parent comment'),
         blank=True,
         null=True,
-        on_delete=models.CASCADE)
+        on_delete=models.CASCADE) # 杨智鑫：关联父级评论，默认为空
     is_enable = models.BooleanField(_('enable'),
-                                    default=False, blank=False, null=False)
+                                    default=False, blank=False, null=False)  # 杨智鑫：是否启用
 
     class Meta:
-        ordering = ['-id']
-        verbose_name = _('comment')
-        verbose_name_plural = verbose_name
-        get_latest_by = 'id'
+        ordering = ['-id']  # 杨智鑫：排序
+        verbose_name = _('comment')  # 杨智鑫：模型名称
+        verbose_name_plural = verbose_name  # 杨智鑫：模型名称复数
+        get_latest_by = 'id'  # 杨智鑫：获取最新
 
     def __str__(self):
-        return self.body
+        return self.body  # 杨智鑫：返回评论内容

src/DjangoBlog-master/comments/tests.py

@@ -0,0 +1,109 @@
+from django.test import Client, RequestFactory, TransactionTestCase
+from django.urls import reverse
+
+from accounts.models import BlogUser
+from blog.models import Category, Article
+from comments.models import Comment
+from comments.templatetags.comments_tags import *  # 杨智鑫：导入所有模板标签函数
+from djangoblog.utils import get_max_articleid_commentid
+
+
+# Create your tests here.
+
+class CommentsTest(TransactionTestCase):
+    def setUp(self):
+        self.client = Client()  # 杨智鑫：创建一个client
+        self.factory = RequestFactory()  # 杨智鑫：创建一个factory
+        from blog.models import BlogSettings
+        value = BlogSettings()  # 杨智鑫：创建一个BlogSettings对象
+        value.comment_need_review = True   # 杨智鑫：设置评论是否需要审核
+        value.save()   # 杨智鑫：保存
+
+        self.user = BlogUser.objects.create_superuser(
+            email="liangliangyy1@gmail.com",
+            username="liangliangyy1",
+            password="liangliangyy1")  # 杨智鑫：创建一个用户
+
+    def update_article_comment_status(self, article):
+        comments = article.comment_set.all()
+        for comment in comments:  # 杨智鑫：遍历所有评论
+            comment.is_enable = True  # 杨智鑫：设置评论是否可用
+            comment.save()   # 杨智鑫：保存
+
+    def test_validate_comment(self):
+        self.client.login(username='liangliangyy1', password='liangliangyy1')  # 杨智鑫：登录
+
+        category = Category()  # 杨智鑫：创建一个分类
+        category.name = "categoryccc"  # 杨智鑫：创建一个分类
+        category.save()
+
+        article = Article()  # 杨智鑫：创建一个文章
+        article.title = "nicetitleccc"   # 杨智鑫：创建一个文章
+        article.body = "nicecontentccc" # 杨智鑫：创建一个文章
+        article.author = self.user
+        article.category = category
+        article.type = 'a'
+        article.status = 'p'
+        article.save()   # 杨智鑫：保存
+
+        comment_url = reverse(
+            'comments:postcomment', kwargs={
+                'article_id': article.id})
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '123ffffffffff'
+                                    })
+
+        self.assertEqual(response.status_code, 302)  # 杨智鑫：判断返回状态码
+
+        article = Article.objects.get(pk=article.pk)
+        self.assertEqual(len(article.comment_list()), 0) #杨智鑫：判断评论数量
+        self.update_article_comment_status(article)
+
+        self.assertEqual(len(article.comment_list()), 1)  #杨智鑫：判断评论数量
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '123ffffffffff',
+                                    })   # 杨智鑫：提交数据
+
+        self.assertEqual(response.status_code, 302)  # 杨智鑫：判断返回状态码
+
+        article = Article.objects.get(pk=article.pk)   # 杨智鑫：获取文章
+        self.update_article_comment_status(article)  # 杨智鑫：更新文章评论状态
+        self.assertEqual(len(article.comment_list()), 2)  #杨智鑫：判断评论数量
+        parent_comment_id = article.comment_list()[0].id #杨智鑫：获取父评论id
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '''
+                                        # Title1
+
+        ```python
+        import os
+        ```
+
+        [url](https://www.lylinux.net/)
+
+        [ddd](http://www.baidu.com)
+
+
+        ''',
+                                        'parent_comment_id': parent_comment_id
+                                    })  # 杨智鑫：提交数据
+
+        self.assertEqual(response.status_code, 302)  # 杨智鑫：判断返回状态码
+        self.update_article_comment_status(article)    # 杨智鑫：更新文章评论状态
+        article = Article.objects.get(pk=article.pk)   # 杨智鑫：获取文章
+        self.assertEqual(len(article.comment_list()), 3)  # 杨智鑫：判断评论数量
+        comment = Comment.objects.get(id=parent_comment_id)  # 杨智鑫：获取父评论
+        tree = parse_commenttree(article.comment_list(), comment)  # 杨智鑫：获取子评论
+        self.assertEqual(len(tree), 1)  # 杨智鑫：判断子评论数量
+        data = show_comment_item(comment, True)  # 杨智鑫：获取评论项
+        self.assertIsNotNone(data)  # 杨智鑫：判断数据是否为空
+        s = get_max_articleid_commentid()  # 杨智鑫：获取最大文章id和评论id
+        self.assertIsNotNone(s)  # 杨智鑫：判断数据是否为空
+
+        from comments.utils import send_comment_email
+        send_comment_email(comment)  # 杨智鑫：发送邮件

src/DjangoBlog-master/comments/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from . import views
+
+app_name = "comments"  # 杨智鑫：定义应用命名空间
+urlpatterns = [
+    path(
+        'article/<int:article_id>/postcomment',
+        views.CommentPostView.as_view(),  # 杨智鑫：定义路由
+        name='postcomment'),  # 杨智鑫：定义路由名称
+]