devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于Python+Djingo实现个人博客系统_基于python的个人博客系统

作者：笔触狂放9 | 2024-06-22 11:54:15

赞

踩

基于python的个人博客系统

作者主页：编程指南针

作者简介：Java领域优质创作者、CSDN博客专家 、掘金特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

主要内容：Java项目、简历模板、学习资料、面试题库、技术互助

收藏点赞不迷路  关注作者有好处

文末获取源码 

项目编号：BS-Python-007

一，环境介绍

语言环境：Python3.8  Django4.2.1

数据库：Mysql: mysql5.7

开发工具：IDEA

前端技术：HTML+CSS+JS

二，项目简介

主要功能：

- 文章，页面，分类目录，标签的添加，删除，编辑等。文章、评论及页面支持`Markdown`，支持代码高亮。

- 支持文章全文搜索。

- 完整的评论功能，包括发表回复评论，以及评论的邮件提醒，支持`Markdown`。

- 侧边栏功能，最新文章，最多阅读，标签云等。

- 支持Oauth登陆，现已有Google,GitHub,facebook,微博,QQ登录。

- 支持`Redis`缓存，支持缓存自动刷新。

- 简单的SEO功能，新建文章等会自动通知Google和百度。

- 集成了简单的图床功能。

- 集成`django-compressor`，自动压缩`css`，`js`。

- 网站异常邮件提醒，若有未捕捉到的异常会自动发送提醒邮件。

- 集成了微信公众号功能，现在可以使用微信公众号来管理你的vps了。

系统的用户可以分为两类，前端用户和后台管理用户，用户的权限可以在后台由管理员进行管理设定。系统功能相对比较完整，包含了用户管理、博文分类管理、博文管理、标签管理、评论管理、友情连接管理、侧边栏管理、第三方授权登录管理等等

三，系统展示

系统首页

前端用户登录

博客详情

文档归类

后台管理

用户管理

分类管理

文章管理

标签管理

网站配置

评论管理

