src/feeds.py

@@ -0,0 +1,83 @@
+# 导入必要的模块和类
+from django.contrib.auth import get_user_model  # 用于获取自定义用户模型
+from django.contrib.syndication.views import Feed  # Django内置的Feed基类，用于生成RSS/Atom订阅
+from django.utils import timezone  # 处理时间相关操作
+from django.utils.feedgenerator import Rss201rev2Feed  # RSS 2.0版本的生成器
+
+from blog.models import Article  # 导入博客文章模型
+from djangoblog.utils import CommonMarkdown  # 导入Markdown处理工具，用于将文章内容转换为HTML
+
+
+class DjangoBlogFeed(Feed):
+    """
+    自定义博客RSS订阅Feed类，继承自Django的Feed基类，用于生成博客文章的RSS订阅源
+    """
+    # 指定Feed类型为RSS 2.0版本（符合Rss201rev2Feed规范）
+    feed_type = Rss201rev2Feed
+
+    # RSS源的描述信息（会显示在订阅源的描述中）
+    description = '大巧无工,重剑无锋.'
+    # RSS源的标题（订阅源的名称）
+    title = "且听风吟 大巧无工,重剑无锋. "
+    # RSS源的链接（通常指向网站的订阅页面）
+    link = "/feed/"
+
+    def author_name(self):
+        """
+        定义订阅源的作者名称
+        这里取系统中第一个用户的昵称作为作者名
+        """
+        return get_user_model().objects.first().nickname
+
+    def author_link(self):
+        """
+        定义订阅源作者的链接
+        这里取系统中第一个用户的个人主页链接（需用户模型实现get_absolute_url方法）
+        """
+        return get_user_model().objects.first().get_absolute_url()
+
+    def items(self):
+        """
+        定义订阅源包含的项目（即文章列表）
+        返回条件：类型为'article'（type='a'）、状态为'已发布'（status='p'）的文章
+        排序方式：按发布时间倒序（最新发布的在前）
+        数量限制：最多返回5篇文章
+        """
+        return Article.objects.filter(type='a', status='p').order_by('-pub_time')[:5]
+
+    def item_title(self, item):
+        """
+        定义单个项目（文章）的标题
+        参数item：从items()方法返回的单个Article对象
+        返回文章的标题
+        """
+        return item.title
+
+    def item_description(self, item):
+        """
+        定义单个项目（文章）的描述内容
+        使用CommonMarkdown工具将文章的Markdown格式正文转换为HTML，作为订阅中的描述
+        """
+        return CommonMarkdown.get_markdown(item.body)
+
+    def feed_copyright(self):
+        """
+        定义订阅源的版权信息
+        格式为"Copyright© 年份 且听风吟"，年份自动获取当前时间的年份
+        """
+        now = timezone.now()
+        return "Copyright© {year} 且听风吟".format(year=now.year)
+
+    def item_link(self, item):
+        """
+        定义单个项目（文章）的链接
+        返回文章的绝对URL（需Article模型实现get_absolute_url方法）
+        """
+        return item.get_absolute_url()
+
+    def item_guid(self, item):
+        """
+        定义单个项目的全局唯一标识符（GUID）
+        此处未实现具体逻辑，可根据需求补充（如返回文章ID或唯一URL等）
+        """
+        return

src/logentryadmin.py

@@ -0,0 +1,145 @@
+# 导入Django管理后台核心模块
+from django.contrib import admin
+# 导入日志相关常量和模型：DELETION表示删除操作的标记
+from django.contrib.admin.models import DELETION
+# 导入ContentType模型，用于处理模型与数据库表的映射关系
+from django.contrib.contenttypes.models import ContentType
+# 导入URL反向解析和异常处理
+from django.urls import reverse, NoReverseMatch
+# 导入字符串处理工具
+from django.utils.encoding import force_str
+# 导入HTML转义工具，防止XSS攻击
+from django.utils.html import escape
+# 导入安全字符串标记工具，标记可信HTML
+from django.utils.safestring import mark_safe
+# 导入国际化翻译工具
+from django.utils.translation import gettext_lazy as _
+
+
+class LogEntryAdmin(admin.ModelAdmin):
+    """
+    自定义日志条目(LogEntry)的管理后台配置类
+    用于在Django admin中展示和管理系统操作日志
+    """
+    # 列表页的筛选器：按内容类型(关联的模型)筛选日志
+    list_filter = [
+        'content_type'
+    ]
+
+    # 搜索字段：支持按对象名称和操作消息搜索日志
+    search_fields = [
+        'object_repr',  # 对象的字符串表示
+        'change_message'  # 操作描述消息
+    ]
+
+    # 列表页中可点击的链接字段
+    list_display_links = [
+        'action_time',  # 操作时间
+        'get_change_message',  # 操作消息
+    ]
+
+    # 列表页展示的字段
+    list_display = [
+        'action_time',  # 操作时间
+        'user_link',  # 操作用户(带链接)
+        'content_type',  # 关联的模型类型
+        'object_link',  # 操作的对象(带链接)
+        'get_change_message',  # 操作消息
+    ]
+
+    def has_add_permission(self, request):
+        """
+        禁用添加日志的权限：日志由系统自动生成，不允许手动添加
+        """
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        """
+        限制修改日志的权限：
+        - 仅超级用户或拥有'admin.change_logentry'权限的用户可查看
+        - 禁止POST请求(防止修改操作)
+        """
+        return (
+                request.user.is_superuser or
+                request.user.has_perm('admin.change_logentry')
+        ) and request.method != 'POST'
+
+    def has_delete_permission(self, request, obj=None):
+        """
+        禁用删除日志的权限：日志需保留，不允许删除
+        """
+        return False
+
+    def object_link(self, obj):
+        """
+        生成操作对象的链接：
+        - 若操作不是删除且存在关联模型，尝试生成指向该对象编辑页的链接
+        - 否则显示对象的字符串表示
+        """
+        object_link = escape(obj.object_repr)  # 转义对象名称，防止XSS
+        content_type = obj.content_type
+
+        # 非删除操作且存在内容类型时尝试生成链接
+        if obj.action_flag != DELETION and content_type is not None:
+            try:
+                # 反向解析对象的admin编辑页URL
+                url = reverse(
+                    'admin:{}_{}_change'.format(content_type.app_label,
+                                                content_type.model),
+                    args=[obj.object_id]
+                )
+                # 生成带链接的HTML
+                object_link = '<a href="{}">{}</a>'.format(url, object_link)
+            except NoReverseMatch:
+                # 解析URL失败时，仅显示对象名称
+                pass
+        # 标记为安全HTML，避免被转义
+        return mark_safe(object_link)
+
+    # 配置列表页字段的排序和显示名称
+    object_link.admin_order_field = 'object_repr'  # 允许按对象名称排序
+    object_link.short_description = _('object')  # 字段显示名称(支持国际化)
+
+    def user_link(self, obj):
+        """
+        生成操作用户的链接：
+        - 尝试生成指向该用户编辑页的链接
+        - 否则显示用户的字符串表示
+        """
+        # 获取用户模型对应的ContentType
+        content_type = ContentType.objects.get_for_model(type(obj.user))
+        user_link = escape(force_str(obj.user))  # 转义用户名
+
+        try:
+            # 反向解析用户的admin编辑页URL
+            url = reverse(
+                'admin:{}_{}_change'.format(content_type.app_label,
+                                            content_type.model),
+                args=[obj.user.pk]
+            )
+            # 生成带链接的HTML
+            user_link = '<a href="{}">{}</a>'.format(url, user_link)
+        except NoReverseMatch:
+            # 解析URL失败时，仅显示用户名
+            pass
+        return mark_safe(user_link)
+
+    # 配置列表页字段的排序和显示名称
+    user_link.admin_order_field = 'user'  # 允许按用户排序
+    user_link.short_description = _('user')  # 字段显示名称(支持国际化)
+
+    def get_queryset(self, request):
+        """
+        优化查询集：预加载content_type关联数据，减少数据库查询次数
+        """
+        queryset = super(LogEntryAdmin, self).get_queryset(request)
+        return queryset.prefetch_related('content_type')
+
+    def get_actions(self, request):
+        """
+        移除批量删除操作：日志不允许批量删除
+        """
+        actions = super(LogEntryAdmin, self).get_actions(request)
+        if 'delete_selected' in actions:
+            del actions['delete_selected']
+        return actions

