Merge branch 'LXY_branch' into develop

.vscode/launch.json

@@ -0,0 +1,7 @@
+{
+    // 使用 IntelliSense 了解相关属性。 
+    // 悬停以查看现有属性的描述。
+    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": []
+}

src/django-master/accounts/admin.py

@@ -1,13 +1,22 @@
+<<<<<<< HEAD
 #django核心组件导入
 from django import forms# Django 表单处理模块
 from django.contrib.auth.admin import UserAdmin # Django 默认用户管理后台类
 from django.contrib.auth.forms import UserChangeForm # 用户信息修改表单基类
 from django.contrib.auth.forms import UsernameField# 用户名专用表单字段
 from django.utils.translation import gettext_lazy as _ # 国际化翻译函数
+=======
+from django import forms# 导入Django表单模块，用于创建自定义表单
+from django.contrib.auth.admin import UserAdmin# 导入Django自带的用户管理类，用于继承扩展
+from django.contrib.auth.forms import UserChangeForm# 导入用户修改表单和用户名字段类
+from django.contrib.auth.forms import UsernameField # 导入国际化翻译工具，用于字段标签的多语言支持
+from django.utils.translation import gettext_lazy as _
+>>>>>>> LXY_branch
 
 <<<<<<< HEAD
 # 本地应用导入
 # Register your models here.
+<<<<<<< HEAD
 from .models import BlogUser # 导入自定义用户模型
 =======
 # 导入自定义用户模型
@@ -36,11 +45,18 @@ class BlogUserCreationForm(forms.ModelForm):
     继承自ModelForm，提供密码验证功能
     """
     # 密码字段，使用PasswordInput小部件确保输入不可见
+=======
+from .models import BlogUser# 导入当前应用下的BlogUser模型（自定义用户模型）
+
+
+class BlogUserCreationForm(forms.ModelForm): # 定义两个密码字段，使用PasswordInput小部件隐藏输入
+>>>>>>> LXY_branch
     password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput)
     # 确认密码字段，用于验证两次输入的密码是否一致
     password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput)
 
     class Meta:
+<<<<<<< HEAD
         # 指定关联的模型
         model = BlogUser
         # 表单中包含的字段，这里只显示邮箱
@@ -53,6 +69,12 @@ class BlogUserCreationForm(forms.ModelForm):
 <<<<<<< HEAD
         Django 表单验证方法，方法名必须以 clean_ 开头
         """
+=======
+        model = BlogUser# 关联的模型是BlogUser
+        fields = ('email',) # 表单中显示的字段（仅邮箱，密码单独定义）
+
+    def clean_password2(self):# 验证两个密码是否一致
+>>>>>>> LXY_branch
         # Check that the two password entries match
         password1 = self.cleaned_data.get("password1")# 获取第一次输入的密码
         password2 = self.cleaned_data.get("password2")# 获取第二次输入的密码
@@ -65,6 +87,7 @@ class BlogUserCreationForm(forms.ModelForm):
         # 检查密码是否存在且不一致
 >>>>>>> JYN_branch
         if password1 and password2 and password1 != password2:
+<<<<<<< HEAD
             raise forms.ValidationError(_("passwords do not match"))# 错误信息（支持国际化）
         return password2# 返回验证后的值
 
@@ -93,6 +116,18 @@ class BlogUserCreationForm(forms.ModelForm):
             # 标记用户来源为管理员站点
             user.source = 'adminsite'
             user.save()
+=======
+            raise forms.ValidationError(_("passwords do not match"))# 密码不一致时抛出错误
+        return password2
+
+    def save(self, commit=True):# 保存用户时，对密码进行哈希处理后存储
+        # Save the provided password in hashed format
+        user = super().save(commit=False)# 先不提交到数据库
+        user.set_password(self.cleaned_data["password1"]) # 哈希处理密码
+        if commit:
+            user.source = 'adminsite'# 标记用户来源为“后台管理”
+            user.save()# 提交到数据库
+>>>>>>> LXY_branch
         return user
 >>>>>>> JYN_branch
 
