标注

src/django-master/accounts/admin.py

@@ -8,45 +8,45 @@ from django.utils.translation import gettext_lazy as _
 from .models import BlogUser# 导入当前应用下的BlogUser模型（自定义用户模型）
 
 
-class BlogUserCreationForm(forms.ModelForm): # 定义两个密码字段，使用PasswordInput小部件隐藏输入
+class BlogUserCreationForm(forms.ModelForm): # lxy定义两个密码字段，使用PasswordInput小部件隐藏输入
     password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput)
     password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput)
 
     class Meta:
-        model = BlogUser# 关联的模型是BlogUser
-        fields = ('email',) # 表单中显示的字段（仅邮箱，密码单独定义）
+        model = BlogUser# lxy关联的模型是BlogUser
+        fields = ('email',) # lxy表单中显示的字段（仅邮箱，密码单独定义）
 
-    def clean_password2(self):# 验证两个密码是否一致
+    def clean_password2(self):# lxy验证两个密码是否一致
         # 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"))# 密码不一致时抛出错误
+            raise forms.ValidationError(_("passwords do not match"))# lxy密码不一致时抛出错误
         return password2
 
-    def save(self, commit=True):# 保存用户时，对密码进行哈希处理后存储
+    def save(self, commit=True):# lxy保存用户时，对密码进行哈希处理后存储
         # Save the provided password in hashed format
-        user = super().save(commit=False)# 先不提交到数据库
-        user.set_password(self.cleaned_data["password1"]) # 哈希处理密码
+        user = super().save(commit=False)# lxy先不提交到数据库
+        user.set_password(self.cleaned_data["password1"]) # lxy哈希处理密码
         if commit:
-            user.source = 'adminsite'# 标记用户来源为“后台管理”
-            user.save()# 提交到数据库
+            user.source = 'adminsite'# lxy标记用户来源为“后台管理”
+            user.save()# lxy提交到数据库
         return user
 
 
 class BlogUserChangeForm(UserChangeForm):
     class Meta:
-        model = BlogUser # 关联的模型是BlogUser
-        fields = '__all__'# 显示模型的所有字段
-        field_classes = {'username': UsernameField}# 为用户名字段指定类（保持Django原生逻辑）
+        model = BlogUser # lxy关联的模型是BlogUser
+        fields = '__all__'# lxy显示模型的所有字段
+        field_classes = {'username': UsernameField}# lxy为用户名字段指定类（保持Django原生逻辑）
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)# 调用父类的初始化方法
+        super().__init__(*args, **kwargs)#lxy调用父类的初始化方法
 
 
 class BlogUserAdmin(UserAdmin):
-    form = BlogUserChangeForm# 指定修改用户时使用的表单
-    add_form = BlogUserCreationForm# 指定创建用户时使用的表单
+    form = BlogUserChangeForm#lxy指定修改用户时使用的表单
+    add_form = BlogUserCreationForm# lxy指定创建用户时使用的表单
     list_display = (
         'id',
         'nickname',
@@ -55,5 +55,5 @@ class BlogUserAdmin(UserAdmin):
         'last_login',
         'date_joined',
         'source')
-    list_display_links = ('id', 'username')# 列表页中可点击跳转的字段
-    ordering = ('-id',)# 列表页的排序方式（按ID倒序）
+    list_display_links = ('id', 'username')#lxy列表页中可点击跳转的字段
+    ordering = ('-id',)#lxy列表页的排序方式（按ID倒序）

src/django-master/accounts/apps.py

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

src/django-master/accounts/forms.py

@@ -15,7 +15,7 @@ class LoginForm(AuthenticationForm):
             attrs={'placeholder': "username", "class": "form-control"})
         self.fields['password'].widget = widgets.PasswordInput(
             attrs={'placeholder': "password", "class": "form-control"})
-#自定义登录表单，在__init__方法中设置username（文本输入，占位符、form-control样式）和password（密码输入，占位符、form-control样式）字段的前端显示样式。
+#lxy自定义登录表单，在__init__方法中设置username（文本输入，占位符、form-control样式）和password（密码输入，占位符、form-control样式）字段的前端显示样式。
 
 class RegisterForm(UserCreationForm):
     def __init__(self, *args, **kwargs):
@@ -29,17 +29,17 @@ class RegisterForm(UserCreationForm):
             attrs={'placeholder': "password", "class": "form-control"})
         self.fields['password2'].widget = widgets.PasswordInput(
             attrs={'placeholder': "repeat password", "class": "form-control"})
-#__init__方法中设置username（文本输入）、email（邮箱输入）、password1和password2（密码输入）字段的占位符与form-control样式
+#lxy__init__方法中设置username（文本输入）、email（邮箱输入）、password1和password2（密码输入）字段的占位符与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
-#clean_email方法验证邮箱是否已被注册，若存在则抛出“邮箱已存在”的验证错误
+#lxyclean_email方法验证邮箱是否已被注册，若存在则抛出“邮箱已存在”的验证错误
     class Meta:
         model = get_user_model()
         fields = ("username", "email")