src/settings.py

@@ -0,0 +1,399 @@
+"""
+Django settings for djangoblog project.
+项目配置文件：包含项目核心设置、数据库、中间件、静态资源等所有全局配置
+Generated by 'django-admin startproject' using Django 1.10.2.
+"""
+import os
+import sys
+from pathlib import Path
+
+# 导入Django国际化翻译工具
+from django.utils.translation import gettext_lazy as _
+
+
+def env_to_bool(env, default):
+    """
+    环境变量转换工具函数：将环境变量的字符串值转为布尔值
+    - 若环境变量未设置，返回默认值
+    - 若环境变量存在，仅当值为'True'时返回True，其他情况返回False
+    """
+    str_val = os.environ.get(env)
+    return default if str_val is None else str_val == 'True'
+
+
+# -------------------------- 基础路径配置 --------------------------
+# 项目根目录：当前配置文件所在目录的父级目录（即项目根目录）
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# -------------------------- 安全与调试配置 --------------------------
+# 快速开发配置（生产环境需修改）
+# SECURITY WARNING: 生产环境必须将SECRET_KEY通过环境变量配置，禁止硬编码
+SECRET_KEY = os.environ.get(
+    'DJANGO_SECRET_KEY') or 'n9ceqv38)#&mwuat@(mjb_p%em$e8$qyr#fw9ot!=ba6lijx-6'
+
+# 调试模式：开发环境开启（True），生产环境必须关闭（False）
+# 通过环境变量控制，默认开启调试
+DEBUG = env_to_bool('DJANGO_DEBUG', True)
+
+# 测试模式标识：当执行python manage.py test时，TESTING为True
+TESTING = len(sys.argv) > 1 and sys.argv[1] == 'test'
+
+# 允许访问的主机列表：生产环境需指定具体域名，禁止使用'*'（存在安全风险）
+ALLOWED_HOSTS = ['*', '127.0.0.1', 'example.com']
+
+# Django 4.0+新增：信任的CSRF源列表，防止跨站请求伪造，生产环境需配置真实域名
+CSRF_TRUSTED_ORIGINS = ['http://example.com']
+
+
+# -------------------------- 应用配置 --------------------------
+INSTALLED_APPS = [
+    # Django内置应用（精简版Admin，仅包含核心功能）
+    'django.contrib.admin.apps.SimpleAdminConfig',
+    'django.contrib.auth',          # 用户认证系统
+    'django.contrib.contenttypes',  # 内容类型框架（关联模型与数据表）
+    'django.contrib.sessions',      # 会话管理
+    'django.contrib.messages',      # 消息提示系统
+    'django.contrib.staticfiles',   # 静态资源管理
+    'django.contrib.sites',         # 多站点支持（用于sitemap等功能）
+    'django.contrib.sitemaps',      # 站点地图生成
+
+    # 第三方应用
+    'mdeditor',     # Markdown编辑器（用于文章编写）
+    'haystack',     # 全文搜索框架
+    'compressor',   # 静态资源压缩（CSS/JS合并压缩）
+
+    # 自定义应用
+    'blog',         # 博客核心功能（文章、分类等）
+    'accounts',     # 用户账户管理（自定义用户模型等）
+    'comments',     # 评论功能
+    'oauth',        # 第三方登录（如GitHub、微信等）
+    'servermanager',# 服务器管理（如系统监控等）
+    'owntracks',    # 位置追踪（可选功能）
+    'djangoblog'    # 项目主应用（全局配置、工具函数等）
+]
+
+
+# -------------------------- 中间件配置 --------------------------
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',  # 安全相关中间件（防XSS、点击劫持等）
+    'django.contrib.sessions.middleware.SessionMiddleware',  # 会话管理
+    'django.middleware.locale.LocaleMiddleware',      # 国际化中间件（多语言支持）
+    'django.middleware.gzip.GZipMiddleware',          # GZip压缩（减少响应体积）
+    # 'django.middleware.cache.UpdateCacheMiddleware', # 缓存更新（注释：当前未启用）
+    'django.middleware.common.CommonMiddleware',      # 通用中间件（处理URL、反向解析等）
+    # 'django.middleware.cache.FetchFromCacheMiddleware', # 缓存读取（注释：当前未启用）
+    'django.middleware.csrf.CsrfViewMiddleware',      # CSRF保护中间件
+    'django.contrib.auth.middleware.AuthenticationMiddleware',  # 用户认证中间件
+    'django.contrib.messages.middleware.MessageMiddleware',     # 消息提示中间件
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',  # 防点击劫持
+    'django.middleware.http.ConditionalGetMiddleware',         # 处理HTTP条件请求（如304缓存）
+    'blog.middleware.OnlineMiddleware'                 # 自定义中间件（跟踪用户在线状态）
+]
+
+
+# -------------------------- URL与模板配置 --------------------------
+# 项目主URL配置文件路径
+ROOT_URLCONF = 'djangoblog.urls'
+
+# 模板配置
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',  # Django模板引擎
+        'DIRS': [os.path.join(BASE_DIR, 'templates')],  # 全局模板目录（项目根目录下的templates）
+        'APP_DIRS': True,  # 允许从各应用的templates目录加载模板
+        'OPTIONS': {
+            # 模板上下文处理器：向所有模板注入全局变量
+            'context_processors': [
+                'django.template.context_processors.debug',  # 调试模式变量
+                'django.template.context_processors.request', # 请求对象（request）
+                'django.contrib.auth.context_processors.auth', # 用户认证变量（user）
+                'django.contrib.messages.context_processors.messages', # 消息提示变量
+                'blog.context_processors.seo_processor' # 自定义SEO处理器（注入SEO相关变量）
+            ],
+        },
+    },
+]
+
+# WSGI应用入口（用于部署，如Gunicorn、uWSGI）
+WSGI_APPLICATION = 'djangoblog.wsgi.application'
+
+
+# -------------------------- 数据库配置 --------------------------
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.mysql',  # 数据库引擎（MySQL）
+        'NAME': os.environ.get('DJANGO_MYSQL_DATABASE') or 'djangoblog',  # 数据库名
+        'USER': os.environ.get('DJANGO_MYSQL_USER') or 'root',  # 数据库用户名
+        'PASSWORD': os.environ.get('DJANGO_MYSQL_PASSWORD') or 'LY181828',  # 数据库密码
+        'HOST': os.environ.get('DJANGO_MYSQL_HOST') or '127.0.0.1',  # 数据库主机
+        'PORT': int(os.environ.get('DJANGO_MYSQL_PORT') or 3306),  # 数据库端口
+        'OPTIONS': {'charset': 'utf8mb4'},  # 数据库字符集（支持emoji表情）
+    }}
+
+
+# -------------------------- 密码验证配置 --------------------------
+AUTH_PASSWORD_VALIDATORS = [
+    # 验证密码与用户名/邮箱是否相似
+    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
+    # 验证密码最小长度（默认8位）
+    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
+    # 验证密码是否为常见弱密码（如123456）
+    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
+    # 验证密码是否全为数字
+    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
+]
+
+
+# -------------------------- 国际化与时间配置 --------------------------
+# 支持的语言列表（英文、简体中文、繁体中文）
+LANGUAGES = (
+    ('en', _('English')),
+    ('zh-hans', _('Simplified Chinese')),
+    ('zh-hant', _('Traditional Chinese')),
+)
+
+# 语言文件目录（存放翻译文件的路径）
+LOCALE_PATHS = (os.path.join(BASE_DIR, 'locale'),)
+
+# 默认语言（简体中文）
+LANGUAGE_CODE = 'zh-hans'
+
+# 时区（上海时区，与UTC时差+8）
+TIME_ZONE = 'Asia/Shanghai'
+
+# 启用国际化
+USE_I18N = True
+
+# 启用本地化（日期、时间格式等）
+USE_L10N = True
+
+# 禁用UTC时间（使用本地时间存储数据库时间）
+USE_TZ = False
+
+
+# -------------------------- 全文搜索配置（Haystack） --------------------------
+HAYSTACK_CONNECTIONS = {
+    'default': {
+        # 搜索引擎：自定义中文Whoosh引擎（支持中文分词）
+        'ENGINE': 'djangoblog.whoosh_cn_backend.WhooshEngine',
+        # 搜索索引存储路径（项目配置文件目录下的whoosh_index）
+        'PATH': os.path.join(os.path.dirname(__file__), 'whoosh_index'),
+    },
+}
+
+# 实时更新搜索索引：当文章新增/修改/删除时，自动更新搜索索引
+HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'
+
+
+# -------------------------- 用户认证配置 --------------------------
+# 自定义认证后端：允许用户用用户名或邮箱登录
+AUTHENTICATION_BACKENDS = ['accounts.user_login_backend.EmailOrUsernameModelBackend']
+
+# 自定义用户模型：替换Django内置的User模型（关联accounts应用的BlogUser）
+AUTH_USER_MODEL = 'accounts.BlogUser'
+
+# 登录页面URL：未登录用户访问需认证页面时，重定向到该URL
+LOGIN_URL = '/login/'
+
+
+# -------------------------- 静态资源与媒体文件配置 --------------------------
+# 静态资源收集目录（生产环境使用python manage.py collectstatic收集后的路径）
+STATIC_ROOT = os.path.join(BASE_DIR, 'collectedstatic')
+
+# 静态资源URL前缀（前端访问静态资源的路径，如http://example.com/static/）
+STATIC_URL = '/static/'
+
+# 全局静态资源目录（项目根目录下的static文件夹）
+STATICFILES = os.path.join(BASE_DIR, 'static')
+
+# 媒体文件（用户上传文件，如文章图片）存储目录
+MEDIA_ROOT = os.path.join(BASE_DIR, 'uploads')
+
+# 媒体文件URL前缀（前端访问上传文件的路径，如http://example.com/media/）
+MEDIA_URL = '/media/'
+
+# 静态资源查找器（指定Django如何查找静态文件）
+STATICFILES_FINDERS = (
+    'django.contrib.staticfiles.finders.FileSystemFinder',  # 从全局STATICFILES目录查找
+    'django.contrib.staticfiles.finders.AppDirectoriesFinder',  # 从各应用的static目录查找
+    'compressor.finders.CompressorFinder',  # 从compressor压缩后的目录查找
+)
+
+
+# -------------------------- 静态资源压缩配置（Compressor） --------------------------
+# 启用压缩（生产环境建议开启，开发环境可关闭）
+COMPRESS_ENABLED = True
+# COMPRESS_OFFLINE = True  # 离线压缩（注释：当前未启用，适合生产环境）
+
+# CSS压缩过滤器：1. 转换相对URL为绝对URL；2. 压缩CSS代码
+COMPRESS_CSS_FILTERS = [
+    'compressor.filters.css_default.CssAbsoluteFilter',
+    'compressor.filters.cssmin.CSSMinFilter'
+]
+
+# JS压缩过滤器：压缩JS代码
+COMPRESS_JS_FILTERS = ['compressor.filters.jsmin.JSMinFilter']
+
+
+# -------------------------- 缓存配置 --------------------------
+# HTTP缓存超时时间（单位：秒，2592000秒=30天）
+CACHE_CONTROL_MAX_AGE = 2592000
+
+# 默认缓存：本地内存缓存（适合开发环境，生产环境建议用Redis/Memcached）
+CACHES = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+        'TIMEOUT': 10800,  # 缓存超时时间（3小时）
+        'LOCATION': 'unique-snowflake',  # 缓存实例标识（唯一即可）
+    }
+}
+
+# 若环境变量配置了Redis地址，则使用Redis作为缓存（生产环境推荐）
+if os.environ.get("DJANGO_REDIS_URL"):
+    CACHES = {
+        'default': {
+            'BACKEND': 'django.core.cache.backends.redis.RedisCache',
+            'LOCATION': f'redis://{os.environ.get("DJANGO_REDIS_URL")}',
+        }
+    }
+
+
+# -------------------------- 其他业务配置 --------------------------
+# 多站点支持的站点ID（默认1，与django.contrib.sites配合使用）
+SITE_ID = 1
+
+# 百度链接提交URL：用于向百度搜索引擎提交新链接（SEO优化）
+BAIDU_NOTIFY_URL = os.environ.get('DJANGO_BAIDU_NOTIFY_URL') or \
+                   'http://data.zz.baidu.com/urls?site=https://www.lylinux.net&token=1uAOGrMsUm5syDGn'
+
+# 时间格式：全局日期时间显示格式
+TIME_FORMAT = '%Y-%m-%d %H:%M:%S'
+DATE_TIME_FORMAT = '%Y-%m-%d'
+
+# Bootstrap颜色样式列表（用于文章标签、按钮等UI组件）
+BOOTSTRAP_COLOR_TYPES = ['default', 'primary', 'success', 'info', 'warning', 'danger']
+
+# 分页配置：每页显示的文章数量
+PAGINATE_BY = 10
+
+# X-Frame-Options配置：仅允许同域嵌入iframe（防点击劫持）
+X_FRAME_OPTIONS = 'SAMEORIGIN'
+
+# 默认自增字段类型（Django 3.2+新增，避免主键溢出）
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+# 微信管理员密码（两次MD5加密，用于微信后台管理验证）
+WXADMIN = os.environ.get('DJANGO_WXADMIN_PASSWORD') or '995F03AC401D6CABABAEF756FC4D43C7'
+
+
+# -------------------------- Elasticsearch配置（可选） --------------------------
+# 若环境变量配置了Elasticsearch地址，则使用Elasticsearch作为搜索引擎（替代Whoosh）
+if os.environ.get('DJANGO_ELASTICSEARCH_HOST'):
+    ELASTICSEARCH_DSL = {
+        'default': {'hosts': os.environ.get('DJANGO_ELASTICSEARCH_HOST')},
+    }
+    HAYSTACK_CONNECTIONS = {
+        'default': {'ENGINE': 'djangoblog.elasticsearch_backend.ElasticSearchEngine'},
+    }
+
+
+# -------------------------- 日志配置 --------------------------
+# 日志存储目录（项目根目录下的logs文件夹）
+LOG_PATH = os.path.join(BASE_DIR, 'logs')
+# 若目录不存在则创建（exist_ok=True避免重复创建报错）
+if not os.path.exists(LOG_PATH):
+    os.makedirs(LOG_PATH, exist_ok=True)
+
+LOGGING = {
+    'version': 1,  # 日志配置版本（固定为1）
+    'disable_existing_loggers': False,  # 不禁用已存在的日志器
+    'root': {  # 根日志器（所有未指定日志器的日志都会走这里）
+        'level': 'INFO',  # 日志级别（INFO及以上会被记录）
+        'handlers': ['console', 'log_file'],  # 日志处理器（控制台+文件）
+    },
+    'formatters': {  # 日志格式
+        'verbose': {  # 详细格式（包含时间、级别、模块、行号等）
+            'format': '[%(asctime)s] %(levelname)s [%(name)s.%(funcName)s:%(lineno)d %(module)s] %(message)s',
+        }
+    },
+    'filters': {  # 日志过滤器
+        'require_debug_false': {'()': 'django.utils.log.RequireDebugFalse'},  # 仅DEBUG=False时生效
+        'require_debug_true': {'()': 'django.utils.log.RequireDebugTrue'},   # 仅DEBUG=True时生效
+    },
+    'handlers': {  # 日志处理器（定义日志如何输出）
+        'log_file': {  # 文件处理器（按天分割日志）
+            'level': 'INFO',
+            'class': 'logging.handlers.TimedRotatingFileHandler',  # 按时间轮转的文件处理器
+            'filename': os.path.join(LOG_PATH, 'djangoblog.log'),  # 日志文件路径
+            'when': 'D',  # 轮转周期（每天一个文件）
+            'formatter': 'verbose',  # 使用详细格式
+            'interval': 1,  # 轮转间隔（1天）
+            'delay': True,  # 延迟创建文件（直到有日志时才创建）
+            'backupCount': 5,  # 保留5个备份日志文件
+            'encoding': 'utf-8'  # 日志文件编码
+        },
+        'console': {  # 控制台处理器（仅开发环境显示）
+            'level': 'DEBUG',
+            'filters': ['require_debug_true'],  # 仅DEBUG=True时生效
+            'class': 'logging.StreamHandler',  # 输出到控制台
+            'formatter': 'verbose'
+        },
+        'null': {'class': 'logging.NullHandler'},  # 空处理器（丢弃日志）
+        'mail_admins': {  # 邮件处理器（发生ERROR时通知管理员）
+            'level': 'ERROR',
+            'filters': ['require_debug_false'],  # 仅生产环境（DEBUG=False）生效
+            'class': 'django.utils.log.AdminEmailHandler'  # 发送邮件给ADMINS列表
+        }
+    },
+    'loggers': {  # 自定义日志器（针对特定模块）
+        'djangoblog': {  # 项目主模块日志
+            'handlers': ['log_file', 'console'],
+            'level': 'INFO',
+            'propagate': True,  # 是否向上传递日志（到root日志器）
+        },
+        'django.request': {  # Django请求相关日志（如404、500错误）
+            'handlers': ['mail_admins'],
+            'level': 'ERROR',
+            'propagate': False,  # 不向上传递（避免重复记录）
+        }
+    }
+}
+
+
+# -------------------------- 邮件配置 --------------------------
+# 邮件后端（SMTP服务）
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+# 是否使用TLS加密（与SSL二选一，根据邮件服务商配置）
+EMAIL_USE_TLS = env_to_bool('DJANGO_EMAIL_TLS', False)
+# 是否使用SSL加密（阿里云邮箱等常用465端口+SSL）
+EMAIL_USE_SSL = env_to_bool('DJANGO_EMAIL_SSL', True)
+# 邮件服务器地址（如阿里云邮箱为smtp.mxhichina.com）
+EMAIL_HOST = os.environ.get('DJANGO_EMAIL_HOST') or 'smtp.mxhichina.com'
+# 邮件服务器端口（SSL通常为465，TLS通常为587）
+EMAIL_PORT = int(os.environ.get('DJANGO_EMAIL_PORT') or 465)
+# 发送邮件的用户名（邮箱地址）
+EMAIL_HOST_USER = os.environ.get('DJANGO_EMAIL_USER')
+# 发送邮件的密码（邮箱授权码，非登录密码）
+EMAIL_HOST_PASSWORD = os.environ.get('DJANGO_EMAIL_PASSWORD')
+# 默认发件人（与EMAIL_HOST_USER一致）
+DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
+# 管理员邮件（与ADMINS配合使用）
+SERVER_EMAIL = EMAIL_HOST_USER
+
+# 管理员列表：发生ERROR时会收到邮件通知
+ADMINS = [('admin', os.environ.get('DJANGO_ADMIN_EMAIL') or 'admin@admin.com')]
+
+
+# -------------------------- 插件系统配置 --------------------------
+# 插件目录（项目根目录下的plugins文件夹）
+PLUGINS_DIR = BASE_DIR / 'plugins'
+
+# 激活的插件列表（按需启用，提供额外功能）
+ACTIVE_PLUGINS = [
+    'article_copyright',  # 文章版权声明
+    'reading_time',       # 文章阅读时长估算
+    'external_links',     # 外部链接处理（如添加nofollow）
+    'view_count',         # 文章阅读量统计
+    'seo_optimize'        # SEO优化（如自动生成meta标签）
+]