@@ -105,6 +140,7 @@ class BlogUserChangeForm(UserChangeForm):
     """
 
     class Meta:
+<<<<<<< HEAD
         model = BlogUser # 关联的模型类
         fields = '__all__'# 显示所有字段
         field_classes = {'username': UsernameField}# 指定用户名使用专用字段类型
@@ -170,6 +206,19 @@ class BlogUserAdmin(UserAdmin):
     # 指定添加用户时使用的表单
     add_form = BlogUserCreationForm
     # 列表页面显示的字段
+=======
+        model = BlogUser # 关联的模型是BlogUser
+        fields = '__all__'# 显示模型的所有字段
+        field_classes = {'username': UsernameField}# 为用户名字段指定类（保持Django原生逻辑）
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)# 调用父类的初始化方法
+
+
+class BlogUserAdmin(UserAdmin):
+    form = BlogUserChangeForm# 指定修改用户时使用的表单
+    add_form = BlogUserCreationForm# 指定创建用户时使用的表单
+>>>>>>> LXY_branch
     list_display = (
         'id',
         'nickname',
@@ -177,6 +226,7 @@ class BlogUserAdmin(UserAdmin):
         'email',
         'last_login',
         'date_joined',
+<<<<<<< HEAD
         'source'
     )
     # 列表页面中可点击跳转的字段
@@ -184,3 +234,8 @@ class BlogUserAdmin(UserAdmin):
     # 排序方式，按id降序排列（最新的用户在前）
     ordering = ('-id',)
 >>>>>>> JYN_branch
+=======
+        'source')
+    list_display_links = ('id', 'username')# 列表页中可点击跳转的字段
+    ordering = ('-id',)# 列表页的排序方式（按ID倒序）
+>>>>>>> LXY_branch

src/django-master/accounts/apps.py

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 from django.apps import AppConfig
      
 
@@ -20,3 +21,10 @@ class AccountsConfig(AppConfig):
     # 这个名称会被Django用来识别和管理应用
     name = 'accounts'
 >>>>>>> JYN_branch
+=======
+from django.apps import AppConfig#导入 Django 框架中用于应用配置的 AppConfig 类，这是 Django 应用配置的核心类
+
+
+class AccountsConfig(AppConfig):#定义 AccountsConfig 类，继承自 AppConfig，用于对 accounts 应用进行自定义配置
+    name = 'accounts'#指定该应用的名称为 accounts，Django 会通过这个名称来识别和管理该应用
+>>>>>>> LXY_branch

src/django-master/accounts/forms.py

@@ -55,9 +55,14 @@ class LoginForm(AuthenticationForm):
         # 自定义密码输入框：添加占位符和CSS类
 >>>>>>> 8b27cdad9a9ccc84febce3bcf1d211ed109f96f2
         self.fields['password'].widget = widgets.PasswordInput(
+<<<<<<< HEAD
             attrs={'placeholder': "password", "class": "form-control"}) #为密码字段设置密码输入小部件，同样定义占位符和样式类。
 
 <<<<<<< HEAD
+=======
+            attrs={'placeholder': "password", "class": "form-control"})
+#自定义登录表单，在__init__方法中设置username（文本输入，占位符、form-control样式）和password（密码输入，占位符、form-control样式）字段的前端显示样式。
+>>>>>>> LXY_branch
 
 <<<<<<< HEAD
 
@@ -93,7 +98,11 @@ class RegisterForm(UserCreationForm):
             attrs={'placeholder': "password", "class": "form-control"})
         self.fields['password2'].widget = widgets.PasswordInput(
             attrs={'placeholder': "repeat password", "class": "form-control"})
+<<<<<<< HEAD
     # 验证邮箱唯一性
+=======
+#__init__方法中设置username（文本输入）、email（邮箱输入）、password1和password2（密码输入）字段的占位符与form-control样式
+>>>>>>> LXY_branch
     def clean_email(self):
         """
         邮箱验证方法：检查邮箱是否已被注册
