9-10周实践任务

doc.gitkeep

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

doc/.gitkeep

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

doc/README.md

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

doc/Readme (2).txt

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

src.gitkeep

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

src/DjangoBlog-master/accounts/apps.py

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

src/DjangoBlog-master/accounts/urls.py

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

src/DjangoBlog-master/accounts/user_login_backend.py

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

src/DjangoBlog-master/accounts/utils.py

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

src/DjangoBlog-master/comments/admin.py

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

src/DjangoBlog-master/comments/forms.py

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

src/DjangoBlog-master/comments/tests.py

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

src/DjangoBlog-master/comments/urls.py

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

src/DjangoBlog-master/comments/views.py

@@ -1,63 +0,0 @@
-# Create your views here.
-from django.core.exceptions import ValidationError
-from django.http import HttpResponseRedirect
-from django.shortcuts import get_object_or_404
-from django.utils.decorators import method_decorator
-from django.views.decorators.csrf import csrf_protect
-from django.views.generic.edit import FormView
-
-from accounts.models import BlogUser
-from blog.models import Article
-from .forms import CommentForm
-from .models import Comment
-
-
-class CommentPostView(FormView):
-    form_class = CommentForm  # 杨智鑫：指定使用的表单类
-    template_name = 'blog/article_detail.html' # 杨智鑫：指定使用的模板
-
-    @method_decorator(csrf_protect)
-    def dispatch(self, *args, **kwargs):  # 杨智鑫：添加csrf_protect装饰器
-        return super(CommentPostView, self).dispatch(*args, **kwargs)  # 杨智鑫：调用父类的dispatch方法
-
-    def get(self, request, *args, **kwargs):
-        article_id = self.kwargs['article_id']  # 杨智鑫：获取文章id
-        article = get_object_or_404(Article, pk=article_id)  # 杨智鑫：获取文章对象
-        url = article.get_absolute_url()  # 杨智鑫：获取文章的url
-        return HttpResponseRedirect(url + "#comments")  # 杨智鑫：跳转到文章的评论区
-
-    def form_invalid(self, form):
-        article_id = self.kwargs['article_id']  # 杨智鑫：获取文章id
-        article = get_object_or_404(Article, pk=article_id)  # 杨智鑫：获取文章对象
-
-        return self.render_to_response({
-            'form': form,
-            'article': article
-        })  # 杨智鑫：返回错误信息
-
-    def form_valid(self, form):
-        """提交的数据验证合法后的逻辑"""
-        user = self.request.user  # 杨智鑫：获取用户
-        author = BlogUser.objects.get(pk=user.pk)  # 杨智鑫：获取用户对象
-        article_id = self.kwargs['article_id']  # 杨智鑫：获取文章id
-        article = get_object_or_404(Article, pk=article_id)  # 杨智鑫：获取文章对象
-
-        if article.comment_status == 'c' or article.status == 'c':
-            raise ValidationError("该文章评论已关闭.") # 杨智鑫：抛出异常
-        comment = form.save(False) # 杨智鑫：保存评论
-        comment.article = article  # 杨智鑫：设置评论所属文章
-        from djangoblog.utils import get_blog_setting
-        settings = get_blog_setting()   # 杨智鑫：获取博客设置
-        if not settings.comment_need_review:
-            comment.is_enable = True
-        comment.author = author  # 杨智鑫：设置评论作者
-
-        if form.cleaned_data['parent_comment_id']:  # 杨智鑫：判断是否有父级评论
-            parent_comment = Comment.objects.get(
-                pk=form.cleaned_data['parent_comment_id']) # 杨智鑫：获取父级评论对象
-            comment.parent_comment = parent_comment  # 杨智鑫：设置父级评论
-
-        comment.save(True) # 杨智鑫：保存评论
-        return HttpResponseRedirect(
-            "%s#div-comment-%d" %
-            (article.get_absolute_url(), comment.pk))  # 杨智鑫：跳转到评论区

src/DjangoBlog-master/oauth/migrations/0001_initial.py