src/sitemap.py

@@ -0,0 +1,124 @@
+# 导入Django站点地图核心类和URL反向解析工具
+from django.contrib.sitemaps import Sitemap
+from django.urls import reverse
+
+# 导入博客相关模型（文章、分类、标签），用于生成动态页面的站点地图
+from blog.models import Article, Category, Tag
+
+
+class StaticViewSitemap(Sitemap):
+    """
+    静态页面站点地图类：用于生成网站静态页面（如首页）的Sitemap条目
+    Sitemap用于告知搜索引擎网站的页面结构，帮助其抓取和索引
+    """
+    # 页面优先级（0.0-1.0）：值越高，搜索引擎认为该页面越重要
+    priority = 0.5
+    # 页面内容更新频率：可选值包括always、hourly、daily、weekly、monthly、yearly、never
+    changefreq = 'daily'
+
+    def items(self):
+        """
+        定义需要包含在站点地图中的静态页面URL名称列表
+        返回的是Django URL配置中定义的'name'属性（如'blog:index'对应首页URL）
+        """
+        return ['blog:index', ]
+
+    def location(self, item):
+        """
+        为items()返回的每个URL名称，生成对应的绝对URL
+        通过reverse()方法解析URL名称，获取实际访问路径（如'blog:index'解析为'/'）
+        """
+        return reverse(item)
+
+
+class ArticleSiteMap(Sitemap):
+    """
+    文章页面站点地图类：用于生成所有已发布文章的Sitemap条目
+    """
+    # 文章页面更新频率：每月（因单篇文章发布后修改频率较低）
+    changefreq = "monthly"
+    # 文章页面优先级：0.6（高于分类/标签，低于首页）
+    priority = "0.6"
+
+    def items(self):
+        """
+        返回所有状态为"已发布"（status='p'）的文章对象
+        仅包含已发布文章，避免搜索引擎抓取草稿或未公开内容
+        """
+        return Article.objects.filter(status='p')
+
+    def lastmod(self, obj):
+        """
+        定义每个文章页面的最后修改时间
+        取值为文章的last_modify_time字段（文章最后更新的时间）
+        帮助搜索引擎识别页面是否有更新，决定是否重新抓取
+        """
+        return obj.last_modify_time
+
+
+class CategorySiteMap(Sitemap):
+    """
+    分类页面站点地图类：用于生成所有文章分类页面的Sitemap条目
+    """
+    # 分类页面更新频率：每周（分类下文章新增/删除会影响分类页，频率低于文章）
+    changefreq = "Weekly"
+    # 分类页面优先级：0.6（与文章同级，高于标签/用户）
+    priority = "0.6"
+
+    def items(self):
+        """返回所有分类对象，生成每个分类页面的Sitemap条目"""
+        return Category.objects.all()
+
+    def lastmod(self, obj):
+        """
+        分类页面的最后修改时间：取值为分类的last_modify_time字段
+        分类信息（如分类名称）修改时，会更新该时间，提示搜索引擎重新抓取
+        """
+        return obj.last_modify_time
+
+
+class TagSiteMap(Sitemap):
+    """
+    标签页面站点地图类：用于生成所有文章标签页面的Sitemap条目
+    """
+    # 标签页面更新频率：每周（标签下文章增减频率较低）
+    changefreq = "Weekly"
+    # 标签页面优先级：0.3（低于首页、文章、分类，属于次要导航页面）
+    priority = "0.3"
+
+    def items(self):
+        """返回所有标签对象，生成每个标签页面的Sitemap条目"""
+        return Tag.objects.all()
+
+    def lastmod(self, obj):
+        """
+        标签页面的最后修改时间：取值为标签的last_modify_time字段
+        标签信息（如标签名称）修改时更新，用于搜索引擎判断页面新鲜度
+        """
+        return obj.last_modify_time
+
+
+class UserSiteMap(Sitemap):
+    """
+    用户页面站点地图类：用于生成所有发布过文章的用户主页的Sitemap条目
+    """
+    # 用户页面更新频率：每周（用户发布新文章或修改资料时才更新）
+    changefreq = "Weekly"
+    # 用户页面优先级：0.3（与标签同级，属于次要页面）
+    priority = "0.3"
+
+    def items(self):
+        """
+        返回所有发布过文章的独特用户对象
+        1. 通过Article.objects.all()获取所有文章，提取每篇文章的author（作者）
+        2. 使用map()遍历文章列表，获取作者集合；用set()去重，避免重复用户
+        3. 转换为list()，符合items()返回可迭代对象的要求
+        """
+        return list(set(map(lambda x: x.author, Article.objects.all())))
+
+    def lastmod(self, obj):
+        """
+        用户页面的最后修改时间：取值为用户的date_joined字段（用户注册时间）
+        此处可根据需求调整（如改为用户最后发布文章时间或最后修改资料时间）
+        """
+        return obj.date_joined

