diff --git a/doc/第六周鞠泆男用例说明.docx b/doc/第六周鞠泆男用例说明.docx
new file mode 100644
index 0000000..ffac333
Binary files /dev/null and b/doc/第六周鞠泆男用例说明.docx differ
diff --git a/src/django-master/accounts/admin.py b/src/django-master/accounts/admin.py
index bc63321..bd5ed47 100644
--- a/src/django-master/accounts/admin.py
+++ b/src/django-master/accounts/admin.py
@@ -4,7 +4,7 @@ from django.contrib.auth.forms import UserChangeForm
 from django.contrib.auth.forms import UsernameField
 from django.utils.translation import gettext_lazy as _
 
-# 导入自定义用户模型
+# jyn:导入自定义用户模型
 from .models import BlogUser
 
 
@@ -13,15 +13,15 @@ class BlogUserCreationForm(forms.ModelForm):
     自定义用户创建表单，用于在管理员界面添加新用户
     继承自ModelForm，提供密码验证功能
     """
-    # 密码字段，使用PasswordInput小部件确保输入不可见
+    # jyn:密码字段，使用PasswordInput小部件确保输入不可见
     password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput)
-    # 确认密码字段，用于验证两次输入的密码是否一致
+    # jyn:确认密码字段，用于验证两次输入的密码是否一致
     password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput)
 
     class Meta:
-        # 指定关联的模型
+        # jyn:指定关联的模型
         model = BlogUser
-        # 表单中包含的字段，这里只显示邮箱
+        # jyn:表单中包含的字段，这里只显示邮箱
         fields = ('email',)
 
     def clean_password2(self):
@@ -31,7 +31,7 @@ class BlogUserCreationForm(forms.ModelForm):
         """
         password1 = self.cleaned_data.get("password1")
         password2 = self.cleaned_data.get("password2")
-        # 检查密码是否存在且不一致
+        # jyn:检查密码是否存在且不一致
         if password1 and password2 and password1 != password2:
             raise forms.ValidationError(_("passwords do not match"))
         return password2
@@ -41,12 +41,12 @@ class BlogUserCreationForm(forms.ModelForm):
         重写保存方法，确保密码以哈希形式存储
         而不是明文存储
         """
-        # 先调用父类方法获取用户对象，但不立即保存到数据库
+        # jyn:先调用父类方法获取用户对象，但不立即保存到数据库
         user = super().save(commit=False)
-        # 使用set_password方法对密码进行哈希处理
+        # jyn:使用set_password方法对密码进行哈希处理
         user.set_password(self.cleaned_data["password1"])
         if commit:
-            # 标记用户来源为管理员站点
+            # jyn:标记用户来源为管理员站点
             user.source = 'adminsite'
             user.save()
         return user
@@ -58,11 +58,11 @@ class BlogUserChangeForm(UserChangeForm):
     继承自Django内置的UserChangeForm
     """
     class Meta:
-        # 指定关联的模型
+        # jyn:指定关联的模型
         model = BlogUser
-        # 显示所有字段
+        # jyn:显示所有字段
         fields = '__all__'
-        # 指定用户名字段的处理类
+        # jyn:指定用户名字段的处理类
         field_classes = {'username': UsernameField}
 
     def __init__(self, *args, **kwargs):
@@ -75,11 +75,11 @@ class BlogUserAdmin(UserAdmin):
     自定义用户管理员类，用于在Django管理后台配置用户模型的显示和操作
     继承自Django内置的UserAdmin
     """
-    # 指定编辑用户时使用的表单
+    # jyn:指定编辑用户时使用的表单
     form = BlogUserChangeForm
-    # 指定添加用户时使用的表单
+    # jyn:指定添加用户时使用的表单
     add_form = BlogUserCreationForm
-    # 列表页面显示的字段
+    # jyn:列表页面显示的字段
     list_display = (
         'id',
         'nickname',
@@ -89,7 +89,7 @@ class BlogUserAdmin(UserAdmin):
         'date_joined',
         'source'
     )
-    # 列表页面中可点击跳转的字段
+    # jyn:列表页面中可点击跳转的字段
     list_display_links = ('id', 'username')
-    # 排序方式，按id降序排列（最新的用户在前）
+    # jyn:排序方式，按id降序排列（最新的用户在前）
     ordering = ('-id',)
\ No newline at end of file
diff --git a/src/django-master/accounts/apps.py b/src/django-master/accounts/apps.py
index 34121a3..2a51746 100644
--- a/src/django-master/accounts/apps.py
+++ b/src/django-master/accounts/apps.py
@@ -8,6 +8,6 @@ class AccountsConfig(AppConfig):
     每个Django应用都需要一个配置类，用于设置应用的各种属性和行为
     通常放在应用目录下的apps.py文件中
     """
-    # 应用的名称，必须与应用目录名一致
-    # 这个名称会被Django用来识别和管理应用
+    # jyn:应用的名称，必须与应用目录名一致
+    # jyn:这个名称会被Django用来识别和管理应用
     name = 'accounts'
\ No newline at end of file
diff --git a/src/django-master/accounts/forms.py b/src/django-master/accounts/forms.py
index 81e3f25..2df6c7d 100644
--- a/src/django-master/accounts/forms.py
+++ b/src/django-master/accounts/forms.py
@@ -28,8 +28,8 @@ 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  # 导入自定义用户模型
+from . import utils  # jyn:导入自定义工具模块，可能用于验证码验证等功能
+from .models import BlogUser  # jyn:导入自定义用户模型
 
 
 class LoginForm(AuthenticationForm):
@@ -38,15 +38,19 @@ class LoginForm(AuthenticationForm):
     用于处理用户登录验证，主要扩展了表单字段的样式
     """
     def __init__(self, *args, **kwargs):
-        # 调用父类构造方法初始化表单
+        # jyn:调用父类构造方法初始化表单
         super(LoginForm, self).__init__(*args, **kwargs)
         
-        # 自定义用户名输入框：添加占位符和CSS类
+        # jyn:自定义用户名输入框：添加占位符和CSS类
         self.fields['username'].widget = widgets.TextInput(
             attrs={'placeholder': "username", "class": "form-control"})
         
+<<<<<<< HEAD
         # 自定义密码输入框：添加占位符和CSS类
 >>>>>>> 8b27cdad9a9ccc84febce3bcf1d211ed109f96f2
+=======
+        # jyn:自定义密码输入框：添加占位符和CSS类
+>>>>>>> ef493f43496bf1ae99bf4389327ac0ae80bb9ae1
         self.fields['password'].widget = widgets.PasswordInput(
             attrs={'placeholder': "password", "class": "form-control"}) #为密码字段设置密码输入小部件，同样定义占位符和样式类。
 
@@ -63,10 +67,10 @@ class RegisterForm(UserCreationForm):
     """
 >>>>>>> 8b27cdad9a9ccc84febce3bcf1d211ed109f96f2
     def __init__(self, *args, **kwargs):