@@ -1,57 +0,0 @@
-# Generated by Django 4.1.7 on 2023-03-07 09:53
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-import django.utils.timezone
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='OAuthConfig',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('type', models.CharField(choices=[('weibo', '微博'), ('google', '谷歌'), ('github', 'GitHub'), ('facebook', 'FaceBook'), ('qq', 'QQ')], default='a', max_length=10, verbose_name='类型')),
-                ('appkey', models.CharField(max_length=200, verbose_name='AppKey')),
-                ('appsecret', models.CharField(max_length=200, verbose_name='AppSecret')),
-                ('callback_url', models.CharField(default='http://www.baidu.com', max_length=200, verbose_name='回调地址')),
-                ('is_enable', models.BooleanField(default=True, verbose_name='是否显示')),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-            ],
-            options={
-                'verbose_name': 'oauth配置',
-                'verbose_name_plural': 'oauth配置',
-                'ordering': ['-created_time'],
-            },
-        ),
-        migrations.CreateModel(
-            name='OAuthUser',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('openid', models.CharField(max_length=50)),
-                ('nickname', models.CharField(max_length=50, verbose_name='昵称')),
-                ('token', models.CharField(blank=True, max_length=150, null=True)),
-                ('picture', models.CharField(blank=True, max_length=350, null=True)),
-                ('type', models.CharField(max_length=50)),
-                ('email', models.CharField(blank=True, max_length=50, null=True)),
-                ('metadata', models.TextField(blank=True, null=True)),
-                ('created_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='创建时间')),
-                ('last_mod_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='修改时间')),
-                ('author', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='用户')),
-            ],
-            options={
-                'verbose_name': 'oauth用户',
-                'verbose_name_plural': 'oauth用户',
-                'ordering': ['-created_time'],
-            },
-        ),
-    ]

src/DjangoBlog-master/oauth/templatetags/oauth_tags.py

@@ -1,22 +0,0 @@
-from django import template
-from django.urls import reverse
-
-from oauth.oauthmanager import get_oauth_apps
-
-register = template.Library()
-
-
-@register.inclusion_tag('oauth/oauth_applications.html')
-def load_oauth_applications(request):
-    applications = get_oauth_apps()
-    if applications:
-        baseurl = reverse('oauth:oauthlogin')
-        path = request.get_full_path()
-
-        apps = list(map(lambda x: (x.ICON_NAME, '{baseurl}?type={type}&next_url={next}'.format(
-            baseurl=baseurl, type=x.ICON_NAME, next=path)), applications))
-    else:
-        apps = []
-    return {
-        'apps': apps
-    }

src/README.md

@@ -1 +0,0 @@
-# 源代码目录 - 项目源代码将存放于此

src/djangoblog-master/accounts/admin.py

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

src/djangoblog-master/accounts/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class AccountsConfig(AppConfig):
+    name = 'accounts'

src/djangoblog-master/accounts/forms.py

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

src/djangoblog-master/accounts/models.py

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

src/djangoblog-master/accounts/tests.py

@@ -1,186 +1,135 @@
-# tests.py - Django测试用例文件
-
-# 导入Django测试相关模块
 from django.test import Client, RequestFactory, TestCase
-# 导入URL反向解析
 from django.urls import reverse
-# 导入时区相关功能
 from django.utils import timezone
-# 导入国际化翻译函数
 from django.utils.translation import gettext_lazy as _
 
-# 导入账户相关模型
 from accounts.models import BlogUser
-# 导入博客相关模型
 from blog.models import Article, Category
-# 导入工具函数
 from djangoblog.utils import *
-# 导入当前应用的工具模块
 from . import utils
 
 
-# 在这里创建测试用例
+# Create your tests here.
 
-# 账户测试类
 class AccountTest(TestCase):
-    # 测试前置设置方法
     def setUp(self):
-        # 创建测试客户端
         self.client = Client()
-        # 创建请求工厂
         self.factory = RequestFactory()
-        # 创建测试用户
         self.blog_user = BlogUser.objects.create_user(
             username="test",
             email="admin@admin.com",
             password="12345678"
         )
-        # 设置测试用的新密码
         self.new_test = "xxx123--="
 
-    # 测试账户验证功能
     def test_validate_account(self):
-        # 获取当前站点域名
         site = get_current_site().domain
-        # 创建超级用户
         user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
             password="qwer!@#$ggg")
-        # 获取刚创建的用户
         testuser = BlogUser.objects.get(username='liangliangyy1')
 
-        # 测试登录功能
         loginresult = self.client.login(
             username='liangliangyy1',
             password='qwer!@#$ggg')
-        # 断言登录成功
         self.assertEqual(loginresult, True)
-        # 测试访问管理员页面
         response = self.client.get('/admin/')
         self.assertEqual(response.status_code, 200)
 
-        # 创建测试分类
         category = Category()
         category.name = "categoryaaa"
         category.creation_time = timezone.now()
         category.last_modify_time = timezone.now()
         category.save()
 