src/spider_notify.py

@@ -0,0 +1,49 @@
+# 导入日志模块，用于记录通知过程中的信息和错误
+import logging
+
+# 导入requests库，用于发送HTTP请求（向搜索引擎提交链接）
+import requests
+# 导入Django项目配置，用于获取百度链接提交的URL（在settings.py中配置）
+from django.conf import settings
+
+# 创建当前模块的日志记录器，用于输出通知相关的日志
+logger = logging.getLogger(__name__)
+
+
+class SpiderNotify():
+    """
+    搜索引擎爬虫通知类：用于向搜索引擎（当前仅百度）提交网站新链接
+    帮助搜索引擎快速发现并收录网站新增或更新的页面，提升SEO效果
+    """
+
+    @staticmethod
+    def baidu_notify(urls):
+        """
+        向百度搜索引擎提交链接的静态方法
+        通过百度链接提交API（BAIDU_NOTIFY_URL），将新页面URL推送给百度爬虫
+
+        Args:
+            urls (list): 需要提交的URL列表（每个元素为一个页面的完整URL或相对URL）
+        """
+        try:
+            # 将URL列表转换为以换行符分隔的字符串，符合百度API的提交格式要求
+            data = '\n'.join(urls)
+            # 发送POST请求到百度链接提交URL，提交URL数据
+            result = requests.post(settings.BAIDU_NOTIFY_URL, data=data)
+            # 记录百度返回的响应结果（成功时包含提交状态，用于调试和审计）
+            logger.info(result.text)
+        except Exception as e:
+            # 捕获请求过程中的所有异常（如网络错误、API地址错误等），记录错误日志
+            logger.error(e)
+
+    @staticmethod
+    def notify(url):
+        """
+        通用通知入口静态方法：统一调用百度链接提交方法
+        此处为简化设计，后续可扩展支持其他搜索引擎（如谷歌、必应）
+
+        Args:
+            url (str/list): 单个URL字符串或URL列表（最终会转为列表提交给百度）
+        """
+        # 调用百度链接提交方法，实现URL推送
+        SpiderNotify.baidu_notify(url)

