diff --git a/.gitignore b/.gitignore index 76302b1..bf9277b 100644 --- a/.gitignore +++ b/.gitignore @@ -77,3 +77,5 @@ uploads/ settings_production.py werobot_session.db bin/datas/ + +.env \ No newline at end of file diff --git a/accounts/admin.py b/accounts/admin.py index 29d162a..46307bf 100644 --- a/accounts/admin.py +++ b/accounts/admin.py @@ -1,60 +1,87 @@ +#shw 导入Django的表单模块 from django import forms +#shw 导入Django后台管理的基础用户管理类 from django.contrib.auth.admin import UserAdmin +#shw 导入Django后台用于修改用户信息的表单 from django.contrib.auth.forms import UserChangeForm +#shw 导入Django后台用于用户名的字段类 from django.contrib.auth.forms import UsernameField +#shw 导入Django的国际化和翻译工具 from django.utils.translation import gettext_lazy as _ -# Register your models here. +#shw 注册你的模型到这里（这是一个注释提示，实际注册在文件末尾） from .models import BlogUser class BlogUserCreationForm(forms.ModelForm): +#shw 自定义用户创建表单，用于在Django Admin后台添加新用户。 +#shw 它继承自 ModelForm，并增加了密码输入和确认的逻辑。 + + #shw 定义第一个密码字段，使用PasswordInput控件隐藏输入内容 password1 = forms.CharField(label=_('password'), widget=forms.PasswordInput) + #shw 定义第二个密码字段，用于确认密码 password2 = forms.CharField(label=_('Enter password again'), widget=forms.PasswordInput) class Meta: - model = BlogUser - fields = ('email',) +#shw Meta类用于配置表单与模型的关联 + model = BlogUser #shw 指定该表单对应的模型是 BlogUser + fields = ('email',) #shw 在创建用户时，除了密码外，只显示邮箱字段 def clean_password2(self): - # Check that the two password entries match - password1 = self.cleaned_data.get("password1") - password2 = self.cleaned_data.get("password2") +#shw 自定义验证方法，用于检查两次输入的密码是否一致 + #shw Check that the two password entries match + password1 = self.cleaned_data.get("password1") #shw 从已清洗的数据中获取第一个密码 + password2 = self.cleaned_data.get("password2") #shw 从已清洗的数据中获取第二个密码 + #shw 如果两个密码都存在且不相等，则抛出验证错误 if password1 and password2 and password1 != password2: raise forms.ValidationError(_("passwords do not match")) - return password2 + return password2 #shw 返回第二个密码作为清洗后的数据 def save(self, commit=True): - # Save the provided password in hashed format - user = super().save(commit=False) - user.set_password(self.cleaned_data["password1"]) +#shw 重写save方法，以便在保存用户时处理密码哈希 + #shw Save the provided password in hashed format + user = super().save(commit=False) #shw 调用父类的save方法，但先不提交到数据库（commit=False） + user.set_password(self.cleaned_data["password1"]) #shw 使用Django的set_password方法将明文密码加密后存储 if commit: - user.source = 'adminsite' - user.save() - return user + user.source = 'adminsite' #shw 如果决定提交，则设置用户的来源为 'adminsite' + user.save() #shw 将用户对象保存到数据库 + return user #shw 返回保存后的用户对象 class BlogUserChangeForm(UserChangeForm): +#shw 自定义用户修改表单，用于在Django Admin后台编辑现有用户信息。 +#shw 它继承自Django的UserChangeForm，以复用大部分功能。 + class Meta: - model = BlogUser - fields = '__all__' +#shw Meta类用于配置表单与模型的关联 + model = BlogUser #shw 指定该表单对应的模型是 BlogUser + fields = '__all__' #shw 在修改用户时，显示模型中的所有字段 + #shw 指定 'username' 字段使用的字段类为 UsernameField field_classes = {'username': UsernameField} def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) +#shw 重写初始化方法，可以在这里添加自定义的初始化逻辑 + super().__init__(*args, **kwargs) #shw 调用父类的初始化方法 class BlogUserAdmin(UserAdmin): - form = BlogUserChangeForm - add_form = BlogUserCreationForm +#shw 自定义用户管理类，用于在Django Admin后台定制 BlogUser 模型的显示和操作方式。 +#shw 它继承自Django的UserAdmin，以复用用户管理的标准功能。 + + form = BlogUserChangeForm #shw 指定修改用户时使用的表单 + add_form = BlogUserCreationForm #shw 指定添加用户时使用的表单 + #shw 定义在用户列表页面显示的列 list_display = ( - 'id', - 'nickname', - 'username', - 'email', - 'last_login', - 'date_joined', - 'source') + 'id', #shw 用户ID + 'nickname', #shw 昵称 + 'username', #shw 用户名 + 'email', #shw 邮箱 + 'last_login', #shw 最后登录时间 + 'date_joined', #shw 注册时间 + 'source') #shw 创建来源 + #shw 定义在列表页面中，哪些列可以点击进入编辑页面 list_display_links = ('id', 'username') + #shw 定义用户列表的默认排序方式，按ID降序排列 ordering = ('-id',) + #shw 定义搜索框可以搜索的字段 search_fields = ('username', 'nickname', 'email') diff --git a/accounts/apps.py b/accounts/apps.py index 9b3fc5a..3830729 100644 --- a/accounts/apps.py +++ b/accounts/apps.py @@ -1,5 +1,11 @@ +#shw 导入Django的应用配置基类 from django.apps import AppConfig class AccountsConfig(AppConfig): +#shw 这是accounts应用的配置类。 +#shw 它用于定义该应用的各种元数据和行为。 + + #shw 指定这个配置类所属的应用的完整Python路径。 + #shw Django通过这个name来找到并加载这个应用。 name = 'accounts' diff --git a/accounts/forms.py b/accounts/forms.py index 964466e..163dacf 100644 --- a/accounts/forms.py +++ b/accounts/forms.py @@ -1,27 +1,44 @@ +#shw 导入Django的表单模块 from django import forms +#shw 导入获取当前激活用户模型的函数 from django.contrib.auth import get_user_model, password_validation +#shw 导入Django内置的认证表单和用户创建表单 from django.contrib.auth.forms import AuthenticationForm, UserCreationForm +#shw 导入Django的验证错误类 from django.core.exceptions import ValidationError +#shw 导入Django的表单控件模块 from django.forms import widgets +#shw 导入Django的国际化和翻译工具 from django.utils.translation import gettext_lazy as _ - from . import utils +#shw 导入本地的BlogUser模型 from .models import BlogUser class LoginForm(AuthenticationForm): +#shw 自定义登录表单，继承自Django的AuthenticationForm。 +#shw 主要用于自定义前端显示的样式。 + def __init__(self, *args, **kwargs): - super(LoginForm, self).__init__(*args, **kwargs) +#shw 重写初始化方法，以自定义字段的控件属性。 + super(LoginForm, self).__init__(*args, **kwargs) #shw 调用父类的初始化方法 + #shw 自定义 'username' 字段的控件，添加placeholder和CSS类 self.fields['username'].widget = widgets.TextInput( attrs={'placeholder': "username", "class": "form-control"}) + #shw 自定义 'password' 字段的控件，添加placeholder和CSS类 self.fields['password'].widget = widgets.PasswordInput( attrs={'placeholder': "password", "class": "form-control"}) class RegisterForm(UserCreationForm): +#shw 自定义注册表单，继承自Django的UserCreationForm。 +#shw 增加了邮箱唯一性验证和前端样式自定义。 + def __init__(self, *args, **kwargs): - super(RegisterForm, self).__init__(*args, **kwargs) +#shw 重写初始化方法，以自定义字段的控件属性。 + super(RegisterForm, self).__init__(*args, **kwargs) #shw 调用父类的初始化方法 + #shw 为各个字段添加Bootstrap风格的CSS类和placeholder self.fields['username'].widget = widgets.TextInput( attrs={'placeholder': "username", "class": "form-control"}) self.fields['email'].widget = widgets.EmailInput( @@ -32,17 +49,23 @@ class RegisterForm(UserCreationForm): attrs={'placeholder': "repeat password", "class": "form-control"}) def clean_email(self): - email = self.cleaned_data['email'] +#shw 自定义邮箱字段的验证方法，确保邮箱在系统中是唯一的。 + email = self.cleaned_data['email'] #shw 获取清洗后的邮箱数据 + #shw 检查数据库中是否已存在该邮箱 if get_user_model().objects.filter(email=email).exists(): - raise ValidationError(_("email already exists")) - return email + raise ValidationError(_("email already exists")) #shw 如果存在，抛出验证错误 + return email #shw 返回清洗后的邮箱 class Meta: - model = get_user_model() - fields = ("username", "email") +#shw Meta类用于配置表单与模型的关联 + model = get_user_model() #shw 动态获取用户模型，而不是硬编码BlogUser，更具可复用性 + fields = ("username", "email") #shw 指定注册表单中显示的字段 class ForgetPasswordForm(forms.Form): +#shw 忘记密码/重置密码表单，继承自基础的Form类。 +#shw 它不直接与模型关联，用于处理通过邮箱和验证码重置密码的流程。 + new_password1 = forms.CharField( label=_("New password"), widget=forms.PasswordInput( @@ -54,7 +77,7 @@ class ForgetPasswordForm(forms.Form): ) new_password2 = forms.CharField( - label="确认密码", + label="确认密码", #shw 这里使用了中文硬编码，建议使用 _("Confirm password") 以支持国际化 widget=forms.PasswordInput( attrs={ "class": "form-control", @@ -64,7 +87,7 @@ class ForgetPasswordForm(forms.Form): ) email = forms.EmailField( - label='邮箱', + label='邮箱', #shw 这里使用了中文硬编码，建议使用 _("Email") widget=forms.TextInput( attrs={ 'class': 'form-control', @@ -84,35 +107,47 @@ class ForgetPasswordForm(forms.Form): ) def clean_new_password2(self): - password1 = self.data.get("new_password1") - password2 = self.data.get("new_password2") +#shw 自定义验证方法，检查两次输入的新密码是否一致，并验证密码强度。 + password1 = self.data.get("new_password1") #shw 从原始数据中获取密码1 + password2 = self.data.get("new_password2") #shw 从原始数据中获取密码2 + #shw 检查两次密码是否一致 if password1 and password2 and password1 != password2: raise ValidationError(_("passwords do not match")) + #shw 使用Django内置的密码验证器来检查密码强度 password_validation.validate_password(password2) - return password2 + return password2 #shw 返回验证通过的新密码 def clean_email(self): - user_email = self.cleaned_data.get("email") +#shw 自定义验证方法，检查输入的邮箱是否存在于数据库中。 + user_email = self.cleaned_data.get("email") #shw 获取清洗后的邮箱 + #shw 检查该邮箱是否已注册 if not BlogUser.objects.filter( email=user_email ).exists(): - # todo 这里的报错提示可以判断一个邮箱是不是注册过，如果不想暴露可以修改 + #shwtodo 这里的报错提示可以判断一个邮箱是不是注册过，如果不想暴露可以修改 + #shw 这是一个安全提示，直接告诉攻击者邮箱未注册可能会被利用。 raise ValidationError(_("email does not exist")) - return user_email + return user_email #shw 返回清洗后的邮箱 def clean_code(self): - code = self.cleaned_data.get("code") +#shw 自定义验证方法，验证邮箱验证码是否正确。 + code = self.cleaned_data.get("code") #shw 获取清洗后的验证码 + #shw 调用工具函数验证邮箱和验证码是否匹配 error = utils.verify( email=self.cleaned_data.get("email"), code=code, ) + #shw 如果工具函数返回错误信息，则抛出验证错误 if error: raise ValidationError(error) - return code + return code #shw 返回验证通过的验证码 class ForgetPasswordCodeForm(forms.Form): +#shw 发送忘记密码验证码的表单。 +#shw 它只包含一个邮箱字段，用于用户输入接收验证码的邮箱地址。 + email = forms.EmailField( - label=_('Email'), + label=_('Email'), #shw 邮箱字段，标签支持国际化 ) diff --git a/accounts/migrations/0001_initial.py b/accounts/migrations/0001_initial.py index 884428e..d2fbcab 100644 --- a/accounts/migrations/0001_initial.py +++ b/accounts/migrations/0001_initial.py @@ -2,8 +2,8 @@ import django.contrib.auth.models import django.contrib.auth.validators -import django.utils.timezone from django.db import migrations, models +import django.utils.timezone class Migration(migrations.Migration): diff --git a/accounts/migrations/0002_alter_bloguser_options_remove_bloguser_created_time_and_more.py b/accounts/migrations/0002_alter_bloguser_options_remove_bloguser_created_time_and_more.py index 854d366..1a9f509 100644 --- a/accounts/migrations/0002_alter_bloguser_options_remove_bloguser_created_time_and_more.py +++ b/accounts/migrations/0002_alter_bloguser_options_remove_bloguser_created_time_and_more.py @@ -1,7 +1,7 @@ # Generated by Django 4.2.5 on 2023-09-06 13:13 -import django.utils.timezone from django.db import migrations, models +import django.utils.timezone class Migration(migrations.Migration): diff --git a/accounts/models.py b/accounts/models.py index 855dfc8..3a2cb46 100644 --- a/accounts/models.py +++ b/accounts/models.py @@ -1,36 +1,54 @@ +#shw 导入Django内置的抽象用户模型基类 from django.contrib.auth.models import AbstractUser +#shw 导入Django的数据库模型模块 from django.db import models +#shw 导入Django的URL反向解析函数 from django.urls import reverse +#shw 导入Django的时区工具，用于获取当前时间 from django.utils.timezone import now +#shw 导入Django的国际化和翻译工具 from django.utils.translation import gettext_lazy as _ - from djangoblog.utils import get_current_site -# Create your models here. +#shw 在这里创建你的模型。 class BlogUser(AbstractUser): +#shw 自定义用户模型，继承自Django的AbstractUser。 +#shw 它扩展了默认用户模型，增加了博客系统所需的额外字段。 + + #shw 用户昵称字段，可为空 nickname = models.CharField(_('nick name'), max_length=100, blank=True) + #shw 用户创建时间字段，默认为当前时间 creation_time = models.DateTimeField(_('creation time'), default=now) + #shw 用户最后修改时间字段，默认为当前时间 last_modify_time = models.DateTimeField(_('last modify time'), default=now) + #shw 用户创建来源字段（如：'adminsite', 'register'），可为空 source = models.CharField(_('create source'), max_length=100, blank=True) def get_absolute_url(self): +#shw 定义获取用户详情页绝对路径的方法。 +#shw Django Admin和其他地方会使用这个方法来获取对象的URL。 return reverse( 'blog:author_detail', kwargs={ - 'author_name': self.username}) + 'author_name': self.username}) #shw 反向解析到博客应用的作者详情页，URL参数为用户名 def __str__(self): - return self.email +#shw 定义对象的字符串表示形式。 +#shw 在Django Admin或打印对象时会显示这个字符串。 + return self.email #shw 返回用户的邮箱作为其字符串表示 def get_full_url(self): - site = get_current_site().domain +#shw 定义获取用户详情页完整URL（包含域名）的方法。 + site = get_current_site().domain #shw 获取当前站点的域名 + #shw 拼接协议、域名和绝对路径，形成完整的URL url = "https://{site}{path}".format(site=site, path=self.get_absolute_url()) return url class Meta: - ordering = ['-id'] - verbose_name = _('user') - verbose_name_plural = verbose_name - get_latest_by = 'id' +#shw Meta类用于定义模型的元数据选项。 + ordering = ['-id'] #shw 默认按ID降序排列 + verbose_name = _('user') #shw 在Django Admin中显示的单数名称，支持国际化 + verbose_name_plural = verbose_name #shw 在Django Admin中显示的复数名称 + get_latest_by = 'id' #shw 当使用 .latest() 方法时，默认按 'id' 字段查找 diff --git a/accounts/tests.py b/accounts/tests.py index e962f67..00440c5 100644 --- a/accounts/tests.py +++ b/accounts/tests.py @@ -1,47 +1,64 @@ +#shw 导入Django的测试客户端、请求工厂和测试用例基类 from django.test import Client, RequestFactory, TestCase +#shw 导入Django的URL反向解析函数 from django.urls import reverse +#shw 导入Django的时区工具 from django.utils import timezone +from django.utils.translation import gettext_lazy as _ +#shw 导入本地的BlogUser模型 from accounts.models import BlogUser +#shw 导入博客应用的Article和Category模型 from blog.models import Article, Category +#shw 从项目工具模块导入所有函数 from djangoblog.utils import * +#shw 导入本地的工具模块 from . import utils -# Create your tests here. +#shw 在这里创建你的测试。 class AccountTest(TestCase): +#shw 账户应用的测试用例集，继承自Django的TestCase。 +#shw TestCase提供了数据库事务回滚和客户端模拟等功能。 + def setUp(self): - self.client = Client() - self.factory = RequestFactory() +#shw 每个测试方法执行前都会运行的初始化方法。 +#shw 用于创建测试所需的公共数据和环境。 + self.client = Client() #shw 创建一个模拟的HTTP客户端，用于发送请求 + self.factory = RequestFactory() #shw 创建一个请求工厂，用于生成请求对象 + #shw 创建一个普通用户用于测试 self.blog_user = BlogUser.objects.create_user( username="test", email="admin@admin.com", password="12345678" ) - self.new_test = "xxx123--=" + self.new_test = "xxx123--=" #shw 定义一个测试用的新密码 def test_validate_account(self): - get_current_site().domain + site = get_current_site().domain user = BlogUser.objects.create_superuser( email="liangliangyy1@gmail.com", username="liangliangyy1", password="qwer!@#$ggg") - BlogUser.objects.get(username='liangliangyy1') + testuser = BlogUser.objects.get(username='liangliangyy1') #shw 从数据库中获取刚创建的超级用户 + #shw 使用client模拟登录 loginresult = self.client.login( username='liangliangyy1', password='qwer!@#$ggg') - self.assertEqual(loginresult, True) - response = self.client.get('/admin/') - self.assertEqual(response.status_code, 200) + self.assertEqual(loginresult, True) #shw 断言登录成功 + response = self.client.get('/admin/') #shw 模拟访问后台管理页面 + self.assertEqual(response.status_code, 200) #shw 断言访问成功，状态码为200 + #shw 创建一个文章分类用于测试 category = Category() category.name = "categoryaaa" category.creation_time = timezone.now() category.last_modify_time = timezone.now() category.save() + #shw 创建一篇文章用于测试 article = Article() article.title = "nicetitleaaa" article.body = "nicecontentaaa" @@ -51,38 +68,47 @@ class AccountTest(TestCase): article.status = 'p' article.save() + #shw 模拟访问文章的后台编辑页面 response = self.client.get(article.get_admin_url()) - self.assertEqual(response.status_code, 200) + self.assertEqual(response.status_code, 200) #shw 断言访问成功 def test_validate_register(self): +#shw 测试用户注册、邮箱验证、登录、登出等一系列流程。 + #shw 断言注册前，数据库中不存在该邮箱的用户 self.assertEquals( 0, len( BlogUser.objects.filter( email='user123@user.com'))) - self.client.post(reverse('account:register'), { + response = self.client.post(reverse('account:register'), { 'username': 'user1233', 'email': 'user123@user.com', 'password1': 'password123!q@wE#R$T', 'password2': 'password123!q@wE#R$T', }) + #shw 断言注册后，数据库中存在该邮箱的用户 self.assertEquals( 1, len( BlogUser.objects.filter( email='user123@user.com'))) - user = BlogUser.objects.filter(email='user123@user.com')[0] + user = BlogUser.objects.filter(email='user123@user.com')[0] #shw 获取新注册的用户 + #shw 生成用于邮箱验证的签名 sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id))) - path = reverse('accounts:result') + path = reverse('accounts:result') #shw 获取验证结果页面的URL路径 + #shw 构造完整的验证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) + response = self.client.get(url) #shw 模拟用户点击邮箱中的验证链接 + self.assertEqual(response.status_code, 200) #shw 断言访问成功 + #shw 模拟用户登录 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 = BlogUser.objects.filter(email='user123@user.com')[0] #shw 重新获取用户对象 + user.is_superuser = True #shw 将用户提升为超级用户，以便访问后台 user.is_staff = True user.save() - delete_sidebar_cache() + delete_sidebar_cache() #shw 删除侧边栏缓存 + + #shw 创建测试用的分类和文章 category = Category() category.name = "categoryaaa" category.creation_time = timezone.now() @@ -94,66 +120,79 @@ class AccountTest(TestCase): article.title = "nicetitle333" article.body = "nicecontentttt" article.author = user - article.type = 'a' article.status = 'p' article.save() + #shw 登录状态下访问文章后台页面 response = self.client.get(article.get_admin_url()) self.assertEqual(response.status_code, 200) + #shw 模拟用户登出 response = self.client.get(reverse('account:logout')) - self.assertIn(response.status_code, [301, 302, 200]) + self.assertIn(response.status_code, [301, 302, 200]) #shw 断言登出成功（重定向或OK） + #shw 登出后再次访问文章后台页面 response = self.client.get(article.get_admin_url()) - self.assertIn(response.status_code, [301, 302, 200]) + self.assertIn(response.status_code, [301, 302, 200]) #shw 断言被重定向到登录页 + #shw 模拟使用错误的密码登录 response = self.client.post(reverse('account:login'), { 'username': 'user1233', - 'password': 'password123' + 'password': 'password123' #shw 错误的密码 }) - self.assertIn(response.status_code, [301, 302, 200]) + self.assertIn(response.status_code, [301, 302, 200]) #shw 断言登录失败，页面重定向 + #shw 登录失败后访问文章后台页面 response = self.client.get(article.get_admin_url()) - self.assertIn(response.status_code, [301, 302, 200]) + self.assertIn(response.status_code, [301, 302, 200]) #shw 断言依然无法访问 def test_verify_email_code(self): +#shw 测试邮箱验证码的生成、发送和验证功能。 to_email = "admin@admin.com" - code = generate_code() - utils.set_code(to_email, code) - utils.send_verify_email(to_email, code) + code = generate_code() #shw 生成一个验证码 + utils.set_code(to_email, code) #shw 将验证码与邮箱关联（通常是存入缓存或数据库） + utils.send_verify_email(to_email, code) #shw 发送验证码邮件（测试环境中可能不会真的发送） + #shw 使用正确的邮箱和验证码进行验证 err = utils.verify("admin@admin.com", code) - self.assertEqual(err, None) + self.assertEqual(err, None) #shw 断言验证成功，无错误信息返回 + #shw 使用错误的邮箱进行验证 err = utils.verify("admin@123.com", code) - self.assertEqual(type(err), str) + self.assertEqual(type(err), str) #shw 断言验证失败，返回一个字符串类型的错误信息 def test_forget_password_email_code_success(self): +#shw 测试成功发送忘记密码验证码的场景。 resp = self.client.post( path=reverse("account:forget_password_code"), - data=dict(email="admin@admin.com") + data=dict(email="admin@admin.com") #shw 使用一个已存在的邮箱 ) - self.assertEqual(resp.status_code, 200) - self.assertEqual(resp.content.decode("utf-8"), "ok") + self.assertEqual(resp.status_code, 200) #shw 断言请求成功 + self.assertEqual(resp.content.decode("utf-8"), "ok") #shw 断言返回内容为"ok" def test_forget_password_email_code_fail(self): +#shw 测试发送忘记密码验证码失败的场景（如邮箱格式错误）。 + #shw 测试不提供邮箱的情况 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"), "错误的邮箱") #shw 断言返回错误提示 + #shw 测试提供格式错误的邮箱的情况 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"), "错误的邮箱") #shw 断言返回错误提示 def test_forget_password_email_success(self): - code = generate_code() - utils.set_code(self.blog_user.email, code) +#shw 测试成功重置密码的场景。 + code = generate_code() #shw 生成一个验证码 + utils.set_code(self.blog_user.email, code) #shw 为测试用户设置验证码 + #shw 构造重置密码的请求数据 data = dict( new_password1=self.new_test, new_password2=self.new_test, @@ -164,20 +203,21 @@ class AccountTest(TestCase): path=reverse("account:forget_password"), data=data ) - self.assertEqual(resp.status_code, 302) + self.assertEqual(resp.status_code, 302) #shw 断言请求成功并重定向 - # 验证用户密码是否修改成功 + #shw 验证用户密码是否真的被修改了 blog_user = BlogUser.objects.filter( email=self.blog_user.email, ).first() # type: BlogUser - self.assertNotEqual(blog_user, None) - self.assertEqual(blog_user.check_password(data["new_password1"]), True) + self.assertNotEqual(blog_user, None) #shw 断言用户依然存在 + self.assertEqual(blog_user.check_password(data["new_password1"]), True) #shw 断言新密码是正确的 def test_forget_password_email_not_user(self): +#shw 测试重置一个不存在用户的密码的场景。 data = dict( new_password1=self.new_test, new_password2=self.new_test, - email="123@123.com", + email="123@123.com", #shw 使用一个不存在的邮箱 code="123456", ) resp = self.client.post( @@ -185,22 +225,23 @@ class AccountTest(TestCase): data=data ) - self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.status_code, 200) #shw 断言请求未重定向，停留在原页面并显示错误 def test_forget_password_email_code_error(self): - code = generate_code() - utils.set_code(self.blog_user.email, code) +#shw 测试使用错误验证码重置密码的场景。 + code = generate_code() #shw 生成一个验证码 + utils.set_code(self.blog_user.email, code) #shw 为测试用户设置验证码 + #shw 构造重置密码的请求数据，但验证码是错误的 data = dict( new_password1=self.new_test, new_password2=self.new_test, email=self.blog_user.email, - code="111111", + code="111111", #shw 错误的验证码 ) resp = self.client.post( path=reverse("account:forget_password"), data=data ) - self.assertEqual(resp.status_code, 200) - + self.assertEqual(resp.status_code, 200) #shw 断言请求未重定向，停留在原页面并显示错误 diff --git a/accounts/urls.py b/accounts/urls.py index 107a801..d673930 100644 --- a/accounts/urls.py +++ b/accounts/urls.py @@ -1,28 +1,44 @@ -from django.urls import path -from django.urls import re_path +#shw 导入Django的path和re_path函数，用于定义URL路由 +from django.urls import path, re_path +#shw 导入本地的视图模块 from . import views +#shw 导入本地的LoginForm表单，用于传递给登录视图 from .forms import LoginForm +#shw 定义应用的命名空间，用于在模板中反向解析URL，如 {% url 'accounts:login' %} app_name = "accounts" -urlpatterns = [re_path(r'^login/$', - views.LoginView.as_view(success_url='/'), - name='login', - kwargs={'authentication_form': LoginForm}), - re_path(r'^register/$', - views.RegisterView.as_view(success_url="/"), - name='register'), - re_path(r'^logout/$', - views.LogoutView.as_view(), - name='logout'), - path(r'account/result.html', - views.account_result, - name='result'), - re_path(r'^forget_password/$', - views.ForgetPasswordView.as_view(), - name='forget_password'), - re_path(r'^forget_password_code/$', - views.ForgetPasswordEmailCode.as_view(), - name='forget_password_code'), - ] +#shw 定义URL模式列表 +urlpatterns = [ + #shw 定义登录页面的URL路由 + re_path(r'^login/$', + views.LoginView.as_view(success_url='/'), #shw 关联到LoginView类视图，并指定登录成功后重定向到根路径 + name='login', #shw 为这个URL模式命名为 'login' + kwargs={'authentication_form': LoginForm}), #shw 向LoginView传递额外的关键字参数，指定使用自定义的LoginForm + + #shw 定义注册页面的URL路由 + re_path(r'^register/$', + views.RegisterView.as_view(success_url="/"), #shw 关联到RegisterView类视图，并指定注册成功后重定向到根路径 + name='register'), #shw 命名为 'register' + + #shw 定义登出页面的URL路由 + re_path(r'^logout/$', + views.LogoutView.as_view(), #shw 关联到LogoutView类视图 + name='logout'), #shw 命名为 'logout' + + #shw 定义注册/操作结果页面的URL路由 + path(r'account/result.html', + views.account_result, #shw 关联到account_result函数视图 + name='result'), #shw 命名为 'result' + + #shw 定义忘记密码页面的URL路由（用于输入新密码和验证码） + re_path(r'^forget_password/$', + views.ForgetPasswordView.as_view(), #shw 关联到ForgetPasswordView类视图 + name='forget_password'), #shw 命名为 'forget_password' + + #shw 定义发送忘记密码验证码的URL路由 + re_path(r'^forget_password_code/$', + views.ForgetPasswordEmailCode.as_view(), #shw 关联到ForgetPasswordEmailCode类视图 + name='forget_password_code'), #shw 命名为 'forget_password_code' +] diff --git a/accounts/user_login_backend.py b/accounts/user_login_backend.py index 73cdca1..497536a 100644 --- a/accounts/user_login_backend.py +++ b/accounts/user_login_backend.py @@ -1,4 +1,6 @@ +#shw 导入Django的获取用户模型函数 from django.contrib.auth import get_user_model +#shw 导入Django默认的基于模型的认证后端基类 from django.contrib.auth.backends import ModelBackend @@ -6,21 +8,33 @@ class EmailOrUsernameModelBackend(ModelBackend): """ 允许使用用户名或邮箱登录 """ +#shw 自定义认证后端，继承自ModelBackend。 +#shw 它扩展了Django默认的认证功能，使用户既可以使用用户名，也可以使用邮箱进行登录。 def authenticate(self, request, username=None, password=None, **kwargs): +#shw 重写authenticate方法，这是认证的核心逻辑。 +#shw Django的login视图会调用这个方法来验证用户身份。 + #shw 判断用户输入的 'username' 字段是否包含 '@' 符号，以此来区分是邮箱还是用户名 if '@' in username: - kwargs = {'email': username} + kwargs = {'email': username} #shw 如果是邮箱，则设置查询条件为 email else: - kwargs = {'username': username} + kwargs = {'username': username} #shw 如果是用户名，则设置查询条件为 username try: + #shw 使用动态构建的查询条件（email或username）去数据库中查找用户 user = get_user_model().objects.get(**kwargs) + #shw 如果找到了用户，则调用 check_password 方法来验证密码是否正确 if user.check_password(password): - return user + return user #shw 密码正确，返回用户对象，认证成功 except get_user_model().DoesNotExist: - return None + #shw 如果根据email或username找不到用户，捕获异常 + return None #shw 返回None，表示认证失败 def get_user(self, username): +#shw 重写get_user方法。 +#shw Django的认证中间件会在每个请求中调用此方法，根据session中的user_id来获取用户对象。 try: - return get_user_model().objects.get(pk=username) + #shw 注意：这里的参数名是username，但实际传入的是用户的主键（pk），通常是ID + return get_user_model().objects.get(pk=username) #shw 根据主键（pk）查找用户 except get_user_model().DoesNotExist: - return None + #shw 如果根据主键找不到用户，捕获异常 + return None #shw 返回None diff --git a/accounts/utils.py b/accounts/utils.py index d416b35..f8372d8 100644 --- a/accounts/utils.py +++ b/accounts/utils.py @@ -1,12 +1,19 @@ +#shw 导入类型提示模块，用于增强代码可读性和健壮性 import typing +#shw 导入时间间隔类，用于定义验证码有效期 from datetime import timedelta +#shw 导入Django的缓存模块 from django.core.cache import cache +#shw 导入Django的翻译函数 from django.utils.translation import gettext +#shw 导入Django的延迟翻译函数，用于在类或模型定义等场景 from django.utils.translation import gettext_lazy as _ +#shw 从项目工具模块导入发送邮件的函数 from djangoblog.utils import send_email +#shw 定义验证码的生存时间（Time To Live）为5分钟 _code_ttl = timedelta(minutes=5) @@ -17,9 +24,11 @@ def send_verify_email(to_mail: str, code: str, subject: str = _("Verify Email")) subject: 邮件主题 code: 验证码 """ + #shw 构造邮件的HTML内容，使用国际化字符串，并将验证码动态插入 html_content = _( "You are resetting the password, the verification code is：%(code)s, valid within 5 minutes, please keep it " "properly") % {'code': code} + #shw 调用项目通用的邮件发送函数来完成发送 send_email([to_mail], subject, html_content) @@ -32,19 +41,23 @@ def verify(email: str, code: str) -> typing.Optional[str]: 如果有错误就返回错误str Node: 这里的错误处理不太合理，应该采用raise抛出 - 否测调用方也需要对error进行处理 + 否测调用方就需要对error进行处理 """ + #shw 从缓存中获取指定邮箱对应的验证码 cache_code = get_code(email) + #shw 比较用户输入的验证码和缓存中的验证码是否一致 if cache_code != code: + #shw 如果不一致，返回一个翻译后的错误信息字符串 return gettext("Verification code error") - return None def set_code(email: str, code: str): """设置code""" + #shw 将验证码存入缓存，键为邮箱，值为验证码，并设置5分钟的过期时间 cache.set(email, code, _code_ttl.seconds) def get_code(email: str) -> typing.Optional[str]: """获取code""" + #shw 从缓存中根据邮箱（键）获取验证码（值） return cache.get(email) diff --git a/accounts/views.py b/accounts/views.py index e9c188e..b878b50 100644 --- a/accounts/views.py +++ b/accounts/views.py @@ -1,59 +1,84 @@ +#shw 导入日志模块 import logging - +from django.utils.translation import gettext_lazy as _ from django.conf import settings +#shw 导入Django的认证模块 from django.contrib import auth +#shw 导入登录后重定向字段的常量名 from django.contrib.auth import REDIRECT_FIELD_NAME +#shw 导入获取用户模型的函数 from django.contrib.auth import get_user_model +#shw 导入登出函数 from django.contrib.auth import logout +#shw 导入Django内置的认证表单 from django.contrib.auth.forms import AuthenticationForm +#shw 导入密码哈希生成函数 from django.contrib.auth.hashers import make_password +#shw 导入HTTP响应相关类 from django.http import HttpResponseRedirect, HttpResponseForbidden from django.http.request import HttpRequest from django.http.response import HttpResponse +#shw 导入Django的快捷函数 from django.shortcuts import get_object_or_404 from django.shortcuts import render +#shw 导入URL反向解析函数 from django.urls import reverse +#shw 导入方法装饰器 from django.utils.decorators import method_decorator +#shw 导入URL安全检查函数 from django.utils.http import url_has_allowed_host_and_scheme +#shw 导入Django的视图基类 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 +#shw 从项目工具模块导入所需函数 from djangoblog.utils import send_email, get_sha256, get_current_site, generate_code, delete_sidebar_cache +#shw 导入本地的工具模块和表单 from . import utils from .forms import RegisterForm, LoginForm, ForgetPasswordForm, ForgetPasswordCodeForm +#shw 导入本地的模型 from .models import BlogUser +#shw 获取当前模块的日志记录器 logger = logging.getLogger(__name__) -# Create your views here. +#shw 在这里创建你的视图。 class RegisterView(FormView): - form_class = RegisterForm - template_name = 'account/registration_form.html' +#shw 用户注册视图，继承自FormView，用于处理用户注册逻辑。 + form_class = RegisterForm #shw 指定使用的表单类 + template_name = 'account/registration_form.html' #shw 指定渲染的模板 @method_decorator(csrf_protect) def dispatch(self, *args, **kwargs): +#shw 为视图的dispatch方法添加CSRF保护 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 +#shw 当表单验证通过时执行此方法 + if form.is_valid(): #shw 再次确认表单有效 + user = form.save(False) #shw 保存表单数据，但先不提交到数据库（commit=False） + user.is_active = False #shw 将用户状态设为未激活，需要邮箱验证 + user.source = 'Register' #shw 设置用户来源为注册 + user.save(True) #shw 现在将用户对象保存到数据库 + + site = get_current_site().domain #shw 获取当前站点域名 + #shw 生成用于邮箱验证的双重哈希签名 sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id))) + #shw 如果是调试模式，则使用本地地址 if settings.DEBUG: site = '127.0.0.1:8000' - path = reverse('account:result') + path = reverse('account:result') #shw 获取结果页面的URL路径 + #shw 构造完整的邮箱验证链接 url = "http://{site}{path}?type=validation&id={id}&sign={sign}".format( site=site, path=path, id=user.id, sign=sign) + #shw 构造邮件内容 content = """