-#Meta类指定关联模型为自定义用户模型，表单字段包含username和email
+#lxy Meta类指定关联模型为自定义用户模型，表单字段包含username和email
 
 class ForgetPasswordForm(forms.Form):
     new_password1 = forms.CharField(
@@ -81,7 +81,7 @@ class ForgetPasswordForm(forms.Form):
             }
         ),
     )
-#定义new_password1（新密码，密码输入）、new_password2（确认密码，密码输入）、email（邮箱，文本输入）、code（验证码，文本输入）字段，均设置form-control样式和占位符。
+#lxy定义new_password1（新密码，密码输入）、new_password2（确认密码，密码输入）、email（邮箱，文本输入）、code（验证码，文本输入）字段，均设置form-control样式和占位符。
     def clean_new_password2(self):
         password1 = self.data.get("new_password1")
         password2 = self.data.get("new_password2")
@@ -90,7 +90,7 @@ class ForgetPasswordForm(forms.Form):
         password_validation.validate_password(password2)
 
         return password2
-# clean_new_password2方法验证两次新密码是否一致，并对密码进行有效性校验
+#lxyclean_new_password2方法验证两次新密码是否一致，并对密码进行有效性校验
     def clean_email(self):
         user_email = self.cleaned_data.get("email")
         if not BlogUser.objects.filter(
@@ -100,7 +100,7 @@ class ForgetPasswordForm(forms.Form):
             raise ValidationError(_("email does not exist"))
         return user_email
 
-# clean_email方法验证邮箱是否已注册（基于BlogUser模型），未注册则抛出“邮箱不存在”的验证错误
+#lxyclean_email方法验证邮箱是否已注册（基于BlogUser模型），未注册则抛出“邮箱不存在”的验证错误
     def clean_code(self):
         code = self.cleaned_data.get("code")
         error = utils.verify(
@@ -110,10 +110,10 @@ class ForgetPasswordForm(forms.Form):
         if error:
             raise ValidationError(error)
         return code
-#clean_code方法调用工具方法utils.verify验证验证码有效性，无效则抛出错误
+#lxy clean_code方法调用工具方法utils.verify验证验证码有效性，无效则抛出错误
 
 class ForgetPasswordCodeForm(forms.Form):
     email = forms.EmailField(
         label=_('Email'),
     )
-#仅包含email字段（邮箱输入），用于忘记密码流程中验证邮箱的步骤
+#lxy仅包含email字段（邮箱输入），用于忘记密码流程中验证邮箱的步骤

src/django-master/accounts/models.py

@@ -8,29 +8,29 @@ from djangoblog.utils import get_current_site
 
 # Create your models here.
 
-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，可为空。
+class BlogUser(AbstractUser):#lxy自定义用户模型BlogUser，继承自Django内置的AbstractUser（可扩展的用户抽象类）。
+    nickname = models.CharField(_('nick name'), max_length=100, blank=True)#lxy定义nickname字段，字符类型，支持国际化翻译，最大长度100，可为空。
+    creation_time = models.DateTimeField(_('creation time'), default=now)#lxy定义creation_time字段，日期时间类型，默认值为当前时间（now方法）。
+    last_modify_time = models.DateTimeField(_('last modify time'), default=now)#lxy定义last_modify_time字段，日期时间类型，默认值为当前时间。
+    source = models.CharField(_('create source'), max_length=100, blank=True)#lxy定义source字段，字符类型，记录用户创建来源，最大长度100，可为空。
 
 
     def get_absolute_url(self):
         return reverse(
             'blog:author_detail', kwargs={
-                'author_name': self.username})#定义获取用户详情页绝对URL的方法，通过reverse反向解析路由blog:author_detail，传递username参数。
+                'author_name': self.username})#lxy定义获取用户详情页绝对URL的方法，通过reverse反向解析路由blog:author_detail，传递username参数。
 
     def __str__(self):
-        return self.email#定义对象的字符串表示方法，返回用户的email
+        return self.email#lxy定义对象的字符串表示方法，返回用户的email
 
     def get_full_url(self):
         site = get_current_site().domain
         url = "https://{site}{path}".format(site=site,
                                             path=self.get_absolute_url())
-        return url#定义获取带域名的完整URL方法，结合当前站点域名和get_absolute_url生成完整链接
+        return url#lxy定义获取带域名的完整URL方法，结合当前站点域名和get_absolute_url生成完整链接
 
     class Meta:
-        ordering = ['-id']#查询结果按id倒序排列
-        verbose_name = _('user')#模型的单数显示名称（支持国际化）
-        verbose_name_plural = verbose_name#模型的复数显示名称与单数一致。
-        get_latest_by = 'id'#指定按id获取最新记录
+        ordering = ['-id']#lxy查询结果按id倒序排列
+        verbose_name = _('user')#lxy模型的单数显示名称（支持国际化）
+        verbose_name_plural = verbose_name#lxy模型的复数显示名称与单数一致。
+        get_latest_by = 'id'#lxy指定按id获取最新记录