src/tests.py

@@ -0,0 +1,32 @@
+from django.test import TestCase
+
+from djangoblog.utils import *
+
+
+class DjangoBlogTest(TestCase):
+    def setUp(self):
+        pass
+
+    def test_utils(self):
+        md5 = get_sha256('test')
+        self.assertIsNotNone(md5)
+        c = CommonMarkdown.get_markdown('''
+        # Title1
+
+        ```python
+        import os
+        ```
+
+        [url](https://www.lylinux.net/)
+
+        [ddd](http://www.baidu.com)
+
+
+        ''')
+        self.assertIsNotNone(c)
+        d = {
+            'd': 'key1',
+            'd2': 'key2'
+        }
+        data = parse_dict_to_url(d)
+        self.assertIsNotNone(data)

src/urls.py

@@ -0,0 +1,98 @@
+"""djangoblog URL Configuration
+项目URL路由总配置文件：定义所有URL与视图/应用的映射关系
+核心作用是将用户访问的URL地址，分发到对应的应用或视图函数处理
+"""
+# 导入项目配置，用于获取静态资源、媒体文件路径等
+from django.conf import settings
+# 导入国际化URL配置工具，支持多语言URL前缀（如/en/、/zh-hans/）
+from django.conf.urls.i18n import i18n_patterns
+# 导入静态资源URL配置工具，用于开发环境下提供静态文件访问
+from django.conf.urls.static import static
+# 导入站点地图视图，用于生成sitemap.xml
+from django.contrib.sitemaps.views import sitemap
+# 导入URL路径配置工具（path用于固定路径，re_path支持正则匹配，include用于包含子应用URL）
+from django.urls import path, include, re_path
+# 导入Haystack搜索视图工厂，用于自定义搜索视图
+from haystack.views import search_view_factory
+
+# 导入自定义视图和配置：博客搜索视图、自定义Admin站点、ElasticSearch搜索表单
+from blog.views import EsSearchView
+from djangoblog.admin_site import admin_site
+from djangoblog.elasticsearch_backend import ElasticSearchModelSearchForm
+# 导入RSS订阅Feed和站点地图类
+from djangoblog.feeds import DjangoBlogFeed
+from djangoblog.sitemap import (ArticleSiteMap, CategorySiteMap,
+                                StaticViewSitemap, TagSiteMap, UserSiteMap)
+
+
+# -------------------------- 站点地图配置 --------------------------
+# 定义站点地图字典：关联不同类型页面的Sitemap类，用于生成sitemap.xml
+sitemaps = {
+    'blog': ArticleSiteMap,    # 文章页面的站点地图
+    'Category': CategorySiteMap,  # 分类页面的站点地图
+    'Tag': TagSiteMap,         # 标签页面的站点地图
+    'User': UserSiteMap,       # 用户主页的站点地图
+    'static': StaticViewSitemap  # 静态页面（如首页）的站点地图
+}
+
+
+# -------------------------- 自定义错误页面配置 --------------------------
+# 配置404（页面不存在）错误对应的处理视图
+handler404 = 'blog.views.page_not_found_view'
+# 配置500（服务器内部错误）错误对应的处理视图
+handler500 = 'blog.views.server_error_view'
+# 配置403（权限不足）错误对应的处理视图
+handle403 = 'blog.views.permission_denied_view'
+
+
+# -------------------------- 基础URL配置 --------------------------
+# 非国际化URL列表：不随语言切换变化的URL
+urlpatterns = [
+    # 国际化切换入口：提供语言选择功能（如切换中英文）
+    path('i18n/', include('django.conf.urls.i18n')),
+]
+
+
+# -------------------------- 国际化URL配置 --------------------------
+# 国际化URL列表：会自动添加语言前缀（如/zh-hans/admin/、/en/admin/）
+# prefix_default_language=False：默认语言（如中文）不添加语言前缀，保持URL简洁
+urlpatterns += i18n_patterns(
+    # 自定义Admin后台URL：使用项目自定义的admin_site（非Django默认Admin）
+    re_path(r'^admin/', admin_site.urls),
+    # 博客核心功能URL：包含文章列表、详情等，命名空间为'blog'
+    re_path(r'', include('blog.urls', namespace='blog')),
+    # Markdown编辑器URL：集成mdeditor插件的路由
+    re_path(r'mdeditor/', include('mdeditor.urls')),
+    # 评论功能URL：包含评论提交、列表等，命名空间为'comment'
+    re_path(r'', include('comments.urls', namespace='comment')),
+    # 用户账户功能URL：包含登录、注册、个人中心等，命名空间为'account'
+    re_path(r'', include('accounts.urls', namespace='account')),
+    # 第三方登录URL：包含GitHub、微信等登录，命名空间为'oauth'
+    re_path(r'', include('oauth.urls', namespace='oauth')),
+    # 站点地图URL：生成sitemap.xml，供搜索引擎抓取
+    re_path(r'^sitemap\.xml$', sitemap, {'sitemaps': sitemaps},
+            name='django.contrib.sitemaps.views.sitemap'),
+    # RSS订阅URL：提供两种路径（/feed/和/rss/），均指向DjangoBlogFeed
+    re_path(r'^feed/$', DjangoBlogFeed()),
+    re_path(r'^rss/$', DjangoBlogFeed()),
+    # 搜索功能URL：使用ElasticSearch搜索视图和表单，命名空间为'search'
+    re_path('^search', search_view_factory(
+        view_class=EsSearchView,
+        form_class=ElasticSearchModelSearchForm
+    ), name='search'),
+    # 服务器管理功能URL：包含系统监控等，命名空间为'servermanager'
+    re_path(r'', include('servermanager.urls', namespace='servermanager')),
+    # 位置追踪功能URL：集成owntracks的路由，命名空间为'owntracks'
+    re_path(r'', include('owntracks.urls', namespace='owntracks')),
+    prefix_default_language=False  # 默认语言URL不添加语言前缀
+)
+
+
+# -------------------------- 静态资源与媒体文件URL配置 --------------------------
+# 开发环境下：添加静态文件URL映射（生产环境由Nginx/Apache处理）
+urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
+
+# DEBUG模式下（开发环境）：添加媒体文件（用户上传文件）的URL映射
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL,
+                          document_root=settings.MEDIA_ROOT)