@@ -104,10 +113,18 @@ class RegisterForm(UserCreationForm):
         if get_user_model().objects.filter(email=email).exists():
             raise ValidationError(_("email already exists"))  # 抛出验证错误
         return email
+<<<<<<< HEAD
     # 指定关联的用户模型和表单字段
     class Meta:
         model = get_user_model()  # 使用项目配置的用户模型（可能是自定义的BlogUser）
         fields = ("username", "email")  # 注册表单中显示的字段
+=======
+#clean_email方法验证邮箱是否已被注册，若存在则抛出“邮箱已存在”的验证错误
+    class Meta:
+        model = get_user_model()
+        fields = ("username", "email")
+#Meta类指定关联模型为自定义用户模型，表单字段包含username和email
+>>>>>>> LXY_branch
 
 # 忘记密码表单（验证邮箱和验证码）
 class ForgetPasswordForm(forms.Form):
@@ -170,7 +187,11 @@ class ForgetPasswordForm(forms.Form):
             }
         ),
     )
+<<<<<<< HEAD
     # 验证两次输入的密码是否一致，并检查密码强度
+=======
+#定义new_password1（新密码，密码输入）、new_password2（确认密码，密码输入）、email（邮箱，文本输入）、code（验证码，文本输入）字段，均设置form-control样式和占位符。
+>>>>>>> LXY_branch
     def clean_new_password2(self):
         """验证两次输入的密码是否一致，并验证密码强度"""
         password1 = self.data.get("new_password1")
@@ -189,7 +210,11 @@ class ForgetPasswordForm(forms.Form):
         
 >>>>>>> JYN_branch
         return password2
+<<<<<<< HEAD
     # 验证邮箱是否已注册
+=======
+# clean_new_password2方法验证两次新密码是否一致，并对密码进行有效性校验
+>>>>>>> LXY_branch
     def clean_email(self):
         """验证邮箱是否已注册"""
         user_email = self.cleaned_data.get("email")
@@ -198,7 +223,12 @@ class ForgetPasswordForm(forms.Form):
             # 提示邮箱不存在（实际应用中可能需要模糊提示以避免信息泄露）
             raise ValidationError(_("email does not exist"))
         return user_email
+<<<<<<< HEAD
     # 验证用户输入的验证码是否正确
+=======
+
+# clean_email方法验证邮箱是否已注册（基于BlogUser模型），未注册则抛出“邮箱不存在”的验证错误
+>>>>>>> LXY_branch
     def clean_code(self):
         """验证验证码是否有效"""
         code = self.cleaned_data.get("code")
@@ -214,8 +244,13 @@ class ForgetPasswordForm(forms.Form):
         if error:
             raise ValidationError(error)  # 验证码无效时抛出错误
         return code
+<<<<<<< HEAD
 
 # 忘记密码功能中的验证码发送表单（仅需邮箱字段）
+=======
+#clean_code方法调用工具方法utils.verify验证验证码有效性，无效则抛出错误
+
+>>>>>>> LXY_branch
 class ForgetPasswordCodeForm(forms.Form):
     """
     发送密码重置验证码的表单
@@ -223,4 +258,9 @@ class ForgetPasswordCodeForm(forms.Form):
     """
     email = forms.EmailField(
         label=_('Email'),
-    )
+<<<<<<< HEAD
+    )
+=======
+    )
+#仅包含email字段（邮箱输入），用于忘记密码流程中验证邮箱的步骤
+>>>>>>> LXY_branch

src/django-master/accounts/models.py

@@ -7,6 +7,7 @@ from djangoblog.utils import get_current_site  # 导入获取当前站点信息
 
 
 # Create your models here.
+<<<<<<< HEAD
 # 自定义用户模型，继承Django内置的AbstractUser
 class BlogUser(AbstractUser):
 <<<<<<< HEAD
