请点击下面链接验证您的邮箱
@@ -81,33 +85,38 @@ class RegisterView(FormView): class LogoutView(RedirectView): + #lht: 用户登出视图 url = '/login/' @method_decorator(never_cache) def dispatch(self, request, *args, **kwargs): + #lht: 处理请求分发，添加不缓存装饰器 return super(LogoutView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): + #lht: 处理GET请求，执行登出操作 logout(request) - delete_sidebar_cache() + delete_sidebar_cache() #lht: 清除侧边栏缓存 return super(LogoutView, self).get(request, *args, **kwargs) class LoginView(FormView): + #lht: 用户登录视图 form_class = LoginForm template_name = 'account/login.html' success_url = '/' redirect_field_name = REDIRECT_FIELD_NAME - login_ttl = 2626560 # 一个月的时间 + login_ttl = 2626560 #lht: 登录会话保持时间（一个月） @method_decorator(sensitive_post_parameters('password')) @method_decorator(csrf_protect) @method_decorator(never_cache) def dispatch(self, request, *args, **kwargs): - + #lht: 处理请求分发，添加敏感参数保护、CSRF保护和不缓存装饰器 return super(LoginView, self).dispatch(request, *args, **kwargs) def get_context_data(self, **kwargs): + #lht: 获取重定向URL redirect_to = self.request.GET.get(self.redirect_field_name) if redirect_to is None: redirect_to = '/' @@ -116,6 +125,7 @@ class LoginView(FormView): return super(LoginView, self).get_context_data(**kwargs) def form_valid(self, form): + #lht: 表单验证成功时的处理逻辑 form = AuthenticationForm(data=self.request.POST, request=self.request) if form.is_valid(): @@ -126,14 +136,13 @@ class LoginView(FormView): 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 }) def get_success_url(self): - + #lht: 获取登录成功后的跳转URL redirect_to = self.request.POST.get(self.redirect_field_name) if not url_has_allowed_host_and_scheme( url=redirect_to, allowed_hosts=[ @@ -143,6 +152,7 @@ class LoginView(FormView): def account_result(request): + #lht: 账户操作结果页面 type = request.GET.get('type') id = request.GET.get('id') @@ -176,10 +186,12 @@ def account_result(request): class ForgetPasswordView(FormView): + #lht: 忘记密码视图 form_class = ForgetPasswordForm template_name = 'account/forget_password.html' def form_valid(self, form): + #lht: 表单验证成功时的处理逻辑 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"]) @@ -190,8 +202,10 @@ class ForgetPasswordView(FormView): class ForgetPasswordEmailCode(View): + #lht: 发送忘记密码验证码视图 def post(self, request: HttpRequest): + #lht: 处理POST请求，发送验证码邮件 form = ForgetPasswordCodeForm(request.POST) if not form.is_valid(): return HttpResponse("错误的邮箱") diff --git a/src/DjangoBlog/blog/admin.py b/src/DjangoBlog/blog/admin.py index 46c3420..27ae7da 100644 --- a/src/DjangoBlog/blog/admin.py +++ b/src/DjangoBlog/blog/admin.py @@ -1,112 +1,172 @@ +#zf：导入Django表单模块 from django import forms +#zf：导入Django管理后台模块 from django.contrib import admin +#zf：导入获取用户模型的函数 from django.contrib.auth import get_user_model +#zf：导入URL反向解析函数 from django.urls import reverse +#zf：导入HTML格式化函数 from django.utils.html import format_html +#zf：导入国际化翻译函数 from django.utils.translation import gettext_lazy as _ -# Register your models here. +#zf：导入博客应用的Article模型 from .models import Article +#zf：定义文章表单类，继承自ModelForm class ArticleForm(forms.ModelForm): + #zf：被注释掉的代码：使用AdminPagedownWidget作为body字段的widget # body = forms.CharField(widget=AdminPagedownWidget()) class Meta: model = Article + #zf：包含所有字段 fields = '__all__' +#zf：定义批量发布文章的操作函数 def makr_article_publish(modeladmin, request, queryset): + #zf：将选中文章的状态更新为'p'(已发布) queryset.update(status='p') - +#zf：定义批量将文章设为草稿的操作函数 def draft_article(modeladmin, request, queryset): + #zf：将选中文章的状态更新为'd'(草稿) queryset.update(status='d') - +#zf：定义批量关闭文章评论的操作函数 def close_article_commentstatus(modeladmin, request, queryset): + #zf：将选中文章的评论状态更新为'c'(关闭) queryset.update(comment_status='c') - +#zf：定义批量开启文章评论的操作函数 def open_article_commentstatus(modeladmin, request, queryset): + #zf：将选中文章的评论状态更新为'o'(开启) queryset.update(comment_status='o') +#zf：为操作函数设置描述信息，用于在管理后台显示（支持国际化） 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') +#zf：定义文章管理类，继承自ModelAdmin class ArticlelAdmin(admin.ModelAdmin): + #zf：每页显示20条记录 list_per_page = 20 + #zf：设置可搜索的字段为body和title search_fields = ('body', 'title') + #zf：使用自定义的ArticleForm form = ArticleForm + #zf：设置在列表页显示的字段 list_display = ( 'id', 'title', 'author', + #zf：自定义的分类链接字段 'link_to_category', 'creation_time', 'views', 'status', 'type', 'article_order') + #zf：设置哪些字段可以作为链接点击进入编辑页 list_display_links = ('id', 'title') + #zf：设置右侧的过滤器字段 list_filter = ('status', 'type', 'category') + #zf：对tags字段使用水平过滤器 filter_horizontal = ('tags',) + #zf：在表单中排除这些字段（由系统自动管理） exclude = ('creation_time', 'last_modify_time') + #zf：启用"在站点上查看"功能 view_on_site = True + #zf：注册自定义的管理操作 actions = [ makr_article_publish, draft_article, close_article_commentstatus, open_article_commentstatus] + #zf：自定义字段：显示分类链接 def link_to_category(self, obj): + #zf：获取分类模型的app_label和model_name info = (obj.category._meta.app_label, obj.category._meta.model_name) + #zf：生成分类编辑页的URL link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,)) + #zf：返回HTML链接 return format_html(u'%s' % (link, obj.category.name)) + #zf：设置字段显示名称 link_to_category.short_description = _('category') + #zf：自定义表单获取方法 def get_form(self, request, obj=None, **kwargs): form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs) + #zf：限制作者字段只能选择超级用户 form.base_fields['author'].queryset = get_user_model( ).objects.filter(is_superuser=True) return form + #zf：保存模型的方法 def save_model(self, request, obj, form, change): super(ArticlelAdmin, self).save_model(request, obj, form, change) + #zf：获取在站点上查看的URL def get_view_on_site_url(self, obj=None): if obj: + #zf：获取文章的完整URL url = obj.get_full_url() return url else: from djangoblog.utils import get_current_site + #zf：获取当前站点域名 site = get_current_site().domain return site +#zf：定义标签管理类 class TagAdmin(admin.ModelAdmin): + #zf：排除这些字段（由系统自动管理） exclude = ('slug', 'last_mod_time', 'creation_time') +#zf：定义分类管理类 class CategoryAdmin(admin.ModelAdmin): + #zf：设置在列表页显示的字段 list_display = ('name', 'parent_category', 'index') + #zf：排除这些字段（由系统自动管理） exclude = ('slug', 'last_mod_time', 'creation_time') +#zf：定义链接管理类 class LinksAdmin(admin.ModelAdmin): + #zf：排除这些字段（由系统自动管理） exclude = ('last_mod_time', 'creation_time') +#zf：定义侧边栏管理类 class SideBarAdmin(admin.ModelAdmin): + #zf：设置在列表页显示的字段 list_display = ('name', 'content', 'is_enable', 'sequence') + #zf：排除这些字段（由系统自动管理） exclude = ('last_mod_time', 'creation_time') +#zf：定义博客设置管理类 class BlogSettingsAdmin(admin.ModelAdmin): + #zf：没有特殊配置 pass + + +#zf：注册模型到管理后台 +#zf：注意：在你提供的代码中，模型注册部分被省略了，通常应该包含如下代码： +#zf：admin.site.register(Article, ArticlelAdmin) +#zf：admin.site.register(Tag, TagAdmin) +#zf：admin.site.register(Category, CategoryAdmin) +#zf：admin.site.register(Links, LinksAdmin) +#zf：admin.site.register(SideBar, SideBarAdmin) +#zf：admin.site.register(BlogSettings, BlogSettingsAdmin) \ No newline at end of file diff --git a/src/DjangoBlog/blog/apps.py b/src/DjangoBlog/blog/apps.py index 7930587..08c1cb6 100644 --- a/src/DjangoBlog/blog/apps.py +++ b/src/DjangoBlog/blog/apps.py @@ -1,5 +1,9 @@ +#zf：导入Django的应用配置基类 from django.apps import AppConfig +#zf：定义博客应用的配置类，继承自AppConfig class BlogConfig(AppConfig): - name = 'blog' + #zf：设置应用的名称为'blog' + #zf：这个名称需要与Django项目中应用的目录名称保持一致 + name = 'blog' \ No newline at end of file diff --git a/src/DjangoBlog/blog/context_processors.py b/src/DjangoBlog/blog/context_processors.py index 73e3088..1debf0f 100644 --- a/src/DjangoBlog/blog/context_processors.py +++ b/src/DjangoBlog/blog/context_processors.py @@ -1,43 +1,79 @@ +#zf：导入日志模块，用于记录日志信息 import logging +#zf：导入Django时区模块，用于获取当前时间 from django.utils import timezone +#zf：从djangoblog.utils模块导入缓存和获取博客设置的工具函数 from djangoblog.utils import cache, get_blog_setting +#zf：从当前包导入Category和Article模型 from .models import Category, Article +#zf：创建日志记录器 logger = logging.getLogger(__name__) +#zf：定义SEO处理器函数，作为Django的上下文处理器 def seo_processor(requests): + #zf：设置缓存键名 key = 'seo_processor' + #zf：尝试从缓存中获取数据 value = cache.get(key) + + #zf：如果缓存中有数据，直接返回 if value: return value else: + #zf：如果缓存中没有数据，记录日志 logger.info('set processor cache.') + #zf：获取博客设置 setting = get_blog_setting() + + #zf：构造要返回的上下文数据字典 value = { + #zf：网站名称 'SITE_NAME': setting.site_name, + #zf：是否显示谷歌广告 'SHOW_GOOGLE_ADSENSE': setting.show_google_adsense, + #zf：谷歌广告代码 'GOOGLE_ADSENSE_CODES': setting.google_adsense_codes, + #zf：网站SEO描述 'SITE_SEO_DESCRIPTION': setting.site_seo_description, + #zf：网站描述 'SITE_DESCRIPTION': setting.site_description, + #zf：网站关键词 'SITE_KEYWORDS': setting.site_keywords, + #zf：网站基础URL（协议+主机名+/） 'SITE_BASE_URL': requests.scheme + '://' + requests.get_host() + '/', + #zf：文章摘要长度 'ARTICLE_SUB_LENGTH': setting.article_sub_length, + #zf：导航分类列表（所有分类） 'nav_category_list': Category.objects.all(), + #zf：导航页面（所有已发布的页面类型文章） 'nav_pages': Article.objects.filter( - type='p', - status='p'), + type='p', #zf：类型为页面('p') + status='p'), #zf：状态为已发布('p') + #zf：是否开启网站评论功能 'OPEN_SITE_COMMENT': setting.open_site_comment, + #zf：备案号 'BEIAN_CODE': setting.beian_code, + #zf：网站统计代码 'ANALYTICS_CODE': setting.analytics_code, + #zf：公安备案号 "BEIAN_CODE_GONGAN": setting.gongan_beiancode, + #zf：是否显示公安备案号 "SHOW_GONGAN_CODE": setting.show_gongan_code, + #zf：当前年份（用于版权信息等） "CURRENT_YEAR": timezone.now().year, + #zf：全局头部内容 "GLOBAL_HEADER": setting.global_header, + #zf：全局尾部内容 "GLOBAL_FOOTER": setting.global_footer, + #zf：评论是否需要审核 "COMMENT_NEED_REVIEW": setting.comment_need_review, } + + #zf：将数据缓存10小时（60秒*60分钟*10小时） cache.set(key, value, 60 * 60 * 10) - return value + #zf：返回构造的数据 + return value \ No newline at end of file diff --git a/src/DjangoBlog/blog/documents.py b/src/DjangoBlog/blog/documents.py index 0f1db7b..75c1b49 100644 --- a/src/DjangoBlog/blog/documents.py +++ b/src/DjangoBlog/blog/documents.py @@ -1,26 +1,42 @@ +#zf：导入时间模块，用于生成时间戳 import time +#zf：导入elasticsearch客户端模块 import elasticsearch.client +#zf：导入Django配置模块 from django.conf import settings +#zf：从elasticsearch_dsl导入各种字段类型和文档类 from elasticsearch_dsl import Document, InnerDoc, Date, Integer, Long, Text, Object, GeoPoint, Keyword, Boolean +#zf：从elasticsearch_dsl.connections导入连接管理器 from elasticsearch_dsl.connections import connections +#zf：从blog.models导入Article模型 from blog.models import Article +#zf：检查是否启用了Elasticsearch功能（通过检查settings中是否有ELASTICSEARCH_DSL配置） ELASTICSEARCH_ENABLED = hasattr(settings, 'ELASTICSEARCH_DSL') +#zf：如果启用了Elasticsearch if ELASTICSEARCH_ENABLED: + #zf：创建Elasticsearch连接 connections.create_connection( hosts=[settings.ELASTICSEARCH_DSL['default']['hosts']]) + #zf：导入Elasticsearch客户端 from elasticsearch import Elasticsearch + #zf：创建Elasticsearch实例 es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) + #zf：导入IngestClient用于管理管道 from elasticsearch.client import IngestClient + #zf：创建IngestClient实例 c = IngestClient(es) try: + #zf：尝试获取名为'geoip'的管道 c.get_pipeline('geoip') except elasticsearch.exceptions.NotFoundError: + #zf：如果管道不存在，则创建一个geoip管道 + #zf：该管道用于根据IP地址添加地理位置信息 c.put_pipeline('geoip', body='''{ "description" : "Add geoip info", "processors" : [ @@ -33,73 +49,117 @@ if ELASTICSEARCH_ENABLED: }''') +#zf：定义GeoIp内部文档类，用于存储地理位置信息 class GeoIp(InnerDoc): - continent_name = Keyword() - country_iso_code = Keyword() - country_name = Keyword() - location = GeoPoint() + #zf：大洲名称 + continent_name = Keyword() + #zf：国家ISO代码 + country_iso_code = Keyword() + #zf：国家名称 + country_name = Keyword() + #zf：地理位置坐标 + location = GeoPoint() +#zf：定义UserAgentBrowser内部文档类，用于存储浏览器信息 class UserAgentBrowser(InnerDoc): - Family = Keyword() - Version = Keyword() + #zf：浏览器家族 + Family = Keyword() + #zf：浏览器版本 + Version = Keyword() +#zf：定义UserAgentOS内部文档类，继承自UserAgentBrowser，用于存储操作系统信息 class UserAgentOS(UserAgentBrowser): pass +#zf：定义UserAgentDevice内部文档类，用于存储设备信息 class UserAgentDevice(InnerDoc): - Family = Keyword() - Brand = Keyword() - Model = Keyword() + #zf：设备家族 + Family = Keyword() + #zf：设备品牌 + Brand = Keyword() + #zf：设备型号 + Model = Keyword() +#zf：定义UserAgent内部文档类，用于存储用户代理信息 class UserAgent(InnerDoc): - browser = Object(UserAgentBrowser, required=False) - os = Object(UserAgentOS, required=False) - device = Object(UserAgentDevice, required=False) - string = Text() - is_bot = Boolean() - - + #zf：浏览器信息 + browser = Object(UserAgentBrowser, required=False) + #zf：操作系统信息 + os = Object(UserAgentOS, required=False) + #zf：设备信息 + device = Object(UserAgentDevice, required=False) + #zf：完整的User-Agent字符串 + string = Text() + #zf：是否为机器人 + is_bot = Boolean() + + +#zf：定义ElapsedTimeDocument文档类，用于存储页面性能数据 class ElapsedTimeDocument(Document): - url = Keyword() - time_taken = Long() - log_datetime = Date() - ip = Keyword() - geoip = Object(GeoIp, required=False) - useragent = Object(UserAgent, required=False) - + #zf：URL地址 + url = Keyword() + #zf：耗时（毫秒） + time_taken = Long() + #zf：记录时间 + log_datetime = Date() + #zf：IP地址 + ip = Keyword() + #zf：地理位置信息 + geoip = Object(GeoIp, required=False) + #zf：用户代理信息 + useragent = Object(UserAgent, required=False) + + #zf：定义索引配置 class Index: - name = 'performance' + #zf：索引名称 + name = 'performance' settings = { - "number_of_shards": 1, - "number_of_replicas": 0 + #zf：分片数量 + "number_of_shards": 1, + #zf：副本数量 + "number_of_replicas": 0 } + #zf：定义文档元数据 class Meta: - doc_type = 'ElapsedTime' + #zf：文档类型 + doc_type = 'ElapsedTime' +#zf：定义ElapsedTime文档管理器类 class ElaspedTimeDocumentManager: + #zf：静态方法：构建索引 @staticmethod def build_index(): from elasticsearch import Elasticsearch + #zf：创建Elasticsearch客户端 client = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) + #zf：检查performance索引是否存在 res = client.indices.exists(index="performance") if not res: + #zf：如果不存在则初始化索引 ElapsedTimeDocument.init() + #zf：静态方法：删除索引 @staticmethod def delete_index(): from elasticsearch import Elasticsearch + #zf：创建Elasticsearch实例 es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) + #zf：删除performance索引，忽略400和404错误 es.indices.delete(index='performance', ignore=[400, 404]) + #zf：静态方法：创建性能记录文档 @staticmethod def create(url, time_taken, log_datetime, useragent, ip): + #zf：构建索引 ElaspedTimeDocumentManager.build_index() + + #zf：创建UserAgent对象并填充数据 ua = UserAgent() ua.browser = UserAgentBrowser() ua.browser.Family = useragent.browser.family @@ -116,98 +176,153 @@ class ElaspedTimeDocumentManager: ua.string = useragent.ua_string ua.is_bot = useragent.is_bot + #zf：创建ElapsedTimeDocument文档 doc = ElapsedTimeDocument( meta={ 'id': int( round( time.time() * - 1000)) + 1000)) #zf：使用当前时间戳作为ID }, url=url, time_taken=time_taken, log_datetime=log_datetime, - useragent=ua, ip=ip) + useragent=ua, + ip=ip) + #zf：保存文档，并使用geoip管道处理 doc.save(pipeline="geoip") +#zf：定义ArticleDocument文档类，用于存储文章搜索数据 class ArticleDocument(Document): + #zf：文章正文，使用ik_max_word分词器进行索引，ik_smart进行搜索 body = Text(analyzer='ik_max_word', search_analyzer='ik_smart') + #zf：文章标题，使用ik_max_word分词器进行索引，ik_smart进行搜索 title = Text(analyzer='ik_max_word', search_analyzer='ik_smart') + #zf：作者信息 author = Object(properties={ - 'nickname': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), - 'id': Integer() + #zf：昵称 + 'nickname': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), + #zf：ID + 'id': Integer() }) + #zf：分类信息 category = Object(properties={ - 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), - 'id': Integer() + #zf：分类名 + 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), + #zf：ID + 'id': Integer() }) + #zf：标签信息 tags = Object(properties={ - 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), - 'id': Integer() + #zf：标签名 + 'name': Text(analyzer='ik_max_word', search_analyzer='ik_smart'), + #zf：ID + 'id': Integer() }) + #zf：发布时间 pub_time = Date() + #zf：文章状态 status = Text() + #zf：评论状态 comment_status = Text() + #zf：文章类型 type = Text() + #zf：浏览量 views = Integer() + #zf：文章排序 article_order = Integer() + #zf：定义索引配置 class Index: - name = 'blog' + #zf：索引名称 + name = 'blog' settings = { - "number_of_shards": 1, - "number_of_replicas": 0 + #zf：分片数量 + "number_of_shards": 1, + #zf：副本数量 + "number_of_replicas": 0 } + #zf：定义文档元数据 class Meta: - doc_type = 'Article' + #zf：文档类型 + doc_type = 'Article' +#zf：定义ArticleDocument管理器类 class ArticleDocumentManager(): - + #zf：初始化方法 def __init__(self): self.create_index() + #zf：创建索引方法 def create_index(self): ArticleDocument.init() + #zf：删除索引方法 def delete_index(self): from elasticsearch import Elasticsearch + #zf：创建Elasticsearch实例 es = Elasticsearch(settings.ELASTICSEARCH_DSL['default']['hosts']) + #zf：删除blog索引，忽略400和404错误 es.indices.delete(index='blog', ignore=[400, 404]) + #zf：将文章对象转换为文档对象的方法 def convert_to_doc(self, articles): return [ ArticleDocument( meta={ - 'id': article.id}, - body=article.body, - title=article.title, + #zf：使用文章ID作为文档ID + 'id': article.id}, + #zf：文章正文 + body=article.body, + #zf：文章标题 + title=article.title, author={ - 'nickname': article.author.username, - 'id': article.author.id}, + #zf：作者昵称 + 'nickname': article.author.username, + #zf：作者ID + 'id': article.author.id}, category={ - 'name': article.category.name, - 'id': article.category.id}, + #zf：分类名 + 'name': article.category.name, + #zf：分类ID + 'id': article.category.id}, tags=[ { - 'name': t.name, - 'id': t.id} for t in article.tags.all()], - pub_time=article.pub_time, - status=article.status, - comment_status=article.comment_status, - type=article.type, - views=article.views, - article_order=article.article_order) for article in articles] - + #zf：标签名 + 'name': t.name, + #zf：标签ID + 'id': t.id} for t in article.tags.all()], + #zf：发布时间 + pub_time=article.pub_time, + #zf：文章状态 + status=article.status, + #zf：评论状态 + comment_status=article.comment_status, + #zf：文章类型 + type=article.type, + #zf：浏览量 + views=article.views, + #zf：排序 + article_order=article.article_order) for article in articles] + + #zf：重建索引方法 def rebuild(self, articles=None): - ArticleDocument.init() + #zf：初始化索引 + ArticleDocument.init() + #zf：如果没有提供文章列表，则获取所有文章 articles = articles if articles else Article.objects.all() + #zf：转换文章为文档对象 docs = self.convert_to_doc(articles) + #zf：保存所有文档 for doc in docs: doc.save() + #zf：更新文档方法 def update_docs(self, docs): + #zf：保存所有文档 for doc in docs: - doc.save() + doc.save() \ No newline at end of file diff --git a/src/DjangoBlog/blog/forms.py b/src/DjangoBlog/blog/forms.py index 715be76..850da68 100644 --- a/src/DjangoBlog/blog/forms.py +++ b/src/DjangoBlog/blog/forms.py @@ -1,19 +1,34 @@ +# 导入日志模块，用于记录日志信息 import logging +# 导入Django表单模块 from django import forms +# 从haystack.forms导入SearchForm，用于实现搜索功能 from haystack.forms import SearchForm +# 创建日志记录器 logger = logging.getLogger(__name__) +# 定义博客搜索表单类，继承自Haystack的SearchForm class BlogSearchForm(SearchForm): + # 定义搜索查询字段，设置为必填项 querydata = forms.CharField(required=True) + # 重写search方法，实现自定义搜索逻辑 def search(self): + # 调用父类的search方法获取搜索结果 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 \ No newline at end of file diff --git a/src/DjangoBlog/blog/middleware.py b/src/DjangoBlog/blog/middleware.py index 94dd70c..6dbc086 100644 --- a/src/DjangoBlog/blog/middleware.py +++ b/src/DjangoBlog/blog/middleware.py @@ -1,42 +1,406 @@ -import logging -import time - -from ipware import get_client_ip -from user_agents import parse - -from blog.documents import ELASTICSEARCH_ENABLED, ElaspedTimeDocumentManager - -logger = logging.getLogger(__name__) - - -class OnlineMiddleware(object): - def __init__(self, get_response=None): - self.get_response = get_response - super().__init__() - - def __call__(self, request): - ''' page render time ''' - start_time = time.time() - response = self.get_response(request) - http_user_agent = request.META.get('HTTP_USER_AGENT', '') - ip, _ = get_client_ip(request) - user_agent = parse(http_user_agent) - if not response.streaming: - try: - cast_time = time.time() - start_time - if ELASTICSEARCH_ENABLED: - time_taken = round((cast_time) * 1000, 2) - url = request.path - from django.utils import timezone - ElaspedTimeDocumentManager.create( - url=url, - time_taken=time_taken, - log_datetime=timezone.now(), - useragent=user_agent, - ip=ip) - response.content = response.content.replace( - b'', str.encode(str(cast_time)[:5])) - except Exception as e: - logger.error("Error OnlineMiddleware: %s" % e) - - return response +#zf：导入os模块，用于文件路径操作 +import os + +#zf：从django.conf导入settings配置 +from django.conf import settings +#zf：从django.core.files.uploadedfile导入SimpleUploadedFile用于模拟文件上传 +from django.core.files.uploadedfile import SimpleUploadedFile +#zf：从django.core.management导入call_command用于调用Django管理命令 +from django.core.management import call_command +#zf：从django.core.paginator导入Paginator用于分页功能测试 +from django.core.paginator import Paginator +#zf：从django.templatetags.static导入static函数用于处理静态文件 +from django.templatetags.static import static +#zf：从django.test导入Client, RequestFactory, TestCase用于测试 +from django.test import Client, RequestFactory, TestCase +#zf：从django.urls导入reverse用于URL反向解析 +from django.urls import reverse +#zf：从django.utils导入timezone用于处理时区 +from django.utils import timezone + +#zf：从accounts.models导入BlogUser博客用户模型 +from accounts.models import BlogUser +#zf：从blog.forms导入BlogSearchForm博客搜索表单 +from blog.forms import BlogSearchForm +#zf：从blog.models导入Article, Category, Tag, SideBar, Links博客相关模型 +from blog.models import Article, Category, Tag, SideBar, Links +#zf：从blog.templatetags.blog_tags导入load_pagination_info, load_articletags模板标签 +from blog.templatetags.blog_tags import load_pagination_info, load_articletags +#zf：从djangoblog.utils导入get_current_site, get_sha256工具函数 +from djangoblog.utils import get_current_site, get_sha256 +#zf：从oauth.models导入OAuthUser, OAuthConfig OAuth认证相关模型 +from oauth.models import OAuthUser, OAuthConfig + + +#zf：创建你的测试用例 + +#zf：定义ArticleTest测试类，继承自Django的TestCase +class ArticleTest(TestCase): + #zf：测试初始化方法，在每个测试方法执行前运行 + def setUp(self): + #zf：创建测试客户端，用于模拟HTTP请求 + self.client = Client() + #zf：创建请求工厂，用于创建请求对象 + self.factory = RequestFactory() + + #zf：测试文章验证功能 + def test_validate_article(self): + #zf：获取当前站点域名 + site = get_current_site().domain + #zf：创建或获取测试用户 + user = BlogUser.objects.get_or_create( + email="liangliangyy@gmail.com", + username="liangliangyy")[0] + #zf：设置用户密码 + user.set_password("liangliangyy") + #zf：设置用户为管理员 + user.is_staff = True + #zf：设置用户为超级用户 + user.is_superuser = True + #zf：保存用户 + user.save() + #zf：测试访问用户个人页面 + response = self.client.get(user.get_absolute_url()) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + #zf：测试访问管理后台邮件发送日志 + response = self.client.get('/admin/servermanager/emailsendlog/') + #zf：测试访问管理后台日志条目 + response = self.client.get('admin/admin/logentry/') + #zf：创建侧边栏对象 + s = SideBar() + #zf：设置侧边栏排序 + s.sequence = 1 + #zf：设置侧边栏名称 + s.name = 'test' + #zf：设置侧边栏内容 + s.content = 'test content' + #zf：设置侧边栏启用状态 + s.is_enable = True + #zf：保存侧边栏 + s.save() + + #zf：创建分类对象 + category = Category() + #zf：设置分类名称 + category.name = "category" + #zf：设置分类创建时间 + category.creation_time = timezone.now() + #zf：设置分类最后修改时间 + category.last_mod_time = timezone.now() + #zf：保存分类 + category.save() + + #zf：创建标签对象 + tag = Tag() + #zf：设置标签名称 + tag.name = "nicetag" + #zf：保存标签 + tag.save() + + #zf：创建文章对象 + article = Article() + #zf：设置文章标题 + article.title = "nicetitle" + #zf：设置文章正文 + article.body = "nicecontent" + #zf：设置文章作者 + article.author = user + #zf：设置文章分类 + article.category = category + #zf：设置文章类型为文章 + article.type = 'a' + #zf：设置文章状态为已发布 + article.status = 'p' + + #zf：保存文章 + article.save() + #zf：断言文章标签数量为0 + self.assertEqual(0, article.tags.count()) + #zf：给文章添加标签 + article.tags.add(tag) + #zf：保存文章 + article.save() + #zf：断言文章标签数量为1 + self.assertEqual(1, article.tags.count()) + + #zf：循环创建20篇文章用于分页测试 + for i in range(20): + article = Article() + #zf：设置文章标题 + article.title = "nicetitle" + str(i) + #zf：设置文章正文 + article.body = "nicetitle" + str(i) + #zf：设置文章作者 + article.author = user + #zf：设置文章分类 + article.category = category + #zf：设置文章类型为文章 + article.type = 'a' + #zf：设置文章状态为已发布 + article.status = 'p' + #zf：保存文章 + article.save() + #zf：给文章添加标签 + article.tags.add(tag) + #zf：保存文章 + article.save() + #zf：从blog.documents导入ELASTICSEARCH_ENABLED常量 + from blog.documents import ELASTICSEARCH_ENABLED + #zf：如果启用了Elasticsearch + if ELASTICSEARCH_ENABLED: + #zf：调用build_index管理命令构建搜索索引 + call_command("build_index") + #zf：测试搜索功能 + response = self.client.get('/search', {'q': 'nicetitle'}) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试访问文章详情页 + response = self.client.get(article.get_absolute_url()) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + #zf：从djangoblog.spider_notify导入SpiderNotify用于通知搜索引擎 + from djangoblog.spider_notify import SpiderNotify + #zf：通知搜索引擎爬虫 + SpiderNotify.notify(article.get_absolute_url()) + #zf：测试访问标签详情页 + response = self.client.get(tag.get_absolute_url()) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试访问分类详情页 + response = self.client.get(category.get_absolute_url()) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试搜索功能 + response = self.client.get('/search', {'q': 'django'}) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + #zf：加载文章标签 + s = load_articletags(article) + #zf：断言结果不为None + self.assertIsNotNone(s) + + #zf：用户登录 + self.client.login(username='liangliangyy', password='liangliangyy') + + #zf：测试访问文章归档页 + response = self.client.get(reverse('blog:archives')) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：创建所有文章的分页器 + p = Paginator(Article.objects.all(), settings.PAGINATE_BY) + #zf：检查分页功能 + self.check_pagination(p, '', '') + + #zf：创建按标签筛选的分页器 + p = Paginator(Article.objects.filter(tags=tag), settings.PAGINATE_BY) + #zf：检查标签归档分页功能 + self.check_pagination(p, '分类标签归档', tag.slug) + + #zf：创建按作者筛选的分页器 + p = Paginator( + Article.objects.filter( + author__username='liangliangyy'), settings.PAGINATE_BY) + #zf：检查作者归档分页功能 + self.check_pagination(p, '作者文章归档', 'liangliangyy') + + #zf：创建按分类筛选的分页器 + p = Paginator(Article.objects.filter(category=category), settings.PAGINATE_BY) + #zf：检查分类归档分页功能 + self.check_pagination(p, '分类目录归档', category.slug) + + #zf：创建博客搜索表单实例 + f = BlogSearchForm() + #zf：执行搜索 + f.search() + #zf：从djangoblog.spider_notify导入SpiderNotify + from djangoblog.spider_notify import SpiderNotify + #zf：通知百度搜索引擎 + SpiderNotify.baidu_notify([article.get_full_url()]) + + #zf：从blog.templatetags.blog_tags导入gravatar_url, gravatar函数 + from blog.templatetags.blog_tags import gravatar_url, gravatar + #zf：获取gravatar头像URL + u = gravatar_url('liangliangyy@gmail.com') + #zf：获取gravatar头像HTML + u = gravatar('liangliangyy@gmail.com') + + #zf：创建友情链接对象 + link = Links( + sequence=1, + name="lylinux", + link='https://wwww.lylinux.net') + #zf：保存友情链接 + link.save() + #zf：测试访问友情链接页面 + response = self.client.get('/links.html') + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试访问RSS订阅页面 + response = self.client.get('/feed/') + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试访问站点地图 + response = self.client.get('/sitemap.xml') + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试访问管理后台文章删除页面 + self.client.get("/admin/blog/article/1/delete/") + #zf：测试访问管理后台邮件发送日志 + self.client.get('/admin/servermanager/emailsendlog/') + #zf：测试访问管理后台日志条目 + self.client.get('/admin/admin/logentry/') + #zf：测试访问管理后台日志条目修改页面 + self.client.get('/admin/admin/logentry/1/change/') + + #zf：检查分页功能的方法 + def check_pagination(self, p, type, value): + #zf：遍历所有分页 + for page in range(1, p.num_pages + 1): + #zf：加载分页信息 + s = load_pagination_info(p.page(page), type, value) + #zf：断言分页信息不为None + self.assertIsNotNone(s) + #zf：如果有上一页URL + if s['previous_url']: + #zf：测试访问上一页 + response = self.client.get(s['previous_url']) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + #zf：如果有下一页URL + if s['next_url']: + #zf：测试访问下一页 + response = self.client.get(s['next_url']) + #zf：断言响应状态码为200 + self.assertEqual(response.status_code, 200) + + #zf：测试图片上传功能 + def test_image(self): + #zf：导入requests模块用于下载图片 + import requests + #zf：下载Python官网Logo图片 + rsp = requests.get( + 'https://www.python.org/static/img/python-logo.png') + #zf：设置图片保存路径 + imagepath = os.path.join(settings.BASE_DIR, 'python.png') + #zf：将图片保存到本地 + with open(imagepath, 'wb') as file: + file.write(rsp.content) + #zf：测试未登录上传图片（应该被拒绝） + rsp = self.client.post('/upload') + #zf：断言响应状态码为403（禁止访问） + self.assertEqual(rsp.status_code, 403) + #zf：生成上传签名 + sign = get_sha256(get_sha256(settings.SECRET_KEY)) + #zf：打开图片文件准备上传 + with open(imagepath, 'rb') as file: + #zf：创建上传文件对象 + imgfile = SimpleUploadedFile( + 'python.png', file.read(), content_type='image/jpg') + #zf：构造表单数据 + form_data = {'python.png': imgfile} + #zf：测试带签名上传图片 + rsp = self.client.post( + '/upload?sign=' + sign, form_data, follow=True) + #zf：断言响应状态码为200 + self.assertEqual(rsp.status_code, 200) + #zf：删除临时图片文件 + os.remove(imagepath) + #zf：从djangoblog.utils导入save_user_avatar, send_email工具函数 + from djangoblog.utils import save_user_avatar, send_email + #zf：测试发送邮件功能 + send_email(['qq@qq.com'], 'testTitle', 'testContent') + #zf：测试保存用户头像功能 + save_user_avatar( + 'https://www.python.org/static/img/python-logo.png') + + #zf：测试错误页面 + def test_errorpage(self): + #zf：测试访问不存在的页面 + rsp = self.client.get('/eee') + #zf：断言响应状态码为404 + self.assertEqual(rsp.status_code, 404) + + #zf：测试管理命令 + def test_commands(self): + #zf：创建或获取测试用户 + user = BlogUser.objects.get_or_create( + email="liangliangyy@gmail.com", + username="liangliangyy")[0] + #zf：设置用户密码 + user.set_password("liangliangyy") + #zf：设置用户为管理员 + user.is_staff = True + #zf：设置用户为超级用户 + user.is_superuser = True + #zf：保存用户 + user.save() + + #zf：创建OAuth配置对象 + c = OAuthConfig() + #zf：设置OAuth类型为QQ + c.type = 'qq' + #zf：设置应用密钥 + c.appkey = 'appkey' + #zf：设置应用密钥 + c.appsecret = 'appsecret' + #zf：保存配置 + c.save() + + #zf：创建OAuth用户对象 + u = OAuthUser() + #zf：设置OAuth类型为QQ + u.type = 'qq' + #zf：设置openid + u.openid = 'openid' + #zf：关联博客用户 + u.user = user + #zf：设置头像为静态图片 + u.picture = static("/blog/img/avatar.png") + #zf：设置用户元数据 + u.metadata = ''' +{ +"figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30" +}''' + #zf：保存OAuth用户 + u.save() + + #zf：创建另一个OAuth用户对象 + u = OAuthUser() + #zf：设置OAuth类型为QQ + u.type = 'qq' + #zf：设置openid + u.openid = 'openid1' + #zf：设置头像URL + u.picture = 'https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30' + #zf：设置用户元数据 + u.metadata = ''' + { + "figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30" + }''' + #zf：保存OAuth用户 + u.save() + + #zf：从blog.documents导入ELASTICSEARCH_ENABLED常量 + from blog.documents import ELASTICSEARCH_ENABLED + #zf：如果启用了Elasticsearch + if ELASTICSEARCH_ENABLED: + #zf：调用build_index命令构建搜索索引 + call_command("build_index") + #zf：调用ping_baidu命令通知百度搜索引擎 + call_command("ping_baidu", "all") + #zf：调用create_testdata命令创建测试数据 + call_command("create_testdata") + #zf：调用clear_cache命令清除缓存 + call_command("clear_cache") + #zf：调用sync_user_avatar命令同步用户头像 + call_command("sync_user_avatar") + #zf：调用build_search_words命令构建搜索词 + call_command("build_search_words") \ No newline at end of file diff --git a/src/DjangoBlog/blog/models.py b/src/DjangoBlog/blog/models.py index 083788b..8b9baae 100644 --- a/src/DjangoBlog/blog/models.py +++ b/src/DjangoBlog/blog/models.py @@ -1,122 +1,187 @@ +#zf：导入日志模块，用于记录日志信息 import logging +#zf：导入正则表达式模块，用于匹配文章中的图片 import re +#zf：从abc模块导入abstractmethod装饰器 from abc import abstractmethod +#zf：导入Django配置模块 from django.conf import settings +#zf：导入Django验证错误异常 from django.core.exceptions import ValidationError +#zf：导入Django数据库模型模块 from django.db import models +#zf：导入Django URL反向解析函数 from django.urls import reverse +#zf：导入Django时区工具 from django.utils.timezone import now +#zf：导入Django国际化翻译函数 from django.utils.translation import gettext_lazy as _ +#zf：导入Markdown编辑器字段 from mdeditor.fields import MDTextField +#zf：导入slugify函数，用于生成slug from uuslug import slugify +#zf：从djangoblog.utils导入缓存装饰器和缓存工具 from djangoblog.utils import cache_decorator, cache +#zf：从djangoblog.utils导入获取当前站点的函数 from djangoblog.utils import get_current_site +#zf：创建日志记录器 logger = logging.getLogger(__name__) +#zf：定义链接显示类型枚举类，继承自TextChoices class LinkShowType(models.TextChoices): - I = ('i', _('index')) - L = ('l', _('list')) - P = ('p', _('post')) - A = ('a', _('all')) - S = ('s', _('slide')) - - + #zf：首页显示 + I = ('i', _('index')) + #zf：列表页显示 + L = ('l', _('list')) + #zf：文章页显示 + P = ('p', _('post')) + #zf：全站显示 + A = ('a', _('all')) + #zf：幻灯片显示 + S = ('s', _('slide')) + + +#zf：定义基础模型类，继承自Django的Model类 class BaseModel(models.Model): + #zf：主键字段 id = models.AutoField(primary_key=True) + #zf：创建时间字段 creation_time = models.DateTimeField(_('creation time'), default=now) + #zf：最后修改时间字段 last_modify_time = models.DateTimeField(_('modify time'), default=now) + #zf：重写save方法 def save(self, *args, **kwargs): + #zf：检查是否是更新文章浏览量的特殊情况 is_update_views = isinstance( self, Article) and 'update_fields' in kwargs and kwargs['update_fields'] == ['views'] if is_update_views: + #zf：如果是更新浏览量，则直接更新数据库，避免触发其他逻辑 Article.objects.filter(pk=self.pk).update(views=self.views) else: + #zf：如果有slug字段，则生成slug if 'slug' in self.__dict__: slug = getattr( self, 'title') if 'title' in self.__dict__ else getattr( self, 'name') setattr(self, 'slug', slugify(slug)) + #zf：调用父类的save方法 super().save(*args, **kwargs) + #zf：获取完整URL方法 def get_full_url(self): + #zf：获取当前站点域名 site = get_current_site().domain + #zf：拼接完整URL url = "https://{site}{path}".format(site=site, path=self.get_absolute_url()) return url + #zf：设置为抽象类 class Meta: abstract = True + #zf：定义抽象方法，子类必须实现 @abstractmethod def get_absolute_url(self): pass +#zf：定义文章模型类，继承自BaseModel class Article(BaseModel): """文章""" + #zf：文章状态选项 STATUS_CHOICES = ( - ('d', _('Draft')), - ('p', _('Published')), + #zf：草稿 + ('d', _('Draft')), + #zf：已发布 + ('p', _('Published')), ) + #zf：评论状态选项 COMMENT_STATUS = ( - ('o', _('Open')), - ('c', _('Close')), + #zf：开启评论 + ('o', _('Open')), + #zf：关闭评论 + ('c', _('Close')), ) + #zf：文章类型选项 TYPE = ( - ('a', _('Article')), - ('p', _('Page')), + #zf：文章 + ('a', _('Article')), + #zf：页面 + ('p', _('Page')), ) + + #zf：标题字段 title = models.CharField(_('title'), max_length=200, unique=True) + #zf：正文字段，使用Markdown编辑器 body = MDTextField(_('body')) + #zf：发布时间字段 pub_time = models.DateTimeField( _('publish time'), blank=False, null=False, default=now) + #zf：状态字段 status = models.CharField( _('status'), max_length=1, choices=STATUS_CHOICES, default='p') + #zf：评论状态字段 comment_status = models.CharField( _('comment status'), max_length=1, choices=COMMENT_STATUS, default='o') + #zf：类型字段 type = models.CharField(_('type'), max_length=1, choices=TYPE, default='a') + #zf：浏览量字段 views = models.PositiveIntegerField(_('views'), default=0) + #zf：作者字段，外键关联到用户模型 author = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('author'), blank=False, null=False, on_delete=models.CASCADE) + #zf：文章排序字段 article_order = models.IntegerField( _('order'), blank=False, null=False, default=0) + #zf：是否显示目录字段 show_toc = models.BooleanField(_('show toc'), blank=False, null=False, default=False) + #zf：分类字段，外键关联到Category模型 category = models.ForeignKey( 'Category', verbose_name=_('category'), on_delete=models.CASCADE, blank=False, null=False) + #zf：标签字段，多对多关联到Tag模型 tags = models.ManyToManyField('Tag', verbose_name=_('tag'), blank=True) + #zf：将文章正文转换为字符串 def body_to_string(self): return self.body + #zf：字符串表示方法 def __str__(self): return self.title + #zf：模型元数据 class Meta: - ordering = ['-article_order', '-pub_time'] - verbose_name = _('article') - verbose_name_plural = verbose_name - get_latest_by = 'id' - + #zf：排序规则 + ordering = ['-article_order', '-pub_time'] + #zf：单数形式显示名称 + verbose_name = _('article') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name + #zf：latest()方法使用的字段 + get_latest_by = 'id' + + #zf：获取绝对URL方法 def get_absolute_url(self): return reverse('blog:detailbyid', kwargs={ 'article_id': self.id, @@ -125,252 +190,364 @@ class Article(BaseModel): 'day': self.creation_time.day }) + #zf：获取分类树方法，使用缓存装饰器缓存10小时 @cache_decorator(60 * 60 * 10) def get_category_tree(self): + #zf：获取分类的分类树 tree = self.category.get_category_tree() + #zf：将分类名称和URL组成元组列表 names = list(map(lambda c: (c.name, c.get_absolute_url()), tree)) return names + #zf：保存方法 def save(self, *args, **kwargs): super().save(*args, **kwargs) + #zf：增加浏览量方法 def viewed(self): self.views += 1 self.save(update_fields=['views']) + #zf：获取评论列表方法 def comment_list(self): + #zf：构造缓存键名 cache_key = 'article_comments_{id}'.format(id=self.id) + #zf：从缓存中获取评论列表 value = cache.get(cache_key) if value: + #zf：如果缓存中有数据，记录日志并返回 logger.info('get article comments:{id}'.format(id=self.id)) return value else: + #zf：如果缓存中没有数据，从数据库查询并缓存 comments = self.comment_set.filter(is_enable=True).order_by('-id') cache.set(cache_key, comments, 60 * 100) logger.info('set article comments:{id}'.format(id=self.id)) return comments + #zf：获取管理后台URL方法 def get_admin_url(self): + #zf：获取模型的app_label和model_name info = (self._meta.app_label, self._meta.model_name) + #zf：生成管理后台编辑页面的URL return reverse('admin:%s_%s_change' % info, args=(self.pk,)) + #zf：获取下一篇文章方法，使用缓存装饰器缓存100分钟 @cache_decorator(expiration=60 * 100) def next_article(self): - # 下一篇 + #zf：下一篇 return Article.objects.filter( id__gt=self.id, status='p').order_by('id').first() + #zf：获取上一篇文章方法，使用缓存装饰器缓存100分钟 @cache_decorator(expiration=60 * 100) def prev_article(self): - # 前一篇 + #zf：前一篇 return Article.objects.filter(id__lt=self.id, status='p').first() + #zf：获取文章中第一张图片的URL方法 def get_first_image_url(self): """ Get the first image url from article.body. :return: """ + #zf：使用正则表达式匹配Markdown图片语法 match = re.search(r'!\[.*?\]\((.+?)\)', self.body) if match: + #zf：如果匹配到图片，返回图片URL return match.group(1) + #zf：如果没有匹配到图片，返回空字符串 return "" +#zf：定义分类模型类，继承自BaseModel class Category(BaseModel): """文章分类""" + #zf：分类名称字段 name = models.CharField(_('category name'), max_length=30, unique=True) + #zf：父级分类字段，外键关联到自身 parent_category = models.ForeignKey( 'self', verbose_name=_('parent category'), blank=True, null=True, on_delete=models.CASCADE) + #zf：slug字段 slug = models.SlugField(default='no-slug', max_length=60, blank=True) + #zf：索引字段，用于排序 index = models.IntegerField(default=0, verbose_name=_('index')) + #zf：模型元数据 class Meta: - ordering = ['-index'] - verbose_name = _('category') - verbose_name_plural = verbose_name - + #zf：按索引降序排列 + ordering = ['-index'] + #zf：单数形式显示名称 + verbose_name = _('category') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name + + #zf：获取绝对URL方法 def get_absolute_url(self): return reverse( 'blog:category_detail', kwargs={ 'category_name': self.slug}) + #zf：字符串表示方法 def __str__(self): return self.name + #zf：获取分类树方法，使用缓存装饰器缓存10小时 @cache_decorator(60 * 60 * 10) def get_category_tree(self): """ 递归获得分类目录的父级 :return: """ + #zf：初始化分类列表 categorys = [] + #zf：递归解析分类树的内部函数 def parse(category): + #zf：将当前分类添加到列表 categorys.append(category) + #zf：如果有父级分类，递归处理父级分类 if category.parent_category: parse(category.parent_category) + #zf：从当前分类开始解析 parse(self) return categorys + #zf：获取子分类方法，使用缓存装饰器缓存10小时 @cache_decorator(60 * 60 * 10) def get_sub_categorys(self): """ 获得当前分类目录所有子集 :return: """ + #zf：初始化分类列表 categorys = [] + #zf：获取所有分类 all_categorys = Category.objects.all() + #zf：递归解析子分类的内部函数 def parse(category): + #zf：如果分类不在列表中，添加到列表 if category not in categorys: categorys.append(category) + #zf：获取当前分类的子分类 childs = all_categorys.filter(parent_category=category) + #zf：遍历子分类 for child in childs: + #zf：如果子分类不在列表中，添加到列表 if category not in categorys: categorys.append(child) + #zf：递归处理子分类 parse(child) + #zf：从当前分类开始解析 parse(self) return categorys +#zf：定义标签模型类，继承自BaseModel class Tag(BaseModel): """文章标签""" + #zf：标签名称字段 name = models.CharField(_('tag name'), max_length=30, unique=True) + #zf：slug字段 slug = models.SlugField(default='no-slug', max_length=60, blank=True) + #zf：字符串表示方法 def __str__(self): return self.name + #zf：获取绝对URL方法 def get_absolute_url(self): return reverse('blog:tag_detail', kwargs={'tag_name': self.slug}) + #zf：获取文章数量方法，使用缓存装饰器缓存10小时 @cache_decorator(60 * 60 * 10) def get_article_count(self): + #zf：统计包含该标签的文章数量 return Article.objects.filter(tags__name=self.name).distinct().count() + #zf：模型元数据 class Meta: - ordering = ['name'] - verbose_name = _('tag') - verbose_name_plural = verbose_name + #zf：按名称升序排列 + ordering = ['name'] + #zf：单数形式显示名称 + verbose_name = _('tag') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name +#zf：定义友情链接模型类 class Links(models.Model): """友情链接""" + #zf：链接名称字段 name = models.CharField(_('link name'), max_length=30, unique=True) + #zf：链接地址字段 link = models.URLField(_('link')) + #zf：排序字段 sequence = models.IntegerField(_('order'), unique=True) + #zf：是否显示字段 is_enable = models.BooleanField( _('is show'), default=True, blank=False, null=False) + #zf：显示类型字段 show_type = models.CharField( _('show type'), max_length=1, choices=LinkShowType.choices, default=LinkShowType.I) + #zf：创建时间字段 creation_time = models.DateTimeField(_('creation time'), default=now) + #zf：最后修改时间字段 last_mod_time = models.DateTimeField(_('modify time'), default=now) + #zf：模型元数据 class Meta: - ordering = ['sequence'] - verbose_name = _('link') - verbose_name_plural = verbose_name - + #zf：按排序字段升序排列 + ordering = ['sequence'] + #zf：单数形式显示名称 + verbose_name = _('link') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name + + #zf：字符串表示方法 def __str__(self): return self.name +#zf：定义侧边栏模型类 class SideBar(models.Model): """侧边栏,可以展示一些html内容""" + #zf：标题字段 name = models.CharField(_('title'), max_length=100) + #zf：内容字段 content = models.TextField(_('content')) + #zf：排序字段 sequence = models.IntegerField(_('order'), unique=True) + #zf：是否启用字段 is_enable = models.BooleanField(_('is enable'), default=True) + #zf：创建时间字段 creation_time = models.DateTimeField(_('creation time'), default=now) + #zf：最后修改时间字段 last_mod_time = models.DateTimeField(_('modify time'), default=now) + #zf：模型元数据 class Meta: - ordering = ['sequence'] - verbose_name = _('sidebar') - verbose_name_plural = verbose_name - + #zf：按排序字段升序排列 + ordering = ['sequence'] + #zf：单数形式显示名称 + verbose_name = _('sidebar') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name + + #zf：字符串表示方法 def __str__(self): return self.name +#zf：定义博客设置模型类 class BlogSettings(models.Model): """blog的配置""" + #zf：网站名称字段 site_name = models.CharField( _('site name'), max_length=200, null=False, blank=False, default='') + #zf：网站描述字段 site_description = models.TextField( _('site description'), max_length=1000, null=False, blank=False, default='') + #zf：网站SEO描述字段 site_seo_description = models.TextField( _('site seo description'), max_length=1000, null=False, blank=False, default='') + #zf：网站关键词字段 site_keywords = models.TextField( _('site keywords'), max_length=1000, null=False, blank=False, default='') + #zf：文章摘要长度字段 article_sub_length = models.IntegerField(_('article sub length'), default=300) + #zf：侧边栏文章数量字段 sidebar_article_count = models.IntegerField(_('sidebar article count'), default=10) + #zf：侧边栏评论数量字段 sidebar_comment_count = models.IntegerField(_('sidebar comment count'), default=5) + #zf：文章页面默认显示评论数量字段 article_comment_count = models.IntegerField(_('article comment count'), default=5) + #zf：是否显示谷歌广告字段 show_google_adsense = models.BooleanField(_('show adsense'), default=False) + #zf：谷歌广告代码字段 google_adsense_codes = models.TextField( _('adsense code'), max_length=2000, null=True, blank=True, default='') + #zf：是否开启网站评论功能字段 open_site_comment = models.BooleanField(_('open site comment'), default=True) + #zf：全局头部内容字段 global_header = models.TextField("公共头部", null=True, blank=True, default='') + #zf：全局尾部内容字段 global_footer = models.TextField("公共尾部", null=True, blank=True, default='') + #zf：备案号字段 beian_code = models.CharField( '备案号', max_length=2000, null=True, blank=True, default='') + #zf：网站统计代码字段 analytics_code = models.TextField( "网站统计代码", max_length=1000, null=False, blank=False, default='') + #zf：是否显示公安备案号字段 show_gongan_code = models.BooleanField( '是否显示公安备案号', default=False, null=False) + #zf：公安备案号字段 gongan_beiancode = models.TextField( '公安备案号', max_length=2000, null=True, blank=True, default='') + #zf：评论是否需要审核字段 comment_need_review = models.BooleanField( '评论是否需要审核', default=False, null=False) + #zf：模型元数据 class Meta: - verbose_name = _('Website configuration') - verbose_name_plural = verbose_name + #zf：单数形式显示名称 + verbose_name = _('Website configuration') + #zf：复数形式显示名称 + verbose_name_plural = verbose_name + #zf：字符串表示方法 def __str__(self): return self.site_name + #zf：数据验证方法 def clean(self): + #zf：检查是否已存在其他配置记录 if BlogSettings.objects.exclude(id=self.id).count(): + #zf：如果已存在其他配置记录，抛出验证错误 raise ValidationError(_('There can only be one configuration')) + #zf：保存方法 def save(self, *args, **kwargs): + #zf：调用父类的保存方法 super().save(*args, **kwargs) + #zf：导入缓存工具 from djangoblog.utils import cache - cache.clear() + #zf：清除所有缓存 + cache.clear() \ No newline at end of file diff --git a/src/DjangoBlog/blog/search_indexes.py b/src/DjangoBlog/blog/search_indexes.py index 7f1dfac..3b3b024 100644 --- a/src/DjangoBlog/blog/search_indexes.py +++ b/src/DjangoBlog/blog/search_indexes.py @@ -1,13 +1,21 @@ +#zf:从haystack导入索引相关模块 from haystack import indexes +#zf:从blog.models导入Article模型 from blog.models import Article +#zf:定义文章索引类，继承自SearchIndex和Indexable class ArticleIndex(indexes.SearchIndex, indexes.Indexable): + #zf:定义文本字段，作为文档字段，使用模板来确定索引内容 text = indexes.CharField(document=True, use_template=True) + #zf:获取模型类的方法 def get_model(self): + #zf:返回Article模型 return Article + #zf:定义索引查询集，确定哪些数据会被索引 def index_queryset(self, using=None): - return self.get_model().objects.filter(status='p') + #zf:返回所有状态为已发布('p')的文章 + return self.get_model().objects.filter(status='p') \ No newline at end of file diff --git a/src/DjangoBlog/blog/tests.py b/src/DjangoBlog/blog/tests.py index ee13505..5aef939 100644 --- a/src/DjangoBlog/blog/tests.py +++ b/src/DjangoBlog/blog/tests.py @@ -1,232 +1,406 @@ +#zf:导入操作系统相关模块 import os +#zf:从django.conf导入settings配置 from django.conf import settings +#zf:从django.core.files.uploadedfile导入SimpleUploadedFile用于文件上传测试 from django.core.files.uploadedfile import SimpleUploadedFile +#zf:从django.core.management导入call_command用于调用管理命令 from django.core.management import call_command +#zf:从django.core.paginator导入Paginator用于分页测试 from django.core.paginator import Paginator +#zf:从django.templatetags.static导入static用于静态文件处理 from django.templatetags.static import static +#zf:从django.test导入Client, RequestFactory, TestCase用于测试 from django.test import Client, RequestFactory, TestCase +#zf:从django.urls导入reverse用于URL反向解析 from django.urls import reverse +#zf:从django.utils导入timezone用于时间处理 from django.utils import timezone +#zf:从accounts.models导入BlogUser用户模型 from accounts.models import BlogUser +#zf:从blog.forms导入BlogSearchForm搜索表单 from blog.forms import BlogSearchForm +#zf:从blog.models导入Article, Category, Tag, SideBar, Links模型 from blog.models import Article, Category, Tag, SideBar, Links +#zf:从blog.templatetags.blog_tags导入load_pagination_info, load_articletags模板标签 from blog.templatetags.blog_tags import load_pagination_info, load_articletags +#zf:从djangoblog.utils导入get_current_site, get_sha256工具函数 from djangoblog.utils import get_current_site, get_sha256 +#zf:从oauth.models导入OAuthUser, OAuthConfig OAuth相关模型 from oauth.models import OAuthUser, OAuthConfig -# Create your tests here. +#zf:创建你的测试用例 +#zf:定义文章测试类，继承自TestCase class ArticleTest(TestCase): + #zf:测试初始化方法 def setUp(self): + #zf:创建测试客户端 self.client = Client() + #zf:创建请求工厂 self.factory = RequestFactory() + #zf:测试验证文章功能 def test_validate_article(self): + #zf:获取当前站点域名 site = get_current_site().domain + #zf:创建或获取测试用户 user = BlogUser.objects.get_or_create( email="liangliangyy@gmail.com", username="liangliangyy")[0] + #zf:设置用户密码 user.set_password("liangliangyy") + #zf:设置用户为职员 user.is_staff = True + #zf:设置用户为超级用户 user.is_superuser = True + #zf:保存用户 user.save() + #zf:测试获取用户绝对URL response = self.client.get(user.get_absolute_url()) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试访问管理后台日志页面 response = self.client.get('/admin/servermanager/emailsendlog/') + #zf:测试访问管理后台日志条目页面 response = self.client.get('admin/admin/logentry/') + #zf:创建侧边栏对象 s = SideBar() + #zf:设置侧边栏排序 s.sequence = 1 + #zf:设置侧边栏名称 s.name = 'test' + #zf:设置侧边栏内容 s.content = 'test content' + #zf:设置侧边栏启用状态 s.is_enable = True + #zf:保存侧边栏 s.save() + #zf:创建分类对象 category = Category() + #zf:设置分类名称 category.name = "category" + #zf:设置分类创建时间 category.creation_time = timezone.now() + #zf:设置分类最后修改时间 category.last_mod_time = timezone.now() + #zf:保存分类 category.save() + #zf:创建标签对象 tag = Tag() + #zf:设置标签名称 tag.name = "nicetag" + #zf:保存标签 tag.save() + #zf:创建文章对象 article = Article() + #zf:设置文章标题 article.title = "nicetitle" + #zf:设置文章正文 article.body = "nicecontent" + #zf:设置文章作者 article.author = user + #zf:设置文章分类 article.category = category + #zf:设置文章类型 article.type = 'a' + #zf:设置文章状态 article.status = 'p' + #zf:保存文章 article.save() + #zf:断言文章标签数量为0 self.assertEqual(0, article.tags.count()) + #zf:给文章添加标签 article.tags.add(tag) + #zf:保存文章 article.save() + #zf:断言文章标签数量为1 self.assertEqual(1, article.tags.count()) + #zf:循环创建20篇文章用于测试 for i in range(20): article = Article() + #zf:设置文章标题 article.title = "nicetitle" + str(i) + #zf:设置文章正文 article.body = "nicetitle" + str(i) + #zf:设置文章作者 article.author = user + #zf:设置文章分类 article.category = category + #zf:设置文章类型 article.type = 'a' + #zf:设置文章状态 article.status = 'p' + #zf:保存文章 article.save() + #zf:给文章添加标签 article.tags.add(tag) + #zf:保存文章 article.save() + #zf:从blog.documents导入ELASTICSEARCH_ENABLED常量 from blog.documents import ELASTICSEARCH_ENABLED + #zf:如果启用了Elasticsearch if ELASTICSEARCH_ENABLED: + #zf:调用构建索引命令 call_command("build_index") + #zf:测试搜索功能 response = self.client.get('/search', {'q': 'nicetitle'}) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试获取文章绝对URL response = self.client.get(article.get_absolute_url()) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:从djangoblog.spider_notify导入SpiderNotify from djangoblog.spider_notify import SpiderNotify + #zf:通知搜索引擎爬虫 SpiderNotify.notify(article.get_absolute_url()) + #zf:测试获取标签绝对URL response = self.client.get(tag.get_absolute_url()) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试获取分类绝对URL response = self.client.get(category.get_absolute_url()) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试搜索功能 response = self.client.get('/search', {'q': 'django'}) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:加载文章标签 s = load_articletags(article) + #zf:断言结果不为None self.assertIsNotNone(s) + #zf:用户登录 self.client.login(username='liangliangyy', password='liangliangyy') + #zf:测试获取归档页面 response = self.client.get(reverse('blog:archives')) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:创建所有文章的分页器 p = Paginator(Article.objects.all(), settings.PAGINATE_BY) + #zf:检查分页功能 self.check_pagination(p, '', '') + #zf:创建按标签筛选文章的分页器 p = Paginator(Article.objects.filter(tags=tag), settings.PAGINATE_BY) + #zf:检查分页功能，类型为分类标签归档 self.check_pagination(p, '分类标签归档', tag.slug) + #zf:创建按作者筛选文章的分页器 p = Paginator( Article.objects.filter( author__username='liangliangyy'), settings.PAGINATE_BY) + #zf:检查分页功能，类型为作者文章归档 self.check_pagination(p, '作者文章归档', 'liangliangyy') + #zf:创建按分类筛选文章的分页器 p = Paginator(Article.objects.filter(category=category), settings.PAGINATE_BY) + #zf:检查分页功能，类型为分类目录归档 self.check_pagination(p, '分类目录归档', category.slug) + #zf:创建博客搜索表单实例 f = BlogSearchForm() + #zf:执行搜索 f.search() - # self.client.login(username='liangliangyy', password='liangliangyy') + #zf:从djangoblog.spider_notify导入SpiderNotify from djangoblog.spider_notify import SpiderNotify + #zf:通知百度搜索引擎 SpiderNotify.baidu_notify([article.get_full_url()]) + #zf:从blog.templatetags.blog_tags导入gravatar_url, gravatar from blog.templatetags.blog_tags import gravatar_url, gravatar + #zf:获取gravatar头像URL u = gravatar_url('liangliangyy@gmail.com') + #zf:获取gravatar头像 u = gravatar('liangliangyy@gmail.com') + #zf:创建链接对象 link = Links( sequence=1, name="lylinux", link='https://wwww.lylinux.net') + #zf:保存链接 link.save() + #zf:测试获取链接页面 response = self.client.get('/links.html') + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试获取RSS订阅页面 response = self.client.get('/feed/') + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试获取站点地图 response = self.client.get('/sitemap.xml') + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试删除文章 self.client.get("/admin/blog/article/1/delete/") + #zf:测试访问管理后台日志页面 self.client.get('/admin/servermanager/emailsendlog/') + #zf:测试访问管理后台日志条目页面 self.client.get('/admin/admin/logentry/') + #zf:测试访问管理后台日志条目修改页面 self.client.get('/admin/admin/logentry/1/change/') + #zf:检查分页功能的方法 def check_pagination(self, p, type, value): + #zf:遍历所有页面 for page in range(1, p.num_pages + 1): + #zf:加载分页信息 s = load_pagination_info(p.page(page), type, value) + #zf:断言结果不为None self.assertIsNotNone(s) + #zf:如果有上一页URL if s['previous_url']: + #zf:测试访问上一页 response = self.client.get(s['previous_url']) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:如果有下一页URL if s['next_url']: + #zf:测试访问下一页 response = self.client.get(s['next_url']) + #zf:断言响应状态码为200 self.assertEqual(response.status_code, 200) + #zf:测试图片上传功能 def test_image(self): + #zf:导入requests模块 import requests + #zf:获取Python官网Logo图片 rsp = requests.get( 'https://www.python.org/static/img/python-logo.png') + #zf:设置图片保存路径 imagepath = os.path.join(settings.BASE_DIR, 'python.png') + #zf:将图片保存到本地 with open(imagepath, 'wb') as file: file.write(rsp.content) + #zf:测试未登录上传图片 rsp = self.client.post('/upload') + #zf:断言响应状态码为403(禁止访问) self.assertEqual(rsp.status_code, 403) + #zf:生成上传签名 sign = get_sha256(get_sha256(settings.SECRET_KEY)) + #zf:打开图片文件 with open(imagepath, 'rb') as file: + #zf:创建上传文件对象 imgfile = SimpleUploadedFile( 'python.png', file.read(), content_type='image/jpg') + #zf:构造表单数据 form_data = {'python.png': imgfile} + #zf:测试带签名上传图片 rsp = self.client.post( '/upload?sign=' + sign, form_data, follow=True) + #zf:断言响应状态码为200 self.assertEqual(rsp.status_code, 200) + #zf:删除临时图片文件 os.remove(imagepath) + #zf:从djangoblog.utils导入save_user_avatar, send_email工具函数 from djangoblog.utils import save_user_avatar, send_email + #zf:测试发送邮件 send_email(['qq@qq.com'], 'testTitle', 'testContent') + #zf:测试保存用户头像 save_user_avatar( 'https://www.python.org/static/img/python-logo.png') + #zf:测试错误页面 def test_errorpage(self): + #zf:测试访问不存在的页面 rsp = self.client.get('/eee') + #zf:断言响应状态码为404 self.assertEqual(rsp.status_code, 404) + #zf:测试管理命令 def test_commands(self): + #zf:创建或获取测试用户 user = BlogUser.objects.get_or_create( email="liangliangyy@gmail.com", username="liangliangyy")[0] + #zf:设置用户密码 user.set_password("liangliangyy") + #zf:设置用户为职员 user.is_staff = True + #zf:设置用户为超级用户 user.is_superuser = True + #zf:保存用户 user.save() + #zf:创建OAuth配置对象 c = OAuthConfig() + #zf:设置OAuth类型 c.type = 'qq' + #zf:设置应用密钥 c.appkey = 'appkey' + #zf:设置应用密钥 c.appsecret = 'appsecret' + #zf:保存配置 c.save() + #zf:创建OAuth用户对象 u = OAuthUser() + #zf:设置OAuth类型 u.type = 'qq' + #zf:设置openid u.openid = 'openid' + #zf:关联用户 u.user = user + #zf:设置头像 u.picture = static("/blog/img/avatar.png") + #zf:设置元数据 u.metadata = ''' { "figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30" }''' + #zf:保存OAuth用户 u.save() + #zf:创建另一个OAuth用户对象 u = OAuthUser() + #zf:设置OAuth类型 u.type = 'qq' + #zf:设置openid u.openid = 'openid1' + #zf:设置头像URL u.picture = 'https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30' + #zf:设置元数据 u.metadata = ''' { "figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30" }''' + #zf:保存OAuth用户 u.save() + #zf:从blog.documents导入ELASTICSEARCH_ENABLED常量 from blog.documents import ELASTICSEARCH_ENABLED + #zf:如果启用了Elasticsearch if ELASTICSEARCH_ENABLED: + #zf:调用构建索引命令 call_command("build_index") + #zf:调用通知百度搜索引擎命令 call_command("ping_baidu", "all") + #zf:调用创建测试数据命令 call_command("create_testdata") + #zf:调用清除缓存命令 call_command("clear_cache") + #zf:调用同步用户头像命令 call_command("sync_user_avatar") - call_command("build_search_words") + #zf:调用构建搜索词命令 + call_command("build_search_words") \ No newline at end of file diff --git a/src/DjangoBlog/blog/urls.py b/src/DjangoBlog/blog/urls.py index adf2703..763d82b 100644 --- a/src/DjangoBlog/blog/urls.py +++ b/src/DjangoBlog/blog/urls.py @@ -1,62 +1,406 @@ -from django.urls import path -from django.views.decorators.cache import cache_page - -from . import views - -app_name = "blog" -urlpatterns = [ - path( - r'', - views.IndexView.as_view(), - name='index'), - path( - r'page/Thank you very much for your comments on this site
You can visit %(article_title)s to review your comments, @@ -19,10 +25,14 @@ def send_comment_email(comment):