src/utils.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+
+# 导入必要模块：日志、文件操作、随机数生成、加密、HTTP请求等
+import logging
+import os
+import random
+import string
+import uuid
+from hashlib import sha256
+
+# 导入第三方库：HTML过滤、Markdown转换、HTTP请求
+import bleach
+import markdown
+import requests
+# 导入Django核心模块：配置、缓存、站点模型、静态文件工具
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.cache import cache
+from django.templatetags.static import static
+
+# 创建当前模块的日志记录器
+logger = logging.getLogger(__name__)
+
+
+def get_max_articleid_commentid():
+    """
+    获取最大的文章ID和评论ID
+    用于系统统计或数据同步场景，快速获取最新数据的ID边界
+    """
+    # 延迟导入模型（避免循环导入问题）
+    from blog.models import Article
+    from comments.models import Comment
+    # 返回最新文章和评论的主键（ID）
+    return (Article.objects.latest().pk, Comment.objects.latest().pk)
+
+
+def get_sha256(str):
+    """
+    对字符串进行SHA256加密
+    用于密码加密、数据校验等场景（如生成唯一标识）
+    """
+    m = sha256(str.encode('utf-8'))  # 编码为UTF-8后加密
+    return m.hexdigest()  # 返回十六进制加密结果
+
+
+def cache_decorator(expiration=3 * 60):
+    """
+    缓存装饰器：为函数添加缓存功能，减少重复计算或数据库查询
+    默认缓存时间为3分钟（180秒），可通过参数调整
+
+    Args:
+        expiration: 缓存过期时间（秒）
+    """
+
+    def wrapper(func):
+        def news(*args, **kwargs):
+            # 尝试从请求对象中获取缓存键（适用于视图函数）
+            try:
+                view = args[0]
+                key = view.get_cache_key()
+            except:
+                key = None  # 非视图函数则生成自定义键
+
+            # 生成自定义缓存键（基于函数和参数的唯一标识）
+            if not key:
+                unique_str = repr((func, args, kwargs))  # 序列化函数和参数
+                m = sha256(unique_str.encode('utf-8'))
+                key = m.hexdigest()  # 生成唯一哈希键
+
+            # 从缓存获取数据
+            value = cache.get(key)
+            if value is not None:
+                # 处理空值标记（避免缓存None导致的重复计算）
+                if str(value) == '__default_cache_value__':
+                    return None
+                else:
+                    return value  # 返回缓存数据
+            else:
+                # 缓存未命中，执行原函数并缓存结果
+                logger.debug(f'cache_decorator set cache:{func.__name__} key:{key}')
+                value = func(*args, **kwargs)
+                # 缓存空值时用特殊标记，避免缓存穿透
+                if value is None:
+                    cache.set(key, '__default_cache_value__', expiration)
+                else:
+                    cache.set(key, value, expiration)
+                return value
+
+        return news
+
+    return wrapper
+
+
+def expire_view_cache(path, servername, serverport, key_prefix=None):
+    '''
+    主动刷新视图缓存：删除指定URL路径的缓存
+    用于数据更新后同步清理缓存，确保用户看到最新内容
+
+    Args:
+        path: URL路径（如'/article/1/'）
+        servername: 服务器域名/主机名
+        serverport: 服务器端口
+        key_prefix: 缓存键前缀
+
+    Returns:
+        bool: 缓存是否成功删除
+    '''
+    from django.http import HttpRequest
+    from django.utils.cache import get_cache_key
+
+    # 构造模拟请求对象（用于生成缓存键）
+    request = HttpRequest()
+    request.META = {'SERVER_NAME': servername, 'SERVER_PORT': serverport}
+    request.path = path
+
+    # 获取缓存键并删除缓存
+    key = get_cache_key(request, key_prefix=key_prefix, cache=cache)
+    if key:
+        logger.info(f'expire_view_cache:get key:{path}')
+        if cache.get(key):
+            cache.delete(key)
+        return True
+    return False
+
+
+@cache_decorator()
+def get_current_site():
+    """
+    获取当前站点信息（缓存装饰器确保高效获取）
+    基于Django的sites框架，用于生成绝对URL等场景
+    """
+    site = Site.objects.get_current()
+    return site
+
+
+class CommonMarkdown:
+    """
+    Markdown转换工具类：将Markdown文本转换为HTML，并支持生成目录（TOC）
+    集成代码高亮、表格等扩展功能
+    """
+
+    @staticmethod
+    def _convert_markdown(value):
+        """内部转换方法：执行Markdown到HTML的转换，返回内容和目录"""
+        md = markdown.Markdown(
+            extensions=[
+                'extra',  # 基础扩展（表格、脚注等）
+                'codehilite',  # 代码高亮
+                'toc',  # 目录生成
+                'tables',  # 表格支持
+            ]
+        )
+        body = md.convert(value)  # 转换正文为HTML
+        toc = md.toc  # 提取目录
+        return body, toc
+
+    @staticmethod
+    def get_markdown_with_toc(value):
+        """获取带目录的HTML内容"""
+        body, toc = CommonMarkdown._convert_markdown(value)
+        return body, toc
+
+    @staticmethod
+    def get_markdown(value):
+        """仅获取转换后的HTML正文（不含目录）"""
+        body, toc = CommonMarkdown._convert_markdown(value)
+        return body
+
+
+def send_email(emailto, title, content):
+    """
+    发送邮件的封装函数：通过信号机制发送邮件，解耦邮件发送逻辑
+    实际发送由信号接收者处理（如调用Django邮件后端）
+    """
+    from djangoblog.blog_signals import send_email_signal
+    # 发送信号，传递邮件参数
+    send_email_signal.send(
+        send_email.__class__,
+        emailto=emailto,
+        title=title,
+        content=content)
+
+
+def generate_code() -> str:
+    """生成6位数字随机验证码，用于邮箱验证、登录等场景"""
+    return ''.join(random.sample(string.digits, 6))  # 从0-9中随机选择6个数字
+
+
+def parse_dict_to_url(dict):
+    """
+    将字典转换为URL查询参数字符串（如{'a':1,'b':2} → 'a=1&b=2'）
+    自动对键值进行URL编码，支持特殊字符
+
+    Args:
+        dict: 键值对字典
+
+    Returns:
+        str: URL查询参数字符串
+    """
+    from urllib.parse import quote
+    return '&'.join([
+        f'{quote(k, safe="/")}={quote(v, safe="/")}'
+        for k, v in dict.items()
+    ])
+
+
+def get_blog_setting():
+    """
+    获取博客系统设置（单例模式），并缓存结果
+    包含站点名称、描述、SEO配置等核心设置
+
+    Returns:
+        BlogSettings对象：系统设置实例
+    """
+    # 先从缓存获取，减少数据库查询
+    value = cache.get('get_blog_setting')
+    if value:
+        return value
+    else:
+        from blog.models import BlogSettings
+        # 若不存在设置记录，创建默认配置
+        if not BlogSettings.objects.count():
+            setting = BlogSettings()
+            setting.site_name = 'djangoblog'
+            setting.site_description = '基于Django的博客系统'
+            setting.site_seo_description = '基于Django的博客系统'
+            setting.site_keywords = 'Django,Python'
+            setting.article_sub_length = 300
+            setting.sidebar_article_count = 10
+            setting.sidebar_comment_count = 5
+            setting.show_google_adsense = False
+            setting.open_site_comment = True
+            setting.analytics_code = ''
+            setting.beian_code = ''
+            setting.show_gongan_code = False
+            setting.comment_need_review = False
+            setting.save()
+        # 获取设置并缓存
+        value = BlogSettings.objects.first()
+        logger.info('set cache get_blog_setting')
+        cache.set('get_blog_setting', value)
+        return value
+
+
+def save_user_avatar(url):
+    '''
+    保存用户头像到本地静态目录，并返回访问URL
+    用于处理第三方登录（如GitHub）的头像保存
+
+    Args:
+        url: 头像的远程URL
+
+    Returns:
+        str: 本地头像的静态文件URL（默认返回系统默认头像）
+    '''
+    logger.info(url)
+    try:
+        # 定义本地保存路径（static/avatar目录）
+        basedir = os.path.join(settings.STATICFILES, 'avatar')
+        # 下载头像图片
+        rsp = requests.get(url, timeout=2)
+        if rsp.status_code == 200:
+            # 创建目录（若不存在）
+            if not os.path.exists(basedir):
+                os.makedirs(basedir)
+
+            # 验证文件类型并确定扩展名
+            image_extensions = ['.jpg', '.png', 'jpeg', '.gif']
+            isimage = len([i for i in image_extensions if url.endswith(i)]) > 0
+            ext = os.path.splitext(url)[1] if isimage else '.jpg'
+            # 生成唯一文件名（UUID避免冲突）
+            save_filename = str(uuid.uuid4().hex) + ext
+            logger.info(f'保存用户头像:{basedir}{save_filename}')
+            # 写入文件
+            with open(os.path.join(basedir, save_filename), 'wb+') as file:
+                file.write(rsp.content)
+            # 返回静态文件URL
+            return static('avatar/' + save_filename)
+    except Exception as e:
+        logger.error(e)
+    # 失败时返回默认头像
+    return static('blog/img/avatar.png')
+
+
+def delete_sidebar_cache():
+    """
+    删除侧边栏缓存：当侧边栏数据（如链接、文章列表）更新时调用
+    确保用户看到最新的侧边栏内容
+    """
+    from blog.models import LinkShowType
+    # 生成所有侧边栏缓存键（基于链接展示类型）
+    keys = ["sidebar" + x for x in LinkShowType.values]
+    for k in keys:
+        logger.info(f'delete sidebar key:{k}')
+        cache.delete(k)
+
+
+def delete_view_cache(prefix, keys):
+    """
+    删除模板片段缓存：用于删除指定前缀和参数的模板缓存
+    如文章详情页的评论区缓存
+
+    Args:
+        prefix: 缓存前缀（模板中定义）
+        keys: 缓存键参数列表
+    """
+    from django.core.cache.utils import make_template_fragment_key
+    key = make_template_fragment_key(prefix, keys)
+    cache.delete(key)
+
+
+def get_resource_url():
+    """
+    获取静态资源基础URL
+    优先使用settings中的STATIC_URL，否则基于当前站点域名生成
+
+    Returns:
+        str: 静态资源URL前缀（如'http://example.com/static/'）
+    """
+    if settings.STATIC_URL:
+        return settings.STATIC_URL
+    else:
+        site = get_current_site()
+        return f'http://{site.domain}/static/'
+
+
+# HTML过滤配置：限制允许的标签和属性，防止XSS攻击
+ALLOWED_TAGS = ['a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i',
+                'li', 'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'p']
+ALLOWED_ATTRIBUTES = {
+    'a': ['href', 'title'],
+    'abbr': ['title'],
+    'acronym': ['title']
+}
+
+
+def sanitize_html(html):
+    """
+    净化HTML内容：仅保留允许的标签和属性，过滤恶意代码
+    用于处理用户输入的HTML（如评论、文章内容），防止XSS攻击
+
+    Args:
+        html: 原始HTML字符串
+
+    Returns:
+        str: 净化后的安全HTML
+    """
+    return bleach.clean(
+        html,
+        tags=ALLOWED_TAGS,
+        attributes=ALLOWED_ATTRIBUTES
+    )

src/wsgi.py

@@ -0,0 +1,28 @@
+"""
+WSGI config for djangoblog project.
+Django博客项目的WSGI配置文件
+WSGI（Web Server Gateway Interface）是Web服务器与Python Web应用之间的通信标准
+负责将Web服务器（如Nginx、Apache）接收的HTTP请求转发给Django应用，再将应用响应返回给服务器
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+该文件将WSGI可调用对象（处理请求的核心入口）暴露为模块级变量，命名为`application`
+Web服务器通过调用这个`application`对象与Django应用交互
+
+For more information on this file, see
+https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/
+"""
+
+# 导入Python内置的os模块，用于读取环境变量、处理路径等
+import os
+
+# 导入Django的WSGI应用生成器：根据项目配置创建WSGI可调用对象
+from django.core.wsgi import get_wsgi_application
+
+# 设置Django项目的配置模块环境变量
+# 告诉Django使用哪个settings文件（此处为项目根目录下的djangoblog.settings）
+# 生产环境中可通过服务器配置修改该环境变量，切换不同配置（如生产/测试配置）
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoblog.settings")
+
+# 创建WSGI应用对象：Django根据上述配置生成处理HTTP请求的核心入口
+# Web服务器（如Gunicorn、uWSGI）会加载这个`application`对象来运行项目
+application = get_wsgi_application()