@@ -32,6 +33,16 @@ class BlogUser(AbstractUser):
 >>>>>>> JYN_branch
     source = models.CharField(_('create source'), max_length=100, blank=True)
     # 获取用户详情页的绝对URL（用于模板中的{% url %}反向解析）
+=======
+
+class BlogUser(AbstractUser):#自定义用户模型BlogUser，继承自Django内置的AbstractUser（可扩展的用户抽象类）。
+    nickname = models.CharField(_('nick name'), max_length=100, blank=True)#定义nickname字段，字符类型，支持国际化翻译，最大长度100，可为空。
+    creation_time = models.DateTimeField(_('creation time'), default=now)#定义creation_time字段，日期时间类型，默认值为当前时间（now方法）。
+    last_modify_time = models.DateTimeField(_('last modify time'), default=now)#定义last_modify_time字段，日期时间类型，默认值为当前时间。
+    source = models.CharField(_('create source'), max_length=100, blank=True)#定义source字段，字符类型，记录用户创建来源，最大长度100，可为空。
+
+
+>>>>>>> LXY_branch
     def get_absolute_url(self):
         """
         返回用户详情页的URL
@@ -40,23 +51,33 @@ class BlogUser(AbstractUser):
         return reverse(
 <<<<<<< HEAD
             'blog:author_detail', kwargs={
+<<<<<<< HEAD
                 'author_name': self.username})
     # 定义对象的字符串表示（Admin后台和shell中显示）
 =======
             'blog:author_detail',  # 对应的URL名称
             kwargs={'author_name': self.username}  # 传递的参数
         )
+=======
+                'author_name': self.username})#定义获取用户详情页绝对URL的方法，通过reverse反向解析路由blog:author_detail，传递username参数。
+>>>>>>> LXY_branch
 
 >>>>>>> JYN_branch
     def __str__(self):
+<<<<<<< HEAD
         """模型的字符串表示，这里返回用户的邮箱"""
         return self.email
     # 获取用户详情页的完整URL（包含域名，用于分享链接）
+=======
+        return self.email#定义对象的字符串表示方法，返回用户的email
+
+>>>>>>> LXY_branch
     def get_full_url(self):
 <<<<<<< HEAD
         site = get_current_site().domain# 获取当前站点域名
         url = "https://{site}{path}".format(site=site,
                                             path=self.get_absolute_url())
+<<<<<<< HEAD
 =======
         """获取用户详情页的完整URL（包含域名）"""
         # 获取当前站点的域名
@@ -82,3 +103,12 @@ class BlogUser(AbstractUser):
         verbose_name_plural = verbose_name  # 模型的复数显示名称（与单数相同）
         get_latest_by = 'id'  # 指定使用id字段获取最新对象（用于Model.objects.latest()）
 >>>>>>> JYN_branch
+=======
+        return url#定义获取带域名的完整URL方法，结合当前站点域名和get_absolute_url生成完整链接
+
+    class Meta:
+        ordering = ['-id']#查询结果按id倒序排列
+        verbose_name = _('user')#模型的单数显示名称（支持国际化）
+        verbose_name_plural = verbose_name#模型的复数显示名称与单数一致。
+        get_latest_by = 'id'#指定按id获取最新记录
+>>>>>>> LXY_branch

src/django-master/accounts/tests.py

@@ -117,8 +117,12 @@ class AccountTest(TestCase):
 
         # 测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
+<<<<<<< HEAD
         self.assertEqual(response.status_code, 200)  # 断言页面访问成功
 >>>>>>> JYN_branch
+=======
+        self.assertEqual(response.status_code, 200)#测试管理员账号登录后台功能：创建超级用户，验证登录状态和后台页面访问状态
+>>>>>>> LXY_branch
 
     # 测试用户注册功能
     def test_validate_register(self):
@@ -259,8 +263,13 @@ class AccountTest(TestCase):
         # 错误登录后访问管理页面
 >>>>>>> JYN_branch
         response = self.client.get(article.get_admin_url())
+<<<<<<< HEAD
         self.assertIn(response.status_code, [301, 302, 200])
     # 测试邮箱验证码验证
+=======
+        self.assertIn(response.status_code, [301, 302, 200])#测试用户注册流程：验证注册前后用户数量变化，邮箱验证链接的有效性，以及注册后用户权限、文章发布等功能
+
+>>>>>>> LXY_branch
     def test_verify_email_code(self):
         """测试邮箱验证码验证功能"""
         to_email = "admin@admin.com"
@@ -273,12 +282,16 @@ class AccountTest(TestCase):
         self.assertEqual(err, None)
         # 测试错误邮箱
         err = utils.verify("admin@123.com", code)
+<<<<<<< HEAD
         self.assertEqual(type(err), str)# 应返回错误信息字符串
     # 测试忘记密码发送验证码功能 - 成功情况
 =======
         code = generate_code()  # 生成验证码
         utils.set_code(to_email, code)  # 存储验证码
         utils.send_verify_email(to_email, code)  # 发送验证邮件
+=======
+        self.assertEqual(type(err), str)#测试邮箱验证码功能：验证有效邮箱和无效邮箱的验证码校验结果
+>>>>>>> LXY_branch
 
         # 验证正确的邮箱和验证码
         err = utils.verify("admin@admin.com", code)
@@ -298,6 +311,7 @@ class AccountTest(TestCase):
         )
 
         self.assertEqual(resp.status_code, 200)
+<<<<<<< HEAD
         self.assertEqual(resp.content.decode("utf-8"), "ok")# 验证返回成功消息
     # 测试忘记密码发送验证码功能 - 失败情况
     def test_forget_password_email_code_fail(self):
@@ -308,6 +322,9 @@ class AccountTest(TestCase):
 
         self.assertEqual(resp.status_code, 200)  # 断言请求成功
         self.assertEqual(resp.content.decode("utf-8"), "ok")  # 断言返回成功信息
+=======
+        self.assertEqual(resp.content.decode("utf-8"), "ok")#测试忘记密码的邮箱验证码发送：分别验证成功和失败场景（如邮箱错误）的接口响应
+>>>>>>> LXY_branch
 
     def test_forget_password_email_code_fail(self):
         """测试发送密码重置验证码失败的情况"""
@@ -424,8 +441,12 @@ class AccountTest(TestCase):
             data=data
         )
 
+<<<<<<< HEAD
 <<<<<<< HEAD
         self.assertEqual(resp.status_code, 200)# 应返回错误页面而非重定向
+=======
+        self.assertEqual(resp.status_code, 200)#测试忘记密码流程：成功场景：验证密码修改后是否生效；失败场景：验证不存在用户、验证码错误时的接口响应
+>>>>>>> LXY_branch
 
 =======
         self.assertEqual(resp.status_code, 200)  # 应返回页面但不重置密码

src/django-master/accounts/urls.py

@@ -46,6 +46,7 @@ from .forms import LoginForm  # 导入自定义的登录表单
 # 定义应用命名空间，避免URL名称冲突
 app_name = "accounts"
 
+<<<<<<< HEAD
 # URL路由配置列表，映射URL路径到对应的视图
 urlpatterns = [
     # 登录页面路由：使用正则匹配以login/结尾的路径
@@ -87,3 +88,26 @@ urlpatterns = [
            name='forget_password_code'),  # URL名称
 ]
 >>>>>>> JYN_branch
+=======
+urlpatterns = [re_path(r'^login/$',
+                       views.LoginView.as_view(success_url='/'),
+                       name='login',
+                       kwargs={'authentication_form': LoginForm}),#登录路由，对应LoginView，用LoginForm表单，成功重定向/
+               re_path(r'^register/$',
+                       views.RegisterView.as_view(success_url="/"),
+                       name='register'),#注册路由，对应RegisterView，成功重定向/。
+
+               re_path(r'^logout/$',
+                       views.LogoutView.as_view(),
+                       name='logout'),#登出路由，对应LogoutView。
+               path(r'account/result.html',
+                    views.account_result,
+                    name='result'),#结果页路由，对应account_result视图
+               re_path(r'^forget_password/$',
+                       views.ForgetPasswordView.as_view(),
+                       name='forget_password'),#忘记密码路由，对应ForgetPasswordView
+               re_path(r'^forget_password_code/$',
+                       views.ForgetPasswordEmailCode.as_view(),
+                       name='forget_password_code'),#忘记密码验证码路由，对应ForgetPasswordEmailCode
+               ]
+>>>>>>> LXY_branch

src/django-master/accounts/user_login_backend.py

@@ -8,7 +8,7 @@ from django.contrib.auth.backends import ModelBackend  # 导入Django内置的
 >>>>>>> JYN_branch
 
 
-class EmailOrUsernameModelBackend(ModelBackend):
+class EmailOrUsernameModelBackend(ModelBackend):#自定义Django认证后端，支持用户名或邮箱两种方式登录。
     """
 <<<<<<< HEAD
     允许使用用户名或邮箱登录