-        # 创建测试文章
         article = Article()
         article.title = "nicetitleaaa"
         article.body = "nicecontentaaa"
         article.author = user
         article.category = category
-        article.type = 'a'  # 文章类型
-        article.status = 'p'  # 发布状态
+        article.type = 'a'
+        article.status = 'p'
         article.save()
 
-        # 测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
         self.assertEqual(response.status_code, 200)
 
-    # 测试用户注册功能
     def test_validate_register(self):
-        # 断言邮箱不存在
         self.assertEquals(
             0, len(
                 BlogUser.objects.filter(
                     email='user123@user.com')))
-        # 发送注册请求
         response = self.client.post(reverse('account:register'), {
             'username': 'user1233',
             'email': 'user123@user.com',
             'password1': 'password123!q@wE#R$T',
             'password2': 'password123!q@wE#R$T',
         })
-        # 断言用户创建成功
         self.assertEquals(
             1, len(
                 BlogUser.objects.filter(
                     email='user123@user.com')))
-        # 获取新创建的用户
         user = BlogUser.objects.filter(email='user123@user.com')[0]
-        # 生成验证签名
         sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
         path = reverse('accounts:result')
-        # 构建验证URL
         url = '{path}?type=validation&id={id}&sign={sign}'.format(
             path=path, id=user.id, sign=sign)
-        # 测试验证页面
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
 
-        # 测试用户登录
         self.client.login(username='user1233', password='password123!q@wE#R$T')
         user = BlogUser.objects.filter(email='user123@user.com')[0]
-        # 设置用户为超级用户和管理员
         user.is_superuser = True
         user.is_staff = True
         user.save()
-        # 清理侧边栏缓存
         delete_sidebar_cache()
-        
-        # 创建分类
         category = Category()
         category.name = "categoryaaa"
         category.creation_time = timezone.now()
         category.last_modify_time = timezone.now()
         category.save()
 
-        # 创建文章
         article = Article()
         article.category = category
         article.title = "nicetitle333"
         article.body = "nicecontentttt"
         article.author = user
+
         article.type = 'a'
         article.status = 'p'
         article.save()
 
-        # 测试访问文章管理页面
         response = self.client.get(article.get_admin_url())
         self.assertEqual(response.status_code, 200)
 
-        # 测试退出登录
         response = self.client.get(reverse('account:logout'))
         self.assertIn(response.status_code, [301, 302, 200])
 
-        # 测试退出后访问管理页面（应该重定向）
         response = self.client.get(article.get_admin_url())
         self.assertIn(response.status_code, [301, 302, 200])
 
-        # 测试错误密码登录
         response = self.client.post(reverse('account:login'), {
             'username': 'user1233',
             'password': 'password123'
         })
         self.assertIn(response.status_code, [301, 302, 200])
 
-        # 测试登录后访问管理页面
         response = self.client.get(article.get_admin_url())
         self.assertIn(response.status_code, [301, 302, 200])
 
-    # 测试邮箱验证码功能
     def test_verify_email_code(self):
         to_email = "admin@admin.com"
-        # 生成验证码
         code = generate_code()
-        # 设置验证码
         utils.set_code(to_email, code)
-        # 发送验证邮件
         utils.send_verify_email(to_email, code)
 
-        # 测试正确验证码
         err = utils.verify("admin@admin.com", code)
         self.assertEqual(err, None)
 
-        # 测试错误邮箱
         err = utils.verify("admin@123.com", code)
         self.assertEqual(type(err), str)
 
-    # 测试成功发送忘记密码验证码
     def test_forget_password_email_code_success(self):
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
@@ -190,40 +139,33 @@ class AccountTest(TestCase):
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp.content.decode("utf-8"), "ok")
 
-    # 测试发送忘记密码验证码失败情况
     def test_forget_password_email_code_fail(self):
-        # 测试空数据
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
             data=dict()
         )
         self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
 
-        # 测试错误邮箱格式
         resp = self.client.post(
             path=reverse("account:forget_password_code"),
             data=dict(email="admin@com")
         )
         self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
 
-    # 测试成功重置密码
     def test_forget_password_email_success(self):
-        # 生成并设置验证码
         code = generate_code()
         utils.set_code(self.blog_user.email, code)
-        # 准备重置密码数据
         data = dict(
             new_password1=self.new_test,
             new_password2=self.new_test,
             email=self.blog_user.email,
             code=code,
         )