-        # 调用父类构造方法初始化表单
+        # jyn:调用父类构造方法初始化表单
         super(RegisterForm, self).__init__(*args, **kwargs)
 
-        # 自定义各字段的输入控件，添加样式和占位符
+        # jyn:自定义各字段的输入控件，添加样式和占位符
         self.fields['username'].widget = widgets.TextInput(
             attrs={'placeholder': "username", "class": "form-control"})
         self.fields['email'].widget = widgets.EmailInput(
@@ -82,14 +86,14 @@ class RegisterForm(UserCreationForm):
         表单验证机制中，以clean_为前缀的方法会自动被调用
         """
         email = self.cleaned_data['email']
-        # 检查该邮箱是否已存在于数据库中
+        # jyn:检查该邮箱是否已存在于数据库中
         if get_user_model().objects.filter(email=email).exists():
-            raise ValidationError(_("email already exists"))  # 抛出验证错误
+            raise ValidationError(_("email already exists"))  #jyn: 抛出验证错误
         return email
 
     class Meta:
-        model = get_user_model()  # 使用项目配置的用户模型（可能是自定义的BlogUser）
-        fields = ("username", "email")  # 注册表单中显示的字段
+        model = get_user_model()  # jyn:使用项目配置的用户模型（可能是自定义的BlogUser）
+        fields = ("username", "email")  # jyn:注册表单中显示的字段
 
 
 class ForgetPasswordForm(forms.Form):
@@ -97,7 +101,7 @@ class ForgetPasswordForm(forms.Form):
     忘记密码表单，用于用户重置密码的流程
     包含新密码、确认密码、邮箱和验证码字段
     """
-    # 新密码字段
+    # jyn:新密码字段
     new_password1 = forms.CharField(
         label=_("New password"),
         widget=forms.PasswordInput(
@@ -108,7 +112,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
-    # 确认新密码字段
+    # jyn:确认新密码字段
     new_password2 = forms.CharField(
         label="确认密码",
         widget=forms.PasswordInput(
@@ -119,7 +123,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
-    # 邮箱字段（用于验证用户身份）
+    # jyn:邮箱字段（用于验证用户身份）
     email = forms.EmailField(
         label='邮箱',
         widget=forms.TextInput(
@@ -130,7 +134,7 @@ class ForgetPasswordForm(forms.Form):
         ),
     )
 
-    # 验证码字段（用于身份验证）
+    # jyn:验证码字段（用于身份验证）
     code = forms.CharField(
         label=_('Code'),
         widget=forms.TextInput(
@@ -146,11 +150,11 @@ class ForgetPasswordForm(forms.Form):
         password1 = self.data.get("new_password1")
         password2 = self.data.get("new_password2")
         
-        # 检查两次密码是否一致
+        # jyn:检查两次密码是否一致
         if password1 and password2 and password1 != password2:
             raise ValidationError(_("passwords do not match"))
         
-        # 使用Django内置的密码验证器验证密码强度
+        # jyn:使用Django内置的密码验证器验证密码强度
         password_validation.validate_password(password2)
         
         return password2
@@ -158,22 +162,22 @@ class ForgetPasswordForm(forms.Form):
     def clean_email(self):
         """验证邮箱是否已注册"""
         user_email = self.cleaned_data.get("email")
-        # 检查该邮箱是否存在于系统中
+        # jyn:检查该邮箱是否存在于系统中
         if not BlogUser.objects.filter(email=user_email).exists():
-            # 提示邮箱不存在（实际应用中可能需要模糊提示以避免信息泄露）
+            # jyn:提示邮箱不存在（实际应用中可能需要模糊提示以避免信息泄露）
             raise ValidationError(_("email does not exist"))
         return user_email
 
     def clean_code(self):
         """验证验证码是否有效"""
         code = self.cleaned_data.get("code")
-        # 调用工具函数验证邮箱和验证码是否匹配
+        # jyn:调用工具函数验证邮箱和验证码是否匹配
         error = utils.verify(
             email=self.cleaned_data.get("email"),
             code=code,
         )
         if error:
-            raise ValidationError(error)  # 验证码无效时抛出错误
+            raise ValidationError(error)  # jyn:验证码无效时抛出错误
         return code
 
 
diff --git a/src/django-master/accounts/models.py b/src/django-master/accounts/models.py
index c1279eb..4e35e93 100644
--- a/src/django-master/accounts/models.py
+++ b/src/django-master/accounts/models.py
@@ -3,28 +3,28 @@ from django.db import models
 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  # 导入获取当前站点信息的工具函数
+from djangoblog.utils import get_current_site  # jyn:导入获取当前站点信息的工具函数
 
 
 # Create your models here.
 
 class BlogUser(AbstractUser):
     """
-    自定义用户模型，继承自Django内置的AbstractUser
+    jyn:自定义用户模型，继承自Django内置的AbstractUser
     扩展了默认用户模型的字段，以满足博客系统的特定需求
     """
-    # 昵称字段，允许为空
+    # jyn:昵称字段，允许为空
     nickname = models.CharField(_('nick name'), max_length=100, blank=True)
-    # 账号创建时间，默认为当前时间
+    # jyn:账号创建时间，默认为当前时间
     creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间，默认为当前时间（通常需要在保存时更新）
+    # jyn:最后修改时间，默认为当前时间（通常需要在保存时更新）
     last_modify_time = models.DateTimeField(_('last modify time'), default=now)
-    # 账号创建来源（如管理员添加、前台注册等），用于追踪用户注册渠道
+    # jyn:账号创建来源（如管理员添加、前台注册等），用于追踪用户注册渠道
     source = models.CharField(_('create source'), max_length=100, blank=True)
 
     def get_absolute_url(self):
         """
-        返回用户详情页的URL
+        jyn:返回用户详情页的URL
         Django推荐为模型定义此方法，用于获取对象的标准URL
         """
         return reverse(
@@ -33,23 +33,23 @@ class BlogUser(AbstractUser):
         )
 
     def __str__(self):
-        """模型的字符串表示，这里返回用户的邮箱"""
+        """jyn:模型的字符串表示，这里返回用户的邮箱"""
         return self.email
 
     def get_full_url(self):
-        """获取用户详情页的完整URL（包含域名）"""
-        # 获取当前站点的域名
+        """jyn:获取用户详情页的完整URL（包含域名）"""
+        # jyn:获取当前站点的域名
         site = get_current_site().domain
-        # 拼接完整URL（协议+域名+路径）
+        # jyn:拼接完整URL（协议+域名+路径）
         url = "https://{site}{path}".format(
             site=site,
-            path=self.get_absolute_url()  # 调用get_absolute_url获取相对路径
+            path=self.get_absolute_url()  # jyn:调用get_absolute_url获取相对路径
         )
         return url
 
     class Meta:
-        """模型的元数据配置"""
-        ordering = ['-id']  # 默认排序方式：按id降序（最新创建的用户在前）
-        verbose_name = _('user')  # 模型的单数显示名称（支持国际化）
-        verbose_name_plural = verbose_name  # 模型的复数显示名称（与单数相同）
-        get_latest_by = 'id'  # 指定使用id字段获取最新对象（用于Model.objects.latest()）
\ No newline at end of file
+        """jyn:模型的元数据配置"""
+        ordering = ['-id']  # jyn:默认排序方式：按id降序（最新创建的用户在前）
+        verbose_name = _('user')  # jyn:模型的单数显示名称（支持国际化）
+        verbose_name_plural = verbose_name  # jyn:模型的复数显示名称（与单数相同）
+        get_latest_by = 'id'  # jyn:指定使用id字段获取最新对象（用于Model.objects.latest()）
\ No newline at end of file
diff --git a/src/django-master/accounts/tests.py b/src/django-master/accounts/tests.py
index 70b2776..ac8263b 100644
--- a/src/django-master/accounts/tests.py
+++ b/src/django-master/accounts/tests.py
@@ -3,10 +3,10 @@ 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  # 导入当前应用的工具函数
+from accounts.models import BlogUser  # jyn:导入自定义用户模型
+from blog.models import Article, Category  # jyn:导入博客相关模型
+from djangoblog.utils import *  # jyn:导入项目工具函数
+from . import utils  # jyn:导入当前应用的工具函数
 
 
 # Create your tests here.
@@ -21,68 +21,68 @@ class AccountTest(TestCase):
         测试前的初始化方法，会在每个测试方法执行前运行
         用于创建测试所需的基础数据
         """
-        self.client = Client()  # 创建测试客户端，用于模拟用户请求
-        self.factory = RequestFactory()  # 创建请求工厂，用于构建请求对象
-        # 创建一个测试用户
+        self.client = Client()  # jyn:创建测试客户端，用于模拟用户请求
+        self.factory = RequestFactory()  # jyn:创建请求工厂，用于构建请求对象
+        # jyn:创建一个测试用户
         self.blog_user = BlogUser.objects.create_user(
             username="test",
             email="admin@admin.com",
             password="12345678"
         )
-        self.new_test = "xxx123--="  # 测试用的新密码
+        self.new_test = "xxx123--="  #jyn: 测试用的新密码
 
     def test_validate_account(self):
         """测试用户账号验证相关功能，包括登录和管理员权限"""
-        site = get_current_site().domain  # 获取当前站点域名
+        site = get_current_site().domain  # jyn:获取当前站点域名
         
-        # 创建一个超级用户
+        # jyn:创建一个超级用户
         user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
             password="qwer!@#$ggg")
-        # 获取创建的用户
+        # jyn:获取创建的用户
         testuser = BlogUser.objects.get(username='liangliangyy1')
 
-        # 测试登录功能
+        # jyn:测试登录功能
         loginresult = self.client.login(
             username='liangliangyy1',
             password='qwer!@#$ggg')
-        self.assertEqual(loginresult, True)  # 断言登录成功
+        self.assertEqual(loginresult, True)  #jyn: 断言登录成功
         
-        # 测试访问管理员页面
+        # jyn:测试访问管理员页面
         response = self.client.get('/admin/')
-        self.assertEqual(response.status_code, 200)  # 断言页面访问成功
+        self.assertEqual(response.status_code, 200)  # jyn:断言页面访问成功
 
-        # 创建测试分类
+        # jyn:创建测试分类
         category = Category()
         category.name = "categoryaaa"
         category.creation_time = timezone.now()
         category.last_modify_time = timezone.now()
         category.save()
 
-        # 创建测试文章
+        # jyn:创建测试文章
         article = Article()
         article.title = "nicetitleaaa"
         article.body = "nicecontentaaa"
         article.author = user
         article.category = category
-        article.type = 'a'  # 假设'a'表示文章类型
-        article.status = 'p'  # 假设'p'表示已发布
+        article.type = 'a'  # jyn:假设'a'表示文章类型
+        article.status = 'p'  # jyn:假设'p'表示已发布
         article.save()
 
-        # 测试访问文章管理页面
+        # jyn:测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
-        self.assertEqual(response.status_code, 200)  # 断言页面访问成功
+        self.assertEqual(response.status_code, 200)  # jyn:断言页面访问成功
 
     def test_validate_register(self):
         """测试用户注册功能，包括注册流程、邮箱验证和权限控制"""
-        # 初始状态下，该邮箱应不存在
+        # jyn:初始状态下，该邮箱应不存在
         self.assertEquals(
             0, len(
                 BlogUser.objects.filter(
                     email='user123@user.com')))
         
-        # 模拟用户注册提交
+        # jyn:模拟用户注册提交
         response = self.client.post(reverse('account:register'), {
             'username': 'user1233',
             'email': 'user123@user.com',
@@ -90,43 +90,43 @@ class AccountTest(TestCase):
             'password2': 'password123!q@wE#R$T',
         })
         
-        # 注册后，该邮箱应存在
+        #jyn: 注册后，该邮箱应存在
         self.assertEquals(
             1, len(
                 BlogUser.objects.filter(
                     email='user123@user.com')))
         
-        # 获取刚注册的用户
+        #jyn: 获取刚注册的用户
         user = BlogUser.objects.filter(email='user123@user.com')[0]
-        # 生成验证链接（模拟邮箱验证流程）
+        # jyn:生成验证链接（模拟邮箱验证流程）
         sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
         path = reverse('accounts:result')
         url = '{path}?type=validation&id={id}&sign={sign}'.format(
             path=path, id=user.id, sign=sign)
         
-        # 访问验证链接
+        # jyn:访问验证链接
         response = self.client.get(url)
-        self.assertEqual(response.status_code, 200)  # 断言验证页面访问成功
+        self.assertEqual(response.status_code, 200)  # jyn:断言验证页面访问成功
 
-        # 登录新注册用户
+        # jyn:登录新注册用户
         self.client.login(username='user1233', password='password123!q@wE#R$T')
-        # 提升用户权限
+        # jyn:提升用户权限
         user = BlogUser.objects.filter(email='user123@user.com')[0]
         user.is_superuser = True
         user.is_staff = True
         user.save()
         
-        # 清除缓存
+        # jyn:清除缓存
         delete_sidebar_cache()
         
-        # 创建测试分类
+        # jyn:创建测试分类
         category = Category()
         category.name = "categoryaaa"
         category.creation_time = timezone.now()
         category.last_modify_time = timezone.now()
         category.save()
 
-        # 创建测试文章
+        # jyn:创建测试文章
         article = Article()
         article.category = category
         article.title = "nicetitle333"
@@ -136,94 +136,94 @@ class AccountTest(TestCase):
         article.status = 'p'
         article.save()
 
-        # 测试访问文章管理页面
+        # jyn:测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
         self.assertEqual(response.status_code, 200)
 
-        # 测试登出功能
+        # jyn:测试登出功能
         response = self.client.get(reverse('account:logout'))
         self.assertIn(response.status_code, [301, 302, 200])  # 登出通常是重定向
 
-        # 登出后访问管理页面（应被拒绝或重定向）
+        # jyn:登出后访问管理页面（应被拒绝或重定向）
         response = self.client.get(article.get_admin_url())
         self.assertIn(response.status_code, [301, 302, 200])
 
-        # 使用错误密码登录
+        # jyn:使用错误密码登录
         response = self.client.post(reverse('account:login'), {
             'username': 'user1233',
             'password': 'password123'
         })
         self.assertIn(response.status_code, [301, 302, 200])
 
-        # 错误登录后访问管理页面
+        # jyn:错误登录后访问管理页面
         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)  # 发送验证邮件
+        code = generate_code()  # jyn:生成验证码
+        utils.set_code(to_email, code)  # jyn:存储验证码
+        utils.send_verify_email(to_email, code)  # jyn:发送验证邮件
 
-        # 验证正确的邮箱和验证码
+        # jyn:验证正确的邮箱和验证码
         err = utils.verify("admin@admin.com", code)
-        self.assertEqual(err, None)  # 应无错误
+        self.assertEqual(err, None)  # jyn:应无错误
 
-        # 验证错误的邮箱和正确的验证码
+        # jyn:验证错误的邮箱和正确的验证码
         err = utils.verify("admin@123.com", code)
-        self.assertEqual(type(err), str)  # 应返回错误信息
+        self.assertEqual(type(err), str)  # jyn:应返回错误信息
 
     def test_forget_password_email_code_success(self):
         """测试发送密码重置验证码成功的情况"""
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
-            data=dict(email="admin@admin.com")  # 使用已存在的邮箱
+            data=dict(email="admin@admin.com")  # jyn:使用已存在的邮箱
         )
 
-        self.assertEqual(resp.status_code, 200)  # 断言请求成功
-        self.assertEqual(resp.content.decode("utf-8"), "ok")  # 断言返回成功信息
+        self.assertEqual(resp.status_code, 200)  # jyn:断言请求成功
+        self.assertEqual(resp.content.decode("utf-8"), "ok")  # jyn:断言返回成功信息
 
     def test_forget_password_email_code_fail(self):
         """测试发送密码重置验证码失败的情况"""
-        # 不提供邮箱
+        # jyn:不提供邮箱
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
             data=dict()
         )
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")  # 断言返回错误信息
+        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")  # jyn:断言返回错误信息
 
-        # 提供无效格式的邮箱
+        # jyn:提供无效格式的邮箱
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
             data=dict(email="admin@com")
         )
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")  # 断言返回错误信息
+        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")  #jyn: 断言返回错误信息
 
     def test_forget_password_email_success(self):
         """测试密码重置成功的情况"""
-        code = generate_code()  # 生成验证码
-        utils.set_code(self.blog_user.email, code)  # 存储验证码
-        # 准备重置密码的数据
+        code = generate_code()  # jyn:生成验证码
+        utils.set_code(self.blog_user.email, code)  #jyn: 存储验证码
+        # jyn:准备重置密码的数据
         data = dict(
             new_password1=self.new_test,
             new_password2=self.new_test,
             email=self.blog_user.email,
             code=code,
         )
-        # 提交密码重置请求
+        # jyn:提交密码重置请求
         resp = self.client.post(
             path=reverse("account:forget_password"),
             data=data
         )
-        self.assertEqual(resp.status_code, 302)  # 成功重置后通常重定向
+        self.assertEqual(resp.status_code, 302)  # jyn:成功重置后通常重定向
 
-        # 验证密码是否已更新
+        # jyn:验证密码是否已更新
         blog_user = BlogUser.objects.filter(
             email=self.blog_user.email,
-        ).first()  # type: BlogUser
-        self.assertNotEqual(blog_user, None)  # 断言用户存在
-        # 断言密码修改成功
+        ).first()  # jyn:type: BlogUser
+        self.assertNotEqual(blog_user, None)  # jyn:断言用户存在
+        # jyn:断言密码修改成功
         self.assertEqual(blog_user.check_password(data["new_password1"]), True)
 
     def test_forget_password_email_not_user(self):
@@ -231,7 +231,7 @@ class AccountTest(TestCase):
         data = dict(
             new_password1=self.new_test,
             new_password2=self.new_test,
-            email="123@123.com",  # 不存在的邮箱
+            email="123@123.com",  # jyn:不存在的邮箱
             code="123456",
         )
         resp = self.client.post(
@@ -239,22 +239,22 @@ class AccountTest(TestCase):
             data=data
         )
 
-        self.assertEqual(resp.status_code, 200)  # 应返回页面但不重置密码
+        self.assertEqual(resp.status_code, 200)  # jyn:应返回页面但不重置密码
 
     def test_forget_password_email_code_error(self):
         """测试使用错误的验证码重置密码的情况"""
-        code = generate_code()  # 生成正确验证码
-        utils.set_code(self.blog_user.email, code)  # 存储验证码
-        # 使用错误的验证码
+        code = generate_code()  # jyn:生成正确验证码
+        utils.set_code(self.blog_user.email, code)  #jyn: 存储验证码
+        # jyn:使用错误的验证码
         data = dict(
             new_password1=self.new_test,
             new_password2=self.new_test,
             email=self.blog_user.email,
-            code="111111",  # 错误的验证码
+            code="111111",  # jyn:错误的验证码
         )
         resp = self.client.post(
             path=reverse("account:forget_password"),
             data=data
         )
 
-        self.assertEqual(resp.status_code, 200)  # 应返回页面但不重置密码
\ No newline at end of file
+        self.assertEqual(resp.status_code, 200)  # jyn:应返回页面但不重置密码
\ No newline at end of file
diff --git a/src/django-master/accounts/urls.py b/src/django-master/accounts/urls.py
index dcde6e9..36b9b7d 100644
--- a/src/django-master/accounts/urls.py
+++ b/src/django-master/accounts/urls.py
@@ -1,49 +1,49 @@
 from django.urls import path
-from django.urls import re_path  # 用于正则表达式匹配URL
+from django.urls import re_path  # jyn:用于正则表达式匹配URL
 
-from . import views  # 导入当前应用的视图函数/类
-from .forms import LoginForm  # 导入自定义的登录表单
+from . import views  # jyn:导入当前应用的视图函数/类
+from .forms import LoginForm  # jyn:导入自定义的登录表单
 
-# 定义应用命名空间，避免URL名称冲突
+# jyn:定义应用命名空间，避免URL名称冲突
 app_name = "accounts"
 
-# URL路由配置列表，映射URL路径到对应的视图
+# jyn:URL路由配置列表，映射URL路径到对应的视图
 urlpatterns = [
-    # 登录页面路由：使用正则匹配以login/结尾的路径
+    # jyn:登录页面路由：使用正则匹配以login/结尾的路径
     re_path(r'^login/$',
-           # 调用LoginView类视图，指定登录成功后重定向到首页（/）
+           # jyn:调用LoginView类视图，指定登录成功后重定向到首页（/）
            views.LoginView.as_view(success_url='/'),
-           name='login',  # URL的名称，用于反向解析
-           # 向视图传递额外参数：指定登录表单为自定义的LoginForm
+           name='login',  # jyn:URL的名称，用于反向解析
+           # jyn:向视图传递额外参数：指定登录表单为自定义的LoginForm
            kwargs={'authentication_form': LoginForm}),
     
-    # 注册页面路由：匹配以register/结尾的路径
+    # jyn:注册页面路由：匹配以register/结尾的路径
     re_path(r'^register/$',
-           # 调用RegisterView类视图，注册成功后重定向到首页
+           # jyn:调用RegisterView类视图，注册成功后重定向到首页
            views.RegisterView.as_view(success_url="/"),
-           name='register'),  # URL名称，用于反向解析
+           name='register'),  # jyn:URL名称，用于反向解析
     
-    # 登出功能路由：匹配以logout/结尾的路径
+    # jyn:登出功能路由：匹配以logout/结尾的路径
     re_path(r'^logout/$',
-           # 调用LogoutView类视图（Django内置或自定义）
+           # jyn:调用LogoutView类视图（Django内置或自定义）
            views.LogoutView.as_view(),
-           name='logout'),  # URL名称
+           name='logout'),  #jyn: URL名称
     
-    # 账号操作结果页面路由：精确匹配account/result.html路径
+    # jyn:账号操作结果页面路由：精确匹配account/result.html路径
     path(r'account/result.html',
-         # 调用函数视图account_result
+         # jyn:调用函数视图account_result
          views.account_result,
-         name='result'),  # URL名称，用于展示注册/验证等结果
+         name='result'),  #jyn: URL名称，用于展示注册/验证等结果
     
-    # 忘记密码页面路由：匹配以forget_password/结尾的路径
+    # jyn:忘记密码页面路由：匹配以forget_password/结尾的路径
     re_path(r'^forget_password/$',
-           # 调用ForgetPasswordView类视图
+           # jyn:调用ForgetPasswordView类视图
            views.ForgetPasswordView.as_view(),
-           name='forget_password'),  # URL名称
+           name='forget_password'),  #jyn: URL名称
     
-    # 发送密码重置验证码页面路由：匹配以forget_password_code/结尾的路径
+    # jyn:发送密码重置验证码页面路由：匹配以forget_password_code/结尾的路径
     re_path(r'^forget_password_code/$',
-           # 调用ForgetPasswordEmailCode类视图（处理发送验证码逻辑）
+           # jyn:调用ForgetPasswordEmailCode类视图（处理发送验证码逻辑）
            views.ForgetPasswordEmailCode.as_view(),
-           name='forget_password_code'),  # URL名称
+           name='forget_password_code'),  # jyn:URL名称
 ]
\ No newline at end of file
diff --git a/src/django-master/accounts/user_login_backend.py b/src/django-master/accounts/user_login_backend.py
index 1b2211c..47c2316 100644
--- a/src/django-master/accounts/user_login_backend.py
+++ b/src/django-master/accounts/user_login_backend.py
@@ -1,5 +1,5 @@
-from django.contrib.auth import get_user_model  # 获取项目配置的用户模型（支持自定义模型）
-from django.contrib.auth.backends import ModelBackend  # 导入Django内置的模型认证后端
+from django.contrib.auth import get_user_model  # jyn:获取项目配置的用户模型（支持自定义模型）
+from django.contrib.auth.backends import ModelBackend  # jyn:导入Django内置的模型认证后端
 
 
 class EmailOrUsernameModelBackend(ModelBackend):
@@ -17,22 +17,22 @@ class EmailOrUsernameModelBackend(ModelBackend):
             - password：前端传入的密码（明文）
         返回：验证成功返回用户对象，失败返回None
         """
-        # 判断输入的「username」是否包含@符号，以此区分邮箱和用户名
+        # jyn:判断输入的「username」是否包含@符号，以此区分邮箱和用户名
         if '@' in username:
-            # 若包含@，则按邮箱字段查询用户
+            # jyn:若包含@，则按邮箱字段查询用户
             kwargs = {'email': username}
         else:
-            # 若不包含@，则按用户名字段查询用户
+            # jyn:若不包含@，则按用户名字段查询用户
             kwargs = {'username': username}
         
         try:
-            # 根据上述条件从数据库查询唯一用户
+            # jyn:根据上述条件从数据库查询唯一用户
             user = get_user_model().objects.get(**kwargs)
-            # 验证密码：check_password会自动将明文密码与数据库中存储的哈希密码比对
+            # jyn:验证密码：check_password会自动将明文密码与数据库中存储的哈希密码比对
             if user.check_password(password):
-                return user  # 密码正确，返回用户对象（认证成功）
+                return user  # jyn:密码正确，返回用户对象（认证成功）
         except get_user_model().DoesNotExist:
-            # 若查询不到用户（用户名/邮箱不存在），返回None（认证失败）
+            # jyn:若查询不到用户（用户名/邮箱不存在），返回None（认证失败）
             return None
 
     def get_user(self, username):
@@ -43,8 +43,8 @@ class EmailOrUsernameModelBackend(ModelBackend):
         返回：存在则返回用户对象，不存在返回None
         """
         try:
-            # 通过主键（ID）查询用户
+            # jyn:通过主键（ID）查询用户
             return get_user_model().objects.get(pk=username)
         except get_user_model().DoesNotExist:
-            # 若用户不存在，返回None
+            # jyn:若用户不存在，返回None
             return None
\ No newline at end of file
diff --git a/src/django-master/accounts/utils.py b/src/django-master/accounts/utils.py
index 858b241..95eb6c3 100644
--- a/src/django-master/accounts/utils.py
+++ b/src/django-master/accounts/utils.py
@@ -1,13 +1,13 @@
 import typing
 from datetime import timedelta
 
-from django.core.cache import cache  # 导入Django缓存模块，用于存储验证码
-from django.utils.translation import gettext  # 用于获取即时翻译文本
-from django.utils.translation import gettext_lazy as _  # 用于延迟翻译文本（支持国际化）
+from django.core.cache import cache  # jyn:导入Django缓存模块，用于存储验证码
+from django.utils.translation import gettext  # jyn:用于获取即时翻译文本
+from django.utils.translation import gettext_lazy as _  # jyn:用于延迟翻译文本（支持国际化）
 
-from djangoblog.utils import send_email  # 导入项目自定义的发送邮件工具函数
+from djangoblog.utils import send_email  #jyn: 导入项目自定义的发送邮件工具函数
 
-# 验证码有效期：5分钟（全局变量，统一控制时效）
+# jyn:验证码有效期：5分钟（全局变量，统一控制时效）
 _code_ttl = timedelta(minutes=5)
 
 
@@ -19,11 +19,11 @@ def send_verify_email(to_mail: str, code: str, subject: str = _("Verify Email"))
         code: 生成的随机验证码
         subject: 邮件主题，默认值为“Verify Email”（支持国际化）
     """
-    # 构造邮件HTML内容，包含验证码和有效期提示，使用%(code)s占位符注入验证码
+    # jyn:构造邮件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}
-    # 调用发送邮件函数，参数依次为：收件人列表、邮件主题、邮件内容
+    # jyn:调用发送邮件函数，参数依次为：收件人列表、邮件主题、邮件内容
     send_email([to_mail], subject, html_content)
 
 
@@ -39,11 +39,11 @@ def verify(email: str, code: str) -> typing.Optional[str]:
         代码注释中指出当前错误处理逻辑不合理：应使用raise抛出异常，而非返回错误字符串
         若返回错误字符串，调用方需额外判断返回值是否为错误，增加了代码耦合度
     """
-    # 从缓存中获取该邮箱对应的验证码
+    # jyn:从缓存中获取该邮箱对应的验证码
     cache_code = get_code(email)
-    # 对比用户输入的验证码与缓存中的验证码
+    # jyn:对比用户输入的验证码与缓存中的验证码
     if cache_code != code:
-        # 验证码不匹配时，返回国际化的错误提示
+        #jyn: 验证码不匹配时，返回国际化的错误提示
         return gettext("Verification code error")
 
 
@@ -54,7 +54,7 @@ def set_code(email: str, code: str):
         email: 作为缓存key的邮箱地址（确保一个邮箱对应一个验证码）
         code: 需要存入缓存的验证码
     """
-    # 调用Django缓存的set方法：key=邮箱，value=验证码，timeout=有效期（秒）
+    # jyn:调用Django缓存的set方法：key=邮箱，value=验证码，timeout=有效期（秒）
     cache.set(email, code, _code_ttl.seconds)
 
 
@@ -66,5 +66,5 @@ def get_code(email: str) -> typing.Optional[str]:
     Return:
         缓存中存在该邮箱对应的验证码时返回字符串，不存在时返回None
     """
-    # 调用Django缓存的get方法，根据邮箱key获取验证码
+    # jyn:调用Django缓存的get方法，根据邮箱key获取验证码
     return cache.get(email)
\ No newline at end of file
diff --git a/src/django-master/accounts/views.py b/src/django-master/accounts/views.py
index 810e352..4a2d837 100644
--- a/src/django-master/accounts/views.py
+++ b/src/django-master/accounts/views.py
@@ -2,45 +2,45 @@ import logging
 from django.utils.translation import gettext_lazy as _
 from django.conf import settings
 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  # Django内置登录表单
-from django.contrib.auth.hashers import make_password  # 密码哈希处理函数
-from django.http import HttpResponseRedirect, HttpResponseForbidden  # HTTP响应类
+from django.contrib.auth import REDIRECT_FIELD_NAME  # jyn:登录后重定向字段名常量
+from django.contrib.auth import get_user_model  # jyn:获取项目配置的用户模型
+from django.contrib.auth import logout  # jyn:登出功能函数
+from django.contrib.auth.forms import AuthenticationForm  # jyn:Django内置登录表单
+from django.contrib.auth.hashers import make_password  # jyn:密码哈希处理函数
+from django.http import HttpResponseRedirect, HttpResponseForbidden  # jyn:HTTP响应类
 from django.http.request import HttpRequest
 from django.http.response import HttpResponse
-from django.shortcuts import get_object_or_404, render  # 快捷函数
-from django.urls import reverse  # URL反向解析
-from django.utils.decorators import method_decorator  # 类视图装饰器工具
-from django.utils.http import url_has_allowed_host_and_scheme  # 验证重定向URL安全性
-from django.views import View  # 基础视图类
-from django.views.decorators.cache import never_cache  # 禁止缓存装饰器
-from django.views.decorators.csrf import csrf_protect  # CSRF保护装饰器
-from django.views.decorators.debug import sensitive_post_parameters  # 敏感参数保护装饰器
-from django.views.generic import FormView, RedirectView  # 通用类视图
+from django.shortcuts import get_object_or_404, render  # jyn:快捷函数
+from django.urls import reverse  # jyn:URL反向解析
+from django.utils.decorators import method_decorator  # jyn:类视图装饰器工具
+from django.utils.http import url_has_allowed_host_and_scheme  # jyn:验证重定向URL安全性
+from django.views import View  # jyn:基础视图类
+from django.views.decorators.cache import never_cache  # jyn:禁止缓存装饰器
+from django.views.decorators.csrf import csrf_protect  #jyn: CSRF保护装饰器
+from django.views.decorators.debug import sensitive_post_parameters  # jyn:敏感参数保护装饰器
+from django.views.generic import FormView, RedirectView  # jyn:通用类视图
 
 from djangoblog.utils import (send_email, get_sha256, get_current_site, 
-                              generate_code, delete_sidebar_cache)  # 项目工具函数
-from . import utils  # 当前应用工具函数（验证码相关）
+                              generate_code, delete_sidebar_cache)  #jyn: 项目工具函数
+from . import utils  # jyn:当前应用工具函数（验证码相关）
 from .forms import (RegisterForm, LoginForm, ForgetPasswordForm, 
-                    ForgetPasswordCodeForm)  # 当前应用表单类
-from .models import BlogUser  # 自定义用户模型
+                    ForgetPasswordCodeForm)  # jyn:当前应用表单类
+from .models import BlogUser  # jyn:自定义用户模型
 
-logger = logging.getLogger(__name__)  # 初始化日志记录器
+logger = logging.getLogger(__name__)  # jyn:初始化日志记录器
 
 
-# Create your views here.
+# jyn:Create your views here.
 
 class RegisterView(FormView):
     """
     用户注册类视图，继承自FormView（处理表单提交的通用视图）
     负责用户注册表单展示、数据验证、发送验证邮件及注册结果跳转
     """
-    form_class = RegisterForm  # 指定使用的注册表单
-    template_name = 'account/registration_form.html'  # 注册页面模板路径
+    form_class = RegisterForm  # jyn:指定使用的注册表单
+    template_name = 'account/registration_form.html'  # jyn:注册页面模板路径
 
-    @method_decorator(csrf_protect)  # 为视图添加CSRF保护
+    @method_decorator(csrf_protect)  # jyn:为视图添加CSRF保护
     def dispatch(self, *args, **kwargs):
         """重写分发方法，添加装饰器后调用父类逻辑"""
         return super(RegisterView, self).dispatch(*args, **kwargs)
@@ -48,26 +48,26 @@ class RegisterView(FormView):
     def form_valid(self, form):
         """表单验证通过后执行的逻辑（注册核心流程）"""
         if form.is_valid():
-            # 1. 暂存用户数据，不立即保存（is_active设为False，需邮箱验证后激活）
+            # jyn:1. 暂存用户数据，不立即保存（is_active设为False，需邮箱验证后激活）
             user = form.save(False)
-            user.is_active = False  # 初始状态：未激活（需邮箱验证）
-            user.source = 'Register'  # 标记注册来源为“前台注册”
-            user.save(True)  # 保存用户到数据库
+            user.is_active = False  # jyn:初始状态：未激活（需邮箱验证）
+            user.source = 'Register'  # jyn:标记注册来源为“前台注册”
+            user.save(True)  # jyn:保存用户到数据库
 
-            # 2. 生成邮箱验证链接（包含签名，防止篡改）
-            site = get_current_site().domain  # 获取当前站点域名
-            # 双重SHA256加密：用SECRET_KEY+用户ID生成签名，确保链接安全性
+            # jyn:2. 生成邮箱验证链接（包含签名，防止篡改）
+            site = get_current_site().domain  # jyn:获取当前站点域名
+            # jyn:双重SHA256加密：用SECRET_KEY+用户ID生成签名，确保链接安全性
             sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
 
-            # 开发环境下替换域名（适配本地测试）
+            # jyn:开发环境下替换域名（适配本地测试）
             if settings.DEBUG:
                 site = '127.0.0.1:8000'
-            # 反向解析结果页URL，拼接完整验证链接
+            # jyn:反向解析结果页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)
 
-            # 3. 构造验证邮件内容并发送
+            # jyn:3. 构造验证邮件内容并发送
             content = """
                             <p>请点击下面链接验证您的邮箱</p>
 
@@ -79,16 +79,16 @@ class RegisterView(FormView):
                             {url}
                             """.format(url=url)
             send_email(
-                emailto=[user.email],  # 收件人邮箱（新注册用户的邮箱）
-                title='验证您的电子邮箱',  # 邮件标题
-                content=content  # 邮件HTML内容
+                emailto=[user.email],  # jyn:收件人邮箱（新注册用户的邮箱）
+                title='验证您的电子邮箱',  #jyn: 邮件标题
+                content=content  #jyn: 邮件HTML内容
             )
 
-            # 4. 跳转到注册结果页（提示用户查收验证邮件）
+            # jyn:4. 跳转到注册结果页（提示用户查收验证邮件）
             url = reverse('accounts:result') + f'?type=register&id={str(user.id)}'
             return HttpResponseRedirect(url)
         else:
-            # 表单验证失败，重新渲染表单并显示错误
+            # jyn:表单验证失败，重新渲染表单并显示错误
             return self.render_to_response({'form': form})
 
 
@@ -97,18 +97,18 @@ class LogoutView(RedirectView):
     用户登出类视图，继承自RedirectView（处理重定向的通用视图）
     负责清除用户会话、缓存，并重定向到登录页
     """
-    url = '/login/'  # 登出后默认重定向地址（登录页）
+    url = '/login/'  # jyn:登出后默认重定向地址（登录页）
 
-    @method_decorator(never_cache)  # 禁止缓存登出页面，避免浏览器缓存导致的问题
+    @method_decorator(never_cache)  # jyn:禁止缓存登出页面，避免浏览器缓存导致的问题
     def dispatch(self, request, *args, **kwargs):
         """重写分发方法，添加装饰器后调用父类逻辑"""
         return super(LogoutView, self).dispatch(request, *args, **kwargs)
 
     def get(self, request, *args, **kwargs):
         """处理GET请求（登出核心逻辑）"""
-        logout(request)  # 清除用户会话，实现登出
-        delete_sidebar_cache()  # 删除侧边栏缓存（可能存储了用户相关信息）
-        return super(LogoutView, self).get(request, *args, **kwargs)  # 执行重定向
+        logout(request)  # jyn:清除用户会话，实现登出
+        delete_sidebar_cache()  # jyn:删除侧边栏缓存（可能存储了用户相关信息）
+        return super(LogoutView, self).get(request, *args, **kwargs)  # jyn:执行重定向
 
 
 class LoginView(FormView):
@@ -116,14 +116,14 @@ class LoginView(FormView):
     用户登录类视图，继承自FormView
     负责登录表单展示、数据验证、用户认证、记住登录状态及重定向
     """
-    form_class = LoginForm  # 指定使用的自定义登录表单
-    template_name = 'account/login.html'  # 登录页面模板路径
-    success_url = '/'  # 登录成功默认重定向地址（首页）
-    redirect_field_name = REDIRECT_FIELD_NAME  # 重定向字段名（默认next）
-    login_ttl = 2626560  # “记住登录”状态的有效期（秒），约等于1个月
-
-    # 为视图添加多重装饰器：敏感参数保护、CSRF保护、禁止缓存
-    @method_decorator(sensitive_post_parameters('password'))  # 保护密码参数，避免日志泄露
+    form_class = LoginForm  #jyn: 指定使用的自定义登录表单
+    template_name = 'account/login.html'  # jyn:登录页面模板路径
+    success_url = '/'  # jyn:登录成功默认重定向地址（首页）
+    redirect_field_name = REDIRECT_FIELD_NAME  # jyn:重定向字段名（默认next）
+    login_ttl = 2626560  #jyn: “记住登录”状态的有效期（秒），约等于1个月
+
+    # jyn:为视图添加多重装饰器：敏感参数保护、CSRF保护、禁止缓存
+    @method_decorator(sensitive_post_parameters('password'))  # jyn:保护密码参数，避免日志泄露
     @method_decorator(csrf_protect)
     @method_decorator(never_cache)
     def dispatch(self, request, *args, **kwargs):
@@ -131,41 +131,41 @@ class LoginView(FormView):
 
     def get_context_data(self, **kwargs):
         """添加额外上下文数据（重定向地址）到模板"""
-        # 获取URL中的重定向参数（如登录前访问的受保护页面）
+        # jyn:获取URL中的重定向参数（如登录前访问的受保护页面）
         redirect_to = self.request.GET.get(self.redirect_field_name)
         if redirect_to is None:
-            redirect_to = '/'  # 默认重定向到首页
-        kwargs['redirect_to'] = redirect_to  # 将重定向地址传入模板上下文
+            redirect_to = '/'  # jyn:默认重定向到首页
+        kwargs['redirect_to'] = redirect_to  # jyn:将重定向地址传入模板上下文
         return super(LoginView, self).get_context_data(** kwargs)
 
     def form_valid(self, form):
         """表单验证通过后执行的逻辑（登录核心流程）"""
-        # 用Django内置AuthenticationForm重新验证（确保认证逻辑符合默认规范）
+        # jyn:用Django内置AuthenticationForm重新验证（确保认证逻辑符合默认规范）
         form = AuthenticationForm(data=self.request.POST, request=self.request)
 
         if form.is_valid():
-            delete_sidebar_cache()  # 删除侧边栏缓存（更新用户登录状态）
-            logger.info(self.redirect_field_name)  # 日志记录重定向字段名
+            delete_sidebar_cache()  # jyn:删除侧边栏缓存（更新用户登录状态）
+            logger.info(self.redirect_field_name)  # jyn:日志记录重定向字段名
 
-            # 执行登录：将用户信息存入会话
+            # jyn:执行登录：将用户信息存入会话
             auth.login(self.request, form.get_user())
-            # 处理“记住我”功能：若勾选，设置会话有效期为1个月
+            # jyn:处理“记住我”功能：若勾选，设置会话有效期为1个月
             if self.request.POST.get("remember"):
                 self.request.session.set_expiry(self.login_ttl)
-            # 调用父类form_valid，执行重定向
+            # jyn:调用父类form_valid，执行重定向
             return super(LoginView, self).form_valid(form)
         else:
-            # 表单验证失败（如密码错误），重新渲染表单并显示错误
+            # jyn:表单验证失败（如密码错误），重新渲染表单并显示错误
             return self.render_to_response({'form': form})
 
     def get_success_url(self):
         """自定义登录成功后的重定向地址（优先使用URL中的next参数）"""
-        # 获取POST请求中的重定向地址（用户登录前尝试访问的页面）
+        # jyn:获取POST请求中的重定向地址（用户登录前尝试访问的页面）
         redirect_to = self.request.POST.get(self.redirect_field_name)
-        # 验证重定向地址的安全性：避免跳转到外部恶意网站
+        # jyn:验证重定向地址的安全性：避免跳转到外部恶意网站
         if not url_has_allowed_host_and_scheme(
                 url=redirect_to, allowed_hosts=[self.request.get_host()]):
-            redirect_to = self.success_url  # 不安全则使用默认重定向地址
+            redirect_to = self.success_url  # jyn:不安全则使用默认重定向地址
         return redirect_to
 
 
@@ -174,48 +174,48 @@ def account_result(request):
     账号操作结果视图函数（函数视图）
     处理注册成功提示、邮箱验证逻辑，并展示结果页面
     """
-    # 从URL参数中获取操作类型（register/validation）和用户ID
+    # jyn:从URL参数中获取操作类型（register/validation）和用户ID
     type = request.GET.get('type')
     id = request.GET.get('id')
 
-    # 获取对应的用户，若不存在则返回404
+    # jyn:获取对应的用户，若不存在则返回404
     user = get_object_or_404(get_user_model(), id=id)
     logger.info(type)  # 日志记录操作类型
 
-    # 若用户已激活，直接重定向到首页（避免重复验证）
+    # jyn:若用户已激活，直接重定向到首页（避免重复验证）
     if user.is_active:
         return HttpResponseRedirect('/')
 
-    # 处理合法的操作类型（注册成功提示/邮箱验证）
+    # jyn:处理合法的操作类型（注册成功提示/邮箱验证）
     if type and type in ['register', 'validation']:
         if type == 'register':
-            # 注册成功：提示用户查收验证邮件
+            # jyn:注册成功：提示用户查收验证邮件
             content = '''
     恭喜您注册成功，一封验证邮件已经发送到您的邮箱，请验证您的邮箱后登录本站。
     '''
             title = '注册成功'
         else:
-            # 邮箱验证：验证签名是否正确，正确则激活用户
-            # 重新计算签名，与URL中的签名对比（防止链接篡改）
+            # jyn:邮箱验证：验证签名是否正确，正确则激活用户
+            # jyn:重新计算签名，与URL中的签名对比（防止链接篡改）
             c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
             sign = request.GET.get('sign')
             if sign != c_sign:
-                return HttpResponseForbidden()  # 签名不匹配，返回403禁止访问
-            # 激活用户：将is_active设为True
+                return HttpResponseForbidden()  # jyn:签名不匹配，返回403禁止访问
+            # jyn:激活用户：将is_active设为True
             user.is_active = True
             user.save()
-            # 验证成功：提示用户可登录
+            # jyn:验证成功：提示用户可登录
             content = '''
             恭喜您已经成功的完成邮箱验证，您现在可以使用您的账号来登录本站。
             '''
             title = '验证成功'
-        # 渲染结果页面，传递标题和内容
+        # jyn:渲染结果页面，传递标题和内容
         return render(request, 'account/result.html', {
             'title': title,
             'content': content
         })
     else:
-        # 操作类型不合法，重定向到首页
+        # jyn:操作类型不合法，重定向到首页
         return HttpResponseRedirect('/')
 
 
@@ -224,23 +224,23 @@ class ForgetPasswordView(FormView):
     忘记密码类视图，继承自FormView
     负责密码重置表单展示、数据验证，及更新用户密码
     """
-    form_class = ForgetPasswordForm  # 指定使用的密码重置表单
-    template_name = 'account/forget_password.html'  # 密码重置页面模板路径
+    form_class = ForgetPasswordForm  # jyn:指定使用的密码重置表单
+    template_name = 'account/forget_password.html'  # jyn:密码重置页面模板路径
 
     def form_valid(self, form):
         """表单验证通过后执行的逻辑（密码重置核心流程）"""
         if form.is_valid():
-            # 1. 获取表单中的邮箱，查询对应的用户
+            # jyn:1. 获取表单中的邮箱，查询对应的用户
             blog_user = BlogUser.objects.filter(
                 email=form.cleaned_data.get("email")
             ).get()
-            # 2. 对新密码进行哈希处理，并更新用户密码
+            # jyn:2. 对新密码进行哈希处理，并更新用户密码
             blog_user.password = make_password(form.cleaned_data["new_password2"])
             blog_user.save()
-            # 3. 密码重置成功，重定向到登录页
+            # jyn:3. 密码重置成功，重定向到登录页
             return HttpResponseRedirect('/login/')
         else:
-            # 表单验证失败（如验证码错误、密码不一致），重新渲染表单
+            # jyn:表单验证失败（如验证码错误、密码不一致），重新渲染表单
             return self.render_to_response({'form': form})
 
 
@@ -251,16 +251,16 @@ class ForgetPasswordEmailCode(View):
     """
     def post(self, request: HttpRequest):
         """处理POST请求（发送验证码核心逻辑）"""
-        # 1. 验证邮箱表单数据
+        #jyn: 1. 验证邮箱表单数据
         form = ForgetPasswordCodeForm(request.POST)
         if not form.is_valid():
-            return HttpResponse("错误的邮箱")  # 邮箱格式不合法，返回错误提示
+            return HttpResponse("错误的邮箱")  # jyn:邮箱格式不合法，返回错误提示
 
-        # 2. 生成验证码并发送邮件
-        to_email = form.cleaned_data["email"]  # 获取合法的邮箱地址
-        code = generate_code()  # 生成随机验证码
-        utils.send_verify_email(to_email, code)  # 发送验证码邮件
-        utils.set_code(to_email, code)  # 将验证码存入缓存（设置有效期）
+        # jyn:2. 生成验证码并发送邮件
+        to_email = form.cleaned_data["email"]  # jyn:获取合法的邮箱地址
+        code = generate_code()  # jyn:生成随机验证码
+        utils.send_verify_email(to_email, code)  # jyn:发送验证码邮件
+        utils.set_code(to_email, code)  # jyn:将验证码存入缓存（设置有效期）
 
-        # 3. 操作成功，返回“ok”提示
+        # jyn:3. 操作成功，返回“ok”提示
         return HttpResponse("ok")
\ No newline at end of file