@@ -75,7 +75,7 @@ class EmailOrUsernameModelBackend(ModelBackend):
             # 若查询不到用户（用户名/邮箱不存在），返回None（认证失败）
 >>>>>>> JYN_branch
             return None
-
+#核心认证逻辑：判断输入是否为邮箱（含@），分别用邮箱或用户名查询用户，验证密码后返回用户对象；若用户不存在则返回None。
     def get_user(self, username):
         """
 <<<<<<< HEAD
@@ -93,6 +93,7 @@ class EmailOrUsernameModelBackend(ModelBackend):
         except get_user_model().DoesNotExist:
              # 用户不存在时返回 None
             return None
+<<<<<<< HEAD
 =======
         根据用户ID获取用户对象（Django认证系统必须实现的方法）
         作用：认证成功后，系统通过此方法获取用户完整信息
@@ -106,3 +107,6 @@ class EmailOrUsernameModelBackend(ModelBackend):
             # 若用户不存在，返回None
             return None
 >>>>>>> JYN_branch
+=======
+#根据用户ID（主键）查询用户，不存在则返回None，用于Django认证系统的用户查询环节
+>>>>>>> LXY_branch

src/django-master/accounts/utils.py

@@ -16,11 +16,15 @@ from django.core.cache import cache  # 导入Django缓存模块，用于存储
 from django.utils.translation import gettext  # 用于获取即时翻译文本
 from django.utils.translation import gettext_lazy as _  # 用于延迟翻译文本（支持国际化）
 
+<<<<<<< HEAD
 from djangoblog.utils import send_email  # 导入项目自定义的发送邮件工具函数
 
 # 验证码有效期：5分钟（全局变量，统一控制时效）
 >>>>>>> JYN_branch
 _code_ttl = timedelta(minutes=5)
+=======
+_code_ttl = timedelta(minutes=5)#验证码有效期，设置为5分钟。
+>>>>>>> LXY_branch
 
 
 def send_verify_email(to_mail: str, code: str, subject: str = _("Verify Email")):
@@ -101,6 +105,7 @@ def set_code(email: str, code: str):
     cache.set(email, code, _code_ttl.seconds)
 
 
+<<<<<<< HEAD
 def get_code(email: str) -> typing.Optional[str]:
     """
 <<<<<<< HEAD