-        # 发送重置密码请求
         resp = self.client.post(
             path=reverse("account:forget_password"),
             data=data
         )
-        self.assertEqual(resp.status_code, 302)  # 重定向响应
+        self.assertEqual(resp.status_code, 302)
 
         # 验证用户密码是否修改成功
         blog_user = BlogUser.objects.filter(
@@ -232,7 +174,6 @@ class AccountTest(TestCase):
         self.assertNotEqual(blog_user, None)
         self.assertEqual(blog_user.check_password(data["new_password1"]), True)
 
-    # 测试重置密码时邮箱不存在的情况
     def test_forget_password_email_not_user(self):
         data = dict(
             new_password1=self.new_test,
@@ -247,7 +188,7 @@ class AccountTest(TestCase):
 
         self.assertEqual(resp.status_code, 200)
 
-    # 测试重置密码时验证码错误的情况
+
     def test_forget_password_email_code_error(self):
         code = generate_code()
         utils.set_code(self.blog_user.email, code)
@@ -255,11 +196,12 @@ class AccountTest(TestCase):
             new_password1=self.new_test,
             new_password2=self.new_test,
             email=self.blog_user.email,
-            code="111111",  # 错误的验证码
+            code="111111",
         )
         resp = self.client.post(
             path=reverse("account:forget_password"),
             data=data
         )
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.status_code, 200)
+

src/djangoblog-master/accounts/urls.py

@@ -0,0 +1,28 @@
+from django.urls import path
+from django.urls import re_path
+
+from . import views
+from .forms import LoginForm
+
+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'),
+               ]

src/djangoblog-master/accounts/user_login_backend.py

@@ -0,0 +1,26 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.backends import ModelBackend
+
+
+class EmailOrUsernameModelBackend(ModelBackend):
+    """
+    允许使用用户名或邮箱登录
+    """
+
+    def authenticate(self, request, username=None, password=None, **kwargs):
+        if '@' in username:
+            kwargs = {'email': username}
+        else:
+            kwargs = {'username': username}
+        try:
+            user = get_user_model().objects.get(**kwargs)
+            if user.check_password(password):
+                return user
+        except get_user_model().DoesNotExist:
+            return None
+
+    def get_user(self, username):
+        try:
+            return get_user_model().objects.get(pk=username)
+        except get_user_model().DoesNotExist:
+            return None

src/djangoblog-master/accounts/utils.py

@@ -0,0 +1,49 @@
+import typing
+from datetime import timedelta
+
+from django.core.cache import cache
+from django.utils.translation import gettext
+from django.utils.translation import gettext_lazy as _
+
+from djangoblog.utils import send_email
+
+_code_ttl = timedelta(minutes=5)
+
+
+def send_verify_email(to_mail: str, code: str, subject: str = _("Verify Email")):
+    """发送重设密码验证码
+    Args:
+        to_mail: 接受邮箱
+        subject: 邮件主题
+        code: 验证码
+    """
+    html_content = _(
+        "You are resetting the password, the verification code is：%(code)s, valid within 5 minutes, please keep it "
+        "properly") % {'code': code}
+    send_email([to_mail], subject, html_content)
+
+
+def verify(email: str, code: str) -> typing.Optional[str]:
+    """验证code是否有效
+    Args:
+        email: 请求邮箱
+        code: 验证码
+    Return:
+        如果有错误就返回错误str
+    Node:
+        这里的错误处理不太合理，应该采用raise抛出
+        否测调用方也需要对error进行处理
+    """
+    cache_code = get_code(email)
+    if cache_code != code:
+        return gettext("Verification code error")
+
+
+def set_code(email: str, code: str):
+    """设置code"""
+    cache.set(email, code, _code_ttl.seconds)
+
+
+def get_code(email: str) -> typing.Optional[str]:
+    """获取code"""
+    return cache.get(email)

src/djangoblog-master/accounts/views.py

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

src/djangoblog-master/blog/admin.py

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

src/djangoblog-master/blog/apps.py

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

src/djangoblog-master/blog/context_processors.py

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

src/djangoblog-master/blog/documents.py

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

src/djangoblog-master/blog/forms.py

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

src/djangoblog-master/blog/middleware.py

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

src/djangoblog-master/blog/models.py

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

src/djangoblog-master/blog/search_indexes.py

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

src/djangoblog-master/blog/tests.py

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

src/djangoblog-master/blog/urls.py

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

src/djangoblog-master/blog/views.py

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