请点击下面链接验证您的邮箱

@@ -64,6 +89,7 @@ class RegisterView(FormView): 如果上面链接无法打开，请将此链接复制至浏览器。 {url} """.format(url=url) + #shw 发送验证邮件 send_email( emailto=[ user.email, @@ -71,135 +97,159 @@ class RegisterView(FormView): title='验证您的电子邮箱', content=content) + #shw 构造注册成功后的跳转URL，提示用户去查收邮件 url = reverse('accounts:result') + \ '?type=register&id=' + str(user.id) - return HttpResponseRedirect(url) + return HttpResponseRedirect(url) #shw 重定向到结果页面 else: + #shw 如果表单无效，重新渲染注册页面并显示错误 return self.render_to_response({ 'form': form }) class LogoutView(RedirectView): - url = '/login/' +#shw 用户登出视图，继承自RedirectView，用于处理用户登出逻辑。 + url = '/login/' #shw 登出后重定向的URL @method_decorator(never_cache) def dispatch(self, request, *args, **kwargs): +#shw 为视图添加never_cache装饰器，确保该页面不被缓存 return super(LogoutView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): - logout(request) - delete_sidebar_cache() - return super(LogoutView, self).get(request, *args, **kwargs) + logout(request) #shw 调用Django的logout函数，清除session信息 + delete_sidebar_cache() #shw 删除侧边栏缓存 + return super(LogoutView, self).get(request, *args, **kwargs) #shw 执行重定向 class LoginView(FormView): - form_class = LoginForm - template_name = 'account/login.html' - success_url = '/' - redirect_field_name = REDIRECT_FIELD_NAME - login_ttl = 2626560 # 一个月的时间 +#shw 用户登录视图，继承自FormView，用于处理用户登录逻辑。 + form_class = LoginForm #shw 指定使用的表单类 + template_name = 'account/login.html' #shw 指定渲染的模板 + success_url = '/' #shw 登录成功后默认的重定向URL + redirect_field_name = REDIRECT_FIELD_NAME #shw 指定包含重定向URL的GET参数名 + login_ttl = 2626560 # 一个月的时间（秒），用于“记住我”功能的session过期时间 @method_decorator(sensitive_post_parameters('password')) @method_decorator(csrf_protect) @method_decorator(never_cache) def dispatch(self, request, *args, **kwargs): - +#shw 为视图添加多个装饰器：保护密码参数、CSRF保护、禁止缓存 return super(LoginView, self).dispatch(request, *args, **kwargs) def get_context_data(self, **kwargs): - redirect_to = self.request.GET.get(self.redirect_field_name) +#shw 向模板上下文中添加额外的数据 + redirect_to = self.request.GET.get(self.redirect_field_name) #shw 获取GET参数中的重定向URL if redirect_to is None: - redirect_to = '/' - kwargs['redirect_to'] = redirect_to + redirect_to = '/' #shw 如果没有，则默认为根路径 + kwargs['redirect_to'] = redirect_to #shw 将重定向URL添加到上下文 return super(LoginView, self).get_context_data(**kwargs) def form_valid(self, form): +#shw 当表单验证通过时执行此方法 + #shw 使用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() #shw 删除侧边栏缓存 + logger.info(self.redirect_field_name) #shw 记录日志 - auth.login(self.request, form.get_user()) + auth.login(self.request, form.get_user()) #shw 调用Django的login函数，将用户信息存入session + #shw 如果用户勾选了“记住我” if self.request.POST.get("remember"): - self.request.session.set_expiry(self.login_ttl) - return super(LoginView, self).form_valid(form) - # return HttpResponseRedirect('/') + self.request.session.set_expiry(self.login_ttl) #shw 设置session的过期时间为一个月 + return super(LoginView, self).form_valid(form) #shw 调用父类方法，处理重定向 else: + #shw 如果验证失败，重新渲染登录页面并显示错误 return self.render_to_response({ 'form': form }) def get_success_url(self): - - redirect_to = self.request.POST.get(self.redirect_field_name) +#shw 获取登录成功后应重定向的URL + redirect_to = self.request.POST.get(self.redirect_field_name) #shw 从POST数据中获取重定向URL + #shw 检查URL是否安全，防止开放重定向攻击 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 #shw 如果URL不安全，则使用默认的success_url return redirect_to def account_result(request): - type = request.GET.get('type') - id = request.GET.get('id') +#shw 函数视图，用于处理注册和邮箱验证的结果展示。 + type = request.GET.get('type') #shw 获取URL参数中的类型 + id = request.GET.get('id') #shw 获取URL参数中的用户ID - user = get_object_or_404(get_user_model(), id=id) - logger.info(type) - if user.is_active: + user = get_object_or_404(get_user_model(), id=id) #shw 根据ID获取用户对象，如果不存在则返回404 + logger.info(type) #shw 记录日志 + if user.is_active: #shw 如果用户已经激活，则直接跳转到首页 return HttpResponseRedirect('/') + #shw 处理两种类型：注册成功提示和邮箱验证 if type and type in ['register', 'validation']: if type == 'register': + #shw 如果是注册类型，显示注册成功、请查收邮件的提示 content = ''' 恭喜您注册成功，一封验证邮件已经发送到您的邮箱，请验证您的邮箱后登录本站。 ''' title = '注册成功' else: - c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id))) - sign = request.GET.get('sign') - if sign != c_sign: + #shw 如果是验证类型，需要验证签名 + c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id))) #shw 重新计算正确的签名 + sign = request.GET.get('sign') #shw 获取URL中的签名 + if sign != c_sign: #shw 比较签名，如果不一致则返回403禁止访问 return HttpResponseForbidden() - user.is_active = True - user.save() + user.is_active = True #shw 激活用户 + user.save() #shw 保存用户状态 + #shw 显示验证成功的提示 content = ''' 恭喜您已经成功的完成邮箱验证，您现在可以使用您的账号来登录本站。 ''' title = '验证成功' + #shw 渲染结果页面 return render(request, 'account/result.html', { 'title': title, 'content': content }) else: + #shw 如果类型不匹配，则跳转到首页 return HttpResponseRedirect('/') class ForgetPasswordView(FormView): - form_class = ForgetPasswordForm - template_name = 'account/forget_password.html' +#shw 忘记密码视图，用于处理通过验证码重置密码的逻辑。 + form_class = ForgetPasswordForm #shw 指定使用的表单 + template_name = 'account/forget_password.html' #shw 指定渲染的模板 def form_valid(self, form): - if form.is_valid(): +#shw 当表单验证通过时执行此方法 + if form.is_valid(): #shw 再次确认表单有效 + #shw 根据邮箱获取用户对象 blog_user = BlogUser.objects.filter(email=form.cleaned_data.get("email")).get() + #shw 使用make_password对新密码进行哈希处理 blog_user.password = make_password(form.cleaned_data["new_password2"]) - blog_user.save() - return HttpResponseRedirect('/login/') + blog_user.save() #shw 保存用户的新密码 + return HttpResponseRedirect('/login/') #shw 重定向到登录页面 else: + #shw 如果表单无效，重新渲染页面并显示错误 return self.render_to_response({'form': form}) class ForgetPasswordEmailCode(View): + #shw 发送忘记密码验证码的视图，继承自基础的View。 @staticmethod def post(request: HttpRequest): - form = ForgetPasswordCodeForm(request.POST) - if not form.is_valid(): - return HttpResponse("错误的邮箱") - to_email = form.cleaned_data["email"] + #shw 只处理POST请求 + form = ForgetPasswordCodeForm(request.POST) #shw 用POST数据实例化表单 + if not form.is_valid(): #shw 验证表单（主要是验证邮箱格式） + return HttpResponse("错误的邮箱") #shw 如果无效，返回错误信息 + to_email = form.cleaned_data["email"] #shw 获取清洗后的邮箱 - code = generate_code() - utils.send_verify_email(to_email, code) - utils.set_code(to_email, code) + code = generate_code() #shw 生成一个验证码 + utils.send_verify_email(to_email, code) #shw 调用工具函数发送验证邮件 + utils.set_code(to_email, code) #shw 调用工具函数将验证码存入缓存 - return HttpResponse("ok") + return HttpResponse("ok") #shw 返回成功信息 diff --git a/blog/admin.py b/blog/admin.py index 3207b63..58941c8 100644 --- a/blog/admin.py +++ b/blog/admin.py @@ -1,3 +1,4 @@ +# bjy: 从Django中导入所需的模块和类 from django import forms from django.contrib import admin from django.contrib.auth import get_user_model @@ -6,109 +7,160 @@ from django.utils.html import format_html from django.utils.translation import gettext_lazy as _ # Register your models here. -from .models import Article +from .models import Article, Category, Tag, Links, SideBar, BlogSettings +# bjy: 为Article模型创建一个自定义的ModelForm class ArticleForm(forms.ModelForm): + # bjy: 示例：如果使用Pagedown编辑器，可以取消下面这行的注释 # body = forms.CharField(widget=AdminPagedownWidget()) class Meta: + # bjy: 指定这个表单对应的模型是Article model = Article + # bjy: 表示在表单中包含模型的所有字段 fields = '__all__' -def makr_article_publish(queryset): +# bjy: 定义一个admin动作，用于将选中的文章发布 +def makr_article_publish(modeladmin, request, queryset): + # bjy: 批量更新查询集中所有文章的状态为'p'（已发布） queryset.update(status='p') -def draft_article(queryset): +# bjy: 定义一个admin动作，用于将选中的文章设为草稿 +def draft_article(modeladmin, request, queryset): + # bjy: 批量更新查询集中所有文章的状态为'd'（草稿） queryset.update(status='d') -def close_article_commentstatus(queryset): +# bjy: 定义一个admin动作，用于关闭选中文章的评论功能 +def close_article_commentstatus(modeladmin, request, queryset): + # bjy: 批量更新查询集中所有文章的评论状态为'c'（关闭） queryset.update(comment_status='c') -def open_article_commentstatus(queryset): +# bjy: 定义一个admin动作，用于开启选中文章的评论功能 +def open_article_commentstatus(modeladmin, request, queryset): + # bjy: 批量更新查询集中所有文章的评论状态为'o'（开启） queryset.update(comment_status='o') +# bjy: 为admin动作设置在后台显示的描述文本 makr_article_publish.short_description = _('Publish selected articles') draft_article.short_description = _('Draft selected articles') close_article_commentstatus.short_description = _('Close article comments') open_article_commentstatus.short_description = _('Open article comments') +# bjy: 为Article模型自定义Admin管理界面 class ArticlelAdmin(admin.ModelAdmin): + # bjy: 设置每页显示20条记录 list_per_page = 20 + # bjy: 启用搜索功能，搜索范围包括文章内容（body）和标题（title） search_fields = ('body', 'title') + # bjy: 指定使用的自定义表单 form = ArticleForm + # bjy: 在列表视图中显示的字段 list_display = ( 'id', 'title', 'author', - 'link_to_category', + 'link_to_category', # bjy: 自定义方法，显示指向分类的链接 'creation_time', 'views', 'status', 'type', 'article_order') + # bjy: 设置列表视图中可点击进入编辑页面的链接字段 list_display_links = ('id', 'title') + # bjy: 启用右侧筛选栏，可按状态、类型、分类进行筛选 list_filter = ('status', 'type', 'category') + # bjy: 启用日期层次导航，按创建时间进行分层 date_hierarchy = 'creation_time' + # bjy: 为多对多字段（tags）提供一个水平筛选的界面 filter_horizontal = ('tags',) + # bjy: 在编辑页面中排除的字段，这些字段将自动处理 exclude = ('creation_time', 'last_modify_time') + # bjy: 在列表页面显示“在站点上查看”的按钮 view_on_site = True + # bjy: 将自定义的admin动作添加到动作下拉列表中 actions = [ makr_article_publish, draft_article, close_article_commentstatus, open_article_commentstatus] + # bjy: 对于外键字段（author, category），显示为一个输入框用于输入ID，而不是下拉列表 raw_id_fields = ('author', 'category',) + # bjy: 自定义方法，用于在列表页面显示一个指向文章分类的链接 def link_to_category(self, obj): + # bjy: 获取分类模型的app_label和model_name，用于构建admin URL info = (obj.category._meta.app_label, obj.category._meta.model_name) + # bjy: 生成指向该分类编辑页面的URL link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,)) + # bjy: 使用format_html安全地生成HTML链接 return format_html(u'%s' % (link, obj.category.name)) + # bjy: 设置该方法在列表页面列标题的显示文本 link_to_category.short_description = _('category') + # bjy: 重写get_form方法，用于动态修改表单 def get_form(self, request, obj=None, **kwargs): + # bjy: 获取父类的表单 form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs) + # bjy: 修改author字段的查询集，只显示超级用户 form.base_fields['author'].queryset = get_user_model( ).objects.filter(is_superuser=True) return form + # bjy: 重写save_model方法，在保存模型时执行额外操作 def save_model(self, request, obj, form, change): + # bjy: 调用父类的save_model方法执行默认保存操作 super(ArticlelAdmin, self).save_model(request, obj, form, change) + # bjy: 重写get_view_on_site_url方法，自定义“在站点上查看”的URL def get_view_on_site_url(self, obj=None): if obj: + # bjy: 如果对象存在，则调用模型的get_full_url方法获取URL url = obj.get_full_url() return url else: + # bjy: 如果对象不存在（例如在添加新对象时），则返回网站首页URL from djangoblog.utils import get_current_site site = get_current_site().domain return site +# bjy: 为Tag模型自定义Admin管理界面 class TagAdmin(admin.ModelAdmin): + # bjy: 在编辑页面中排除的字段 exclude = ('slug', 'last_mod_time', 'creation_time') +# bjy: 为Category模型自定义Admin管理界面 class CategoryAdmin(admin.ModelAdmin): + # bjy: 在列表视图中显示的字段 list_display = ('name', 'parent_category', 'index') + # bjy: 在编辑页面中排除的字段 exclude = ('slug', 'last_mod_time', 'creation_time') +# bjy: 为Links模型自定义Admin管理界面 class LinksAdmin(admin.ModelAdmin): + # bjy: 在编辑页面中排除的字段 exclude = ('last_mod_time', 'creation_time') +# bjy: 为SideBar模型自定义Admin管理界面 class SideBarAdmin(admin.ModelAdmin): + # bjy: 在列表视图中显示的字段 list_display = ('name', 'content', 'is_enable', 'sequence') + # bjy: 在编辑页面中排除的字段 exclude = ('last_mod_time', 'creation_time') +# bjy: 为BlogSettings模型自定义Admin管理界面 class BlogSettingsAdmin(admin.ModelAdmin): + # bjy: 使用默认配置，无需自定义 pass diff --git a/blog/apps.py b/blog/apps.py index 7930587..0198010 100644 --- a/blog/apps.py +++ b/blog/apps.py @@ -1,5 +1,8 @@ +# bjy: 从Django中导入AppConfig基类，用于配置应用程序 from django.apps import AppConfig +# bjy: 定义一个名为BlogConfig的配置类，它继承自AppConfig class BlogConfig(AppConfig): + # bjy: 指定这个配置类对应的应用程序名称（通常是Python包的路径） name = 'blog' diff --git a/blog/context_processors.py b/blog/context_processors.py index 73e3088..6f1d347 100644 --- a/blog/context_processors.py +++ b/blog/context_processors.py @@ -1,43 +1,76 @@ +# bjy: 导入日志模块 import logging +# bjy: 从Django中导入时区工具 from django.utils import timezone +# bjy: 从项目工具模块中导入缓存和获取博客设置的函数 from djangoblog.utils import cache, get_blog_setting +# bjy: 从当前应用的models中导入Category和Article模型 from .models import Category, Article +# bjy: 获取一个名为__name__的logger实例，用于记录日志 logger = logging.getLogger(__name__) +# bjy: 定义一个上下文处理器，用于在所有模板中注入全局变量 def seo_processor(requests): + # bjy: 定义一个缓存键名 key = 'seo_processor' + # bjy: 尝试从缓存中获取数据 value = cache.get(key) + # bjy: 如果缓存中存在数据，则直接返回 if value: return value else: + # bjy: 如果缓存中没有数据，则记录一条日志 logger.info('set processor cache.') + # bjy: 获取博客的设置对象 setting = get_blog_setting() + # bjy: 构建一个包含所有SEO和全局设置的字典 value = { + # bjy: 网站名称 'SITE_NAME': setting.site_name, + # bjy: 是否显示Google AdSense广告 'SHOW_GOOGLE_ADSENSE': setting.show_google_adsense, + # bjy: Google AdSense的广告代码 'GOOGLE_ADSENSE_CODES': setting.google_adsense_codes, + # bjy: 网站的SEO描述 'SITE_SEO_DESCRIPTION': setting.site_seo_description, + # bjy: 网站的普通描述 'SITE_DESCRIPTION': setting.site_description, + # bjy: 网站的关键词 'SITE_KEYWORDS': setting.site_keywords, + # bjy: 网站的完整基础URL（协议+域名） 'SITE_BASE_URL': requests.scheme + '://' + requests.get_host() + '/', + # bjy: 文章列表页的摘要长度 'ARTICLE_SUB_LENGTH': setting.article_sub_length, + # bjy: 用于导航栏的所有分类列表 'nav_category_list': Category.objects.all(), + # bjy: 用于导航栏的所有已发布的“页面”类型的文章 'nav_pages': Article.objects.filter( - type='p', - status='p'), + type='p', # bjy: 类型为'p'（page） + status='p'), # bjy: 状态为'p'（published） + # bjy: 是否开启全站评论功能 'OPEN_SITE_COMMENT': setting.open_site_comment, + # bjy: 网站的ICP备案号 'BEIAN_CODE': setting.beian_code, + # bjy: 网站统计代码（如Google Analytics） 'ANALYTICS_CODE': setting.analytics_code, + # bjy: 公安备案号 "BEIAN_CODE_GONGAN": setting.gongan_beiancode, + # bjy: 是否显示公安备案号 "SHOW_GONGAN_CODE": setting.show_gongan_code, + # bjy: 当前年份，用于页脚版权信息 "CURRENT_YEAR": timezone.now().year, + # bjy: 全局页头HTML代码 "GLOBAL_HEADER": setting.global_header, + # bjy: 全局页脚HTML代码 "GLOBAL_FOOTER": setting.global_footer, + # bjy: 评论是否需要审核 "COMMENT_NEED_REVIEW": setting.comment_need_review, } + # bjy: 将构建好的字典存入缓存，缓存时间为10小时（60*60*10秒） cache.set(key, value, 60 * 60 * 10) + # bjy: 返回这个字典，它将被注入到所有模板的上下文中 return value diff --git a/blog/documents.py b/blog/documents.py index 2b0c883..f662223 100644 --- a/blog/documents.py +++ b/blog/documents.py @@ -1,26 +1,40 @@ +# bjy: 导入时间模块 import time +# bjy: 导入Elasticsearch的客户端模块和异常类 import elasticsearch.client +import elasticsearch.exceptions +# bjy: 导入Django的设置 from django.conf import settings +# bjy: 从elasticsearch_dsl中导入文档、内部文档、字段类型和连接管理器 from elasticsearch_dsl import Document, InnerDoc, Date, Integer, Long, Text, Object, GeoPoint, Keyword, Boolean from elasticsearch_dsl.connections import connections +# bjy: 从blog应用中导入Article模型 from blog.models import Article +# bjy: 检查Django设置中是否配置了ELASTICSEARCH_DSL，以决定是否启用Elasticsearch功能 ELASTICSEARCH_ENABLED = hasattr(settings, 'ELASTICSEARCH_DSL') +# bjy: 如果启用了Elasticsearch if ELASTICSEARCH_ENABLED: + # bjy: 根据Django设置创建到Elasticsearch的连接 connections.create_connection( hosts=[settings.ELASTICSEARCH_DSL['default']['hosts']]) + # bjy: 导入并实例化Elasticsearch客户端 from elasticsearch import Elasticsearch es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) + # bjy: 导入并实例化Ingest客户端，用于管理管道 from elasticsearch.client import IngestClient c = IngestClient(es) + # bjy: 尝试获取名为'geoip'的管道 try: c.get_pipeline('geoip') + # bjy: 如果管道不存在，则创建它 except elasticsearch.exceptions.NotFoundError: + # bjy: 创建一个geoip管道，用于根据IP地址添加地理位置信息 c.put_pipeline('geoip', body='''{ "description" : "Add geoip info", "processors" : [ @@ -33,58 +47,90 @@ if ELASTICSEARCH_ENABLED: }''') +# bjy: 定义一个内部文档（InnerDoc）结构，用于存储IP地理位置信息 class GeoIp(InnerDoc): + # bjy: 大洲名称 continent_name = Keyword() + # bjy: 国家ISO代码 country_iso_code = Keyword() + # bjy: 国家名称 country_name = Keyword() + # bjy: 地理坐标（经纬度） location = GeoPoint() +# bjy: 定义内部文档，用于存储用户代理（User-Agent）中的浏览器信息 class UserAgentBrowser(InnerDoc): + # bjy: 浏览器家族（如Chrome, Firefox） Family = Keyword() + # bjy: 浏览器版本 Version = Keyword() +# bjy: 定义内部文档，用于存储用户代理中的操作系统信息 class UserAgentOS(UserAgentBrowser): + # bjy: 继承自UserAgentBrowser，结构相同 pass +# bjy: 定义内部文档，用于存储用户代理中的设备信息 class UserAgentDevice(InnerDoc): + # bjy: 设备家族（如iPhone, Android） Family = Keyword() + # bjy: 设备品牌（如Apple, Samsung） Brand = Keyword() + # bjy: 设备型号（如iPhone 12） Model = Keyword() +# bjy: 定义内部文档，用于存储完整的用户代理信息 class UserAgent(InnerDoc): + # bjy: 嵌套浏览器信息 browser = Object(UserAgentBrowser, required=False) + # bjy: 嵌套操作系统信息 os = Object(UserAgentOS, required=False) + # bjy: 嵌套设备信息 device = Object(UserAgentDevice, required=False) + # bjy: 原始User-Agent字符串 string = Text() + # bjy: 是否为爬虫或机器人 is_bot = Boolean() +# bjy: 定义一个Elasticsearch文档，用于存储页面性能数据（如响应时间） class ElapsedTimeDocument(Document): + # bjy: 请求的URL url = Keyword() + # bjy: 请求耗时（毫秒） time_taken = Long() + # bjy: 日志记录时间 log_datetime = Date() + # bjy: 客户端IP地址 ip = Keyword() + # bjy: 嵌套的IP地理位置信息 geoip = Object(GeoIp, required=False) + # bjy: 嵌套的用户代理信息 useragent = Object(UserAgent, required=False) class Index: + # bjy: 指定索引名称为'performance' name = 'performance' + # bjy: 设置索引的分片和副本数 settings = { "number_of_shards": 1, "number_of_replicas": 0 } class Meta: + # bjy: 指定文档类型 doc_type = 'ElapsedTime' +# bjy: 定义一个管理类，用于操作ElapsedTimeDocument索引 class ElaspedTimeDocumentManager: @staticmethod def build_index(): + # bjy: 如果索引不存在，则创建它 from elasticsearch import Elasticsearch client = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) res = client.indices.exists(index="performance") @@ -93,13 +139,16 @@ class ElaspedTimeDocumentManager: @staticmethod def delete_index(): + # bjy: 删除'performance'索引 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): + # bjy: 确保索引存在 ElaspedTimeDocumentManager.build_index() + # bjy: 构建UserAgent内部文档对象 ua = UserAgent() ua.browser = UserAgentBrowser() ua.browser.Family = useragent.browser.family @@ -116,8 +165,10 @@ class ElaspedTimeDocumentManager: ua.string = useragent.ua_string ua.is_bot = useragent.is_bot + # bjy: 创建ElapsedTimeDocument文档实例 doc = ElapsedTimeDocument( meta={ + # bjy: 使用当前时间的毫秒数作为文档ID 'id': int( round( time.time() * @@ -127,60 +178,78 @@ class ElaspedTimeDocumentManager: time_taken=time_taken, log_datetime=log_datetime, useragent=ua, ip=ip) + # bjy: 保存文档，并使用'geoip'管道处理IP地址 doc.save(pipeline="geoip") +# bjy: 定义一个Elasticsearch文档，用于存储博客文章数据，以支持全文搜索 class ArticleDocument(Document): + # bjy: 文章内容，使用ik分词器进行索引和搜索 body = Text(analyzer='ik_max_word', search_analyzer='ik_smart') + # bjy: 文章标题，使用ik分词器 title = Text(analyzer='ik_max_word', search_analyzer='ik_smart') + # bjy: 作者信息，为一个对象类型 author = Object(properties={ 'nickname': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), 'id': Integer() }) + # bjy: 分类信息，为一个对象类型 category = Object(properties={ 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), 'id': Integer() }) + # bjy: 标签信息，为一个对象类型 tags = Object(properties={ 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), 'id': Integer() }) + # bjy: 发布时间 pub_time = Date() + # bjy: 文章状态 status = Text() + # bjy: 评论状态 comment_status = Text() + # bjy: 文章类型 type = Text() + # bjy: 浏览量 views = Integer() + # bjy: 文章排序权重 article_order = Integer() class Index: + # bjy: 指定索引名称为'blog' name = 'blog' + # bjy: 设置索引的分片和副本数 settings = { "number_of_shards": 1, "number_of_replicas": 0 } class Meta: + # bjy: 指定文档类型 doc_type = 'Article' -class ArticleDocumentManager: +# bjy: 定义一个管理类，用于操作ArticleDocument索引 +class ArticleDocumentManager(): def __init__(self): + # bjy: 初始化时创建索引 self.create_index() - @staticmethod - def create_index(): + def create_index(self): + # bjy: 创建'blog'索引 ArticleDocument.init() - @staticmethod - def delete_index(): + def delete_index(self): + # bjy: 删除'blog'索引 from elasticsearch import Elasticsearch es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) es.indices.delete(index='blog', ignore=[400, 404]) - @staticmethod - def convert_to_doc(articles): + def convert_to_doc(self, articles): + # bjy: 将Django的Article查询集转换为ArticleDocument对象列表 return [ ArticleDocument( meta={ @@ -205,13 +274,15 @@ class ArticleDocumentManager: article_order=article.article_order) for article in articles] def rebuild(self, articles=None): + # bjy: 重建索引。如果未提供articles，则使用所有文章 ArticleDocument.init() articles = articles if articles else Article.objects.all() docs = self.convert_to_doc(articles) + # bjy: 遍历并保存每个文档 for doc in docs: doc.save() - @staticmethod - def update_docs(docs): + def update_docs(self, docs): + # bjy: 更新一组文档 for doc in docs: doc.save() diff --git a/blog/forms.py b/blog/forms.py index 715be76..283fcf9 100644 --- a/blog/forms.py +++ b/blog/forms.py @@ -1,19 +1,32 @@ +# bjy: 导入日志模块 import logging +# bjy: 从Django中导入表单模块 from django import forms +# bjy: 从haystack（一个Django搜索框架）中导入基础搜索表单 from haystack.forms import SearchForm +# bjy: 获取一个名为__name__的logger实例，用于记录日志 logger = logging.getLogger(__name__) +# bjy: 定义一个自定义的博客搜索表单，继承自Haystack的SearchForm class BlogSearchForm(SearchForm): + # bjy: 定义一个名为querydata的字符字段，用于接收用户输入的搜索关键词，并设置为必填 querydata = forms.CharField(required=True) + # bjy: 重写search方法，用于执行搜索逻辑 def search(self): + # bjy: 调用父类的search方法，执行默认的搜索并返回结果集 datas = super(BlogSearchForm, self).search() + # bjy: 检查表单数据是否有效 if not self.is_valid(): + # bjy: 如果表单无效，则调用no_query_found方法（通常返回一个空的结果集） return self.no_query_found() + # bjy: 如果用户在querydata字段中输入了内容 if self.cleaned_data['querydata']: + # bjy: 将用户输入的搜索关键词记录到日志中 logger.info(self.cleaned_data['querydata']) + # bjy: 返回搜索结果 return datas diff --git a/blog/management/commands/build_index.py b/blog/management/commands/build_index.py index 3c4acd7..96a88f8 100644 --- a/blog/management/commands/build_index.py +++ b/blog/management/commands/build_index.py @@ -1,18 +1,23 @@ -from django.core.management.base import BaseCommand - -from blog.documents import ElapsedTimeDocument, ArticleDocumentManager, ElaspedTimeDocumentManager, \ - ELASTICSEARCH_ENABLED - - # TODO 参数化 +# bjy: 定义一个继承自BaseCommand的命令类，用于执行构建搜索索引的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"构建搜索索引" help = 'build search index' + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 检查Elasticsearch功能是否已启用，确保在启用状态下才执行索引操作 if ELASTICSEARCH_ENABLED: + # bjy: 调用ElapsedTimeDocumentManager的类方法，构建用于记录耗时的文档索引 ElaspedTimeDocumentManager.build_index() + + # bjy: 创建ElapsedTimeDocument的实例，并调用其init方法进行初始化（可能是数据同步或设置） manager = ElapsedTimeDocument() manager.init() + + # bjy: 创建ArticleDocumentManager的实例，用于管理文章的搜索索引 manager = ArticleDocumentManager() + # bjy: 删除现有的文章索引，为重建做准备，防止旧数据冲突 manager.delete_index() + # bjy: 重新构建文章索引，将数据库中的最新文章数据同步到Elasticsearch manager.rebuild() diff --git a/blog/management/commands/build_search_words.py b/blog/management/commands/build_search_words.py index cfe7e0d..359a75a 100644 --- a/blog/management/commands/build_search_words.py +++ b/blog/management/commands/build_search_words.py @@ -1,13 +1,20 @@ +# bjy: 从Django核心管理模块导入BaseCommand基类，用于创建自定义管理命令 from django.core.management.base import BaseCommand +# bjy: 从当前应用的models模块导入Tag和Category模型，用于获取数据 from blog.models import Tag, Category # TODO 参数化 +# bjy: 定义一个继承自BaseCommand的命令类，用于执行构建搜索词的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"构建搜索词" help = 'build search words' + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 使用集合推导式获取所有Tag和Category的name字段，并自动去重 datas = set([t.name for t in Tag.objects.all()] + [t.name for t in Category.objects.all()]) + # bjy: 将去重后的搜索词集合中的每个元素用换行符连接，并打印到标准输出 print('\n'.join(datas)) diff --git a/blog/management/commands/clear_cache.py b/blog/management/commands/clear_cache.py index 0d66172..20bf8e5 100644 --- a/blog/management/commands/clear_cache.py +++ b/blog/management/commands/clear_cache.py @@ -1,11 +1,18 @@ +# bjy: 从Django核心管理模块导入BaseCommand基类，用于创建自定义管理命令 from django.core.management.base import BaseCommand +# bjy: 从项目工具模块导入cache实例，用于操作缓存 from djangoblog.utils import cache +# bjy: 定义一个继承自BaseCommand的命令类，用于执行清空缓存的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"清空所有缓存" help = 'clear the whole cache' + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 调用cache实例的clear方法，清空所有缓存 cache.clear() + # bjy: 使用成功样式向标准输出写入操作成功的信息，并附带换行符 self.stdout.write(self.style.SUCCESS('Cleared cache\n')) diff --git a/blog/management/commands/create_testdata.py b/blog/management/commands/create_testdata.py index 675d2ba..89d4204 100644 --- a/blog/management/commands/create_testdata.py +++ b/blog/management/commands/create_testdata.py @@ -1,40 +1,65 @@ +# bjy: 从Django的auth模块导入get_user_model函数，用于动态获取当前项目激活的用户模型 from django.contrib.auth import get_user_model +# bjy: 从Django的auth模块导入make_password函数，用于创建加密后的密码哈希 from django.contrib.auth.hashers import make_password +# bjy: 从Django核心管理模块导入BaseCommand基类，用于创建自定义管理命令 from django.core.management.base import BaseCommand +# bjy: 从当前应用的models模块导入Article, Tag, Category模型，用于创建测试数据 from blog.models import Article, Tag, Category +# bjy: 定义一个继承自BaseCommand的命令类，用于执行创建测试数据的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"创建测试数据" help = 'create test datas' + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 获取或创建一个测试用户，如果不存在则创建，密码已加密 user = get_user_model().objects.get_or_create( email='test@test.com', username='测试用户', password=make_password('test!q@w#eTYU'))[0] + # bjy: 获取或创建一个父级分类，parent_category为None表示它是顶级分类 pcategory = Category.objects.get_or_create( name='我是父类目', parent_category=None)[0] + # bjy: 获取或创建一个子分类，并设置其父分类为上面创建的父级分类 category = Category.objects.get_or_create( name='子类目', parent_category=pcategory)[0] + # bjy: 显式保存子分类实例，确保数据已写入数据库（虽然get_or_create通常会保存） category.save() + + # bjy: 创建一个基础标签，所有文章都将共用此标签 basetag = Tag() basetag.name = "标签" basetag.save() + + # bjy: 循环19次，创建19篇测试文章和对应的标签 for i in range(1, 20): + # bjy: 获取或创建一篇文章，关联到上面创建的分类、用户，并设置标题和内容 article = Article.objects.get_or_create( category=category, title='nice title ' + str(i), body='nice content ' + str(i), author=user)[0] + + # bjy: 为每篇文章创建一个专属标签 tag = Tag() tag.name = "标签" + str(i) tag.save() + + # bjy: 将专属标签和基础标签都添加到当前文章的标签集合中 article.tags.add(tag) article.tags.add(basetag) + + # bjy: 保存文章，使标签关联生效 article.save() + # bjy: 导入项目的cache工具，用于清理缓存 from djangoblog.utils import cache + # bjy: 清空所有缓存，以确保新创建的数据能被正确加载 cache.clear() + # bjy: 使用成功样式向标准输出写入操作完成的信息 self.stdout.write(self.style.SUCCESS('created test datas \n')) diff --git a/blog/management/commands/ping_baidu.py b/blog/management/commands/ping_baidu.py index 0063ea1..e35df7d 100644 --- a/blog/management/commands/ping_baidu.py +++ b/blog/management/commands/ping_baidu.py @@ -1,16 +1,23 @@ +# bjy: 从Django核心管理模块导入BaseCommand基类，用于创建自定义管理命令 from django.core.management.base import BaseCommand -from blog.models import Article, Tag, Category from djangoblog.spider_notify import SpiderNotify +# bjy: 从项目工具模块导入get_current_site函数，用于获取当前站点域名等信息 from djangoblog.utils import get_current_site +from blog.models import Article, Tag, Category +# bjy: 获取当前站点的域名，用于拼接完整URL site = get_current_site().domain +# bjy: 定义一个继承自BaseCommand的命令类，用于执行通知百度抓取URL的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"通知百度URL" help = 'notify baidu url' + # bjy: 为命令添加参数，允许用户指定通知的数据类型 def add_arguments(self, parser): + # bjy: 添加一个名为data_type的位置参数，类型为字符串，且只能从给定的选项中选择 parser.add_argument( 'data_type', type=str, @@ -21,31 +28,43 @@ class Command(BaseCommand): 'category'], help='article : all article,tag : all tag,category: all category,all: All of these') + # bjy: 定义一个辅助方法，用于根据路径拼接完整的URL @staticmethod def get_full_url(path): + # bjy: 使用https协议和当前站点域名拼接完整URL url = "https://{site}{path}".format(site=site, path=path) return url + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 获取用户指定的data_type参数，决定通知哪些类型的URL type = options['data_type'] + # bjy: 输出开始获取指定类型URL的信息 self.stdout.write('start get %s' % type) + # bjy: 初始化一个空列表，用于收集所有待通知的URL urls = [] + # bjy: 如果类型为article或all，则收集所有已发布文章的完整URL if type == 'article' or type == 'all': for article in Article.objects.filter(status='p'): urls.append(article.get_full_url()) + # bjy: 如果类型为tag或all，则收集所有标签的完整URL if type == 'tag' or type == 'all': for tag in Tag.objects.all(): url = tag.get_absolute_url() urls.append(self.get_full_url(url)) + # bjy: 如果类型为category或all，则收集所有分类的完整URL if type == 'category' or type == 'all': for category in Category.objects.all(): url = category.get_absolute_url() urls.append(self.get_full_url(url)) + # bjy: 输出开始通知URL的数量信息，使用成功样式 self.stdout.write( self.style.SUCCESS( 'start notify %d urls' % len(urls))) + # bjy: 调用SpiderNotify的百度通知方法，将收集到的URL发送给百度 SpiderNotify.baidu_notify(urls) + # bjy: 输出通知完成的信息，使用成功样式 self.stdout.write(self.style.SUCCESS('finish notify')) diff --git a/blog/management/commands/sync_user_avatar.py b/blog/management/commands/sync_user_avatar.py index bab11b4..0d98f14 100644 --- a/blog/management/commands/sync_user_avatar.py +++ b/blog/management/commands/sync_user_avatar.py @@ -1,48 +1,76 @@ +# bjy: 导入requests库，用于发起HTTP请求，检测头像URL是否可访问 import requests +# bjy: 从Django核心管理模块导入BaseCommand基类，用于创建自定义管理命令 from django.core.management.base import BaseCommand +# bjy: 从Django模板标签模块导入static函数，用于生成静态文件的URL from django.templatetags.static import static +# bjy: 从项目工具模块导入save_user_avatar函数，用于保存用户头像到本地 from djangoblog.utils import save_user_avatar +# bjy: 从oauth应用导入OAuthUser模型，用于获取所有OAuth用户数据 from oauth.models import OAuthUser +# bjy: 从oauth应用导入get_manager_by_type函数，用于根据OAuth类型获取对应的管理器 from oauth.oauthmanager import get_manager_by_type +# bjy: 定义一个继承自BaseCommand的命令类，用于执行同步用户头像的任务 class Command(BaseCommand): + # bjy: 设置命令的帮助信息，描述该命令的功能是"同步用户头像" help = 'sync user avatar' + # bjy: 定义一个辅助方法，用于测试给定的URL是否可访问（返回200状态码） @staticmethod def test_picture(url): try: + # bjy: 尝试GET请求，设置2秒超时，如果状态码为200则返回True if requests.get(url, timeout=2).status_code == 200: return True except: + # bjy: 任何异常都视为不可访问，静默忽略 pass + # bjy: 定义命令的执行逻辑，当命令被调用时此方法会运行 def handle(self, *args, **options): + # bjy: 获取项目静态文件的基础URL，用于判断头像是否为本地静态文件 static_url = static("../") + # bjy: 获取所有OAuth用户 users = OAuthUser.objects.all() + # bjy: 输出开始同步用户头像的总数信息 self.stdout.write(f'开始同步{len(users)}个用户头像') + # bjy: 遍历每个用户，进行头像同步 for u in users: + # bjy: 输出当前正在同步的用户昵称 self.stdout.write(f'开始同步:{u.nickname}') + # bjy: 获取用户当前的头像URL url = u.picture + # bjy: 如果头像URL不为空，则执行同步逻辑 if url: + # bjy: 如果当前头像URL是本地静态文件路径 if url.startswith(static_url): + # bjy: 测试该静态文件是否可访问，若可访问则跳过此用户 if self.test_picture(url): continue else: + # bjy: 如果不可访问，且用户有metadata信息，则尝试通过OAuth管理器重新获取头像URL并保存 if u.metadata: manage = get_manager_by_type(u.type) url = manage.get_picture(u.metadata) url = save_user_avatar(url) else: + # bjy: 如果没有metadata，则使用默认头像 url = static('blog/img/avatar.png') else: + # bjy: 如果头像URL不是本地静态文件，则直接保存到本地 url = save_user_avatar(url) else: + # bjy: 如果头像URL为空，则使用默认头像 url = static('blog/img/avatar.png') + # bjy: 如果最终得到的URL不为空，则更新用户头像并保存 if url: + # bjy: 输出同步完成后的用户昵称和头像URL self.stdout.write( f'结束同步:{u.nickname}.url:{url}') u.picture = url u.save() + # bjy: 输出同步全部结束的信息 self.stdout.write('结束同步') diff --git a/blog/middleware.py b/blog/middleware.py index 881c347..16c9983 100644 --- a/blog/middleware.py +++ b/blog/middleware.py @@ -1,42 +1,68 @@ +# bjy: 导入日志模块 import logging +# bjy: 导入时间模块，用于计算页面渲染时间 import time +# bjy: 从ipware库导入get_client_ip函数，用于获取客户端真实IP from ipware import get_client_ip +# bjy: 从user_agents库导入parse函数，用于解析User-Agent字符串 from user_agents import parse +# bjy: 从blog应用的documents模块中导入Elasticsearch是否启用的标志和性能文档管理器 from blog.documents import ELASTICSEARCH_ENABLED, ElaspedTimeDocumentManager +# bjy: 获取一个名为__name__的logger实例，用于记录日志 logger = logging.getLogger(__name__) +# bjy: 定义一个中间件类，用于记录页面性能和在线用户信息 class OnlineMiddleware(object): + # bjy: Django 1.10+ 兼容的初始化方法 def __init__(self, get_response=None): + # bjy: 保存get_response可调用对象，它是Django请求-响应链中的下一个处理器 self.get_response = get_response + # bjy: 调用父类的初始化方法 super().__init__() + # bjy: 中间件的核心调用方法，每个请求都会经过这里 def __call__(self, request): """ page render time """ + # bjy: 记录页面渲染开始时间 start_time = time.time() + # bjy: 调用下一个中间件或视图，获取响应对象 response = self.get_response(request) + # bjy: 从请求头中获取User-Agent字符串 http_user_agent = request.META.get('HTTP_USER_AGENT', '') + # bjy: 使用ipware库获取客户端的IP地址 ip, _ = get_client_ip(request) + # bjy: 解析User-Agent字符串，得到结构化的用户代理信息 user_agent = parse(http_user_agent) + # bjy: 检查响应是否为流式响应（如文件下载），如果不是，则进行处理 if not response.streaming: try: + # bjy: 计算页面渲染耗时（秒） cast_time = time.time() - start_time + # bjy: 如果启用了Elasticsearch if ELASTICSEARCH_ENABLED: - time_taken = round(cast_time * 1000, 2) + # bjy: 将耗时转换为毫秒并四舍五入 + time_taken = round((cast_time) * 1000, 2) + # bjy: 获取请求的URL路径 url = request.path + # bjy: 导入Django的时区工具 from django.utils import timezone + # bjy: 调用文档管理器，将性能数据保存到Elasticsearch ElaspedTimeDocumentManager.create( url=url, time_taken=time_taken, log_datetime=timezone.now(), useragent=user_agent, ip=ip) + # bjy: 将页面渲染耗时替换到响应内容的特定占位符中 response.content = response.content.replace( b'', str.encode(str(cast_time)[:5])) + # bjy: 捕获并记录处理过程中可能发生的任何异常 except Exception as e: logger.error("Error OnlineMiddleware: %s" % e) + # bjy: 返回最终的响应对象 return response diff --git a/blog/migrations/0001_initial.py b/blog/migrations/0001_initial.py index 525c125..3d391b6 100644 --- a/blog/migrations/0001_initial.py +++ b/blog/migrations/0001_initial.py @@ -1,9 +1,10 @@ # Generated by Django 4.1.7 on 2023-03-02 07:14 -import django.utils.timezone -import mdeditor.fields from django.conf import settings from django.db import migrations, models +import django.db.models.deletion +import django.utils.timezone +import mdeditor.fields class Migration(migrations.Migration): diff --git a/blog/migrations/0002_blogsettings_global_footer_and_more.py b/blog/migrations/0002_blogsettings_global_footer_and_more.py index adbaa36..0e92fe9 100644 --- a/blog/migrations/0002_blogsettings_global_footer_and_more.py +++ b/blog/migrations/0002_blogsettings_global_footer_and_more.py @@ -1,23 +1,35 @@ -# Generated by Django 4.1.7 on 2023-03-29 06:08 +# bjy: 此文件由Django 4.1.7于2023-03-29 06:08自动生成，用于数据库结构迁移 +# bjy: 从Django数据库模块导入migrations和models，用于定义迁移操作和模型字段 from django.db import migrations, models +# bjy: 定义一个迁移类，用于对blog应用进行数据库结构变更 class Migration(migrations.Migration): + # bjy: 定义此迁移的依赖关系，它依赖于blog应用的0001_initial迁移，确保基础表已存在 dependencies = [ ('blog', '0001_initial'), ] + # bjy: 定义此迁移要执行的一系列操作 operations = [ + # bjy: 操作1：为BlogSettings模型添加一个名为'global_footer'的字段 migrations.AddField( + # bjy: 指定要操作的模型名称 model_name='blogsettings', + # bjy: 指定新字段的名称 name='global_footer', + # bjy: 定义新字段的类型和属性：文本类型，可为空，默认空字符串，并设置verbose_name field=models.TextField(blank=True, default='', null=True, verbose_name='公共尾部'), ), + # bjy: 操作2：为BlogSettings模型添加一个名为'global_header'的字段 migrations.AddField( + # bjy: 指定要操作的模型名称 model_name='blogsettings', + # bjy: 指定新字段的名称 name='global_header', + # bjy: 定义新字段的类型和属性：文本类型，可为空，默认空字符串，并设置verbose_name field=models.TextField(blank=True, default='', null=True, verbose_name='公共头部'), ), ] diff --git a/blog/migrations/0003_blogsettings_comment_need_review.py b/blog/migrations/0003_blogsettings_comment_need_review.py index e9f5502..b408d83 100644 --- a/blog/migrations/0003_blogsettings_comment_need_review.py +++ b/blog/migrations/0003_blogsettings_comment_need_review.py @@ -1,17 +1,25 @@ -# Generated by Django 4.2.1 on 2023-05-09 07:45 +# bjy: 此文件由Django 4.2.1于2023-05-09 07:45自动生成，用于数据库结构迁移 +# bjy: 从Django数据库模块导入migrations和models，用于定义迁移操作和模型字段 from django.db import migrations, models +# bjy: 定义一个迁移类，用于对blog应用进行数据库结构变更 class Migration(migrations.Migration): + # bjy: 定义此迁移的依赖关系，它依赖于blog应用的0002_blogsettings_global_footer_and_more迁移 dependencies = [ ('blog', '0002_blogsettings_global_footer_and_more'), ] + # bjy: 定义此迁移要执行的一系列操作 operations = [ + # bjy: 操作：为BlogSettings模型添加一个新字段 migrations.AddField( + # bjy: 指定要操作的模型名称为'blogsettings' model_name='blogsettings', + # bjy: 指定新字段的名称为'comment_need_review' name='comment_need_review', + # bjy: 定义新字段的类型和属性：布尔类型，默认值为False，并设置verbose_name field=models.BooleanField(default=False, verbose_name='评论是否需要审核'), ), ] diff --git a/blog/migrations/0004_rename_analyticscode_blogsettings_analytics_code_and_more.py b/blog/migrations/0004_rename_analyticscode_blogsettings_analytics_code_and_more.py index ceb1398..198d53e 100644 --- a/blog/migrations/0004_rename_analyticscode_blogsettings_analytics_code_and_more.py +++ b/blog/migrations/0004_rename_analyticscode_blogsettings_analytics_code_and_more.py @@ -1,27 +1,43 @@ -# Generated by Django 4.2.1 on 2023-05-09 07:51 +# bjy: 此文件由Django 4.2.1于2023-05-09 07:51自动生成，用于数据库结构迁移 +# bjy: 从Django数据库模块导入migrations，用于定义迁移操作 from django.db import migrations +# bjy: 定义一个迁移类，用于对blog应用进行数据库结构变更 class Migration(migrations.Migration): + # bjy: 定义此迁移的依赖关系，它依赖于blog应用的0003_blogsettings_comment_need_review迁移 dependencies = [ ('blog', '0003_blogsettings_comment_need_review'), ] + # bjy: 定义此迁移要执行的一系列操作 operations = [ + # bjy: 操作1：重命名BlogSettings模型中的一个字段 migrations.RenameField( + # bjy: 指定要操作的模型名称为'blogsettings' model_name='blogsettings', + # bjy: 指定字段的原始名称为'analyticscode' old_name='analyticscode', + # bjy: 指定字段的新名称为'analytics_code' new_name='analytics_code', ), + # bjy: 操作2：重命名BlogSettings模型中的另一个字段 migrations.RenameField( + # bjy: 指定要操作的模型名称为'blogsettings' model_name='blogsettings', + # bjy: 指定字段的原始名称为'beiancode' old_name='beiancode', + # bjy: 指定字段的新名称为'beian_code' new_name='beian_code', ), + # bjy: 操作3：重命名BlogSettings模型中的第三个字段 migrations.RenameField( + # bjy: 指定要操作的模型名称为'blogsettings' model_name='blogsettings', + # bjy: 指定字段的原始名称为'sitename' old_name='sitename', + # bjy: 指定字段的新名称为'site_name' new_name='site_name', ), ] diff --git a/blog/migrations/0005_alter_article_options_alter_category_options_and_more.py b/blog/migrations/0005_alter_article_options_alter_category_options_and_more.py index 398a9c7..d08e853 100644 --- a/blog/migrations/0005_alter_article_options_alter_category_options_and_more.py +++ b/blog/migrations/0005_alter_article_options_alter_category_options_and_more.py @@ -1,9 +1,10 @@ # Generated by Django 4.2.5 on 2023-09-06 13:13 -import django.utils.timezone -import mdeditor.fields from django.conf import settings from django.db import migrations, models +import django.db.models.deletion +import django.utils.timezone +import mdeditor.fields class Migration(migrations.Migration): diff --git a/blog/migrations/0006_alter_blogsettings_options.py b/blog/migrations/0006_alter_blogsettings_options.py index e36feb4..560a1a4 100644 --- a/blog/migrations/0006_alter_blogsettings_options.py +++ b/blog/migrations/0006_alter_blogsettings_options.py @@ -1,17 +1,24 @@ -# Generated by Django 4.2.7 on 2024-01-26 02:41 +# bjy: 此文件由Django 4.2.7于2024-01-26 02:41自动生成，用于数据库结构迁移 +# bjy: 从Django数据库模块导入migrations，用于定义迁移操作 from django.db import migrations +# bjy: 定义一个迁移类，用于对blog应用进行数据库结构变更 class Migration(migrations.Migration): + # bjy: 定义此迁移的依赖关系，它依赖于blog应用的0005迁移 dependencies = [ ('blog', '0005_alter_article_options_alter_category_options_and_more'), ] + # bjy: 定义此迁移要执行的一系列操作 operations = [ + # bjy: 操作：修改BlogSettings模型的Meta选项，更新verbose_name为英文 migrations.AlterModelOptions( + # bjy: 指定要操作的模型名称为'blogsettings' name='blogsettings', + # bjy: 更新模型的verbose_name和verbose_name_plural为'Website configuration' options={'verbose_name': 'Website configuration', 'verbose_name_plural': 'Website configuration'}, ), ] diff --git a/blog/models.py b/blog/models.py index 083788b..71c3b4f 100644 --- a/blog/models.py +++ b/blog/models.py @@ -1,49 +1,74 @@ +# bjy: 导入日志模块 import logging +# bjy: 导入正则表达式模块 import re +# bjy: 导入抽象基类模块，用于定义抽象方法 from abc import abstractmethod +# bjy: 从Django中导入设置、异常、模型、URL反向解析、时区和国际化工具 from django.conf import settings from django.core.exceptions import ValidationError from django.db import models from django.urls import reverse from django.utils.timezone import now from django.utils.translation import gettext_lazy as _ +# bjy: 从Django MDEditor中导入Markdown文本字段 from mdeditor.fields import MDTextField +# bjy: 从uuslug中导入slugify函数，用于生成URL友好的slug from uuslug import slugify +# bjy: 从项目工具模块中导入缓存装饰器和缓存对象 from djangoblog.utils import cache_decorator, cache +# bjy: 从项目工具模块中导入获取当前站点的函数 from djangoblog.utils import get_current_site +# bjy: 获取一个名为__name__的logger实例，用于记录日志 logger = logging.getLogger(__name__) +# bjy: 定义一个文本选择类，用于链接显示类型 class LinkShowType(models.TextChoices): + # bjy: 首页 I = ('i', _('index')) + # bjy: 列表页 L = ('l', _('list')) + # bjy: 文章页 P = ('p', _('post')) + # bjy: 所有页面 A = ('a', _('all')) + # bjy: 幻灯片 S = ('s', _('slide')) +# bjy: 定义一个基础模型类，作为其他模型的父类 class BaseModel(models.Model): + # bjy: 自增主键 id = models.AutoField(primary_key=True) + # bjy: 创建时间，默认为当前时间 creation_time = models.DateTimeField(_('creation time'), default=now) + # bjy: 最后修改时间，默认为当前时间 last_modify_time = models.DateTimeField(_('modify time'), default=now) + # bjy: 重写save方法，以实现自定义逻辑 def save(self, *args, **kwargs): + # bjy: 检查是否是更新文章浏览量的操作 is_update_views = isinstance( self, Article) and 'update_fields' in kwargs and kwargs['update_fields'] == ['views'] if is_update_views: + # bjy: 如果是，则直接更新数据库中的views字段，避免触发其他save逻辑 Article.objects.filter(pk=self.pk).update(views=self.views) else: + # bjy: 如果模型有slug字段，则根据title或name自动生成slug if 'slug' in self.__dict__: slug = getattr( self, 'title') if 'title' in self.__dict__ else getattr( self, 'name') setattr(self, 'slug', slugify(slug)) + # bjy: 调用父类的save方法 super().save(*args, **kwargs) + # bjy: 获取模型的完整URL（包括域名） def get_full_url(self): site = get_current_site().domain url = "https://{site}{path}".format(site=site, @@ -51,72 +76,96 @@ class BaseModel(models.Model): return url class Meta: + # bjy: 设置为抽象模型，不会在数据库中创建表 abstract = True + # bjy: 定义一个抽象方法，要求子类必须实现 @abstractmethod def get_absolute_url(self): pass +# bjy: 定义文章模型 class Article(BaseModel): """文章""" + # bjy: 文章状态选择 STATUS_CHOICES = ( ('d', _('Draft')), ('p', _('Published')), ) + # bjy: 评论状态选择 COMMENT_STATUS = ( ('o', _('Open')), ('c', _('Close')), ) + # bjy: 文章类型选择 TYPE = ( ('a', _('Article')), ('p', _('Page')), ) + # bjy: 文章标题，唯一 title = models.CharField(_('title'), max_length=200, unique=True) + # bjy: 文章正文，使用Markdown编辑器 body = MDTextField(_('body')) + # bjy: 发布时间 pub_time = models.DateTimeField( _('publish time'), blank=False, null=False, default=now) + # bjy: 文章状态 status = models.CharField( _('status'), max_length=1, choices=STATUS_CHOICES, default='p') + # bjy: 评论状态 comment_status = models.CharField( _('comment status'), max_length=1, choices=COMMENT_STATUS, default='o') + # bjy: 文章类型 type = models.CharField(_('type'), max_length=1, choices=TYPE, default='a') + # bjy: 浏览量 views = models.PositiveIntegerField(_('views'), default=0) + # bjy: 作者，外键关联到用户模型 author = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('author'), blank=False, null=False, on_delete=models.CASCADE) + # bjy: 文章排序权重 article_order = models.IntegerField( _('order'), blank=False, null=False, default=0) + # bjy: 是否显示目录 show_toc = models.BooleanField(_('show toc'), blank=False, null=False, default=False) + # bjy: 分类，外键关联到Category模型 category = models.ForeignKey( 'Category', verbose_name=_('category'), on_delete=models.CASCADE, blank=False, null=False) + # bjy: 标签，多对多关联到Tag模型 tags = models.ManyToManyField('Tag', verbose_name=_('tag'), blank=True) + # bjy: 将body字段转换为字符串 def body_to_string(self): return self.body + # bjy: 定义文章的字符串表示 def __str__(self): return self.title class Meta: + # bjy: 默认排序方式 ordering = ['-article_order', '-pub_time'] + # bjy: 模型的单数和复数名称 verbose_name = _('article') verbose_name_plural = verbose_name + # bjy: 指定按哪个字段获取最新对象 get_latest_by = 'id' + # bjy: 获取文章的绝对URL def get_absolute_url(self): return reverse('blog:detailbyid', kwargs={ 'article_id': self.id, @@ -125,6 +174,7 @@ class Article(BaseModel): 'day': self.creation_time.day }) + # bjy: 获取文章的分类树路径，带缓存 @cache_decorator(60 * 60 * 10) def get_category_tree(self): tree = self.category.get_category_tree() @@ -132,13 +182,16 @@ class Article(BaseModel): return names + # bjy: 重写save方法 def save(self, *args, **kwargs): super().save(*args, **kwargs) + # bjy: 增加浏览量 def viewed(self): self.views += 1 self.save(update_fields=['views']) + # bjy: 获取文章的评论列表，带缓存 def comment_list(self): cache_key = 'article_comments_{id}'.format(id=self.id) value = cache.get(cache_key) @@ -151,21 +204,25 @@ class Article(BaseModel): logger.info('set article comments:{id}'.format(id=self.id)) return comments + # bjy: 获取文章在Admin后台的编辑URL def get_admin_url(self): info = (self._meta.app_label, self._meta.model_name) return reverse('admin:%s_%s_change' % info, args=(self.pk,)) + # bjy: 获取下一篇文章，带缓存 @cache_decorator(expiration=60 * 100) def next_article(self): # 下一篇 return Article.objects.filter( id__gt=self.id, status='p').order_by('id').first() + # bjy: 获取上一篇文章，带缓存 @cache_decorator(expiration=60 * 100) def prev_article(self): # 前一篇 return Article.objects.filter(id__lt=self.id, status='p').first() + # bjy: 从文章正文中提取第一张图片的URL def get_first_image_url(self): """ Get the first image url from article.body. @@ -177,31 +234,40 @@ class Article(BaseModel): return "" +# bjy: 定义分类模型 class Category(BaseModel): """文章分类""" + # bjy: 分类名称，唯一 name = models.CharField(_('category name'), max_length=30, unique=True) + # bjy: 父分类，自关联外键 parent_category = models.ForeignKey( 'self', verbose_name=_('parent category'), blank=True, null=True, on_delete=models.CASCADE) + # bjy: URL友好的别名 slug = models.SlugField(default='no-slug', max_length=60, blank=True) + # bjy: 排序索引 index = models.IntegerField(default=0, verbose_name=_('index')) class Meta: + # bjy: 按索引降序排列 ordering = ['-index'] verbose_name = _('category') verbose_name_plural = verbose_name + # bjy: 获取分类的绝对URL def get_absolute_url(self): return reverse( 'blog:category_detail', kwargs={ 'category_name': self.slug}) + # bjy: 定义分类的字符串表示 def __str__(self): return self.name + # bjy: 递归获取分类的所有父级分类，带缓存 @cache_decorator(60 * 60 * 10) def get_category_tree(self): """ @@ -218,6 +284,7 @@ class Category(BaseModel): parse(self) return categorys + # bjy: 获取当前分类的所有子分类，带缓存 @cache_decorator(60 * 60 * 10) def get_sub_categorys(self): """ @@ -240,136 +307,186 @@ class Category(BaseModel): return categorys +# bjy: 定义标签模型 class Tag(BaseModel): """文章标签""" + # bjy: 标签名称，唯一 name = models.CharField(_('tag name'), max_length=30, unique=True) + # bjy: URL友好的别名 slug = models.SlugField(default='no-slug', max_length=60, blank=True) + # bjy: 定义标签的字符串表示 def __str__(self): return self.name + # bjy: 获取标签的绝对URL def get_absolute_url(self): return reverse('blog:tag_detail', kwargs={'tag_name': self.slug}) + # bjy: 获取使用该标签的文章数量，带缓存 @cache_decorator(60 * 60 * 10) def get_article_count(self): return Article.objects.filter(tags__name=self.name).distinct().count() class Meta: + # bjy: 按名称排序 ordering = ['name'] verbose_name = _('tag') verbose_name_plural = verbose_name +# bjy: 定义友情链接模型 class Links(models.Model): """友情链接""" + # bjy: 链接名称，唯一 name = models.CharField(_('link name'), max_length=30, unique=True) + # bjy: 链接URL link = models.URLField(_('link')) + # bjy: 排序权重，唯一 sequence = models.IntegerField(_('order'), unique=True) + # bjy: 是否启用 is_enable = models.BooleanField( _('is show'), default=True, blank=False, null=False) + # bjy: 显示类型 show_type = models.CharField( _('show type'), max_length=1, choices=LinkShowType.choices, default=LinkShowType.I) + # bjy: 创建时间 creation_time = models.DateTimeField(_('creation time'), default=now) + # bjy: 最后修改时间 last_mod_time = models.DateTimeField(_('modify time'), default=now) class Meta: + # bjy: 按排序权重升序排列 ordering = ['sequence'] verbose_name = _('link') verbose_name_plural = verbose_name + # bjy: 定义链接的字符串表示 def __str__(self): return self.name +# bjy: 定义侧边栏模型 class SideBar(models.Model): """侧边栏,可以展示一些html内容""" + # bjy: 侧边栏标题 name = models.CharField(_('title'), max_length=100) + # bjy: 侧边栏内容（HTML） content = models.TextField(_('content')) + # bjy: 排序权重，唯一 sequence = models.IntegerField(_('order'), unique=True) + # bjy: 是否启用 is_enable = models.BooleanField(_('is enable'), default=True) + # bjy: 创建时间 creation_time = models.DateTimeField(_('creation time'), default=now) + # bjy: 最后修改时间 last_mod_time = models.DateTimeField(_('modify time'), default=now) class Meta: + # bjy: 按排序权重升序排列 ordering = ['sequence'] verbose_name = _('sidebar') verbose_name_plural = verbose_name + # bjy: 定义侧边栏的字符串表示 def __str__(self): return self.name +# bjy: 定义博客设置模型 class BlogSettings(models.Model): """blog的配置""" + # bjy: 网站名称 site_name = models.CharField( _('site name'), max_length=200, null=False, blank=False, default='') + # bjy: 网站描述 site_description = models.TextField( _('site description'), max_length=1000, null=False, blank=False, default='') + # bjy: SEO描述 site_seo_description = models.TextField( _('site seo description'), max_length=1000, null=False, blank=False, default='') + # bjy: 网站关键词 site_keywords = models.TextField( _('site keywords'), max_length=1000, null=False, blank=False, default='') + # bjy: 文章摘要长度 article_sub_length = models.IntegerField(_('article sub length'), default=300) + # bjy: 侧边栏文章数量 sidebar_article_count = models.IntegerField(_('sidebar article count'), default=10) + # bjy: 侧边栏评论数量 sidebar_comment_count = models.IntegerField(_('sidebar comment count'), default=5) + # bjy: 文章页评论数量 article_comment_count = models.IntegerField(_('article comment count'), default=5) + # bjy: 是否显示Google AdSense show_google_adsense = models.BooleanField(_('show adsense'), default=False) + # bjy: Google AdSense代码 google_adsense_codes = models.TextField( _('adsense code'), max_length=2000, null=True, blank=True, default='') + # bjy: 是否开启全站评论 open_site_comment = models.BooleanField(_('open site comment'), default=True) + # bjy: 公共头部HTML代码 global_header = models.TextField("公共头部", null=True, blank=True, default='') + # bjy: 公共尾部HTML代码 global_footer = models.TextField("公共尾部", null=True, blank=True, default='') + # bjy: ICP备案号 beian_code = models.CharField( '备案号', max_length=2000, null=True, blank=True, default='') + # bjy: 网站统计代码 analytics_code = models.TextField( "网站统计代码", max_length=1000, null=False, blank=False, default='') + # bjy: 是否显示公安备案号 show_gongan_code = models.BooleanField( '是否显示公安备案号', default=False, null=False) + # bjy: 公安备案号 gongan_beiancode = models.TextField( '公安备案号', max_length=2000, null=True, blank=True, default='') + # bjy: 评论是否需要审核 comment_need_review = models.BooleanField( '评论是否需要审核', default=False, null=False) class Meta: + # bjy: 模型的单数和复数名称 verbose_name = _('Website configuration') verbose_name_plural = verbose_name + # bjy: 定义设置的字符串表示 def __str__(self): return self.site_name + # bjy: 重写clean方法，用于模型验证 def clean(self): + # bjy: 确保数据库中只能有一条配置记录 if BlogSettings.objects.exclude(id=self.id).count(): raise ValidationError(_('There can only be one configuration')) + # bjy: 重写save方法，保存后清除缓存 def save(self, *args, **kwargs): super().save(*args, **kwargs) from djangoblog.utils import cache diff --git a/blog/search_indexes.py b/blog/search_indexes.py index 7f1dfac..055ddf7 100644 --- a/blog/search_indexes.py +++ b/blog/search_indexes.py @@ -1,13 +1,21 @@ +# bjy: 从haystack框架中导入indexes模块，用于创建搜索索引 from haystack import indexes +# bjy: 从blog应用中导入Article模型 from blog.models import Article +# bjy: 为Article模型定义一个搜索索引类 class ArticleIndex(indexes.SearchIndex, indexes.Indexable): + # bjy: 定义一个主文本字段，`document=True`表示这是搜索的主要字段 + # bjy: `use_template=True`表示该字段的内容将由一个模板来生成 text = indexes.CharField(document=True, use_template=True) + # bjy: `get_model`方法必须实现，用于返回此索引对应的模型类 def get_model(self): return Article + # bjy: `index_queryset`方法定义了哪些模型实例应该被建立索引 def index_queryset(self, using=None): + # bjy: 这里只返回状态为'p'（已发布）的文章 return self.get_model().objects.filter(status='p') diff --git a/blog/static/account/css/account.css b/blog/static/account/css/account.css index 7d4cec7..7daa472 100644 --- a/blog/static/account/css/account.css +++ b/blog/static/account/css/account.css @@ -1,9 +1,17 @@ +/* bjy: 定义一个名为.button的CSS类，用于设置按钮的通用样式 */ .button { + /* bjy: 移除按钮的默认边框 */ border: none; + /* bjy: 设置按钮的内边距，上下4像素，左右80像素 */ padding: 4px 80px; + /* bjy: 设置按钮内部文本的水平居中对齐 */ text-align: center; + /* bjy: 移除文本装饰（如下划线），通常用于链接样式的按钮 */ text-decoration: none; + /* bjy: 将按钮设置为行内块级元素，使其可以设置宽高并与其他元素在同一行显示 */ display: inline-block; + /* bjy: 设置按钮内部文本的字体大小为16像素 */ font-size: 16px; + /* bjy: 设置按钮的外边距，上下4像素，左右2像素，用于控制按钮之间的间距 */ margin: 4px 2px; -} \ No newline at end of file +} diff --git a/blog/static/account/js/account.js b/blog/static/account/js/account.js index f1a8771..25e977a 100644 --- a/blog/static/account/js/account.js +++ b/blog/static/account/js/account.js @@ -1,45 +1,76 @@ +// bjy: 声明一个全局变量wait，用于倒计时，初始值为60秒 let wait = 60; +// bjy: 定义一个名为time的函数，用于处理按钮的倒计时效果 +// bjy: 参数o代表触发倒计时的按钮元素 function time(o) { + // bjy: 如果倒计时结束（wait为0） if (wait == 0) { + // bjy: 移除按钮的disabled属性，使其重新可点击 o.removeAttribute("disabled"); + // bjy: 将按钮的显示文本恢复为“获取验证码” o.value = "获取验证码"; + // bjy: 重置倒计时变量为60，以便下次使用 wait = 60 + // bjy: 结束函数执行 return false } else { + // bjy: 如果倒计时未结束，禁用按钮，防止重复点击 o.setAttribute("disabled", true); + // bjy: 更新按钮的显示文本，显示剩余的倒计时秒数 o.value = "重新发送(" + wait + ")"; + // bjy: 倒计时秒数减一 wait--; + // bjy: 设置一个1秒（1000毫秒）后执行的定时器 setTimeout(function () { + // bjy: 定时器回调函数中递归调用time函数，实现每秒更新一次倒计时 time(o) }, 1000) } } +// bjy: 为ID为"btn"的元素绑定点击事件处理函数 document.getElementById("btn").onclick = function () { + // bjy: 使用jQuery选择器获取邮箱输入框元素 let id_email = $("#id_email") + // bjy: 使用jQuery选择器获取CSRF令牌的值，用于Django的POST请求安全验证 let token = $("*[name='csrfmiddlewaretoken']").val() + // bjy: 将this（即被点击的按钮）的引用保存到ts变量中，以便在AJAX回调中使用 let ts = this + // bjy: 使用jQuery选择器获取用于显示错误信息的元素 let myErr = $("#myErr") + // bjy: 使用jQuery发起一个AJAX请求 $.ajax( { + // bjy: 请求的URL地址 url: "/forget_password_code/", + // bjy: 请求的类型为POST type: "POST", + // bjy: 发送到服务器的数据，包含邮箱和CSRF令牌 data: { "email": id_email.val(), "csrfmiddlewaretoken": token }, + // bjy: 定义请求成功时的回调函数，result是服务器返回的数据 success: function (result) { + // bjy: 如果服务器返回的结果不是"ok"（表示发送失败或有错误） if (result != "ok") { + // bjy: 移除页面上可能存在的旧错误提示 myErr.remove() + // bjy: 在邮箱输入框后面动态添加一个错误提示列表，显示服务器返回的错误信息 id_email.after("") + // bjy: 结束函数执行 return } + // bjy: 如果发送成功，移除页面上可能存在的旧错误提示 myErr.remove() + // bjy: 调用time函数，开始按钮的倒计时效果 time(ts) }, + // bjy: 定义请求失败时的回调函数，e是错误对象 error: function (e) { + // bjy: 弹出一个警告框，提示用户发送失败 alert("发送失败,请重试") } } diff --git a/blog/static/assets/js/ie-emulation-modes-warning.js b/blog/static/assets/js/ie-emulation-modes-warning.js index 3f97ba5..cc9df91 100644 --- a/blog/static/assets/js/ie-emulation-modes-warning.js +++ b/blog/static/assets/js/ie-emulation-modes-warning.js @@ -8,44 +8,64 @@ * details, see https://creativecommons.org/licenses/by/3.0/. */ // Intended to prevent false-positive bug reports about Bootstrap not working properly in old versions of IE due to folks testing using IE's unreliable emulation modes. +// bjy: 使用一个立即执行函数表达式（IIFE）来创建一个独立的作用域，避免污染全局命名空间 (function () { + // bjy: 启用严格模式，有助于捕获常见的编码错误和“不安全”的操作 'use strict'; + // bjy: 定义一个函数，用于从用户代理字符串中获取IE的模拟版本号 function emulatedIEMajorVersion() { + // bjy: 使用正则表达式匹配用户代理字符串中的 "MSIE x.x" 部分 var groups = /MSIE ([0-9.]+)/.exec(window.navigator.userAgent) + // bjy: 如果匹配不到，说明不是IE或版本号无法识别，返回null if (groups === null) { return null } + // bjy: 将匹配到的版本号字符串（如 "10.0"）转换为整数 var ieVersionNum = parseInt(groups[1], 10) + // bjy: 取整数部分作为主版本号 var ieMajorVersion = Math.floor(ieVersionNum) + // bjy: 返回模拟的IE主版本号 return ieMajorVersion } + // bjy: 定义一个函数，用于检测当前浏览器实际运行的IE版本，即使它处于旧版IE的模拟模式下 function actualNonEmulatedIEMajorVersion() { - // Detects the actual version of IE in use, even if it's in an older-IE emulation mode. - // IE JavaScript conditional compilation docs: https://msdn.microsoft.com/library/121hztk3%28v=vs.94%29.aspx - // @cc_on docs: https://msdn.microsoft.com/library/8ka90k2e%28v=vs.94%29.aspx + // bjy: 此函数通过IE特有的JScript条件编译来检测真实版本 + // bjy: IE JavaScript条件编译文档: https://msdn.microsoft.com/library/121hztk3%28v=vs.94%29.aspx + // bjy: @cc_on 文档: https://msdn.microsoft.com/library/8ka90k2e%28v=vs.94%29.aspx + // bjy: 创建一个新的Function，其内容是IE的条件编译语句，用于获取JScript版本 var jscriptVersion = new Function('/*@cc_on return @_jscript_version; @*/')() // jshint ignore:line + // bjy: 如果jscriptVersion未定义，说明是IE11或更高版本，且不在模拟模式下 if (jscriptVersion === undefined) { return 11 // IE11+ not in emulation mode } + // bjy: 如果JScript版本小于9，则判断为IE8或更低版本 if (jscriptVersion < 9) { return 8 // IE8 (or lower; haven't tested on IE<8) } + // bjy: 否则，返回JScript版本，这对应于IE9或IE10（在任何模式下），或IE11在非IE11模式下 return jscriptVersion // IE9 or IE10 in any mode, or IE11 in non-IE11 mode } + // bjy: 获取当前浏览器的用户代理字符串 var ua = window.navigator.userAgent + // bjy: 检查用户代理中是否包含'Opera'或'Presto'（Opera的旧版渲染引擎） if (ua.indexOf('Opera') > -1 || ua.indexOf('Presto') > -1) { return // Opera, which might pretend to be IE } + // bjy: 调用函数，获取模拟的IE版本号 var emulated = emulatedIEMajorVersion() + // bjy: 如果模拟版本为null，说明不是IE浏览器，直接返回 if (emulated === null) { return // Not IE } + // bjy: 调用函数，获取实际的IE版本号 var nonEmulated = actualNonEmulatedIEMajorVersion() + // bjy: 比较模拟版本和实际版本，如果不相同，说明IE正处于模拟模式下 if (emulated !== nonEmulated) { + // bjy: 弹出一个警告框，提示用户当前正处于IE模拟模式，并警告其行为可能与真实旧版IE不同 window.alert('WARNING: You appear to be using IE' + nonEmulated + ' in IE' + emulated + ' emulation mode.\nIE emulation modes can behave significantly differently from ACTUAL older versions of IE.\nPLEASE DON\'T FILE BOOTSTRAP BUGS based on testing in IE emulation modes!') } })(); diff --git a/blog/static/assets/js/ie10-viewport-bug-workaround.js b/blog/static/assets/js/ie10-viewport-bug-workaround.js index 479a6eb..0da33b3 100644 --- a/blog/static/assets/js/ie10-viewport-bug-workaround.js +++ b/blog/static/assets/js/ie10-viewport-bug-workaround.js @@ -7,17 +7,27 @@ // See the Getting Started docs for more information: // http://getbootstrap.com/getting-started/#support-ie10-width +// bjy: 使用一个立即执行函数表达式（IIFE）来创建一个独立的作用域，避免污染全局命名空间 (function () { + // bjy: 启用严格模式，有助于捕获常见的编码错误和“不安全”的操作 'use strict'; + // bjy: 检查当前浏览器的用户代理字符串（User Agent）是否匹配IEMobile/10.0 + // bjy: 这是为了专门识别运行在Windows Phone 8上的IE10移动版浏览器 if (navigator.userAgent.match(/IEMobile\/10\.0/)) { + // bjy: 如果匹配，则创建一个新的