@@ -115,6 +120,9 @@ def get_code(email: str) -> typing.Optional[str]:
             - 不存在或过期返回 None
     """
     # 直接调用 Django 缓存的 get 方法
+=======
+def get_code(email: str) -> typing.Optional[str]:#从缓存中获取指定邮箱对应的验证码
+>>>>>>> LXY_branch
     """获取code"""
     return cache.get(email)
 =======

src/django-master/accounts/views.py

@@ -88,8 +88,13 @@ class RegisterView(FormView):
 <<<<<<< HEAD
      # 指定使用的表单类
     form_class = RegisterForm
+<<<<<<< HEAD
     template_name = 'account/registration_form.html'
     # 使用装饰器确保视图禁用缓存（never_cache）并启用 CSRF 防护
+=======
+    template_name = 'account/registration_form.html'#处理用户注册逻辑，指定表单类RegisterForm和模板account/registration_form.html。
+
+>>>>>>> LXY_branch
     @method_decorator(csrf_protect)
     def dispatch(self, *args, **kwargs):
           # 调用父类方法处理请求
@@ -180,12 +185,16 @@ class RegisterView(FormView):
             # 表单无效时重新渲染表单（显示错误信息）
             return self.render_to_response({
                 'form': form
+<<<<<<< HEAD
             })
 =======
                 emailto=[user.email],  # 收件人邮箱（新注册用户的邮箱）
                 title='验证您的电子邮箱',  # 邮件标题
                 content=content  # 邮件HTML内容
             )
+=======
+            })#form_valid方法中，保存用户并设置为非活跃状态，生成邮箱验证链接并发送验证邮件，最后重定向到结果页。
+>>>>>>> LXY_branch
 
             # 4. 跳转到注册结果页（提示用户查收验证邮件）
             url = reverse('accounts:result') + f'?type=register&id={str(user.id)}'
@@ -197,10 +206,15 @@ class RegisterView(FormView):
 
 # 登出视图，继承自RedirectView，重定向到登录页面
 class LogoutView(RedirectView):
+<<<<<<< HEAD
 <<<<<<< HEAD
        # 登出后重定向的URL
     url = '/login/'
     # 使用never_cache装饰器确保视图不会被缓存
+=======
+    url = '/login/'#处理用户登出，登出后重定向到/login/
+
+>>>>>>> LXY_branch
     @method_decorator(never_cache)
     def dispatch(self, request, *args, **kwargs):
         # 调用父类的dispatch方法处理请求
@@ -223,6 +237,7 @@ class LogoutView(RedirectView):
         logout(request)
         # 删除侧边栏缓存
         delete_sidebar_cache()
+<<<<<<< HEAD
         # 调用父类的get方法完成重定向
         return super(LogoutView, self).get(request, *args, **kwargs)
 =======
@@ -231,6 +246,9 @@ class LogoutView(RedirectView):
         delete_sidebar_cache()  # 删除侧边栏缓存（可能存储了用户相关信息）
         return super(LogoutView, self).get(request, *args, **kwargs)  # 执行重定向
 >>>>>>> JYN_branch
+=======
+        return super(LogoutView, self).get(request, *args, **kwargs)#get方法中调用logout登出用户，删除侧边栏缓存后完成重定向
+>>>>>>> LXY_branch
 
 # 登录视图，继承自FormView
 class LoginView(FormView):
@@ -287,6 +305,7 @@ class LoginView(FormView):
         kwargs['redirect_to'] = redirect_to
         # 调用父类方法获取其他上下文数据
 
+<<<<<<< HEAD
         return super(LoginView, self).get_context_data(**kwargs)
     # 表单验证通过后的处理
     def form_valid(self, form):
@@ -296,6 +315,9 @@ class LoginView(FormView):
         kwargs['redirect_to'] = redirect_to  # 将重定向地址传入模板上下文
         return super(LoginView, self).get_context_data(** kwargs)
 
+=======
+        return super(LoginView, self).get_context_data(**kwargs)#处理用户登录逻辑，指定表单类LoginForm、模板account / login.html和成功后重定向地址 /
+>>>>>>> LXY_branch
     def form_valid(self, form):
         """表单验证通过后执行的逻辑（登录核心流程）"""
         # 用Django内置AuthenticationForm重新验证（确保认证逻辑符合默认规范）
@@ -334,8 +356,13 @@ class LoginView(FormView):
             # 表单无效，重新渲染表单并显示错误
             return self.render_to_response({
                 'form': form
+<<<<<<< HEAD
             })
    # 获取成功后的跳转URL
+=======
+            })#form_valid方法中验证表单，登录用户并根据“记住我”选项设置会话过期时间
+
+>>>>>>> LXY_branch
     def get_success_url(self):
 
         # 从POST参数中获取重定向URL
@@ -346,6 +373,7 @@ class LoginView(FormView):
                     self.request.get_host()]):
             # 如果不安全则使用默认成功URL
             redirect_to = self.success_url
+<<<<<<< HEAD
 =======
             # 表单验证失败（如密码错误），重新渲染表单并显示错误
             return self.render_to_response({'form': form})
@@ -360,6 +388,9 @@ class LoginView(FormView):
             redirect_to = self.success_url  # 不安全则使用默认重定向地址
 >>>>>>> JYN_branch
         return redirect_to
+=======
+        return redirect_to#get_success_url方法处理登录后的重定向地址，确保其安全性
+>>>>>>> LXY_branch
 
 # 账户操作结果页面（如注册成功、邮箱验证等）
 def account_result(request):
@@ -385,9 +416,13 @@ def account_result(request):
 
     # 获取对应的用户，若不存在则返回404
     user = get_object_or_404(get_user_model(), id=id)
+<<<<<<< HEAD
     logger.info(type)  # 日志记录操作类型
 
     # 若用户已激活，直接重定向到首页（避免重复验证）
+=======
+    logger.info(type)#处理注册和邮箱验证的结果逻辑，根据type参数区分场景：
+>>>>>>> LXY_branch
     if user.is_active:
         return HttpResponseRedirect('/')
 
@@ -451,6 +486,7 @@ class ForgetPasswordView(FormView):
 <<<<<<< HEAD
     # 使用的表单类
     form_class = ForgetPasswordForm
+<<<<<<< HEAD
     # 模板文件路径
     template_name = 'account/forget_password.html'
 =======
@@ -461,6 +497,9 @@ class ForgetPasswordView(FormView):
     form_class = ForgetPasswordForm  # 指定使用的密码重置表单
     template_name = 'account/forget_password.html'  # 密码重置页面模板路径
 >>>>>>> JYN_branch
+=======
+    template_name = 'account/forget_password.html'#处理忘记密码逻辑，指定表单类ForgetPasswordForm和模板account/forget_password.html
+>>>>>>> LXY_branch
 
 
     # 表单验证通过后的处理
@@ -485,6 +524,7 @@ class ForgetPasswordView(FormView):
             # 重定向到登录页面
             return HttpResponseRedirect('/login/')
         else:
+<<<<<<< HEAD
             # 表单无效，重新渲染表单并显示错误
 =======
             # 3. 密码重置成功，重定向到登录页
@@ -498,6 +538,13 @@ class ForgetPasswordView(FormView):
 class ForgetPasswordEmailCode(View):
 <<<<<<< HEAD
     # 处理POST请求
+=======
+            return self.render_to_response({'form': form})#form_valid方法中验证表单后，重置用户密码并重定向到登录页
+
+
+class ForgetPasswordEmailCode(View):# 处理忘记密码的邮箱验证码发送逻辑
+
+>>>>>>> LXY_branch
     def post(self, request: HttpRequest):
         # 验证表单
         form = ForgetPasswordCodeForm(request.POST)
@@ -512,6 +559,7 @@ class ForgetPasswordEmailCode(View):
         utils.send_verify_email(to_email, code)
         # 存储验证码（通常有有效期）
         utils.set_code(to_email, code)
+<<<<<<< HEAD
         # 返回成功响应
         return HttpResponse("ok")
 =======
@@ -535,3 +583,7 @@ class ForgetPasswordEmailCode(View):
         # 3. 操作成功，返回“ok”提示
         return HttpResponse("ok")
 >>>>>>> JYN_branch
+=======
+
+        return HttpResponse("ok")# post方法中验证邮箱表单，生成并发送验证码，将验证码存入缓存后返回成功标识
+>>>>>>> LXY_branch