四，核心代码展示

  1. from django.contrib.admin import AdminSite
  2. from django.contrib.admin.models import LogEntry
  3. from django.contrib.sites.admin import SiteAdmin
  4. from django.contrib.sites.models import Site
  5.  
  6. from accounts.admin import *
  7. from blog.admin import *
  8. from blog.models import *
  9. from comments.admin import *
  10. from comments.models import *
  11. from djangoblog.logentryadmin import LogEntryAdmin
  12. from oauth.admin import *
  13. from oauth.models import *
  14. from owntracks.admin import *
  15. from owntracks.models import *
  16. from servermanager.admin import *
  17. from servermanager.models import *
  18.  
  19.  
  20. class DjangoBlogAdminSite(AdminSite):
  21.     site_header = 'Python博客后台管理'
  22.     site_title = '后台管理'
  23.  
  24.     def __init__(self, name='admin'):
  25.         super().__init__(name)
  26.  
  27.     def has_permission(self, request):
  28.         return request.user.is_superuser
  29.  
  30.     # def get_urls(self):
  31.     #     urls = super().get_urls()
  32.     #     from django.urls import path
  33.     #     from blog.views import refresh_memcache
  34.     #
  35.     #     my_urls = [
  36.     #         path('refresh/', self.admin_view(refresh_memcache), name="refresh"),
  37.     #     ]
  38.     #     return urls + my_urls
  39.  
  40.  
  41. admin_site = DjangoBlogAdminSite(name='admin')
  42.  
  43. admin_site.register(Article, ArticlelAdmin)
  44. admin_site.register(Category, CategoryAdmin)
  45. admin_site.register(Tag, TagAdmin)
  46. admin_site.register(Links, LinksAdmin)
  47. admin_site.register(SideBar, SideBarAdmin)
  48. admin_site.register(BlogSettings, BlogSettingsAdmin)
  49.  
  50. admin_site.register(commands, CommandsAdmin)
  51. admin_site.register(EmailSendLog, EmailSendLogAdmin)
  52.  
  53. admin_site.register(BlogUser, BlogUserAdmin)
  54.  
  55. admin_site.register(Comment, CommentAdmin)
  56.  
  57. admin_site.register(OAuthUser, OAuthUserAdmin)
  58. admin_site.register(OAuthConfig, OAuthConfigAdmin)
  59.  
  60. admin_site.register(OwnTrackLog, OwnTrackLogsAdmin)
  61.  
  62. admin_site.register(Site, SiteAdmin)
  63.  
  64. admin_site.register(LogEntry, LogEntryAdmin)

  1. from django.contrib import admin
  2. from django.contrib.admin.models import LogEntry, ADDITION, CHANGE, DELETION
  3. from django.contrib.contenttypes.models import ContentType
  4. from django.urls import reverse, NoReverseMatch
  5. from django.utils.encoding import force_str
  6. from django.utils.html import escape
  7. from django.utils.safestring import mark_safe
  8. from django.utils.translation import pgettext_lazy, gettext_lazy  as _
  9.  
  10. action_names = {
  11.     ADDITION: pgettext_lazy('logentry_admin:action_type', 'Addition'),
  12.     DELETION: pgettext_lazy('logentry_admin:action_type', 'Deletion'),
  13.     CHANGE: pgettext_lazy('logentry_admin:action_type', 'Change'),
  14. }
  15.  
  16.  
  17. class LogEntryAdmin(admin.ModelAdmin):
  18.     date_hierarchy = 'action_time'
  19.  
  20.     readonly_fields = ([f.name for f in LogEntry._meta.fields] +
  21.                        ['object_link', 'action_description', 'user_link',
  22.                         'get_change_message'])
  23.  
  24.     fieldsets = (
  25.         (_('Metadata'), {
  26.             'fields': (
  27.                 'action_time',
  28.                 'user_link',
  29.                 'action_description',
  30.                 'object_link',
  31.             )
  32.         }),
  33.         (_('Details'), {
  34.             'fields': (
  35.                 'get_change_message',
  36.                 'content_type',
  37.                 'object_id',
  38.                 'object_repr',
  39.             )
  40.         }),
  41.     )
  42.  
  43.     list_filter = [
  44.         'content_type'
  45.     ]
  46.  
  47.     search_fields = [
  48.         'object_repr',
  49.         'change_message'
  50.     ]
  51.  
  52.     list_display_links = [
  53.         'action_time',
  54.         'get_change_message',
  55.     ]
  56.     list_display = [
  57.         'action_time',
  58.         'user_link',
  59.         'content_type',
  60.         'object_link',
  61.         'action_description',
  62.         'get_change_message',
  63.     ]
  64.  
  65.     def has_add_permission(self, request):
  66.         return False
  67.  
  68.     def has_change_permission(self, request, obj=None):
  69.         return (
  70.                        request.user.is_superuser or
  71.                        request.user.has_perm('admin.change_logentry')
  72.                ) and request.method != 'POST'
  73.  
  74.     def has_delete_permission(self, request, obj=None):
  75.         return False
  76.  
  77.     def object_link(self, obj):
  78.         object_link = escape(obj.object_repr)
  79.         content_type = obj.content_type
  80.  
  81.         if obj.action_flag != DELETION and content_type is not None:
  82.             # try returning an actual link instead of object repr string
  83.             try:
  84.                 url = reverse(
  85.                     'admin:{}_{}_change'.format(content_type.app_label,
  86.                                                 content_type.model),
  87.                     args=[obj.object_id]
  88.                 )
  89.                 object_link = '<a href="{}">{}</a>'.format(url, object_link)
  90.             except NoReverseMatch:
  91.                 pass
  92.         return mark_safe(object_link)
  93.  
  94.     object_link.admin_order_field = 'object_repr'
  95.     object_link.short_description = _('object')
  96.  
  97.     def user_link(self, obj):
  98.         content_type = ContentType.objects.get_for_model(type(obj.user))
  99.         user_link = escape(force_str(obj.user))
  100.         try:
  101.             # try returning an actual link instead of object repr string
  102.             url = reverse(
  103.                 'admin:{}_{}_change'.format(content_type.app_label,
  104.                                             content_type.model),
  105.                 args=[obj.user.pk]
  106.             )
  107.             user_link = '<a href="{}">{}</a>'.format(url, user_link)
  108.         except NoReverseMatch:
  109.             pass
  110.         return mark_safe(user_link)
  111.  
  112.     user_link.admin_order_field = 'user'
  113.     user_link.short_description = _('user')
  114.  
  115.     def get_queryset(self, request):
  116.         queryset = super(LogEntryAdmin, self).get_queryset(request)
  117.         return queryset.prefetch_related('content_type')
  118.  
  119.     def get_actions(self, request):
  120.         actions = super(LogEntryAdmin, self).get_actions(request)
  121.         if 'delete_selected' in actions:
  122.             del actions['delete_selected']
  123.         return actions
  124.  
  125.     def action_description(self, obj):
  126.         return action_names[obj.action_flag]
  127.  
  128.     action_description.short_description = _('action')
  129.  
  130.     def get_change_message(self, obj):
  131.         return obj.get_change_message()
  132.  
  133.     get_change_message.short_description = _('change message')
  1. # encoding: utf-8
  2.  
  3. from __future__ import absolute_import, division, print_function, unicode_literals
  4.  
  5. import json
  6. import os
  7. import re
  8. import shutil
  9. import threading
  10. import warnings
  11.  
  12. import six
  13. from django.conf import settings
  14. from django.core.exceptions import ImproperlyConfigured
  15. from django.utils.datetime_safe import datetime
  16. from django.utils.encoding import force_str
  17. from haystack.backends import BaseEngine, BaseSearchBackend, BaseSearchQuery, EmptyResults, log_query
  18. from haystack.constants import DJANGO_CT, DJANGO_ID, ID
  19. from haystack.exceptions import MissingDependency, SearchBackendError, SkipDocument
  20. from haystack.inputs import Clean, Exact, PythonData, Raw
  21. from haystack.models import SearchResult
  22. from haystack.utils import get_identifier, get_model_ct
  23. from haystack.utils import log as logging
  24. from haystack.utils.app_loading import haystack_get_model
  25. from jieba.analyse import ChineseAnalyzer
  26. from whoosh import index
  27. from whoosh.analysis import StemmingAnalyzer
  28. from whoosh.fields import BOOLEAN, DATETIME, IDLIST, KEYWORD, NGRAM, NGRAMWORDS, NUMERIC, Schema, TEXT
  29. from whoosh.fields import ID as WHOOSH_ID
  30. from whoosh.filedb.filestore import FileStorage, RamStorage
  31. from whoosh.highlight import ContextFragmenter, HtmlFormatter
  32. from whoosh.highlight import highlight as whoosh_highlight
  33. from whoosh.qparser import QueryParser
  34. from whoosh.searching import ResultsPage
  35. from whoosh.writing import AsyncWriter
  36.  
  37. try:
  38.     import whoosh
  39. except ImportError:
  40.     raise MissingDependency(
  41.         "The 'whoosh' backend requires the installation of 'Whoosh'. Please refer to the documentation.")
  42.  
  43. # Handle minimum requirement.
  44. if not hasattr(whoosh, '__version__') or whoosh.__version__ < (2, 5, 0):
  45.     raise MissingDependency(
  46.         "The 'whoosh' backend requires version 2.5.0 or greater.")
  47.  
  48. # Bubble up the correct error.
  49.  
  50. DATETIME_REGEX = re.compile(
  51.     '^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})T(?P<hour>\d{2}):(?P<minute>\d{2}):(?P<second>\d{2})(\.\d{3,6}Z?)?$')
  52. LOCALS = threading.local()
  53. LOCALS.RAM_STORE = None
  54.  
  55.  
  56. class WhooshHtmlFormatter(HtmlFormatter):
  57.     """
  58.     This is a HtmlFormatter simpler than the whoosh.HtmlFormatter.
  59.     We use it to have consistent results across backends. Specifically,
  60.     Solr, Xapian and Elasticsearch are using this formatting.
  61.     """
  62.     template = '<%(tag)s>%(t)s</%(tag)s>'
  63.  
  64.  
  65. class WhooshSearchBackend(BaseSearchBackend):
  66.     # Word reserved by Whoosh for special use.
  67.     RESERVED_WORDS = (
  68.         'AND',
  69.         'NOT',
  70.         'OR',
  71.         'TO',
  72.     )
  73.  
  74.     # Characters reserved by Whoosh for special use.
  75.     # The '\\' must come first, so as not to overwrite the other slash
  76.     # replacements.
  77.     RESERVED_CHARACTERS = (
  78.         '\\', '+', '-', '&&', '||', '!', '(', ')', '{', '}',
  79.         '[', ']', '^', '"', '~', '*', '?', ':', '.',
  80.     )
  81.  
  82.     def __init__(self, connection_alias, **connection_options):
  83.         super(
  84.             WhooshSearchBackend,
  85.             self).__init__(
  86.             connection_alias,
  87.             **connection_options)
  88.         self.setup_complete = False
  89.         self.use_file_storage = True
  90.         self.post_limit = getattr(
  91.             connection_options,
  92.             'POST_LIMIT',
  93.             128 * 1024 * 1024)
  94.         self.path = connection_options.get('PATH')
  95.  
  96.         if connection_options.get('STORAGE', 'file') != 'file':
  97.             self.use_file_storage = False
  98.  
  99.         if self.use_file_storage and not self.path:
  100.             raise ImproperlyConfigured(
  101.                 "You must specify a 'PATH' in your settings for connection '%s'." %
  102.                 connection_alias)
  103.  
  104.         self.log = logging.getLogger('haystack')
  105.  
  106.     def setup(self):
  107.         """
  108.         Defers loading until needed.
  109.         """
  110.         from haystack import connections
  111.         new_index = False
  112.  
  113.         # Make sure the index is there.
  114.         if self.use_file_storage and not os.path.exists(self.path):
  115.             os.makedirs(self.path)
  116.             new_index = True
  117.  
  118.         if self.use_file_storage and not os.access(self.path, os.W_OK):
  119.             raise IOError(
  120.                 "The path to your Whoosh index '%s' is not writable for the current user/group." %
  121.                 self.path)
  122.  
  123.         if self.use_file_storage:
  124.             self.storage = FileStorage(self.path)
  125.         else:
  126.             global LOCALS
  127.  
  128.             if getattr(LOCALS, 'RAM_STORE', None) is None:
  129.                 LOCALS.RAM_STORE = RamStorage()
  130.  
  131.             self.storage = LOCALS.RAM_STORE
  132.  
  133.         self.content_field_name, self.schema = self.build_schema(
  134.             connections[self.connection_alias].get_unified_index().all_searchfields())
  135.         self.parser = QueryParser(self.content_field_name, schema=self.schema)
  136.  
  137.         if new_index is True:
  138.             self.index = self.storage.create_index(self.schema)
  139.         else:
  140.             try:
  141.                 self.index = self.storage.open_index(schema=self.schema)
  142.             except index.EmptyIndexError:
  143.                 self.index = self.storage.create_index(self.schema)
  144.  
  145.         self.setup_complete = True
  146.  
  147.     def build_schema(self, fields):
  148.         schema_fields = {
  149.             ID: WHOOSH_ID(stored=True, unique=True),
  150.             DJANGO_CT: WHOOSH_ID(stored=True),
  151.             DJANGO_ID: WHOOSH_ID(stored=True),
  152.         }
  153.         # Grab the number of keys that are hard-coded into Haystack.
  154.         # We'll use this to (possibly) fail slightly more gracefully later.
  155.         initial_key_count = len(schema_fields)
  156.         content_field_name = ''
  157.  
  158.         for field_name, field_class in fields.items():
  159.             if field_class.is_multivalued:
  160.                 if field_class.indexed is False:
  161.                     schema_fields[field_class.index_fieldname] = IDLIST(
  162.                         stored=True, field_boost=field_class.boost)
  163.                 else:
  164.                     schema_fields[field_class.index_fieldname] = KEYWORD(
  165.                         stored=True, commas=True, scorable=True, field_boost=field_class.boost)
  166.             elif field_class.field_type in ['date', 'datetime']:
  167.                 schema_fields[field_class.index_fieldname] = DATETIME(
  168.                     stored=field_class.stored, sortable=True)
  169.             elif field_class.field_type == 'integer':
  170.                 schema_fields[field_class.index_fieldname] = NUMERIC(
  171.                     stored=field_class.stored, numtype=int, field_boost=field_class.boost)
  172.             elif field_class.field_type == 'float':
  173.                 schema_fields[field_class.index_fieldname] = NUMERIC(
  174.                     stored=field_class.stored, numtype=float, field_boost=field_class.boost)
  175.             elif field_class.field_type == 'boolean':
  176.                 # Field boost isn't supported on BOOLEAN as of 1.8.2.
  177.                 schema_fields[field_class.index_fieldname] = BOOLEAN(
  178.                     stored=field_class.stored)
  179.             elif field_class.field_type == 'ngram':
  180.                 schema_fields[field_class.index_fieldname] = NGRAM(
  181.                     minsize=3, maxsize=15, stored=field_class.stored, field_boost=field_class.boost)
  182.             elif field_class.field_type == 'edge_ngram':
  183.                 schema_fields[field_class.index_fieldname] = NGRAMWORDS(minsize=2, maxsize=15, at='start',
  184.                                                                         stored=field_class.stored,
  185.                                                                         field_boost=field_class.boost)
  186.             else:
  187.                 # schema_fields[field_class.index_fieldname] = TEXT(stored=True, analyzer=StemmingAnalyzer(), field_boost=field_class.boost, sortable=True)
  188.                 schema_fields[field_class.index_fieldname] = TEXT(
  189.                     stored=True, analyzer=ChineseAnalyzer(), field_boost=field_class.boost, sortable=True)
  190.             if field_class.document is True:
  191.                 content_field_name = field_class.index_fieldname
  192.                 schema_fields[field_class.index_fieldname].spelling = True
  193.  
  194.         # Fail more gracefully than relying on the backend to die if no fields
  195.         # are found.
  196.         if len(schema_fields) <= initial_key_count:
  197.             raise SearchBackendError(
  198.                 "No fields were found in any search_indexes. Please correct this before attempting to search.")
  199.  
  200.         return (content_field_name, Schema(**schema_fields))
  201.  
  202.     def update(self, index, iterable, commit=True):
  203.         if not self.setup_complete:
  204.             self.setup()
  205.  
  206.         self.index = self.index.refresh()
  207.         writer = AsyncWriter(self.index)
  208.  
  209.         for obj in iterable:
  210.             try:
  211.                 doc = index.full_prepare(obj)
  212.             except SkipDocument:
  213.                 self.log.debug(u"Indexing for object `%s` skipped", obj)
  214.             else:
  215.                 # Really make sure it's unicode, because Whoosh won't have it any
  216.                 # other way.
  217.                 for key in doc:
  218.                     doc[key] = self._from_python(doc[key])
  219.  
  220.                 # Document boosts aren't supported in Whoosh 2.5.0+.
  221.                 if 'boost' in doc:
  222.                     del doc['boost']
  223.  
  224.                 try:
  225.                     writer.update_document(**doc)
  226.                 except Exception as e:
  227.                     if not self.silently_fail:
  228.                         raise
  229.  
  230.                     # We'll log the object identifier but won't include the actual object
  231.                     # to avoid the possibility of that generating encoding errors while
  232.                     # processing the log message:
  233.                     self.log.error(
  234.                         u"%s while preparing object for update" %
  235.                         e.__class__.__name__,
  236.                         exc_info=True,
  237.                         extra={
  238.                             "data": {
  239.                                 "index": index,
  240.                                 "object": get_identifier(obj)}})
  241.  
  242.         if len(iterable) > 0:
  243.             # For now, commit no matter what, as we run into locking issues
  244.             # otherwise.
  245.             writer.commit()
  246.  
  247.     def remove(self, obj_or_string, commit=True):
  248.         if not self.setup_complete:
  249.             self.setup()
  250.  
  251.         self.index = self.index.refresh()
  252.         whoosh_id = get_identifier(obj_or_string)
  253.  
  254.         try:
  255.             self.index.delete_by_query(
  256.                 q=self.parser.parse(
  257.                     u'%s:"%s"' %
  258.                     (ID, whoosh_id)))
  259.         except Exception as e:
  260.             if not self.silently_fail:
  261.                 raise
  262.  
  263.             self.log.error(
  264.                 "Failed to remove document '%s' from Whoosh: %s",
  265.                 whoosh_id,
  266.                 e,
  267.                 exc_info=True)
  268.  
  269.     def clear(self, models=None, commit=True):
  270.         if not self.setup_complete:
  271.             self.setup()
  272.  
  273.         self.index = self.index.refresh()
  274.  
  275.         if models is not None:
  276.             assert isinstance(models, (list, tuple))
  277.  
  278.         try:
  279.             if models is None:
  280.                 self.delete_index()
  281.             else:
  282.                 models_to_delete = []
  283.  
  284.                 for model in models:
  285.                     models_to_delete.append(
  286.                         u"%s:%s" %
  287.                         (DJANGO_CT, get_model_ct(model)))
  288.  
  289.                 self.index.delete_by_query(
  290.                     q=self.parser.parse(
  291.                         u" OR ".join(models_to_delete)))
  292.         except Exception as e:
  293.             if not self.silently_fail:
  294.                 raise
  295.  
  296.             if models is not None:
  297.                 self.log.error(
  298.                     "Failed to clear Whoosh index of models '%s': %s",
  299.                     ','.join(models_to_delete),
  300.                     e,
  301.                     exc_info=True)
  302.             else:
  303.                 self.log.error(
  304.                     "Failed to clear Whoosh index: %s", e, exc_info=True)
  305.  
  306.     def delete_index(self):
  307.         # Per the Whoosh mailing list, if wiping out everything from the index,
  308.         # it's much more efficient to simply delete the index files.
  309.         if self.use_file_storage and os.path.exists(self.path):
  310.             shutil.rmtree(self.path)
  311.         elif not self.use_file_storage:
  312.             self.storage.clean()
  313.  
  314.         # Recreate everything.
  315.         self.setup()
  316.  
  317.     def optimize(self):
  318.         if not self.setup_complete:
  319.             self.setup()
  320.  
  321.         self.index = self.index.refresh()
  322.         self.index.optimize()
  323.  
  324.     def calculate_page(self, start_offset=0, end_offset=None):
  325.         # Prevent against Whoosh throwing an error. Requires an end_offset
  326.         # greater than 0.
  327.         if end_offset is not None and end_offset <= 0:
  328.             end_offset = 1
  329.  
  330.         # Determine the page.
  331.         page_num = 0
  332.  
  333.         if end_offset is None:
  334.             end_offset = 1000000
  335.  
  336.         if start_offset is None:
  337.             start_offset = 0
  338.  
  339.         page_length = end_offset - start_offset
  340.  
  341.         if page_length and page_length > 0:
  342.             page_num = int(start_offset / page_length)
  343.  
  344.         # Increment because Whoosh uses 1-based page numbers.
  345.         page_num += 1
  346.         return page_num, page_length
  347.  
  348.     @log_query
  349.     def search(
  350.             self,
  351.             query_string,
  352.             sort_by=None,
  353.             start_offset=0,
  354.             end_offset=None,
  355.             fields='',
  356.             highlight=False,
  357.             facets=None,
  358.             date_facets=None,
  359.             query_facets=None,
  360.             narrow_queries=None,
  361.             spelling_query=None,
  362.             within=None,
  363.             dwithin=None,
  364.             distance_point=None,
  365.             models=None,
  366.             limit_to_registered_models=None,
  367.             result_class=None,
  368.             **kwargs):
  369.         if not self.setup_complete:
  370.             self.setup()
  371.  
  372.         # A zero length query should return no results.
  373.         if len(query_string) == 0:
  374.             return {
  375.                 'results': [],
  376.                 'hits': 0,
  377.             }
  378.  
  379.         query_string = force_str(query_string)
  380.  
  381.         # A one-character query (non-wildcard) gets nabbed by a stopwords
  382.         # filter and should yield zero results.
  383.         if len(query_string) <= 1 and query_string != u'*':
  384.             return {
  385.                 'results': [],
  386.                 'hits': 0,
  387.             }
  388.  
  389.         reverse = False
  390.  
  391.         if sort_by is not None:
  392.             # Determine if we need to reverse the results and if Whoosh can
  393.             # handle what it's being asked to sort by. Reversing is an
  394.             # all-or-nothing action, unfortunately.
  395.             sort_by_list = []
  396.             reverse_counter = 0
  397.  
  398.             for order_by in sort_by:
  399.                 if order_by.startswith('-'):
  400.                     reverse_counter += 1
  401.  
  402.             if reverse_counter and reverse_counter != len(sort_by):
  403.                 raise SearchBackendError("Whoosh requires all order_by fields"
  404.                                          " to use the same sort direction")
  405.  
  406.             for order_by in sort_by:
  407.                 if order_by.startswith('-'):
  408.                     sort_by_list.append(order_by[1:])
  409.  
  410.                     if len(sort_by_list) == 1:
  411.                         reverse = True
  412.                 else:
  413.                     sort_by_list.append(order_by)
  414.  
  415.                     if len(sort_by_list) == 1:
  416.                         reverse = False
  417.  
  418.             sort_by = sort_by_list[0]
  419.  
  420.         if facets is not None:
  421.             warnings.warn(
  422.                 "Whoosh does not handle faceting.",
  423.                 Warning,
  424.                 stacklevel=2)
  425.  
  426.         if date_facets is not None:
  427.             warnings.warn(
  428.                 "Whoosh does not handle date faceting.",
  429.                 Warning,
  430.                 stacklevel=2)
  431.  
  432.         if query_facets is not None:
  433.             warnings.warn(
  434.                 "Whoosh does not handle query faceting.",
  435.                 Warning,
  436.                 stacklevel=2)
  437.  
  438.         narrowed_results = None
  439.         self.index = self.index.refresh()
  440.  
  441.         if limit_to_registered_models is None:
  442.             limit_to_registered_models = getattr(
  443.                 settings, 'HAYSTACK_LIMIT_TO_REGISTERED_MODELS', True)
  444.  
  445.         if models and len(models):
  446.             model_choices = sorted(get_model_ct(model) for model in models)
  447.         elif limit_to_registered_models:
  448.             # Using narrow queries, limit the results to only models handled
  449.             # with the current routers.
  450.             model_choices = self.build_models_list()
  451.         else:
  452.             model_choices = []
  453.  
  454.         if len(model_choices) > 0:
  455.             if narrow_queries is None:
  456.                 narrow_queries = set()
  457.  
  458.             narrow_queries.add(' OR '.join(
  459.                 ['%s:%s' % (DJANGO_CT, rm) for rm in model_choices]))
  460.  
  461.         narrow_searcher = None
  462.  
  463.         if narrow_queries is not None:
  464.             # Potentially expensive? I don't see another way to do it in
  465.             # Whoosh...
  466.             narrow_searcher = self.index.searcher()
  467.  
  468.             for nq in narrow_queries:
  469.                 recent_narrowed_results = narrow_searcher.search(
  470.                     self.parser.parse(force_str(nq)), limit=None)
  471.  
  472.                 if len(recent_narrowed_results) <= 0:
  473.                     return {
  474.                         'results': [],
  475.                         'hits': 0,
  476.                     }
  477.  
  478.                 if narrowed_results:
  479.                     narrowed_results.filter(recent_narrowed_results)
  480.                 else:
  481.                     narrowed_results = recent_narrowed_results
  482.  
  483.         self.index = self.index.refresh()
  484.  
  485.         if self.index.doc_count():
  486.             searcher = self.index.searcher()
  487.             parsed_query = self.parser.parse(query_string)
  488.  
  489.             # In the event of an invalid/stopworded query, recover gracefully.
  490.             if parsed_query is None:
  491.                 return {
  492.                     'results': [],
  493.                     'hits': 0,
  494.                 }
  495.  
  496.             page_num, page_length = self.calculate_page(
  497.                 start_offset, end_offset)
  498.  
  499.             search_kwargs = {
  500.                 'pagelen': page_length,
  501.                 'sortedby': sort_by,
  502.                 'reverse': reverse,
  503.             }
  504.  
  505.             # Handle the case where the results have been narrowed.
  506.             if narrowed_results is not None:
  507.                 search_kwargs['filter'] = narrowed_results
  508.  
  509.             try:
  510.                 raw_page = searcher.search_page(
  511.                     parsed_query,
  512.                     page_num,
  513.                     **search_kwargs
  514.                 )
  515.             except ValueError:
  516.                 if not self.silently_fail:
  517.                     raise
  518.  
  519.                 return {
  520.                     'results': [],
  521.                     'hits': 0,
  522.                     'spelling_suggestion': None,
  523.                 }
  524.  
  525.             # Because as of Whoosh 2.5.1, it will return the wrong page of
  526.             # results if you request something too high. :(
  527.             if raw_page.pagenum < page_num:
  528.                 return {
  529.                     'results': [],
  530.                     'hits': 0,
  531.                     'spelling_suggestion': None,
  532.                 }
  533.  
  534.             results = self._process_results(
  535.                 raw_page,
  536.                 highlight=highlight,
  537.                 query_string=query_string,
  538.                 spelling_query=spelling_query,
  539.                 result_class=result_class)
  540.             searcher.close()
  541.  
  542.             if hasattr(narrow_searcher, 'close'):
  543.                 narrow_searcher.close()
  544.  
  545.             return results
  546.         else:
  547.             if self.include_spelling:
  548.                 if spelling_query:
  549.                     spelling_suggestion = self.create_spelling_suggestion(
  550.                         spelling_query)
  551.                 else:
  552.                     spelling_suggestion = self.create_spelling_suggestion(
  553.                         query_string)
  554.             else:
  555.                 spelling_suggestion = None
  556.  
  557.             return {
  558.                 'results': [],
  559.                 'hits': 0,
  560.                 'spelling_suggestion': spelling_suggestion,
  561.             }
  562.  
  563.     def more_like_this(
  564.             self,
  565.             model_instance,
  566.             additional_query_string=None,
  567.             start_offset=0,
  568.             end_offset=None,
  569.             models=None,
  570.             limit_to_registered_models=None,
  571.             result_class=None,
  572.             **kwargs):
  573.         if not self.setup_complete:
  574.             self.setup()
  575.  
  576.         # Deferred models will have a different class ("RealClass_Deferred_fieldname")
  577.         # which won't be in our registry:
  578.         model_klass = model_instance._meta.concrete_model
  579.  
  580.         field_name = self.content_field_name
  581.         narrow_queries = set()
  582.         narrowed_results = None
  583.         self.index = self.index.refresh()
  584.  
  585.         if limit_to_registered_models is None:
  586.             limit_to_registered_models = getattr(
  587.                 settings, 'HAYSTACK_LIMIT_TO_REGISTERED_MODELS', True)
  588.  
  589.         if models and len(models):
  590.             model_choices = sorted(get_model_ct(model) for model in models)
  591.         elif limit_to_registered_models:
  592.             # Using narrow queries, limit the results to only models handled
  593.             # with the current routers.
  594.             model_choices = self.build_models_list()
  595.         else:
  596.             model_choices = []
  597.  
  598.         if len(model_choices) > 0:
  599.             if narrow_queries is None:
  600.                 narrow_queries = set()
  601.  
  602.             narrow_queries.add(' OR '.join(
  603.                 ['%s:%s' % (DJANGO_CT, rm) for rm in model_choices]))
  604.  
  605.         if additional_query_string and additional_query_string != '*':
  606.             narrow_queries.add(additional_query_string)
  607.  
  608.         narrow_searcher = None
  609.  
  610.         if narrow_queries is not None:
  611.             # Potentially expensive? I don't see another way to do it in
  612.             # Whoosh...
  613.             narrow_searcher = self.index.searcher()
  614.  
  615.             for nq in narrow_queries:
  616.                 recent_narrowed_results = narrow_searcher.search(
  617.                     self.parser.parse(force_str(nq)), limit=None)
  618.  
  619.                 if len(recent_narrowed_results) <= 0:
  620.                     return {
  621.                         'results': [],
  622.                         'hits': 0,
  623.                     }
  624.  
  625.                 if narrowed_results:
  626.                     narrowed_results.filter(recent_narrowed_results)
  627.                 else:
  628.                     narrowed_results = recent_narrowed_results
  629.  
  630.         page_num, page_length = self.calculate_page(start_offset, end_offset)
  631.  
  632.         self.index = self.index.refresh()
  633.         raw_results = EmptyResults()
  634.  
  635.         if self.index.doc_count():
  636.             query = "%s:%s" % (ID, get_identifier(model_instance))
  637.             searcher = self.index.searcher()
  638.             parsed_query = self.parser.parse(query)
  639.             results = searcher.search(parsed_query)
  640.  
  641.             if len(results):
  642.                 raw_results = results[0].more_like_this(
  643.                     field_name, top=end_offset)
  644.  
  645.             # Handle the case where the results have been narrowed.
  646.             if narrowed_results is not None and hasattr(raw_results, 'filter'):
  647.                 raw_results.filter(narrowed_results)
  648.  
  649.         try:
  650.             raw_page = ResultsPage(raw_results, page_num, page_length)
  651.         except ValueError:
  652.             if not self.silently_fail:
  653.                 raise
  654.  
  655.             return {
  656.                 'results': [],
  657.                 'hits': 0,
  658.                 'spelling_suggestion': None,
  659.             }
  660.  
  661.         # Because as of Whoosh 2.5.1, it will return the wrong page of
  662.         # results if you request something too high. :(
  663.         if raw_page.pagenum < page_num:
  664.             return {
  665.                 'results': [],
  666.                 'hits': 0,
  667.                 'spelling_suggestion': None,
  668.             }
  669.  
  670.         results = self._process_results(raw_page, result_class=result_class)
  671.         searcher.close()
  672.  
  673.         if hasattr(narrow_searcher, 'close'):
  674.             narrow_searcher.close()
  675.  
  676.         return results
  677.  
  678.     def _process_results(
  679.             self,
  680.             raw_page,
  681.             highlight=False,
  682.             query_string='',
  683.             spelling_query=None,
  684.             result_class=None):
  685.         from haystack import connections
  686.         results = []
  687.  
  688.         # It's important to grab the hits first before slicing. Otherwise, this
  689.         # can cause pagination failures.
  690.         hits = len(raw_page)
  691.  
  692.         if result_class is None:
  693.             result_class = SearchResult
  694.  
  695.         facets = {}
  696.         spelling_suggestion = None
  697.         unified_index = connections[self.connection_alias].get_unified_index()
  698.         indexed_models = unified_index.get_indexed_models()
  699.  
  700.         for doc_offset, raw_result in enumerate(raw_page):
  701.             score = raw_page.score(doc_offset) or 0
  702.             app_label, model_name = raw_result[DJANGO_CT].split('.')
  703.             additional_fields = {}
  704.             model = haystack_get_model(app_label, model_name)
  705.  
  706.             if model and model in indexed_models:
  707.                 for key, value in raw_result.items():
  708.                     index = unified_index.get_index(model)
  709.                     string_key = str(key)
  710.  
  711.                     if string_key in index.fields and hasattr(
  712.                             index.fields[string_key], 'convert'):
  713.                         # Special-cased due to the nature of KEYWORD fields.
  714.                         if index.fields[string_key].is_multivalued:
  715.                             if value is None or len(value) == 0:
  716.                                 additional_fields[string_key] = []
  717.                             else:
  718.                                 additional_fields[string_key] = value.split(
  719.                                     ',')
  720.                         else:
  721.                             additional_fields[string_key] = index.fields[string_key].convert(
  722.                                 value)
  723.                     else:
  724.                         additional_fields[string_key] = self._to_python(value)
  725.  
  726.                 del (additional_fields[DJANGO_CT])
  727.                 del (additional_fields[DJANGO_ID])
  728.  
  729.                 if highlight:
  730.                     sa = StemmingAnalyzer()
  731.                     formatter = WhooshHtmlFormatter('em')
  732.                     terms = [token.text for token in sa(query_string)]
  733.  
  734.                     whoosh_result = whoosh_highlight(
  735.                         additional_fields.get(self.content_field_name),
  736.                         terms,
  737.                         sa,
  738.                         ContextFragmenter(),
  739.                         formatter
  740.                     )
  741.                     additional_fields['highlighted'] = {
  742.                         self.content_field_name: [whoosh_result],
  743.                     }
  744.  
  745.                 result = result_class(
  746.                     app_label,
  747.                     model_name,
  748.                     raw_result[DJANGO_ID],
  749.                     score,
  750.                     **additional_fields)
  751.                 results.append(result)
  752.             else:
  753.                 hits -= 1
  754.  
  755.         if self.include_spelling:
  756.             if spelling_query:
  757.                 spelling_suggestion = self.create_spelling_suggestion(
  758.                     spelling_query)
  759.             else:
  760.                 spelling_suggestion = self.create_spelling_suggestion(
  761.                     query_string)
  762.  
  763.         return {
  764.             'results': results,
  765.             'hits': hits,
  766.             'facets': facets,
  767.             'spelling_suggestion': spelling_suggestion,
  768.         }
  769.  
  770.     def create_spelling_suggestion(self, query_string):
  771.         spelling_suggestion = None
  772.         reader = self.index.reader()
  773.         corrector = reader.corrector(self.content_field_name)
  774.         cleaned_query = force_str(query_string)
  775.  
  776.         if not query_string:
  777.             return spelling_suggestion
  778.  
  779.         # Clean the string.
  780.         for rev_word in self.RESERVED_WORDS:
  781.             cleaned_query = cleaned_query.replace(rev_word, '')
  782.  
  783.         for rev_char in self.RESERVED_CHARACTERS:
  784.             cleaned_query = cleaned_query.replace(rev_char, '')
  785.  
  786.         # Break it down.
  787.         query_words = cleaned_query.split()
  788.         suggested_words = []
  789.  
  790.         for word in query_words:
  791.             suggestions = corrector.suggest(word, limit=1)
  792.  
  793.             if len(suggestions) > 0:
  794.                 suggested_words.append(suggestions[0])
  795.  
  796.         spelling_suggestion = ' '.join(suggested_words)
  797.         return spelling_suggestion
  798.  
  799.     def _from_python(self, value):
  800.         """
  801.         Converts Python values to a string for Whoosh.
  803.         Code courtesy of pysolr.
  804.         """
  805.         if hasattr(value, 'strftime'):
  806.             if not hasattr(value, 'hour'):
  807.                 value = datetime(value.year, value.month, value.day, 0, 0, 0)
  808.         elif isinstance(value, bool):
  809.             if value:
  810.                 value = 'true'
  811.             else:
  812.                 value = 'false'
  813.         elif isinstance(value, (list, tuple)):
  814.             value = u','.join([force_str(v) for v in value])
  815.         elif isinstance(value, (six.integer_types, float)):
  816.             # Leave it alone.
  817.             pass
  818.         else:
  819.             value = force_str(value)
  820.         return value
  821.  
  822.     def _to_python(self, value):
  823.         """
  824.         Converts values from Whoosh to native Python values.
  826.         A port of the same method in pysolr, as they deal with data the same way.
  827.         """
  828.         if value == 'true':
  829.             return True
  830.         elif value == 'false':
  831.             return False
  832.  
  833.         if value and isinstance(value, six.string_types):
  834.             possible_datetime = DATETIME_REGEX.search(value)
  835.  
  836.             if possible_datetime:
  837.                 date_values = possible_datetime.groupdict()
  838.  
  839.                 for dk, dv in date_values.items():
  840.                     date_values[dk] = int(dv)
  841.  
  842.                 return datetime(
  843.                     date_values['year'],
  844.                     date_values['month'],
  845.                     date_values['day'],
  846.                     date_values['hour'],
  847.                     date_values['minute'],
  848.                     date_values['second'])
  849.  
  850.         try:
  851.             # Attempt to use json to load the values.
  852.             converted_value = json.loads(value)
  853.  
  854.             # Try to handle most built-in types.
  855.             if isinstance(
  856.                     converted_value,
  857.                     (list,
  858.                      tuple,
  859.                      set,
  860.                      dict,
  861.                      six.integer_types,
  862.                      float,
  863.                      complex)):
  864.                 return converted_value
  865.         except BaseException:
  866.             # If it fails (SyntaxError or its ilk) or we don't trust it,
  867.             # continue on.
  868.             pass
  869.  
  870.         return value
  871.  
  872.  
  873. class WhooshSearchQuery(BaseSearchQuery):
  874.     def _convert_datetime(self, date):
  875.         if hasattr(date, 'hour'):
  876.             return force_str(date.strftime('%Y%m%d%H%M%S'))
  877.         else:
  878.             return force_str(date.strftime('%Y%m%d000000'))
  879.  
  880.     def clean(self, query_fragment):
  881.         """
  882.         Provides a mechanism for sanitizing user input before presenting the
  883.         value to the backend.
  885.         Whoosh 1.X differs here in that you can no longer use a backslash
  886.         to escape reserved characters. Instead, the whole word should be
  887.         quoted.
  888.         """
  889.         words = query_fragment.split()
  890.         cleaned_words = []
  891.  
  892.         for word in words:
  893.             if word in self.backend.RESERVED_WORDS:
  894.                 word = word.replace(word, word.lower())
  895.  
  896.             for char in self.backend.RESERVED_CHARACTERS:
  897.                 if char in word:
  898.                     word = "'%s'" % word
  899.                     break
  900.  
  901.             cleaned_words.append(word)
  902.  
  903.         return ' '.join(cleaned_words)
  904.  
  905.     def build_query_fragment(self, field, filter_type, value):
  906.         from haystack import connections
  907.         query_frag = ''
  908.         is_datetime = False
  909.  
  910.         if not hasattr(value, 'input_type_name'):
  911.             # Handle when we've got a ``ValuesListQuerySet``...
  912.             if hasattr(value, 'values_list'):
  913.                 value = list(value)
  914.  
  915.             if hasattr(value, 'strftime'):
  916.                 is_datetime = True
  917.  
  918.             if isinstance(value, six.string_types) and value != ' ':
  919.                 # It's not an ``InputType``. Assume ``Clean``.
  920.                 value = Clean(value)
  921.             else:
  922.                 value = PythonData(value)
  923.  
  924.         # Prepare the query using the InputType.
  925.         prepared_value = value.prepare(self)
  926.  
  927.         if not isinstance(prepared_value, (set, list, tuple)):
  928.             # Then convert whatever we get back to what pysolr wants if needed.
  929.             prepared_value = self.backend._from_python(prepared_value)
  930.  
  931.         # 'content' is a special reserved word, much like 'pk' in
  932.         # Django's ORM layer. It indicates 'no special field'.
  933.         if field == 'content':
  934.             index_fieldname = ''
  935.         else:
  936.             index_fieldname = u'%s:' % connections[self._using].get_unified_index(
  937.             ).get_index_fieldname(field)
  938.  
  939.         filter_types = {
  940.             'content': '%s',
  941.             'contains': '*%s*',
  942.             'endswith': "*%s",
  943.             'startswith': "%s*",
  944.             'exact': '%s',
  945.             'gt': "{%s to}",
  946.             'gte': "[%s to]",
  947.             'lt': "{to %s}",
  948.             'lte': "[to %s]",
  949.             'fuzzy': u'%s~',
  950.         }
  951.  
  952.         if value.post_process is False:
  953.             query_frag = prepared_value
  954.         else:
  955.             if filter_type in [
  956.                 'content',
  957.                 'contains',
  958.                 'startswith',
  959.                 'endswith',
  960.                 'fuzzy']:
  961.                 if value.input_type_name == 'exact':
  962.                     query_frag = prepared_value
  963.                 else:
  964.                     # Iterate over terms & incorportate the converted form of
  965.                     # each into the query.
  966.                     terms = []
  967.  
  968.                     if isinstance(prepared_value, six.string_types):
  969.                         possible_values = prepared_value.split(' ')
  970.                     else:
  971.                         if is_datetime is True:
  972.                             prepared_value = self._convert_datetime(
  973.                                 prepared_value)
  974.  
  975.                         possible_values = [prepared_value]
  976.  
  977.                     for possible_value in possible_values:
  978.                         terms.append(
  979.                             filter_types[filter_type] %
  980.                             self.backend._from_python(possible_value))
  981.  
  982.                     if len(terms) == 1:
  983.                         query_frag = terms[0]
  984.                     else:
  985.                         query_frag = u"(%s)" % " AND ".join(terms)
  986.             elif filter_type == 'in':
  987.                 in_options = []
  988.  
  989.                 for possible_value in prepared_value:
  990.                     is_datetime = False
  991.  
  992.                     if hasattr(possible_value, 'strftime'):
  993.                         is_datetime = True
  994.  
  995.                     pv = self.backend._from_python(possible_value)
  996.  
  997.                     if is_datetime is True:
  998.                         pv = self._convert_datetime(pv)
  999.  
  1000.                     if isinstance(pv, six.string_types) and not is_datetime:
  1001.                         in_options.append('"%s"' % pv)
  1002.                     else:
  1003.                         in_options.append('%s' % pv)
  1004.  
  1005.                 query_frag = "(%s)" % " OR ".join(in_options)
  1006.             elif filter_type == 'range':
  1007.                 start = self.backend._from_python(prepared_value[0])
  1008.                 end = self.backend._from_python(prepared_value[1])
  1009.  
  1010.                 if hasattr(prepared_value[0], 'strftime'):
  1011.                     start = self._convert_datetime(start)
  1012.  
  1013.                 if hasattr(prepared_value[1], 'strftime'):
  1014.                     end = self._convert_datetime(end)
  1015.  
  1016.                 query_frag = u"[%s to %s]" % (start, end)
  1017.             elif filter_type == 'exact':
  1018.                 if value.input_type_name == 'exact':
  1019.                     query_frag = prepared_value
  1020.                 else:
  1021.                     prepared_value = Exact(prepared_value).prepare(self)
  1022.                     query_frag = filter_types[filter_type] % prepared_value
  1023.             else:
  1024.                 if is_datetime is True:
  1025.                     prepared_value = self._convert_datetime(prepared_value)
  1026.  
  1027.                 query_frag = filter_types[filter_type] % prepared_value
  1028.  
  1029.         if len(query_frag) and not isinstance(value, Raw):
  1030.             if not query_frag.startswith('(') and not query_frag.endswith(')'):
  1031.                 query_frag = "(%s)" % query_frag
  1032.  
  1033.         return u"%s%s" % (index_fieldname, query_frag)
  1034.  
  1035.         # if not filter_type in ('in', 'range'):
  1036.         #     # 'in' is a bit of a special case, as we don't want to
  1037.         #     # convert a valid list/tuple to string. Defer handling it
  1038.         #     # until later...
  1039.         #     value = self.backend._from_python(value)
  1040.  
  1041.  
  1042. class WhooshEngine(BaseEngine):
  1043.     backend = WhooshSearchBackend
  1044.     query = WhooshSearchQuery

五，项目总结

对于博客系统来讲，用JAVA开发的较多，Python开发的相对较少，功能完整又比较全面的更是不多，这个系统做的整体功能完整，界面简洁大方，使用了较新的组件和技术框架，相对比较优秀。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/746431
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号