提交

提交

doc/DjangoBlog界面设计说明书.md

@@ -0,0 +1,211 @@
+# "DjangoBlog"软件系统的界面设计
+
+组号：19
+
+小组成员：张恒祺，胡振，李裕祥，杜英硕，王浩
+
+## 软件系统概述
+
+DjangoBlog 是一款基于 Django 框架开发的现代化博客系统，旨在为个人博主、技术团队和企业提供功能完善的内容发布平台。系统通过用户友好的界面设计和清晰的模板架构，实现了从文章发布、内容管理到读者互动的全流程服务。系统解决了传统博客系统界面单一、功能有限、维护困难等问题，为作者提供便捷的内容创作体验，同时为读者提供优质的阅读体验。
+
+## 功能分析
+
+系统主要实现以下核心功能模块：
+
+### 1. 用户端功能
+
+**文章展示模块**：以列表和详情形式展示所有文章，支持分类浏览和标签筛选
+
+**智能搜索模块**：支持全文搜索，提供精准的搜索结果和高亮显示
+
+**文章归档模块**：按时间维度组织文章，支持年月日多级归档浏览
+
+**评论互动模块**：读者评论、点赞、分享等社交功能
+
+**用户认证模块**：用户注册、登录、密码重置等账户管理功能
+
+### 2. 管理端功能
+
+**文章管理模块**：文章的增删改查、发布状态控制、分类标签管理
+
+**评论管理模块**：评论审核、回复、垃圾评论过滤
+
+**数据统计模块**：访问统计、热门文章分析、读者行为分析
+
+**系统设置模块**：博客信息配置、主题样式管理、SEO设置
+
+## 软件主要的界面设计
+
+### 1. 系统首页界面
+
+**界面功能**：文章列表展示、分类导航、搜索入口
+
+**界面元素**：
+- 顶部导航栏：包含Logo、主导航菜单（首页、分类、归档、关于）
+- 侧边栏区域：搜索框、分类列表、热门文章、标签云
+- 文章列表区：采用卡片式布局展示文章标题、摘要、发布时间、阅读量
+- 分页导航：支持多页文章浏览
+
+### 2. 文章详情界面
+
+**界面功能**：完整文章内容展示、评论系统、相关文章推荐
+
+**界面组件**：
+- 面包屑导航：显示当前位置和导航路径
+- 文章标题区：文章标题、作者信息、发布时间、阅读统计
+- 文章内容区：支持Markdown渲染、代码高亮、目录导航
+- 文章元信息：标签列表、分类信息、社交分享按钮
+- 评论区域：评论列表、评论表单、评论分页
+
+### 3. 搜索界面
+
+**界面功能**：全文搜索、结果展示、高级筛选
+
+**界面元素**：
+- 搜索框：支持关键词联想和搜索历史
+- 搜索结果：以列表形式展示，支持按相关度、时间排序
+- 高亮显示：搜索关键词在结果中高亮标记
+- 筛选选项：支持按分类、标签、时间范围筛选
+
+### 4. 归档界面
+
+**界面功能**：按时间浏览历史文章
+
+**界面组件**：
+- 时间树形结构：按年-月-日层次展示文章分布
+- 文章链接列表：每个时间节点下的文章标题链接
+- 统计信息：各时间段文章数量统计
+
+**界面关系图**：
+![图片描述](https://code.educoder.net/api/pqkpsr3gu/DjangoBlog/raw/src%2Fimg%2Ff5b2b176a93286ba173c053e60bb4b0d.png?ref=hz_branch)
+
+## 模板设计
+
+### 模板架构设计
+
+本系统采用Django模板引擎，基于MTV架构设计了一套完整的模板系统，实现了界面元素的高度复用和统一管理。模板系统采用分层设计理念，从基础布局到具体功能页面，形成了清晰的继承和包含关系。
+
+### 模板继承关系
+![归档界面时间树结构](https://code.educoder.net/api/pqkpsr3gu/DjangoBlog/raw/src%2Fimg%2Fbb816f59d4732648c2ce554565975e06.png?ref=hz_branch)
+### 模板继承机制说明
+
+#### 1. 基础模板层次
+
+**base.html (基础布局)**
+- 提供网站整体HTML结构
+- 包含全局CSS和JavaScript资源
+- 定义主要的内容区块（header、content、footer、sidebar）
+
+**base_account.html (用户认证页面布局)**
+- 继承base.html但采用简化布局
+- 专门用于登录、注册等认证页面
+- 移除侧边栏，专注于表单功能
+
+**各功能页面模板**
+- article_index.html (文章列表)：展示分页文章列表
+- article_detail.html (文章详情)：完整文章内容和评论系统
+- article_archives.html (文章归档)：时间维度的文章组织
+- error_page.html (错误页面)：友好的错误提示
+- search.html (搜索页面)：搜索结果展示
+
+#### 2. 模板包含关系
+
+**base.html 包含关系**：
+- nav.html (导航菜单)：主导航和响应式菜单
+- footer.html (页脚)：版权信息、友情链接、备案信息
+- adsense.html (广告)：广告位和统计代码
+
+**内容区块结构**：
+- content (主要内容)：各页面特有的内容区域
+- sidebar (侧边栏)：通过sidebar.html加载辅助功能组件
+
+#### 3. 模板标签系统
+
+**核心模板标签 (blog_tags.py)**：
+- `load_article_detail`：加载文章详情数据
+- `load_sidebar`：动态生成侧边栏内容
+- `load_breadcrumb`：生成面包屑导航
+- `load_article_metas`：加载文章元信息（作者、时间、阅读量）
+- `load_pagination_info`：生成分页导航
+
+**模板标签文件结构**：
+```
+templates/blog/tags/
+├── article_info.html (文章基本信息展示)
+├── article_meta_info.html (文章元信息展示)
+├── article_pagination.html (分页控件)
+├── article_tag_list.html (标签云和标签列表)
+├── breadcrumb.html (面包屑导航)
+└── sidebar.html (侧边栏组件集合)
+```
+
+#### 4. 模板功能分析
+
+**基础模板 (base.html) 功能**：
+- HTML5 文档结构和语义化标签
+- SEO 元标签优化（title、description、keywords）
+- OpenGraph 和 Twitter Card 社交媒体支持
+- 响应式设计支持和移动端适配
+- 全局样式表和JavaScript资源管理
+- 网站头部导航和底部信息统一管理
+
+**文章列表模板 (article_index.html) 特点**：
+- 支持多种布局模式（列表、网格）
+- 智能分页机制，优化大量数据展示
+- 多维度筛选（分类、标签、时间）
+- 集成搜索功能和排序选项
+- SEO友好的URL结构和标题层次
+
+**文章详情模板 (article_detail.html) 功能**：
+- Markdown内容渲染和代码高亮
+- 自动生成文章目录（TOC）导航
+- 多级评论系统和回复功能
+- 相关文章推荐算法
+- 社交分享按钮和统计代码
+- 阅读进度指示器和阅读时间估算
+
+**侧边栏模板 (sidebar.html) 组件**：
+- 智能搜索框（支持自动补全）
+- 分类树形结构和文章计数
+- 热门文章排行榜（按阅读量、评论数）
+- 最近评论列表和作者回复
+- 标签云可视化展示
+- 友情链接管理和展示
+- 管理员功能快捷入口
+
+### 界面设计特点
+
+#### 1. 响应式设计
+- 采用移动优先的响应式设计理念
+- 支持从手机到桌面的全设备适配
+- 自适应侧边栏布局（桌面端显示，移动端可隐藏）
+- 触摸友好的交互元素设计
+
+#### 2. SEO 优化
+- 完整的meta标签体系和结构化数据
+- JSON-LD格式的富片段标记
+- 面包屑导航和规范的URL结构
+- 语义化HTML5标签使用
+- 图片alt属性和延迟加载
+
+#### 3. 用户体验
+- 清晰的视觉层次和信息架构
+- 快速的页面加载和流畅的交互
+- 智能的内容推荐和个性化展示
+- 无障碍访问支持（ARIA标签）
+- 一致的操作反馈和状态提示
+
+#### 4. 性能优化
+- 模板片段缓存和数据库查询优化
+- 静态资源压缩和CDN加速
+- 图片懒加载和响应式图片
+- 渐进式加载和骨架屏技术
+- 服务端渲染和客户端增强
+
+## 总结
+
+DjangoBlog 系统采用了清晰的模板继承和包含关系，通过基础模板提供统一布局，通过模板标签实现组件化开发。整个系统具有良好的可维护性和扩展性，适合作为博客系统的基础框架进行二次开发。
+
+界面设计注重用户体验和 SEO 优化，通过响应式布局和丰富的交互功能，为用户提供了良好的浏览体验。模板系统的模块化设计使得系统易于维护和扩展，同时为后续功能迭代提供了良好的基础架构。
+
+系统的界面流转逻辑清晰，用户可以从多个入口访问内容，最终都汇聚到核心的文章详情页面。这种设计既保证了内容的可发现性，又提供了连贯的用户体验。模板标签系统的细粒度组件设计，使得界面元素的复用和定制变得简单高效。

src/.coveragerc

@@ -1,10 +0,0 @@
-[run]
-source = .
-include = *.py
-omit =
-    *migrations*
-    *tests*
-    *.html
-    *whoosh_cn_backend*
-    *settings.py*
-    *venv*

src/.dockerignore

@@ -8,4 +8,5 @@ settings_production.py
 *.md
 docs/
 logs/
-static/
+static/
+.github/

src/.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5

src/.github/workflows/codeql-analysis.yml

@@ -38,10 +38,12 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-
+        uses: github/codeql-action/init@v3
+        with:
+          languages: python
+          
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
+        uses: github/codeql-action/autobuild@v3
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3

src/.github/workflows/deploy-master.yml

@@ -0,0 +1,176 @@
+name: 自动部署到生产环境
+
+on:
+  workflow_run:
+    workflows: ["Django CI"]
+    types:
+      - completed
+    branches:
+      - master
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: '部署环境'
+        required: true
+        default: 'production'
+        type: choice
+        options:
+        - production
+        - staging
+      image_tag:
+        description: '镜像标签 (默认: latest)'
+        required: false
+        default: 'latest'
+        type: string
+      skip_tests:
+        description: '跳过测试直接部署'
+        required: false
+        default: false
+        type: boolean
+
+env:
+  REGISTRY: registry.cn-shenzhen.aliyuncs.com
+  IMAGE_NAME: liangliangyy/djangoblog
+  NAMESPACE: djangoblog
+
+jobs:
+  deploy:
+    name: 构建镜像并部署到生产环境
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
+    
+    steps:
+    - name: 检出代码
+      uses: actions/checkout@v4
+      
+    - name: 设置部署参数
+      id: deploy-params
+      run: |
+        if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+          echo "trigger_type=手动触发" >> $GITHUB_OUTPUT
+          echo "environment=${{ github.event.inputs.environment }}" >> $GITHUB_OUTPUT
+          echo "image_tag=${{ github.event.inputs.image_tag }}" >> $GITHUB_OUTPUT
+          echo "skip_tests=${{ github.event.inputs.skip_tests }}" >> $GITHUB_OUTPUT
+        else
+          echo "trigger_type=CI自动触发" >> $GITHUB_OUTPUT
+          echo "environment=production" >> $GITHUB_OUTPUT
+          echo "image_tag=latest" >> $GITHUB_OUTPUT
+          echo "skip_tests=false" >> $GITHUB_OUTPUT
+        fi
+        
+    - name: 显示部署信息
+      run: |
+        echo "🚀 部署信息："
+        echo "   触发方式: ${{ steps.deploy-params.outputs.trigger_type }}"
+        echo "   部署环境: ${{ steps.deploy-params.outputs.environment }}"
+        echo "   镜像标签: ${{ steps.deploy-params.outputs.image_tag }}"
+        echo "   跳过测试: ${{ steps.deploy-params.outputs.skip_tests }}"
+      
+    - name: 设置Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      
+    - name: 登录私有镜像仓库
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ secrets.REGISTRY_USERNAME }}
+        password: ${{ secrets.REGISTRY_PASSWORD }}
+        
+    - name: 提取镜像元数据
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+        tags: |
+          type=ref,event=branch
+          type=sha,prefix={{branch}}-
+          type=raw,value=${{ steps.deploy-params.outputs.image_tag }}
+          
+    - name: 构建并推送Docker镜像
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./Dockerfile
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        platforms: linux/amd64
+        
+    - name: 部署到生产服务器
+      uses: appleboy/ssh-action@v1.0.3
+      with:
+        host: ${{ secrets.PRODUCTION_HOST }}
+        username: ${{ secrets.PRODUCTION_USER }}
+        key: ${{ secrets.PRODUCTION_SSH_KEY }}
+        port: ${{ secrets.PRODUCTION_PORT || 22 }}
+        script: |
+          echo "🚀 开始部署 DjangoBlog..."
+          
+          # 检查kubectl是否可用
+          if ! command -v kubectl &> /dev/null; then
+            echo "❌ 错误: kubectl 未安装或不在PATH中"
+            exit 1
+          fi
+          
+          # 检查命名空间是否存在
+          if ! kubectl get namespace ${{ env.NAMESPACE }} &> /dev/null; then
+            echo "❌ 错误: 命名空间 ${{ env.NAMESPACE }} 不存在"
+            exit 1
+          fi
+          
+          # 更新deployment镜像
+          echo "📦 更新deployment镜像为: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.deploy-params.outputs.image_tag }}"
+          kubectl set image deployment/djangoblog \
+            djangoblog=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.deploy-params.outputs.image_tag }} \
+            -n ${{ env.NAMESPACE }}
+          
+          # 重启deployment
+          echo "🔄 重启deployment..."
+          kubectl -n ${{ env.NAMESPACE }} rollout restart deployment djangoblog
+          
+          # 等待deployment完成
+          echo "⏳ 等待deployment完成..."
+          kubectl rollout status deployment/djangoblog -n ${{ env.NAMESPACE }} --timeout=300s
+          
+          # 检查deployment状态
+          echo "✅ 检查deployment状态..."
+          kubectl get deployment djangoblog -n ${{ env.NAMESPACE }}
+          kubectl get pods -l app=djangoblog -n ${{ env.NAMESPACE }}
+          
+          echo "🎉 部署完成！"
+          
+    - name: 发送部署通知
+      if: always()
+      run: |
+        # 设置通知内容
+        if [ "${{ job.status }}" = "success" ]; then
+          TITLE="✅ DjangoBlog部署成功"
+          STATUS="成功"
+        else
+          TITLE="❌ DjangoBlog部署失败"
+          STATUS="失败"
+        fi
+        
+        MESSAGE="部署状态: ${STATUS}
+        触发方式: ${{ steps.deploy-params.outputs.trigger_type }}
+        部署环境: ${{ steps.deploy-params.outputs.environment }}
+        镜像标签: ${{ steps.deploy-params.outputs.image_tag }}
+        提交者: ${{ github.actor }}
+        时间: $(date '+%Y-%m-%d %H:%M:%S')
+        
+        查看详情: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+        
+        # 发送Server酱通知
+        if [ -n "${{ secrets.SERVERCHAN_KEY }}" ]; then
+          echo "{\"title\": \"${TITLE}\", \"desp\": \"${MESSAGE}\"}" > /tmp/serverchan.json
+          
+          curl --location "https://sctapi.ftqq.com/${{ secrets.SERVERCHAN_KEY }}.send" \
+            --header "Content-Type: application/json" \
+            --data @/tmp/serverchan.json \
+            --silent > /dev/null
+          
+          rm -f /tmp/serverchan.json
+          echo "📱 部署通知已发送"
+        fi

src/.github/workflows/django.yml

@@ -19,55 +19,59 @@ on:
       - '**/*.js'
 
 jobs:
-  build-normal:
+  test:
     runs-on: ubuntu-latest
     strategy:
-      max-parallel: 4
+      fail-fast: false
       matrix:
-        python-version: ["3.10","3.11" ]
+        include:
+          # 标准测试 - Python 3.10
+          - python-version: "3.10"
+            test-type: "standard"
+            database: "mysql"
+            elasticsearch: false
+            coverage: false
+            
+          # 标准测试 - Python 3.11  
+          - python-version: "3.11"
+            test-type: "standard" 
+            database: "mysql"
+            elasticsearch: false
+            coverage: false
+            
+          # 完整测试 - 包含ES和覆盖率
+          - python-version: "3.11"
+            test-type: "full"
+            database: "mysql"
+            elasticsearch: true
+            coverage: true
+            
+          # Docker构建测试
+          - python-version: "3.11"
+            test-type: "docker"
+            database: "none"
+            elasticsearch: false
+            coverage: false
 
+    name: Test (${{ matrix.test-type }}, Python ${{ matrix.python-version }})
+    
     steps:
-      - name: Start MySQL
-        uses: samin/mysql-action@v1.3
-        with:
-          host port: 3306
-          container port: 3306
-          character set server: utf8mb4
-          collation server: utf8mb4_general_ci
-          mysql version: latest
-          mysql root password: root
-          mysql database: djangoblog
-          mysql user: root
-          mysql password: root
-
-      - uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: 'pip'
-      - name: Install Dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt
-      - name: Run Tests
-        env:
-          DJANGO_MYSQL_PASSWORD: root
-          DJANGO_MYSQL_HOST: 127.0.0.1
+      - name: Checkout代码
+        uses: actions/checkout@v4
+        
+      - name: 设置测试信息
+        id: test-info
         run: |
-          python manage.py makemigrations
-          python manage.py migrate
-          python manage.py test
-
-  build-with-es:
-    runs-on: ubuntu-latest
-    strategy:
-      max-parallel: 4
-      matrix:
-        python-version: ["3.10","3.11" ]
-
-    steps:
-      - name: Start MySQL
+          echo "test_name=${{ matrix.test-type }}-py${{ matrix.python-version }}" >> $GITHUB_OUTPUT
+          if [ "${{ matrix.test-type }}" = "docker" ]; then
+            echo "skip_python_setup=true" >> $GITHUB_OUTPUT
+          else
+            echo "skip_python_setup=false" >> $GITHUB_OUTPUT
+          fi
+          
+      # MySQL数据库设置 (只有需要数据库的测试才执行)
+      - name: 启动MySQL数据库
+        if: matrix.database == 'mysql'
         uses: samin/mysql-action@v1.3
         with:
           host port: 3306
@@ -79,58 +83,289 @@ jobs:
           mysql database: djangoblog
           mysql user: root
           mysql password: root
-
-      - name: Configure sysctl limits
+          
+      # Elasticsearch设置 (只有完整测试才执行)
+      - name: 配置系统参数 (ES)
+        if: matrix.elasticsearch == true
         run: |
           sudo swapoff -a
           sudo sysctl -w vm.swappiness=1
           sudo sysctl -w fs.file-max=262144
           sudo sysctl -w vm.max_map_count=262144
-
-      - uses: miyataka/elasticsearch-github-actions@1
-
+          
+      - name: 启动Elasticsearch
+        if: matrix.elasticsearch == true
+        uses: miyataka/elasticsearch-github-actions@1
         with:
           stack-version: '7.12.1'
           plugins: 'https://release.infinilabs.com/analysis-ik/stable/elasticsearch-analysis-ik-7.12.1.zip'
-
-
-      - uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+          
+      # Python环境设置 (Docker测试跳过)
+      - name: 设置Python ${{ matrix.python-version }}
+        if: steps.test-info.outputs.skip_python_setup == 'false'
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
           cache: 'pip'
-      - name: Install Dependencies
+          cache-dependency-path: 'requirements.txt'
+          
+      # 多层缓存策略优化
+      - name: 缓存Python依赖
+        if: steps.test-info.outputs.skip_python_setup == 'false'
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+            .pytest_cache
+          key: ${{ runner.os }}-python-${{ matrix.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('**/pyproject.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-python-${{ matrix.python-version }}-${{ hashFiles('requirements.txt') }}-
+            ${{ runner.os }}-python-${{ matrix.python-version }}-
+            ${{ runner.os }}-python-
+            
+      # Django缓存优化 (测试数据库等)
+      - name: 缓存Django资源
+        if: matrix.test-type != 'docker'
+        uses: actions/cache@v4
+        with:
+          path: |
+            .coverage*
+            htmlcov/
+            .django_cache/
+          key: ${{ runner.os }}-django-${{ matrix.test-type }}-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-django-${{ matrix.test-type }}-
+            ${{ runner.os }}-django-
+            
+      - name: 安装Python依赖
+        if: steps.test-info.outputs.skip_python_setup == 'false'
         run: |
-          python -m pip install --upgrade pip
+          echo "📦 安装Python依赖 (Python ${{ matrix.python-version }})"
+          python -m pip install --upgrade pip setuptools wheel
+          
+          # 安装基础依赖
           pip install -r requirements.txt
-      - name: Run Tests
+          
+          # 根据测试类型安装额外依赖
+          if [ "${{ matrix.coverage }}" = "true" ]; then
+            echo "📊 安装覆盖率工具"
+            pip install coverage[toml]
+          fi
+          
+          # 验证关键依赖
+          echo "🔍 验证关键依赖安装"
+          python -c "import django; print(f'Django version: {django.get_version()}')"
+          python -c "import MySQLdb; print('MySQL client: OK')" || python -c "import pymysql; print('PyMySQL client: OK')"
+          
+          if [ "${{ matrix.elasticsearch }}" = "true" ]; then
+            python -c "import elasticsearch; print('Elasticsearch client: OK')"
+          fi
+          
+      # Django环境准备
+      - name: 准备Django环境
+        if: matrix.test-type != 'docker'
         env:
           DJANGO_MYSQL_PASSWORD: root
           DJANGO_MYSQL_HOST: 127.0.0.1
-          DJANGO_ELASTICSEARCH_HOST: 127.0.0.1:9200
+          DJANGO_ELASTICSEARCH_HOST: ${{ matrix.elasticsearch && '127.0.0.1:9200' || '' }}
         run: |
-          python manage.py makemigrations
-          python manage.py migrate
-          coverage run manage.py test
-          coverage xml
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v1
-
-  docker:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Build and push
-        uses: docker/build-push-action@v3
+          echo "🔧 准备Django测试环境"
+          
+          # 等待数据库就绪
+          echo "⏳ 等待MySQL数据库启动..."
+          for i in {1..30}; do
+            if python -c "import MySQLdb; MySQLdb.connect(host='127.0.0.1', user='root', passwd='root', db='djangoblog')" 2>/dev/null; then
+              echo "✅ MySQL数据库连接成功"
+              break
+            fi
+            echo "🔄 等待数据库启动... ($i/30)"
+            sleep 2
+          done
+          
+          # 等待Elasticsearch就绪 (如果启用)
+          if [ "${{ matrix.elasticsearch }}" = "true" ]; then
+            echo "⏳ 等待Elasticsearch启动..."
+            for i in {1..30}; do
+              if curl -s http://127.0.0.1:9200/_cluster/health | grep -q '"status":"green"\|"status":"yellow"'; then
+                echo "✅ Elasticsearch连接成功"
+                break
+              fi
+              echo "🔄 等待Elasticsearch启动... ($i/30)"
+              sleep 2
+            done
+          fi
+          
+      # Django测试执行
+      - name: 执行数据库迁移
+        if: matrix.test-type != 'docker'
+        env:
+          DJANGO_MYSQL_PASSWORD: root
+          DJANGO_MYSQL_HOST: 127.0.0.1
+          DJANGO_ELASTICSEARCH_HOST: ${{ matrix.elasticsearch && '127.0.0.1:9200' || '' }}
+        run: |
+          echo "🗄️ 执行数据库迁移"
+          
+          # 检查迁移文件
+          echo "📋 检查待应用的迁移..."
+          python manage.py showmigrations
+          
+          # 检查是否有未创建的迁移
+          python manage.py makemigrations --check --verbosity 2
+          
+          # 执行迁移
+          python manage.py migrate --verbosity 2
+          
+          echo "✅ 数据库迁移完成"
+          
+      - name: 运行Django测试
+        if: matrix.test-type != 'docker'
+        env:
+          DJANGO_MYSQL_PASSWORD: root
+          DJANGO_MYSQL_HOST: 127.0.0.1
+          DJANGO_ELASTICSEARCH_HOST: ${{ matrix.elasticsearch && '127.0.0.1:9200' || '' }}
+        run: |
+          echo "🧪 开始执行 ${{ matrix.test-type }} 测试 (Python ${{ matrix.python-version }})"
+          
+          # 显示Django配置信息
+          python manage.py diffsettings | head -20
+          
+          # 运行测试
+          if [ "${{ matrix.coverage }}" = "true" ]; then
+            echo "📊 运行测试并生成覆盖率报告"
+            coverage run --source='.' --omit='*/venv/*,*/migrations/*,*/tests/*,manage.py' manage.py test --verbosity=2
+            
+            echo "📈 生成覆盖率报告"
+            coverage xml
+            coverage report --show-missing
+            coverage html
+            
+            echo "📋 覆盖率统计:"
+            coverage report | tail -1
+          else
+            echo "🧪 运行标准测试"
+            python manage.py test --verbosity=2 --failfast
+          fi
+          
+          echo "✅ 测试执行完成"
+          
+      # 覆盖率报告上传 (只有完整测试才执行)
+      - name: 上传覆盖率到Codecov
+        if: matrix.coverage == true && success()
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          file: ./coverage.xml
+          flags: unittests
+          name: codecov-${{ steps.test-info.outputs.test_name }}
+          fail_ci_if_error: false
+          verbose: true
+          
+      - name: 上传覆盖率到Codecov (备用)
+        if: matrix.coverage == true && failure()
+        uses: codecov/codecov-action@v4
+        with:
+          file: ./coverage.xml
+          flags: unittests
+          name: codecov-${{ steps.test-info.outputs.test_name }}-fallback
+          fail_ci_if_error: false
+          verbose: true
+          
+      # Docker构建测试
+      - name: 设置QEMU
+        if: matrix.test-type == 'docker'
+        uses: docker/setup-qemu-action@v3
+        
+      - name: 设置Docker Buildx
+        if: matrix.test-type == 'docker'
+        uses: docker/setup-buildx-action@v3
+        
+      - name: Docker构建测试
+        if: matrix.test-type == 'docker'
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: false
-          tags: djangoblog/djangoblog:dev
+          tags: djangoblog/djangoblog:test-${{ github.sha }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          
+      # 收集测试工件 (失败时收集调试信息)
+      - name: 收集测试工件
+        if: failure() && matrix.test-type != 'docker'
+        run: |
+          echo "🔍 收集测试失败的调试信息"
+          
+          # 收集Django日志
+          if [ -d "logs" ]; then
+            echo "📄 Django日志文件:"
+            ls -la logs/
+            if [ -f "logs/djangoblog.log" ]; then
+              echo "🔍 最新日志内容:"
+              tail -100 logs/djangoblog.log
+            fi
+          fi
+          
+          # 显示数据库状态
+          echo "🗄️ 数据库连接状态:"
+          python -c "
+          try:
+              from django.db import connection
+              cursor = connection.cursor()
+              cursor.execute('SELECT VERSION()')
+              print(f'MySQL版本: {cursor.fetchone()[0]}')
+              cursor.execute('SHOW TABLES')
+              tables = cursor.fetchall()
+              print(f'数据库表数量: {len(tables)}')
+          except Exception as e:
+              print(f'数据库连接错误: {e}')
+          " || true
+          
+          # Elasticsearch状态 (如果启用)
+          if [ "${{ matrix.elasticsearch }}" = "true" ]; then
+            echo "🔍 Elasticsearch状态:"
+            curl -s http://127.0.0.1:9200/_cluster/health?pretty || true
+          fi
+          
+      # 上传测试工件
+      - name: 上传覆盖率HTML报告
+        if: matrix.coverage == true && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report-${{ steps.test-info.outputs.test_name }}
+          path: htmlcov/
+          retention-days: 30
+          
+      # 性能统计
+      - name: 测试性能统计
+        if: always() && matrix.test-type != 'docker'
+        run: |
+          echo "⚡ 测试性能统计:"
+          echo "   开始时间: $(date -d '@${{ job.started_at }}' '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo '未知')"
+          echo "   当前时间: $(date '+%Y-%m-%d %H:%M:%S')"
+          
+          # 系统资源使用情况
+          echo "💻 系统资源:"
+          echo "   CPU使用: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)%"
+          echo "   内存使用: $(free -h | awk '/^Mem:/ {printf "%.1f%%", $3/$2 * 100}')"
+          echo "   磁盘使用: $(df -h / | awk 'NR==2{printf "%s", $5}')"
+          
+      # 测试结果汇总
+      - name: 测试完成总结
+        if: always()
+        run: |
+          echo "📋 ============ 测试执行总结 ============"
+          echo "   🏷️  测试类型: ${{ matrix.test-type }}"
+          echo "   🐍 Python版本: ${{ matrix.python-version }}"
+          echo "   🗄️  数据库: ${{ matrix.database }}"
+          echo "   🔍 Elasticsearch: ${{ matrix.elasticsearch }}"
+          echo "   📊 覆盖率: ${{ matrix.coverage }}"
+          echo "   ⚡ 状态: ${{ job.status }}"
+          echo "   📅 完成时间: $(date '+%Y-%m-%d %H:%M:%S')"
+          echo "============================================"
+          
+          # 根据测试结果显示不同消息
+          if [ "${{ job.status }}" = "success" ]; then
+            echo "🎉 测试执行成功！"
+          else
+            echo "❌ 测试执行失败，请检查上面的日志"
+          fi

src/.github/workflows/docker.yml

@@ -8,7 +8,7 @@ on:
     branches:
       - 'master'
       - 'dev'
-
+  workflow_dispatch:
 jobs:
   docker:
     runs-on: ubuntu-latest
@@ -22,19 +22,19 @@ jobs:
         run: |
          echo "DOCKER_TAG=latest" >> $GITHUB_ENV
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
     
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       - name: Build and push
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true

src/.gitignore

@@ -62,7 +62,6 @@ target/
 # http://www.jetbrains.com/pycharm/webhelp/project.html
 .idea
 .iml
-static/
 # virtualenv
 venv/
 

src/README.md

@@ -0,0 +1,158 @@
+# DjangoBlog
+
+<p align="center">
+  <a href="https://github.com/liangliangyy/DjangoBlog/actions/workflows/django.yml"><img src="https://github.com/liangliangyy/DjangoBlog/actions/workflows/django.yml/badge.svg" alt="Django CI"></a>
+  <a href="https://github.com/liangliangyy/DjangoBlog/actions/workflows/codeql-analysis.yml"><img src="https://github.com/liangliangyy/DjangoBlog/actions/workflows/codeql-analysis.yml/badge.svg" alt="CodeQL"></a>
+  <a href="https://codecov.io/gh/liangliangyy/DjangoBlog"><img src="https://codecov.io/gh/liangliangyy/DjangoBlog/branch/master/graph/badge.svg" alt="codecov"></a>
+  <a href="https://github.com/liangliangyy/DjangoBlog/blob/master/LICENSE"><img src="https://img.shields.io/github/license/liangliangyy/djangoblog.svg" alt="license"></a>
+</p>
+
+<p align="center">
+  <b>一款功能强大、设计优雅的现代化博客系统</b>
+  <br>
+  <a href="/docs/README-en.md">English</a> • <b>简体中文</b>
+</p>
+
+---
+
+DjangoBlog 是一款基于 Python 3.10 和 Django 4.0 构建的高性能博客平台。它不仅提供了传统博客的所有核心功能，还通过一个灵活的插件系统，让您可以轻松扩展和定制您的网站。无论您是个人博主、技术爱好者还是内容创作者，DjangoBlog 都旨在为您提供一个稳定、高效且易于维护的写作和发布环境。
+
+## ✨ 特性亮点
+
+- **强大的内容管理**: 支持文章、独立页面、分类和标签的完整管理。内置强大的 Markdown 编辑器，支持代码语法高亮。
+- **全文搜索**: 集成搜索引擎，提供快速、精准的文章内容搜索。
+- **互动评论系统**: 支持回复、邮件提醒等功能，评论内容同样支持 Markdown。
+- **灵活的侧边栏**: 可自定义展示最新文章、最多阅读、标签云等模块。
+- **社交化登录**: 内置 OAuth 支持，已集成 Google, GitHub, Facebook, 微博, QQ 等主流平台。
+- **高性能缓存**: 原生支持 Redis 缓存，并提供自动刷新机制，确保网站高速响应。
+- **SEO 友好**: 具备基础 SEO 功能，新内容发布后可自动通知 Google 和百度。
+- **便捷的插件系统**: 通过创建独立的插件来扩展博客功能，代码解耦，易于维护。我们已经通过插件实现了文章浏览计数、SEO 优化等功能！
+- **集成图床**: 内置简单的图床功能，方便图片上传和管理。
+- **自动化前端**: 集成 `django-compressor`，自动压缩和优化 CSS 及 JavaScript 文件。
+- **健壮的运维**: 内置网站异常邮件提醒和微信公众号管理功能。
+
+## 🛠️ 技术栈
+
+- **后端**: Python 3.10, Django 4.0
+- **数据库**: MySQL, SQLite (可配置)
+- **缓存**: Redis
+- **前端**: HTML5, CSS3, JavaScript
+- **搜索**: Whoosh, Elasticsearch (可配置)
+- **编辑器**: Markdown (mdeditor)
+
+## 🚀 快速开始
+
+### 1. 环境准备
+
+确保您的系统中已安装 Python 3.10+ 和 MySQL/MariaDB。
+
+### 2. 克隆与安装
+
+```bash
+# 克隆项目到本地
+git clone https://github.com/liangliangyy/DjangoBlog.git
+cd DjangoBlog
+
+# 安装依赖
+pip install -r requirements.txt
+```
+
+### 3. 项目配置
+
+- **数据库**:
+  打开 `djangoblog/settings.py` 文件，找到 `DATABASES` 配置项，修改为您的 MySQL 连接信息。
+
+  ```python
+  DATABASES = {
+      'default': {
+          'ENGINE': 'django.db.backends.mysql',
+          'NAME': 'djangoblog',
+          'USER': 'root',
+          'PASSWORD': 'your_password',
+          'HOST': '127.0.0.1',
+          'PORT': 3306,
+      }
+  }
+  ```
+  在 MySQL 中创建数据库:
+  ```sql
+  CREATE DATABASE `djangoblog` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+  ```
+
+- **更多配置**:
+  关于邮件发送、OAuth 登录、缓存等更多高级配置，请参阅我们的 [详细配置文档](/docs/config.md)。
+
+### 4. 初始化数据库
+
+```bash
+python manage.py makemigrations
+python manage.py migrate
+
+# 创建一个超级管理员账户
+python manage.py createsuperuser
+```
+
+### 5. 运行项目
+
+```bash
+# (可选) 生成一些测试数据
+python manage.py create_testdata
+
+# (可选) 收集和压缩静态文件
+python manage.py collectstatic --noinput
+python manage.py compress --force
+
+# 启动开发服务器
+python manage.py runserver
+```
+
+现在，在您的浏览器中访问 `http://127.0.0.1:8000/`，您应该能看到 DjangoBlog 的首页了！
+
+## 部署
+
+- **传统部署**: 我们为您准备了非常详细的 [服务器部署教程](https://www.lylinux.net/article/2019/8/5/58.html)。
+- **Docker 部署**: 项目已全面支持 Docker。如果您熟悉容器化技术，请参考 [Docker 部署文档](/docs/docker.md) 来快速启动。
+- **Kubernetes 部署**: 我们也提供了完整的 [Kubernetes 部署指南](/docs/k8s.md)，助您轻松上云。
+
+## 🧩 插件系统
+
+插件系统是 DjangoBlog 的核心特色之一。它允许您在不修改核心代码的情况下，通过编写独立的插件来为您的博客添加新功能。
+
+- **工作原理**: 插件通过在预定义的“钩子”上注册回调函数来工作。例如，当一篇文章被渲染时，`after_article_body_get` 钩子会被触发，所有注册到此钩子的函数都会被执行。
+- **现有插件**: `view_count`（浏览计数）, `seo_optimizer`（SEO优化）等都是通过插件系统实现的。
+- **开发您自己的插件**: 只需在 `plugins` 目录下创建一个新的文件夹，并编写您的 `plugin.py`。欢迎探索并为 DjangoBlog 社区贡献您的创意！
+
+## 🤝 贡献指南
+
+我们热烈欢迎任何形式的贡献！如果您有好的想法或发现了 Bug，请随时提交 Issue 或 Pull Request。
+
+## 📄 许可证
+
+本项目基于 [MIT License](LICENSE) 开源。
+
+---
+
+## ❤️ 支持与赞助
+
+如果您觉得这个项目对您有帮助，并且希望支持我继续维护和开发新功能，欢迎请我喝杯咖啡！您的每一份支持都是我前进的最大动力。
+
+<p align="center">
+  <img src="/docs/imgs/alipay.jpg" width="150" alt="支付宝赞助">
+  <img src="/docs/imgs/wechat.jpg" width="150" alt="微信赞助">
+</p>
+<p align="center">
+  <i>(左) 支付宝 / (右) 微信</i>
+</p>
+
+## 🙏 鸣谢
+
+特别感谢 **JetBrains** 为本项目提供的免费开源许可证。
+
+<p align="center">
+  <a href="https://www.jetbrains.com/?from=DjangoBlog">
+    <img src="/docs/imgs/pycharm_logo.png" width="150" alt="JetBrains Logo">
+  </a>
+</p>
+
+---
+> 如果本项目帮助到了你，请在[这里](https://github.com/liangliangyy/DjangoBlog/issues/214)留下你的网址，让更多的人看到。您的回复将会是我继续更新维护下去的动力。

src/accounts/admin.py

@@ -57,3 +57,4 @@ class BlogUserAdmin(UserAdmin):
         'source')
     list_display_links = ('id', 'username')
     ordering = ('-id',)
+    search_fields = ('username', 'nickname', 'email')

src/blog/admin.py

@@ -6,9 +6,9 @@ from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 
 # Register your models here.
-from .models import Article
-
+from .models import Article, Category, Tag, Links, SideBar, BlogSettings
 
+#zhq: 文章表单类 - 可用于定制文章编辑表单
 class ArticleForm(forms.ModelForm):
     # body = forms.CharField(widget=AdminPagedownWidget())
 
@@ -16,29 +16,29 @@ class ArticleForm(forms.ModelForm):
         model = Article
         fields = '__all__'
 
-
+#zhq: Admin动作函数 - 批量发布文章
 def makr_article_publish(modeladmin, request, queryset):
     queryset.update(status='p')
 
-
+#zhq: Admin动作函数 - 批量设为草稿
 def draft_article(modeladmin, request, queryset):
     queryset.update(status='d')
 
-
+#zhq: Admin动作函数 - 批量关闭评论
 def close_article_commentstatus(modeladmin, request, queryset):
     queryset.update(comment_status='c')
 
-
+#zhq: Admin动作函数 - 批量开启评论
 def open_article_commentstatus(modeladmin, request, queryset):
     queryset.update(comment_status='o')
 
-
+#zhq: 设置动作的描述信息
 makr_article_publish.short_description = _('Publish selected articles')
 draft_article.short_description = _('Draft selected articles')
 close_article_commentstatus.short_description = _('Close article comments')
 open_article_commentstatus.short_description = _('Open article comments')
 
-
+#zhq: 文章管理类 - 定制文章在Admin中的显示和行为
 class ArticlelAdmin(admin.ModelAdmin):
     list_per_page = 20
     search_fields = ('body', 'title')
@@ -55,6 +55,7 @@ class ArticlelAdmin(admin.ModelAdmin):
         'article_order')
     list_display_links = ('id', 'title')
     list_filter = ('status', 'type', 'category')
+    date_hierarchy = 'creation_time'
     filter_horizontal = ('tags',)
     exclude = ('creation_time', 'last_modify_time')
     view_on_site = True
@@ -62,9 +63,15 @@ class ArticlelAdmin(admin.ModelAdmin):
         makr_article_publish,
         draft_article,
         close_article_commentstatus,
+<<<<<<< HEAD
         open_article_commentstatus]
+    raw_id_fields = ('author', 'category',)
+=======
+        open_article_commentstatus] #zhq: 注册批量动作
+>>>>>>> ff9fd39bdd141837237a8123ff2dc58c9bfa8e25
 
     def link_to_category(self, obj):
+        # zhq: 自定义方法，生成分类的管理后台链接
         info = (obj.category._meta.app_label, obj.category._meta.model_name)
         link = reverse('admin:%s_%s_change' % info, args=(obj.category.id,))
         return format_html(u'<a href="%s">%s</a>' % (link, obj.category.name))
@@ -72,6 +79,7 @@ class ArticlelAdmin(admin.ModelAdmin):
     link_to_category.short_description = _('category')
 
     def get_form(self, request, obj=None, **kwargs):
+        # zhq: 限制作者字段只能选择超级用户
         form = super(ArticlelAdmin, self).get_form(request, obj, **kwargs)
         form.base_fields['author'].queryset = get_user_model(
         ).objects.filter(is_superuser=True)
@@ -81,6 +89,7 @@ class ArticlelAdmin(admin.ModelAdmin):
         super(ArticlelAdmin, self).save_model(request, obj, form, change)
 
     def get_view_on_site_url(self, obj=None):
+        # zhq: 获取文章在前台的访问链接
         if obj:
             url = obj.get_full_url()
             return url
@@ -89,24 +98,24 @@ class ArticlelAdmin(admin.ModelAdmin):
             site = get_current_site().domain
             return site
 
-
+#zhq: 标签管理类 - 简化管理界面
 class TagAdmin(admin.ModelAdmin):
     exclude = ('slug', 'last_mod_time', 'creation_time')
 
-
+#zhq: 分类管理类 - 显示父级分类信息
 class CategoryAdmin(admin.ModelAdmin):
     list_display = ('name', 'parent_category', 'index')
     exclude = ('slug', 'last_mod_time', 'creation_time')
 
-
+#zhq: 友情链接管理类
 class LinksAdmin(admin.ModelAdmin):
     exclude = ('last_mod_time', 'creation_time')
 
-
+#zhq: 侧边栏管理类
 class SideBarAdmin(admin.ModelAdmin):
     list_display = ('name', 'content', 'is_enable', 'sequence')
     exclude = ('last_mod_time', 'creation_time')
 
-
+#zhq: 博客设置管理类 - 使用默认管理界面
 class BlogSettingsAdmin(admin.ModelAdmin):
     pass

src/blog/apps.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig
 
-
+#zhq: 博客应用配置类 - 继承自Django的AppConfig基类
 class BlogConfig(AppConfig):
-    name = 'blog'
+    name = 'blog' #zhq: 应用名称，对应INSTALLED_APPS中的名称

src/blog/context_processors.py

@@ -7,7 +7,7 @@ from .models import Category, Article
 
 logger = logging.getLogger(__name__)
 
-
+#zhq: SEO上下文处理器 - 为所有模板提供SEO相关变量和导航数据
 def seo_processor(requests):
     key = 'seo_processor'
     value = cache.get(key)
@@ -15,29 +15,32 @@ def seo_processor(requests):
         return value
     else:
         logger.info('set processor cache.')
+        # zhq: 获取博客全局设置
         setting = get_blog_setting()
+        # zhq: 构建上下文数据字典
         value = {
-            'SITE_NAME': setting.site_name,
-            'SHOW_GOOGLE_ADSENSE': setting.show_google_adsense,
-            'GOOGLE_ADSENSE_CODES': setting.google_adsense_codes,
-            'SITE_SEO_DESCRIPTION': setting.site_seo_description,
-            'SITE_DESCRIPTION': setting.site_description,
-            'SITE_KEYWORDS': setting.site_keywords,
-            'SITE_BASE_URL': requests.scheme + '://' + requests.get_host() + '/',
-            'ARTICLE_SUB_LENGTH': setting.article_sub_length,
-            'nav_category_list': Category.objects.all(),
+            'SITE_NAME': setting.site_name,#zhq: 网站名称
+            'SHOW_GOOGLE_ADSENSE': setting.show_google_adsense,#zhq: 是否显示Google广告
+            'GOOGLE_ADSENSE_CODES': setting.google_adsense_codes,#zhq: Google广告代码
+            'SITE_SEO_DESCRIPTION': setting.site_seo_description,#zhq: SEO描述
+            'SITE_DESCRIPTION': setting.site_description,#zhq: 网站描述
+            'SITE_KEYWORDS': setting.site_keywords,#zhq: 网站关键词
+            'SITE_BASE_URL': requests.scheme + '://' + requests.get_host() + '/',#zhq: 网站基础URL
+            'ARTICLE_SUB_LENGTH': setting.article_sub_length,#zhq: 文章摘要长度
+            'nav_category_list': Category.objects.all(),#zhq: 导航分类列表
             'nav_pages': Article.objects.filter(
-                type='p',
-                status='p'),
-            'OPEN_SITE_COMMENT': setting.open_site_comment,
-            'BEIAN_CODE': setting.beian_code,
-            'ANALYTICS_CODE': setting.analytics_code,
-            "BEIAN_CODE_GONGAN": setting.gongan_beiancode,
-            "SHOW_GONGAN_CODE": setting.show_gongan_code,
-            "CURRENT_YEAR": timezone.now().year,
-            "GLOBAL_HEADER": setting.global_header,
-            "GLOBAL_FOOTER": setting.global_footer,
-            "COMMENT_NEED_REVIEW": setting.comment_need_review,
+                type='p',#zhq: 页面类型
+                status='p'),#zhq: 发布状态
+            'OPEN_SITE_COMMENT': setting.open_site_comment,#zhq: 是否开启全站评论
+            'BEIAN_CODE': setting.beian_code,#zhq: ICP备案号
+            'ANALYTICS_CODE': setting.analytics_code,#zhq: 网站统计代码
+            "BEIAN_CODE_GONGAN": setting.gongan_beiancode,#zhq: 公安备案号
+            "SHOW_GONGAN_CODE": setting.show_gongan_code,#zhq: 是否显示公安备案号
+            "CURRENT_YEAR": timezone.now().year,#zhq: 当前年份
+            "GLOBAL_HEADER": setting.global_header,#zhq: 全局头部HTML
+            "GLOBAL_FOOTER": setting.global_footer,#zhq: 全局尾部HTML
+            "COMMENT_NEED_REVIEW": setting.comment_need_review,#zhq: 评论是否需要审核
         }
+        # zhq: 缓存上下文数据10小时，提高性能
         cache.set(key, value, 60 * 60 * 10)
         return value

src/blog/forms.py

@@ -5,15 +5,18 @@ from haystack.forms import SearchForm
 
 logger = logging.getLogger(__name__)
 
-
+#zhq: 博客搜索表单类 - 继承自Haystack的SearchForm
 class BlogSearchForm(SearchForm):
     querydata = forms.CharField(required=True)
 
     def search(self):
+        #zhq: 执行搜索操作，调用父类的search方法
         datas = super(BlogSearchForm, self).search()
+        # zhq: 如果表单验证失败，返回空结果
         if not self.is_valid():
             return self.no_query_found()
-
+        
+        # zhq: 记录搜索关键词到日志
         if self.cleaned_data['querydata']:
             logger.info(self.cleaned_data['querydata'])
         return datas

src/blog/management/commands/init_canteen_data.py

@@ -0,0 +1,90 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.hashers import make_password
+from django.core.management.base import BaseCommand
+
+from blog.models import Article, Tag, Category
+
+
+class Command(BaseCommand):
+    help = 'Initialize canteen ordering themed test data'
+
+    def handle(self, *args, **options):
+        user = get_user_model().objects.get_or_create(
+            email='canteen@test.com', username='食堂管理员', password=make_password('canteen!Q@W#2025'))[0]
+
+        # 顶级分类：校园食堂
+        canteen_category = Category.objects.get_or_create(
+            name='校园食堂', parent_category=None, defaults={"index": 100}
+        )[0]
+
+        # 二级分类：各食堂
+        east_canteen = Category.objects.get_or_create(
+            name='东区食堂', parent_category=canteen_category, defaults={"index": 90}
+        )[0]
+        west_canteen = Category.objects.get_or_create(
+            name='西区食堂', parent_category=canteen_category, defaults={"index": 80}
+        )[0]
+
+        # 三级分类：档口
+        stalls = [
+            Category.objects.get_or_create(name='川味档口', parent_category=east_canteen, defaults={"index": 70})[0],
+            Category.objects.get_or_create(name='面点档口', parent_category=east_canteen, defaults={"index": 60})[0],
+            Category.objects.get_or_create(name='简餐档口', parent_category=west_canteen, defaults={"index": 50})[0],
+            Category.objects.get_or_create(name='风味小吃', parent_category=west_canteen, defaults={"index": 40})[0],
+        ]
+
+        # 标签：口味与饮食偏好
+        base_tags = [
+            Tag.objects.get_or_create(name='辣味')[0],
+            Tag.objects.get_or_create(name='清淡')[0],
+            Tag.objects.get_or_create(name='无辣')[0],
+            Tag.objects.get_or_create(name='主食')[0],
+            Tag.objects.get_or_create(name='素食可选')[0],
+        ]
+
+        # 示例菜品以文章承载：标题为菜名，正文为描述/价格
+        dish_specs = [
+            ("宫保鸡丁套餐", "包含米饭+素菜，价格￥18，可加辣"),
+            ("红烧牛肉面", "大份牛肉足量，价格￥22，清淡口可选"),
+            ("番茄鸡蛋盖浇饭", "酸甜开胃，价格￥15，老少皆宜"),
+            ("麻辣香锅", "自选配菜，称重计价，约￥20-30/份"),
+            ("素什锦炒面", "少油少盐，价格￥14，素食友好"),
+            ("鸡排饭", "现炸鸡排+配菜，价格￥19，无辣版本可选"),
+            ("牛肉卷饼", "现烙饼皮，价格￥12，可加蛋+2"),
+            ("酸辣粉", "地道红薯粉，价格￥13，可微辣/中特/特辣"),
+        ]
+
+        tag_cycle = base_tags * 4
+        idx = 0
+        for stall in stalls:
+            for dish_title, dish_body in dish_specs:
+                article = Article.objects.get_or_create(
+                    category=stall,
+                    title=f'{stall.name}-{dish_title}',
+                    defaults={
+                        'body': f'{dish_body}\n\n口味标签：{tag_cycle[idx % len(tag_cycle)].name}',
+                        'author': user,
+                        'status': 'p',
+                        'comment_status': 'o',
+                        'type': 'a',
+                        'article_order': 0,
+                        'show_toc': False,
+                    }
+                )[0]
+                # 绑定两个标签
+                article.tags.add(tag_cycle[idx % len(tag_cycle)])
+                article.tags.add(tag_cycle[(idx + 1) % len(tag_cycle)])
+                article.save()
+                idx += 1
+
+        from djangoblog.utils import cache
+        cache.clear()
+        self.stdout.write(self.style.SUCCESS('Initialized canteen ordering themed test data.'))
+
+
+
+
+
+
+
+

src/blog/middleware.py

@@ -9,6 +9,7 @@ from blog.documents import ELASTICSEARCH_ENABLED, ElaspedTimeDocumentManager
 logger = logging.getLogger(__name__)
 
 
+#zhq: 在线中间件类 - 用于监控页面加载时间和用户访问信息
 class OnlineMiddleware(object):
     def __init__(self, get_response=None):
         self.get_response = get_response
@@ -16,16 +17,20 @@ class OnlineMiddleware(object):
 
     def __call__(self, request):
         ''' page render time '''
+        # zhq: 记录请求开始时间
         start_time = time.time()
         response = self.get_response(request)
+        #zhq: 获取客户端IP地址和User-Agent信息
         http_user_agent = request.META.get('HTTP_USER_AGENT', '')
         ip, _ = get_client_ip(request)
         user_agent = parse(http_user_agent)
         if not response.streaming:
             try:
+                #zhq: 计算页面渲染时间
                 cast_time = time.time() - start_time
+                # zhq: 如果启用了Elasticsearch，记录性能数据
                 if ELASTICSEARCH_ENABLED:
-                    time_taken = round((cast_time) * 1000, 2)
+                    time_taken = round((cast_time) * 1000, 2) #zhq: 转换为毫秒并保留2位小数
                     url = request.path
                     from django.utils import timezone
                     ElaspedTimeDocumentManager.create(
@@ -34,8 +39,9 @@ class OnlineMiddleware(object):
                         log_datetime=timezone.now(),
                         useragent=user_agent,
                         ip=ip)
+                    # zhq: 在响应内容中替换加载时间占位符
                 response.content = response.content.replace(
-                    b'<!!LOAD_TIMES!!>', str.encode(str(cast_time)[:5]))
+                    b'<!!LOAD_TIMES!!>', str.encode(str(cast_time)[:5])) #zhq: 保留前5位字符
             except Exception as e:
                 logger.error("Error OnlineMiddleware: %s" % e)
 

src/blog/models.py

@@ -16,27 +16,28 @@ from djangoblog.utils import get_current_site
 
 logger = logging.getLogger(__name__)
 
-
+#zhq: 链接显示类型选择类 - 定义链接在不同页面的显示方式
 class LinkShowType(models.TextChoices):
-    I = ('i', _('index'))
-    L = ('l', _('list'))
-    P = ('p', _('post'))
-    A = ('a', _('all'))
-    S = ('s', _('slide'))
-
+    I = ('i', _('index'))#zhq: 首页显示
+    L = ('l', _('list'))#zhq: 列表页显示
+    P = ('p', _('post'))#zhq: 文章页显示
+    A = ('a', _('all'))#zhq: 所有页面显示
+    S = ('s', _('slide'))#zhq: 幻灯片显示
 
+#zhq: 基础模型抽象类 - 所有模型的基类，包含公共字段和方法
 class BaseModel(models.Model):
     id = models.AutoField(primary_key=True)
     creation_time = models.DateTimeField(_('creation time'), default=now)
     last_modify_time = models.DateTimeField(_('modify time'), default=now)
 
-    def save(self, *args, **kwargs):
+    def save(self, *args, **kwargs):#zhq: 特殊处理文章浏览量的更新，避免触发其他字段的保存逻辑
         is_update_views = isinstance(
             self,
             Article) and 'update_fields' in kwargs and kwargs['update_fields'] == ['views']
         if is_update_views:
             Article.objects.filter(pk=self.pk).update(views=self.views)
         else:
+            # zhq: 自动生成slug字段，用于SEO友好的URL
             if 'slug' in self.__dict__:
                 slug = getattr(
                     self, 'title') if 'title' in self.__dict__ else getattr(
@@ -45,6 +46,7 @@ class BaseModel(models.Model):
             super().save(*args, **kwargs)
 
     def get_full_url(self):
+        # zhq: 获取对象的完整URL地址
         site = get_current_site().domain
         url = "https://{site}{path}".format(site=site,
                                             path=self.get_absolute_url())
@@ -55,9 +57,10 @@ class BaseModel(models.Model):
 
     @abstractmethod
     def get_absolute_url(self):
+        # zhq: 抽象方法，子类必须实现获取绝对URL的方法
         pass
 
-
+#zhq: 文章模型 - 博客的核心内容模型
 class Article(BaseModel):
     """文章"""
     STATUS_CHOICES = (
@@ -112,7 +115,7 @@ class Article(BaseModel):
         return self.title
 
     class Meta:
-        ordering = ['-article_order', '-pub_time']
+        ordering = ['-article_order', '-pub_time']#zhq: 按排序和发布时间降序排列
         verbose_name = _('article')
         verbose_name_plural = verbose_name
         get_latest_by = 'id'
@@ -127,6 +130,7 @@ class Article(BaseModel):
 
     @cache_decorator(60 * 60 * 10)
     def get_category_tree(self):
+        # zhq: 获取文章所属分类的完整树形结构
         tree = self.category.get_category_tree()
         names = list(map(lambda c: (c.name, c.get_absolute_url()), tree))
 
@@ -136,10 +140,12 @@ class Article(BaseModel):
         super().save(*args, **kwargs)
 
     def viewed(self):
+        # zhq: 增加文章浏览量
         self.views += 1
         self.save(update_fields=['views'])
 
     def comment_list(self):
+        # zhq: 获取文章的评论列表，带缓存功能
         cache_key = 'article_comments_{id}'.format(id=self.id)
         value = cache.get(cache_key)
         if value:
@@ -152,6 +158,7 @@ class Article(BaseModel):
             return comments
 
     def get_admin_url(self):
+        # zhq: 获取文章在Admin后台的编辑链接
         info = (self._meta.app_label, self._meta.model_name)
         return reverse('admin:%s_%s_change' % info, args=(self.pk,))
 
@@ -176,7 +183,7 @@ class Article(BaseModel):
             return match.group(1)
         return ""
 
-
+#zhq: 分类模型 - 支持多级分类结构
 class Category(BaseModel):
     """文章分类"""
     name = models.CharField(_('category name'), max_length=30, unique=True)
@@ -185,7 +192,7 @@ class Category(BaseModel):
         verbose_name=_('parent category'),
         blank=True,
         null=True,
-        on_delete=models.CASCADE)
+        on_delete=models.CASCADE) #zhq: 自关联，支持多级分类
     slug = models.SlugField(default='no-slug', max_length=60, blank=True)
     index = models.IntegerField(default=0, verbose_name=_('index'))
 
@@ -239,7 +246,7 @@ class Category(BaseModel):
         parse(self)
         return categorys
 
-
+#zhq: 标签模型 - 简单的标签管理
 class Tag(BaseModel):
     """文章标签"""
     name = models.CharField(_('tag name'), max_length=30, unique=True)
@@ -253,6 +260,7 @@ class Tag(BaseModel):
 
     @cache_decorator(60 * 60 * 10)
     def get_article_count(self):
+        # zhq: 获取该标签下的文章数量
         return Article.objects.filter(tags__name=self.name).distinct().count()
 
     class Meta:
@@ -260,32 +268,32 @@ class Tag(BaseModel):
         verbose_name = _('tag')
         verbose_name_plural = verbose_name
 
-
+#zhq: 友情链接模型
 class Links(models.Model):
     """友情链接"""
 
     name = models.CharField(_('link name'), max_length=30, unique=True)
     link = models.URLField(_('link'))
-    sequence = models.IntegerField(_('order'), unique=True)
+    sequence = models.IntegerField(_('order'), unique=True) #zhq: 链接显示顺序
     is_enable = models.BooleanField(
         _('is show'), default=True, blank=False, null=False)
     show_type = models.CharField(
         _('show type'),
         max_length=1,
         choices=LinkShowType.choices,
-        default=LinkShowType.I)
+        default=LinkShowType.I) #zhq: 链接显示类型
     creation_time = models.DateTimeField(_('creation time'), default=now)
     last_mod_time = models.DateTimeField(_('modify time'), default=now)
 
     class Meta:
-        ordering = ['sequence']
+        ordering = ['sequence'] #zhq: 按顺序排列
         verbose_name = _('link')
         verbose_name_plural = verbose_name
 
     def __str__(self):
         return self.name
 
-
+#zhq: 侧边栏模型 - 支持自定义HTML内容
 class SideBar(models.Model):
     """侧边栏,可以展示一些html内容"""
     name = models.CharField(_('title'), max_length=100)
@@ -303,7 +311,7 @@ class SideBar(models.Model):
     def __str__(self):
         return self.name
 
-
+#zhq: 博客设置模型 - 单例模式，存储全局配置
 class BlogSettings(models.Model):
     """blog的配置"""
     site_name = models.CharField(
@@ -326,11 +334,11 @@ class BlogSettings(models.Model):
         null=False,
         blank=False,
         default='')
-    article_sub_length = models.IntegerField(_('article sub length'), default=300)
-    sidebar_article_count = models.IntegerField(_('sidebar article count'), default=10)
-    sidebar_comment_count = models.IntegerField(_('sidebar comment count'), default=5)
-    article_comment_count = models.IntegerField(_('article comment count'), default=5)
-    show_google_adsense = models.BooleanField(_('show adsense'), default=False)
+    article_sub_length = models.IntegerField(_('article sub length'), default=300) #zhq: 文章摘要长度
+    sidebar_article_count = models.IntegerField(_('sidebar article count'), default=10) #zhq: 侧边栏文章数量
+    sidebar_comment_count = models.IntegerField(_('sidebar comment count'), default=5) #zhq: 侧边栏评论数量
+    article_comment_count = models.IntegerField(_('article comment count'), default=5) #zhq: 文章页评论数量
+    show_google_adsense = models.BooleanField(_('show adsense'), default=False) #zhq:是否显示Google广告
     google_adsense_codes = models.TextField(
         _('adsense code'), max_length=2000, null=True, blank=True, default='')
     open_site_comment = models.BooleanField(_('open site comment'), default=True)
@@ -341,13 +349,13 @@ class BlogSettings(models.Model):
         max_length=2000,
         null=True,
         blank=True,
-        default='')
+        default='') #zhq: ICP备案号
     analytics_code = models.TextField(
         "网站统计代码",
         max_length=1000,
         null=False,
         blank=False,
-        default='')
+        default='') #zhq: 网站统计代码
     show_gongan_code = models.BooleanField(
         '是否显示公安备案号', default=False, null=False)
     gongan_beiancode = models.TextField(
@@ -357,7 +365,7 @@ class BlogSettings(models.Model):
         blank=True,
         default='')
     comment_need_review = models.BooleanField(
-        '评论是否需要审核', default=False, null=False)
+        '评论是否需要审核', default=False, null=False) #zhq: 评论审核开关
 
     class Meta:
         verbose_name = _('Website configuration')
@@ -367,6 +375,7 @@ class BlogSettings(models.Model):
         return self.site_name
 
     def clean(self):
+        # zhq: 确保配置表只有一条记录（单例模式）
         if BlogSettings.objects.exclude(id=self.id).count():
             raise ValidationError(_('There can only be one configuration'))
 

src/blog/static/account/css/account.css

@@ -0,0 +1,9 @@
+.button {
+    border: none;
+    padding: 4px 80px;
+    text-align: center;
+    text-decoration: none;
+    display: inline-block;
+    font-size: 16px;
+    margin: 4px 2px;
+}

src/blog/static/account/js/account.js

@@ -0,0 +1,47 @@
+let wait = 60;
+
+function time(o) {
+    if (wait == 0) {
+        o.removeAttribute("disabled");
+        o.value = "获取验证码";
+        wait = 60
+        return false
+    } else {
+        o.setAttribute("disabled", true);
+        o.value = "重新发送(" + wait + ")";
+        wait--;
+        setTimeout(function () {
+                time(o)
+            },
+            1000)
+    }
+}
+
+document.getElementById("btn").onclick = function () {
+    let id_email = $("#id_email")
+    let token = $("*[name='csrfmiddlewaretoken']").val()
+    let ts = this
+    let myErr = $("#myErr")
+    $.ajax(
+        {
+            url: "/forget_password_code/",
+            type: "POST",
+            data: {
+                "email": id_email.val(),
+                "csrfmiddlewaretoken": token
+            },
+            success: function (result) {
+                if (result != "ok") {
+                    myErr.remove()
+                    id_email.after("<ul className='errorlist' id='myErr'><li>" + result + "</li></ul>")
+                    return
+                }
+                myErr.remove()
+                time(ts)
+            },
+            error: function (e) {
+                alert("发送失败,请重试")
+            }
+        }
+    );
+}

src/blog/static/assets/css/ie10-viewport-bug-workaround.css

@@ -0,0 +1,13 @@
+/*!
+ * IE10 viewport hack for Surface/desktop Windows 8 bug
+ * Copyright 2014-2015 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ */
+
+/*
+ * See the Getting Started docs for more information:
+ * http://getbootstrap.com/getting-started/#support-ie10-width
+ */
+@-ms-viewport     { width: device-width; }
+@-o-viewport      { width: device-width; }
+@viewport         { width: device-width; }

src/blog/static/assets/css/signin.css

@@ -0,0 +1,58 @@
+body {
+  padding-top: 40px;
+  padding-bottom: 40px;
+  background-color: #fff;
+}
+
+.form-signin {
+  max-width: 330px;
+  padding: 15px;
+  margin: 0 auto;
+}
+.form-signin-heading {
+  margin: 0 0 15px;
+  font-size: 18px;
+  font-weight: 400;
+  color: #555;
+}
+.form-signin .checkbox {
+  margin-bottom: 10px;
+  font-weight: normal;
+}
+.form-signin .form-control {
+  position: relative;
+  height: auto;
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+  padding: 10px;
+  font-size: 16px;
+}
+.form-signin .form-control:focus {
+  z-index: 2;
+}
+.form-signin input[type="email"] {
+  margin-bottom: 10px;
+}
+.form-signin input[type="password"] {
+  margin-bottom: 10px;
+}
+.card {
+  width: 304px;
+  padding: 20px 25px 30px;
+  margin: 0 auto 25px;
+  background-color: #f7f7f7;
+  border-radius: 2px;
+  -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, .3);
+          box-shadow: 0 2px 2px rgba(0, 0, 0, .3);
+}
+.card-signin {
+  width: 354px;
+  padding: 40px;
+}
+.card-signin .profile-img {
+  display: block;
+  width: 96px;
+  height: 96px;
+  margin: 0 auto 10px;
+}

src/blog/static/assets/js/ie-emulation-modes-warning.js

@@ -0,0 +1,51 @@
+// NOTICE!! DO NOT USE ANY OF THIS JAVASCRIPT
+// IT'S JUST JUNK FOR OUR DOCS!
+// ++++++++++++++++++++++++++++++++++++++++++
+/*!
+ * Copyright 2014-2015 Twitter, Inc.
+ *
+ * Licensed under the Creative Commons Attribution 3.0 Unported License. For
+ * details, see https://creativecommons.org/licenses/by/3.0/.
+ */
+// Intended to prevent false-positive bug reports about Bootstrap not working properly in old versions of IE due to folks testing using IE's unreliable emulation modes.
+(function () {
+  'use strict';
+
+  function emulatedIEMajorVersion() {
+    var groups = /MSIE ([0-9.]+)/.exec(window.navigator.userAgent)
+    if (groups === null) {
+      return null
+    }
+    var ieVersionNum = parseInt(groups[1], 10)
+    var ieMajorVersion = Math.floor(ieVersionNum)
+    return ieMajorVersion
+  }
+
+  function actualNonEmulatedIEMajorVersion() {
+    // Detects the actual version of IE in use, even if it's in an older-IE emulation mode.
+    // IE JavaScript conditional compilation docs: https://msdn.microsoft.com/library/121hztk3%28v=vs.94%29.aspx
+    // @cc_on docs: https://msdn.microsoft.com/library/8ka90k2e%28v=vs.94%29.aspx
+    var jscriptVersion = new Function('/*@cc_on return @_jscript_version; @*/')() // jshint ignore:line
+    if (jscriptVersion === undefined) {
+      return 11 // IE11+ not in emulation mode
+    }
+    if (jscriptVersion < 9) {
+      return 8 // IE8 (or lower; haven't tested on IE<8)
+    }
+    return jscriptVersion // IE9 or IE10 in any mode, or IE11 in non-IE11 mode
+  }
+
+  var ua = window.navigator.userAgent
+  if (ua.indexOf('Opera') > -1 || ua.indexOf('Presto') > -1) {
+    return // Opera, which might pretend to be IE
+  }
+  var emulated = emulatedIEMajorVersion()
+  if (emulated === null) {
+    return // Not IE
+  }
+  var nonEmulated = actualNonEmulatedIEMajorVersion()
+
+  if (emulated !== nonEmulated) {
+    window.alert('WARNING: You appear to be using IE' + nonEmulated + ' in IE' + emulated + ' emulation mode.\nIE emulation modes can behave significantly differently from ACTUAL older versions of IE.\nPLEASE DON\'T FILE BOOTSTRAP BUGS based on testing in IE emulation modes!')
+  }
+})();

src/blog/static/assets/js/ie10-viewport-bug-workaround.js

@@ -0,0 +1,23 @@
+/*!
+ * IE10 viewport hack for Surface/desktop Windows 8 bug
+ * Copyright 2014-2015 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ */
+
+// See the Getting Started docs for more information:
+// http://getbootstrap.com/getting-started/#support-ie10-width
+
+(function () {
+  'use strict';
+
+  if (navigator.userAgent.match(/IEMobile\/10\.0/)) {
+    var msViewportStyle = document.createElement('style')
+    msViewportStyle.appendChild(
+      document.createTextNode(
+        '@-ms-viewport{width:auto!important}'
+      )
+    )
+    document.querySelector('head').appendChild(msViewportStyle)
+  }
+
+})();

src/blog/static/blog/css/ie.css

@@ -0,0 +1,273 @@
+/*
+Styles for older IE versions (previous to IE9).
+*/
+
+body {
+	background-color: #e6e6e6;
+}
+body.custom-background-empty {
+	background-color: #fff;
+}
+body.custom-background-empty .site,
+body.custom-background-white .site {
+	box-shadow: none;
+	margin-bottom: 0;
+	margin-top: 0;
+	padding: 0;
+}
+.assistive-text,
+.site .screen-reader-text {
+	clip: rect(1px 1px 1px 1px);
+}
+.full-width .site-content {
+	float: none;
+	width: 100%;
+}
+img.size-full,
+img.size-large,
+img.header-image,
+img.wp-post-image,
+img[class*="align"],
+img[class*="wp-image-"],
+img[class*="attachment-"] {
+	width: auto; /* Prevent stretching of full-size and large-size images with height and width attributes in IE8 */
+}
+.author-avatar {
+	float: left;
+	margin-top: 8px;
+	margin-top: 0.571428571rem;
+}
+.author-description {
+	float: right;
+	width: 80%;
+}
+.site {
+	box-shadow: 0 2px 6px rgba(100, 100, 100, 0.3);
+	margin: 48px auto;
+	max-width: 960px;
+	overflow: hidden;
+	padding: 0 40px;
+}
+.site-content {
+	float: left;
+	width: 65.104166667%;
+}
+body.template-front-page .site-content,
+body.attachment .site-content,
+body.full-width .site-content {
+	width: 100%;
+}
+.widget-area {
+	float: right;
+	width: 26.041666667%;
+}
+.site-header h1,
+.site-header h2 {
+	text-align: left;
+}
+.site-header h1 {
+	font-size: 26px;
+	line-height: 1.846153846;
+}
+.main-navigation ul.nav-menu,
+.main-navigation div.nav-menu > ul {
+	border-bottom: 1px solid #ededed;
+	border-top: 1px solid #ededed;
+	display: inline-block !important;
+	text-align: left;
+	width: 100%;
+}
+.main-navigation ul {
+	margin: 0;
+	text-indent: 0;
+}
+.main-navigation li a,
+.main-navigation li {
+	display: inline-block;
+	text-decoration: none;
+}
+.ie7 .main-navigation li a,
+.ie7 .main-navigation li {
+	display: inline;
+}
+.main-navigation li a {
+	border-bottom: 0;
+	color: #6a6a6a;
+	line-height: 3.692307692;
+	text-transform: uppercase;
+}
+.main-navigation li a:hover {
+	color: #000;
+}
+.main-navigation li {
+	margin: 0 40px 0 0;
+	position: relative;
+}
+.main-navigation li ul {
+	margin: 0;
+	padding: 0;
+	position: absolute;
+	top: 100%;
+	z-index: 1;
+	height: 1px;
+	width: 1px;
+	overflow: hidden;
+	clip: rect(1px, 1px, 1px, 1px);
+}
+.ie7 .main-navigation li ul {
+	clip: inherit;
+	display: none;
+	left: 0;
+	overflow: visible;
+}
+.main-navigation li ul ul,
+.ie7 .main-navigation li ul ul {
+	top: 0;
+	left: 100%;
+}
+.main-navigation ul li:hover > ul,
+.main-navigation ul li:focus > ul,
+.main-navigation .focus > ul {
+	border-left: 0;
+	clip: inherit;
+	overflow: inherit;
+	height: inherit;
+	width: inherit;
+}
+.ie7 .main-navigation ul li:hover > ul,
+.ie7 .main-navigation ul li:focus > ul {
+	display: block;
+}
+.main-navigation li ul li a {
+	background: #efefef;
+	border-bottom: 1px solid #ededed;
+	display: block;
+	font-size: 11px;
+	line-height: 2.181818182;
+	padding: 8px 10px;
+	width: 180px;
+}
+.main-navigation li ul li a:hover {
+	background: #e3e3e3;
+	color: #444;
+}
+.main-navigation .current-menu-item > a,
+.main-navigation .current-menu-ancestor > a,
+.main-navigation .current_page_item > a,
+.main-navigation .current_page_ancestor > a {
+	color: #636363;
+	font-weight: bold;
+}
+.main-navigation .menu-toggle {
+	display: none;
+}
+.entry-header .entry-title {
+	font-size: 22px;
+}
+#respond form input[type="text"] {
+	width: 46.333333333%;
+}
+#respond form textarea.blog-textarea {
+	width: 79.666666667%;
+}
+.template-front-page .site-content,
+.template-front-page article {
+	overflow: hidden;
+}
+.template-front-page.has-post-thumbnail article {
+	float: left;
+	width: 47.916666667%;
+}
+.entry-page-image {
+	float: right;
+	margin-bottom: 0;
+	width: 47.916666667%;
+}
+/* IE Front Page Template Widget fix */
+.template-front-page .widget-area {
+	clear: both;
+}
+.template-front-page .widget {
+	width: 100% !important;
+	border: none;
+}
+.template-front-page .widget-area .widget,
+.template-front-page .first.front-widgets,
+.template-front-page.two-sidebars .widget-area .front-widgets {
+	float: left;
+	margin-bottom: 24px;
+	width: 51.875%;
+}
+.template-front-page .second.front-widgets,
+.template-front-page .widget-area .widget:nth-child(odd) {
+	clear: right;
+}
+.template-front-page .first.front-widgets,
+.template-front-page .second.front-widgets,
+.template-front-page.two-sidebars .widget-area .front-widgets + .front-widgets {
+	float: right;
+	margin: 0 0 24px;
+	width: 39.0625%;
+}
+.template-front-page.two-sidebars .widget,
+.template-front-page.two-sidebars .widget:nth-child(even) {
+	float: none;
+	width: auto;
+}
+/* add input font for <IE9 Password Box to make the bullets show up */
+input[type="password"] {
+	font-family: Helvetica, Arial, sans-serif;
+}
+
+/* RTL overrides for IE7 and IE8
+-------------------------------------------------------------- */
+.rtl .site-header h1,
+.rtl .site-header h2 {
+	text-align: right;
+}
+.rtl .widget-area,
+.rtl .author-description {
+	float: left;
+}
+.rtl .author-avatar,
+.rtl .site-content {
+	float: right;
+}
+.rtl .main-navigation ul.nav-menu,
+.rtl .main-navigation div.nav-menu > ul {
+	text-align: right;
+}
+.rtl .main-navigation ul li ul li,
+.rtl .main-navigation ul li ul li ul li {
+	margin-left: 40px;
+	margin-right: auto;
+}
+.rtl .main-navigation li ul ul {
+	position: absolute;
+	bottom: 0;
+	right: 100%;
+	z-index: 1;
+}
+.ie7 .rtl .main-navigation li ul ul {
+	position: absolute;
+	bottom: 0;
+	right: 100%;
+	z-index: 1;
+}
+.ie7 .rtl .main-navigation ul li {
+	z-index: 99;
+}
+.ie7 .rtl .main-navigation li ul {
+	position: absolute;
+	bottom: 100%;
+	right: 0;
+	z-index: 1;
+}
+.ie7 .rtl .main-navigation li {
+	margin-right: auto;
+	margin-left: 40px;
+}
+.ie7 .rtl .main-navigation li ul ul ul {
+	position: relative;
+	z-index: 1;
+}

src/blog/static/blog/css/nprogress.css

@@ -0,0 +1,74 @@
+/* Make clicks pass-through */
+#nprogress {
+  pointer-events: none;
+}
+
+#nprogress .bar {
+  background: red;
+
+  position: fixed;
+  z-index: 1031;
+  top: 0;
+  left: 0;
+
+  width: 100%;
+  height: 2px;
+}
+
+/* Fancy blur effect */
+#nprogress .peg {
+  display: block;
+  position: absolute;
+  right: 0px;
+  width: 100px;
+  height: 100%;
+  box-shadow: 0 0 10px #29d, 0 0 5px #29d;
+  opacity: 1.0;
+
+  -webkit-transform: rotate(3deg) translate(0px, -4px);
+      -ms-transform: rotate(3deg) translate(0px, -4px);
+          transform: rotate(3deg) translate(0px, -4px);
+}
+
+/* Remove these to get rid of the spinner */
+#nprogress .spinner {
+  display: block;
+  position: fixed;
+  z-index: 1031;
+  top: 15px;
+  right: 15px;
+}
+
+#nprogress .spinner-icon {
+  width: 18px;
+  height: 18px;
+  box-sizing: border-box;
+
+  border: solid 2px transparent;
+  border-top-color: red;
+  border-left-color: red;
+  border-radius: 50%;
+
+  -webkit-animation: nprogress-spinner 400ms linear infinite;
+          animation: nprogress-spinner 400ms linear infinite;
+}
+
+.nprogress-custom-parent {
+  overflow: hidden;
+  position: relative;
+}
+
+.nprogress-custom-parent #nprogress .spinner,
+.nprogress-custom-parent #nprogress .bar {
+  position: absolute;
+}
+
+@-webkit-keyframes nprogress-spinner {
+  0%   { -webkit-transform: rotate(0deg); }
+  100% { -webkit-transform: rotate(360deg); }
+}
+@keyframes nprogress-spinner {
+  0%   { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+

src/blog/static/blog/css/oauth_style.css

@@ -0,0 +1,305 @@
+
+.icon-sn-google {
+    background-position: 0 -28px;
+}
+
+.icon-sn-bg-google {
+    background-color: #4285f4;
+    background-position: 0 0;
+}
+
+.fa-sn-google {
+    color: #4285f4;
+}
+
+.icon-sn-github {
+    background-position: -28px -28px;
+}
+
+.icon-sn-bg-github {
+    background-color: #333;
+    background-position: -28px 0;
+}
+
+.fa-sn-github {
+    color: #333;
+}
+
+.icon-sn-weibo {
+    background-position: -56px -28px;
+}
+
+.icon-sn-bg-weibo {
+    background-color: #e90d24;
+    background-position: -56px 0;
+}
+
+.fa-sn-weibo {
+    color: #e90d24;
+}
+
+.icon-sn-qq {
+    background-position: -84px -28px;
+}
+
+.icon-sn-bg-qq {
+    background-color: #0098e6;
+    background-position: -84px 0;
+}
+
+.fa-sn-qq {
+    color: #0098e6;
+}
+
+.icon-sn-twitter {
+    background-position: -112px -28px;
+}
+
+.icon-sn-bg-twitter {
+    background-color: #50abf1;
+    background-position: -112px 0;
+}
+
+.fa-sn-twitter {
+    color: #50abf1;
+}
+
+.icon-sn-facebook {
+    background-position: -140px -28px;
+}
+
+.icon-sn-bg-facebook {
+    background-color: #4862a3;
+    background-position: -140px 0;
+}
+
+.fa-sn-facebook {
+    color: #4862a3;
+}
+
+.icon-sn-renren {
+    background-position: -168px -28px;
+}
+
+.icon-sn-bg-renren {
+    background-color: #197bc8;
+    background-position: -168px 0;
+}
+
+.fa-sn-renren {
+    color: #197bc8;
+}
+
+.icon-sn-tqq {
+    background-position: -196px -28px;
+}
+
+.icon-sn-bg-tqq {
+    background-color: #1f9ed2;
+    background-position: -196px 0;
+}
+
+.fa-sn-tqq {
+    color: #1f9ed2;
+}
+
+.icon-sn-douban {
+    background-position: -224px -28px;
+}
+
+.icon-sn-bg-douban {
+    background-color: #279738;
+    background-position: -224px 0;
+}
+
+.fa-sn-douban {
+    color: #279738;
+}
+
+.icon-sn-weixin {
+    background-position: -252px -28px;
+}
+
+.icon-sn-bg-weixin {
+    background-color: #00b500;
+    background-position: -252px 0;
+}
+
+.fa-sn-weixin {
+    color: #00b500;
+}
+
+.icon-sn-dotted {
+    background-position: -280px -28px;
+}
+
+.icon-sn-bg-dotted {
+    background-color: #eee;
+    background-position: -280px 0;
+}
+
+.fa-sn-dotted {
+    color: #eee;
+}
+
+.icon-sn-site {
+    background-position: -308px -28px;
+}
+
+.icon-sn-bg-site {
+    background-color: #00b500;
+    background-position: -308px 0;
+}
+
+.fa-sn-site {
+    color: #00b500;
+}
+
+.icon-sn-linkedin {
+    background-position: -336px -28px;
+}
+
+.icon-sn-bg-linkedin {
+    background-color: #0077b9;
+    background-position: -336px 0;
+}
+
+.fa-sn-linkedin {
+    color: #0077b9;
+}
+
+[class*=icon-sn-] {
+    display: inline-block;
+    background-image: url('../img/icon-sn.svg');
+    background-repeat: no-repeat;
+    width: 28px;
+    height: 28px;
+    vertical-align: middle;
+    background-size: auto 56px;
+}
+
+[class*=icon-sn-]:hover {
+    opacity: .8;
+    filter: alpha(opacity=80);
+}
+
+.btn-sn-google {
+    background: #4285f4;
+}
+
+.btn-sn-google:active, .btn-sn-google:focus, .btn-sn-google:hover {
+    background: #2a75f3;
+}
+
+.btn-sn-github {
+    background: #333;
+}
+
+.btn-sn-github:active, .btn-sn-github:focus, .btn-sn-github:hover {
+    background: #262626;
+}
+
+.btn-sn-weibo {
+    background: #e90d24;
+}
+
+.btn-sn-weibo:active, .btn-sn-weibo:focus, .btn-sn-weibo:hover {
+    background: #d10c20;
+}
+
+.btn-sn-qq {
+    background: #0098e6;
+}
+
+.btn-sn-qq:active, .btn-sn-qq:focus, .btn-sn-qq:hover {
+    background: #0087cd;
+}
+
+.btn-sn-twitter {
+    background: #50abf1;
+}
+
+.btn-sn-twitter:active, .btn-sn-twitter:focus, .btn-sn-twitter:hover {
+    background: #38a0ef;
+}
+
+.btn-sn-facebook {
+    background: #4862a3;
+}
+
+.btn-sn-facebook:active, .btn-sn-facebook:focus, .btn-sn-facebook:hover {
+    background: #405791;
+}
+
+.btn-sn-renren {
+    background: #197bc8;
+}
+
+.btn-sn-renren:active, .btn-sn-renren:focus, .btn-sn-renren:hover {
+    background: #166db1;
+}
+
+.btn-sn-tqq {
+    background: #1f9ed2;
+}
+
+.btn-sn-tqq:active, .btn-sn-tqq:focus, .btn-sn-tqq:hover {
+    background: #1c8dbc;
+}
+
+.btn-sn-douban {
+    background: #279738;
+}
+
+.btn-sn-douban:active, .btn-sn-douban:focus, .btn-sn-douban:hover {
+    background: #228330;
+}
+
+.btn-sn-weixin {
+    background: #00b500;
+}
+
+.btn-sn-weixin:active, .btn-sn-weixin:focus, .btn-sn-weixin:hover {
+    background: #009c00;
+}
+
+.btn-sn-dotted {
+    background: #eee;
+}
+
+.btn-sn-dotted:active, .btn-sn-dotted:focus, .btn-sn-dotted:hover {
+    background: #e1e1e1;
+}
+
+.btn-sn-site {
+    background: #00b500;
+}
+
+.btn-sn-site:active, .btn-sn-site:focus, .btn-sn-site:hover {
+    background: #009c00;
+}
+
+.btn-sn-linkedin {
+    background: #0077b9;
+}
+
+.btn-sn-linkedin:active, .btn-sn-linkedin:focus, .btn-sn-linkedin:hover {
+    background: #0067a0;
+}
+
+[class*=btn-sn-], [class*=btn-sn-]:active, [class*=btn-sn-]:focus, [class*=btn-sn-]:hover {
+    border: none;
+    color: #fff;
+}
+
+.btn-sn-more {
+    padding: 0;
+}
+
+.btn-sn-more, .btn-sn-more:active, .btn-sn-more:hover {
+    box-shadow: none;
+}
+
+[class*=btn-sn-] [class*=icon-sn-] {
+    background-color: transparent;
+}

src/blog/static/blog/fonts/open-sans.css

@@ -0,0 +1,600 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtE6F15M.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWvU6F15M.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtU6F15M.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuk6F15M.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWu06F15M.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWxU6F15M.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqW106F15M.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtk6F15M.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWt06F15M.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuU6F.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtE6F15M.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWvU6F15M.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtU6F15M.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuk6F15M.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWu06F15M.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWxU6F15M.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqW106F15M.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtk6F15M.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWt06F15M.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuU6F.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtE6F15M.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWvU6F15M.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtU6F15M.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuk6F15M.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWu06F15M.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWxU6F15M.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqW106F15M.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWtk6F15M.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWt06F15M.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: italic;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memtYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWqWuU6F.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSKmu1aB.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSumu1aB.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSOmu1aB.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSymu1aB.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS2mu1aB.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTVOmu1aB.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTUGmu1aB.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSCmu1aB.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSGmu1aB.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 300;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS-muw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSKmu1aB.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSumu1aB.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSOmu1aB.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSymu1aB.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS2mu1aB.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTVOmu1aB.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTUGmu1aB.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSCmu1aB.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSGmu1aB.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS-muw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSKmu1aB.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSumu1aB.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSOmu1aB.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSymu1aB.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* hebrew */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS2mu1aB.woff2) format('woff2');
+  unicode-range: U+0307-0308, U+0590-05FF, U+200C-2010, U+20AA, U+25CC, U+FB1D-FB4F;
+}
+/* math */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTVOmu1aB.woff2) format('woff2');
+  unicode-range: U+0302-0303, U+0305, U+0307-0308, U+0310, U+0312, U+0315, U+031A, U+0326-0327, U+032C, U+032F-0330, U+0332-0333, U+0338, U+033A, U+0346, U+034D, U+0391-03A1, U+03A3-03A9, U+03B1-03C9, U+03D1, U+03D5-03D6, U+03F0-03F1, U+03F4-03F5, U+2016-2017, U+2034-2038, U+203C, U+2040, U+2043, U+2047, U+2050, U+2057, U+205F, U+2070-2071, U+2074-208E, U+2090-209C, U+20D0-20DC, U+20E1, U+20E5-20EF, U+2100-2112, U+2114-2115, U+2117-2121, U+2123-214F, U+2190, U+2192, U+2194-21AE, U+21B0-21E5, U+21F1-21F2, U+21F4-2211, U+2213-2214, U+2216-22FF, U+2308-230B, U+2310, U+2319, U+231C-2321, U+2336-237A, U+237C, U+2395, U+239B-23B7, U+23D0, U+23DC-23E1, U+2474-2475, U+25AF, U+25B3, U+25B7, U+25BD, U+25C1, U+25CA, U+25CC, U+25FB, U+266D-266F, U+27C0-27FF, U+2900-2AFF, U+2B0E-2B11, U+2B30-2B4C, U+2BFE, U+3030, U+FF5B, U+FF5D, U+1D400-1D7FF, U+1EE00-1EEFF;
+}
+/* symbols */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTUGmu1aB.woff2) format('woff2');
+  unicode-range: U+0001-000C, U+000E-001F, U+007F-009F, U+20DD-20E0, U+20E2-20E4, U+2150-218F, U+2190, U+2192, U+2194-2199, U+21AF, U+21E6-21F0, U+21F3, U+2218-2219, U+2299, U+22C4-22C6, U+2300-243F, U+2440-244A, U+2460-24FF, U+25A0-27BF, U+2800-28FF, U+2921-2922, U+2981, U+29BF, U+29EB, U+2B00-2BFF, U+4DC0-4DFF, U+FFF9-FFFB, U+10140-1018E, U+10190-1019C, U+101A0, U+101D0-101FD, U+102E0-102FB, U+10E60-10E7E, U+1D2C0-1D2D3, U+1D2E0-1D37F, U+1F000-1F0FF, U+1F100-1F1AD, U+1F1E6-1F1FF, U+1F30D-1F30F, U+1F315, U+1F31C, U+1F31E, U+1F320-1F32C, U+1F336, U+1F378, U+1F37D, U+1F382, U+1F393-1F39F, U+1F3A7-1F3A8, U+1F3AC-1F3AF, U+1F3C2, U+1F3C4-1F3C6, U+1F3CA-1F3CE, U+1F3D4-1F3E0, U+1F3ED, U+1F3F1-1F3F3, U+1F3F5-1F3F7, U+1F408, U+1F415, U+1F41F, U+1F426, U+1F43F, U+1F441-1F442, U+1F444, U+1F446-1F449, U+1F44C-1F44E, U+1F453, U+1F46A, U+1F47D, U+1F4A3, U+1F4B0, U+1F4B3, U+1F4B9, U+1F4BB, U+1F4BF, U+1F4C8-1F4CB, U+1F4D6, U+1F4DA, U+1F4DF, U+1F4E3-1F4E6, U+1F4EA-1F4ED, U+1F4F7, U+1F4F9-1F4FB, U+1F4FD-1F4FE, U+1F503, U+1F507-1F50B, U+1F50D, U+1F512-1F513, U+1F53E-1F54A, U+1F54F-1F5FA, U+1F610, U+1F650-1F67F, U+1F687, U+1F68D, U+1F691, U+1F694, U+1F698, U+1F6AD, U+1F6B2, U+1F6B9-1F6BA, U+1F6BC, U+1F6C6-1F6CF, U+1F6D3-1F6D7, U+1F6E0-1F6EA, U+1F6F0-1F6F3, U+1F6F7-1F6FC, U+1F700-1F7FF, U+1F800-1F80B, U+1F810-1F847, U+1F850-1F859, U+1F860-1F887, U+1F890-1F8AD, U+1F8B0-1F8BB, U+1F8C0-1F8C1, U+1F900-1F90B, U+1F93B, U+1F946, U+1F984, U+1F996, U+1F9E9, U+1FA00-1FA6F, U+1FA70-1FA7C, U+1FA80-1FA89, U+1FA8F-1FAC6, U+1FACE-1FADC, U+1FADF-1FAE9, U+1FAF0-1FAF8, U+1FB00-1FBFF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSCmu1aB.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTSGmu1aB.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-stretch: 100%;
+  font-display: swap;
+  src: url(memvYaGs126MiZpBA-UvWbX2vVnXBbObj2OVTS-muw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}

src/blog/static/blog/js/blog.js

@@ -0,0 +1,91 @@
+/**
+ * Created by liangliang on 2016/11/20.
+ */
+
+
+function do_reply(parentid) {
+    console.log(parentid);
+    $("#id_parent_comment_id").val(parentid)
+    $("#commentform").appendTo($("#div-comment-" + parentid));
+    $("#reply-title").hide();
+    $("#cancel_comment").show();
+}
+
+function cancel_reply() {
+    $("#reply-title").show();
+    $("#cancel_comment").hide();
+    $("#id_parent_comment_id").val('')
+    $("#commentform").appendTo($("#respond"));
+}
+
+NProgress.start();
+NProgress.set(0.4);
+//Increment
+var interval = setInterval(function () {
+    NProgress.inc();
+}, 1000);
+$(document).ready(function () {
+    NProgress.done();
+    clearInterval(interval);
+});
+
+
+/** 侧边栏回到顶部 */
+var rocket = $('#rocket');
+
+$(window).on('scroll', debounce(slideTopSet, 300));
+
+function debounce(func, wait) {
+    var timeout;
+    return function () {
+        clearTimeout(timeout);
+        timeout = setTimeout(func, wait);
+    };
+}
+
+function slideTopSet() {
+    var top = $(document).scrollTop();
+
+    if (top > 200) {
+        rocket.addClass('show');
+    } else {
+        rocket.removeClass('show');
+    }
+}
+
+$(document).on('click', '#rocket', function (event) {
+    rocket.addClass('move');
+    $('body, html').animate({
+        scrollTop: 0
+    }, 800);
+});
+$(document).on('animationEnd', function () {
+    setTimeout(function () {
+        rocket.removeClass('move');
+    }, 400);
+
+});
+$(document).on('webkitAnimationEnd', function () {
+    setTimeout(function () {
+        rocket.removeClass('move');
+    }, 400);
+});
+
+
+window.onload = function () {
+  var replyLinks = document.querySelectorAll(".comment-reply-link");
+  for (var i = 0; i < replyLinks.length; i++) {
+    replyLinks[i].onclick = function () {
+      var pk = this.getAttribute("data-pk");
+      do_reply(pk);
+    };
+  }
+};
+
+// $(document).ready(function () {
+//     var form = $('#i18n-form');
+//     var selector = $('.i18n-select');
+//     selector.on('change', function () {
+//         form.submit();
+//     });
+// });

src/blog/static/blog/js/html5.js

@@ -0,0 +1,8 @@
+/*
+ HTML5 Shiv v3.7.0 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
+*/
+(function(l,f){function m(){var a=e.elements;return"string"==typeof a?a.split(" "):a}function i(a){var b=n[a[o]];b||(b={},h++,a[o]=h,n[h]=b);return b}function p(a,b,c){b||(b=f);if(g)return b.createElement(a);c||(c=i(b));b=c.cache[a]?c.cache[a].cloneNode():r.test(a)?(c.cache[a]=c.createElem(a)).cloneNode():c.createElem(a);return b.canHaveChildren&&!s.test(a)?c.frag.appendChild(b):b}function t(a,b){if(!b.cache)b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag();
+a.createElement=function(c){return!e.shivMethods?b.createElem(c):p(c,a,b)};a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+m().join().replace(/[\w\-]+/g,function(a){b.createElem(a);b.frag.createElement(a);return'c("'+a+'")'})+");return n}")(e,b.frag)}function q(a){a||(a=f);var b=i(a);if(e.shivCSS&&!j&&!b.hasCSS){var c,d=a;c=d.createElement("p");d=d.getElementsByTagName("head")[0]||d.documentElement;c.innerHTML="x<style>article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}</style>";
+c=d.insertBefore(c.lastChild,d.firstChild);b.hasCSS=!!c}g||t(a,b);return a}var k=l.html5||{},s=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,r=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,j,o="_html5shiv",h=0,n={},g;(function(){try{var a=f.createElement("a");a.innerHTML="<xyz></xyz>";j="hidden"in a;var b;if(!(b=1==a.childNodes.length)){f.createElement("a");var c=f.createDocumentFragment();b="undefined"==typeof c.cloneNode||
+"undefined"==typeof c.createDocumentFragment||"undefined"==typeof c.createElement}g=b}catch(d){g=j=!0}})();var e={elements:k.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output progress section summary template time video",version:"3.7.0",shivCSS:!1!==k.shivCSS,supportsUnknownElements:g,shivMethods:!1!==k.shivMethods,type:"default",shivDocument:q,createElement:p,createDocumentFragment:function(a,b){a||(a=f);
+if(g)return a.createDocumentFragment();for(var b=b||i(a),c=b.frag.cloneNode(),d=0,e=m(),h=e.length;d<h;d++)c.createElement(e[d]);return c}};l.html5=e;q(f)})(this,document);

src/blog/static/blog/js/mathjax-loader.js

@@ -0,0 +1,142 @@
+/**
+ * MathJax 智能加载器
+ * 检测页面是否包含数学公式，如果有则动态加载和配置MathJax
+ */
+(function() {
+    'use strict';
+    
+    /**
+     * 检测页面是否包含数学公式
+     * @returns {boolean} 是否包含数学公式
+     */
+    function hasMathFormulas() {
+        const content = document.body.textContent || document.body.innerText || '';
+        // 检测常见的数学公式语法
+        return /\$.*?\$|\$\$.*?\$\$|\\begin\{.*?\}|\\end\{.*?\}|\\[a-zA-Z]+\{/.test(content);
+    }
+    
+    /**
+     * 配置MathJax
+     */
+    function configureMathJax() {
+        window.MathJax = {
+            tex: {
+                // 行内公式和块级公式分隔符
+                inlineMath: [['$', '$']],
+                displayMath: [['$$', '$$']],
+                // 处理转义字符和LaTeX环境
+                processEscapes: true,
+                processEnvironments: true,
+                // 自动换行
+                tags: 'ams'
+            },
+            options: {
+                // 跳过这些HTML标签，避免处理代码块等
+                skipHtmlTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code', 'a'],
+                // CSS类控制
+                ignoreHtmlClass: 'tex2jax_ignore',
+                processHtmlClass: 'tex2jax_process'
+            },
+            // 启动配置
+            startup: {
+                ready() {
+                    console.log('MathJax配置完成，开始初始化...');
+                    MathJax.startup.defaultReady();
+                    
+                    // 处理特定区域的数学公式
+                    const contentEl = document.getElementById('content');
+                    const commentsEl = document.getElementById('comments');
+                    
+                    const promises = [];
+                    if (contentEl) {
+                        promises.push(MathJax.typesetPromise([contentEl]));
+                    }
+                    if (commentsEl) {
+                        promises.push(MathJax.typesetPromise([commentsEl]));
+                    }
+                    
+                    // 等待所有渲染完成
+                    Promise.all(promises).then(() => {
+                        console.log('MathJax渲染完成');
+                        // 触发自定义事件，通知其他脚本MathJax已就绪
+                        document.dispatchEvent(new CustomEvent('mathjaxReady'));
+                    }).catch(error => {
+                        console.error('MathJax渲染失败:', error);
+                    });
+                }
+            },
+            // 输出配置
+            chtml: {
+                scale: 1,
+                minScale: 0.5,
+                matchFontHeight: false,
+                displayAlign: 'center',
+                displayIndent: '0'
+            }
+        };
+    }
+    
+    /**
+     * 加载MathJax库
+     */
+    function loadMathJax() {
+        console.log('检测到数学公式，开始加载MathJax...');
+        
+        const script = document.createElement('script');
+        script.src = 'https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js';
+        script.async = true;
+        script.defer = true;
+        
+        script.onload = function() {
+            console.log('MathJax库加载成功');
+        };
+        
+        script.onerror = function() {
+            console.error('MathJax库加载失败，尝试备用CDN...');
+            // 备用CDN
+            const fallbackScript = document.createElement('script');
+            fallbackScript.src = 'https://polyfill.io/v3/polyfill.min.js?features=es6';
+            fallbackScript.onload = function() {
+                const mathJaxScript = document.createElement('script');
+                mathJaxScript.src = 'https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML';
+                mathJaxScript.async = true;
+                document.head.appendChild(mathJaxScript);
+            };
+            document.head.appendChild(fallbackScript);
+        };
+        
+        document.head.appendChild(script);
+    }
+    
+    /**
+     * 初始化函数
+     */
+    function init() {
+        // 等待DOM完全加载
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', init);
+            return;
+        }
+        
+        // 检测是否需要加载MathJax
+        if (hasMathFormulas()) {
+            // 先配置，再加载
+            configureMathJax();
+            loadMathJax();
+        } else {
+            console.log('未检测到数学公式，跳过MathJax加载');
+        }
+    }
+    
+    // 提供重新渲染的全局方法，供动态内容使用
+    window.rerenderMathJax = function(element) {
+        if (window.MathJax && window.MathJax.typesetPromise) {
+            const target = element || document.body;
+            return window.MathJax.typesetPromise([target]);
+        }
+        return Promise.resolve();
+    };
+    
+    // 启动初始化
+    init();
+})();

src/blog/static/blog/js/navigation.js

@@ -0,0 +1,55 @@
+/**
+ * Handles toggling the navigation menu for small screens and
+ * accessibility for submenu items.
+ */
+( function() {
+	var nav = document.getElementById( 'site-navigation' ), button, menu;
+	if ( ! nav ) {
+		return;
+	}
+
+	button = nav.getElementsByTagName( 'button' )[0];
+	menu   = nav.getElementsByTagName( 'ul' )[0];
+	if ( ! button ) {
+		return;
+	}
+
+	// Hide button if menu is missing or empty.
+	if ( ! menu || ! menu.childNodes.length ) {
+		button.style.display = 'none';
+		return;
+	}
+
+	button.onclick = function() {
+		if ( -1 === menu.className.indexOf( 'nav-menu' ) ) {
+			menu.className = 'nav-menu';
+		}
+
+		if ( -1 !== button.className.indexOf( 'toggled-on' ) ) {
+			button.className = button.className.replace( ' toggled-on', '' );
+			menu.className = menu.className.replace( ' toggled-on', '' );
+		} else {
+			button.className += ' toggled-on';
+			menu.className += ' toggled-on';
+		}
+	};
+} )();
+
+// Better focus for hidden submenu items for accessibility.
+( function( $ ) {
+	$( '.main-navigation' ).find( 'a' ).on( 'focus.twentytwelve blur.twentytwelve', function() {
+		$( this ).parents( '.menu-item, .page_item' ).toggleClass( 'focus' );
+	} );
+
+  if ( 'ontouchstart' in window ) {
+    $('body').on( 'touchstart.twentytwelve',  '.menu-item-has-children > a, .page_item_has_children > a', function( e ) {
+      var el = $( this ).parent( 'li' );
+
+      if ( ! el.hasClass( 'focus' ) ) {
+        e.preventDefault();
+        el.toggleClass( 'focus' );
+        el.siblings( '.focus').removeClass( 'focus' );
+      }
+    } );
+  }
+} )( jQuery );

src/blog/static/blog/js/nprogress.js

@@ -0,0 +1,480 @@
+/* NProgress, (c) 2013, 2014 Rico Sta. Cruz - http://ricostacruz.com/nprogress
+ * @license MIT */
+
+;(function(root, factory) {
+
+  if (typeof define === 'function' && define.amd) {
+    define(factory);
+  } else if (typeof exports === 'object') {
+    module.exports = factory();
+  } else {
+    root.NProgress = factory();
+  }
+
+})(this, function() {
+  var NProgress = {};
+
+  NProgress.version = '0.2.0';
+
+  var Settings = NProgress.settings = {
+    minimum: 0.08,
+    easing: 'linear',
+    positionUsing: '',
+    speed: 200,
+    trickle: true,
+    trickleSpeed: 200,
+    showSpinner: true,
+    barSelector: '[role="bar"]',
+    spinnerSelector: '[role="spinner"]',
+    parent: 'body',
+    template: '<div class="bar" role="bar"><div class="peg"></div></div><div class="spinner" role="spinner"><div class="spinner-icon"></div></div>'
+  };
+
+  /**
+   * Updates configuration.
+   *
+   *     NProgress.configure({
+   *       minimum: 0.1
+   *     });
+   */
+  NProgress.configure = function(options) {
+    var key, value;
+    for (key in options) {
+      value = options[key];
+      if (value !== undefined && options.hasOwnProperty(key)) Settings[key] = value;
+    }
+
+    return this;
+  };
+
+  /**
+   * Last number.
+   */
+
+  NProgress.status = null;
+
+  /**
+   * Sets the progress bar status, where `n` is a number from `0.0` to `1.0`.
+   *
+   *     NProgress.set(0.4);
+   *     NProgress.set(1.0);
+   */
+
+  NProgress.set = function(n) {
+    var started = NProgress.isStarted();
+
+    n = clamp(n, Settings.minimum, 1);
+    NProgress.status = (n === 1 ? null : n);
+
+    var progress = NProgress.render(!started),
+        bar      = progress.querySelector(Settings.barSelector),
+        speed    = Settings.speed,
+        ease     = Settings.easing;
+
+    progress.offsetWidth; /* Repaint */
+
+    queue(function(next) {
+      // Set positionUsing if it hasn't already been set
+      if (Settings.positionUsing === '') Settings.positionUsing = NProgress.getPositioningCSS();
+
+      // Add transition
+      css(bar, barPositionCSS(n, speed, ease));
+
+      if (n === 1) {
+        // Fade out
+        css(progress, {
+          transition: 'none',
+          opacity: 1
+        });
+        progress.offsetWidth; /* Repaint */
+
+        setTimeout(function() {
+          css(progress, {
+            transition: 'all ' + speed + 'ms linear',
+            opacity: 0
+          });
+          setTimeout(function() {
+            NProgress.remove();
+            next();
+          }, speed);
+        }, speed);
+      } else {
+        setTimeout(next, speed);
+      }
+    });
+
+    return this;
+  };
+
+  NProgress.isStarted = function() {
+    return typeof NProgress.status === 'number';
+  };
+
+  /**
+   * Shows the progress bar.
+   * This is the same as setting the status to 0%, except that it doesn't go backwards.
+   *
+   *     NProgress.start();
+   *
+   */
+  NProgress.start = function() {
+    if (!NProgress.status) NProgress.set(0);
+
+    var work = function() {
+      setTimeout(function() {
+        if (!NProgress.status) return;
+        NProgress.trickle();
+        work();
+      }, Settings.trickleSpeed);
+    };
+
+    if (Settings.trickle) work();
+
+    return this;
+  };
+
+  /**
+   * Hides the progress bar.
+   * This is the *sort of* the same as setting the status to 100%, with the
+   * difference being `done()` makes some placebo effect of some realistic motion.
+   *
+   *     NProgress.done();
+   *
+   * If `true` is passed, it will show the progress bar even if its hidden.
+   *
+   *     NProgress.done(true);
+   */
+
+  NProgress.done = function(force) {
+    if (!force && !NProgress.status) return this;
+
+    return NProgress.inc(0.3 + 0.5 * Math.random()).set(1);
+  };
+
+  /**
+   * Increments by a random amount.
+   */
+
+  NProgress.inc = function(amount) {
+    var n = NProgress.status;
+
+    if (!n) {
+      return NProgress.start();
+    } else if(n > 1) {
+
+    } else {
+      if (typeof amount !== 'number') {
+        if (n >= 0 && n < 0.2) { amount = 0.1; }
+        else if (n >= 0.2 && n < 0.5) { amount = 0.04; }
+        else if (n >= 0.5 && n < 0.8) { amount = 0.02; }
+        else if (n >= 0.8 && n < 0.99) { amount = 0.005; }
+        else { amount = 0; }
+      }
+
+      n = clamp(n + amount, 0, 0.994);
+      return NProgress.set(n);
+    }
+  };
+
+  NProgress.trickle = function() {
+    return NProgress.inc();
+  };
+
+  /**
+   * Waits for all supplied jQuery promises and
+   * increases the progress as the promises resolve.
+   *
+   * @param $promise jQUery Promise
+   */
+  (function() {
+    var initial = 0, current = 0;
+
+    NProgress.promise = function($promise) {
+      if (!$promise || $promise.state() === "resolved") {
+        return this;
+      }
+
+      if (current === 0) {
+        NProgress.start();
+      }
+
+      initial++;
+      current++;
+
+      $promise.always(function() {
+        current--;
+        if (current === 0) {
+            initial = 0;
+            NProgress.done();
+        } else {
+            NProgress.set((initial - current) / initial);
+        }
+      });
+
+      return this;
+    };
+
+  })();
+
+  /**
+   * (Internal) renders the progress bar markup based on the `template`
+   * setting.
+   */
+
+  NProgress.render = function(fromStart) {
+    if (NProgress.isRendered()) return document.getElementById('nprogress');
+
+    addClass(document.documentElement, 'nprogress-busy');
+
+    var progress = document.createElement('div');
+    progress.id = 'nprogress';
+    progress.innerHTML = Settings.template;
+
+    var bar      = progress.querySelector(Settings.barSelector),
+        perc     = fromStart ? '-100' : toBarPerc(NProgress.status || 0),
+        parent   = document.querySelector(Settings.parent),
+        spinner;
+
+    css(bar, {
+      transition: 'all 0 linear',
+      transform: 'translate3d(' + perc + '%,0,0)'
+    });
+
+    if (!Settings.showSpinner) {
+      spinner = progress.querySelector(Settings.spinnerSelector);
+      spinner && removeElement(spinner);
+    }
+
+    if (parent != document.body) {
+      addClass(parent, 'nprogress-custom-parent');
+    }
+
+    parent.appendChild(progress);
+    return progress;
+  };
+
+  /**
+   * Removes the element. Opposite of render().
+   */
+
+  NProgress.remove = function() {
+    removeClass(document.documentElement, 'nprogress-busy');
+    removeClass(document.querySelector(Settings.parent), 'nprogress-custom-parent');
+    var progress = document.getElementById('nprogress');
+    progress && removeElement(progress);
+  };
+
+  /**
+   * Checks if the progress bar is rendered.
+   */
+
+  NProgress.isRendered = function() {
+    return !!document.getElementById('nprogress');
+  };
+
+  /**
+   * Determine which positioning CSS rule to use.
+   */
+
+  NProgress.getPositioningCSS = function() {
+    // Sniff on document.body.style
+    var bodyStyle = document.body.style;
+
+    // Sniff prefixes
+    var vendorPrefix = ('WebkitTransform' in bodyStyle) ? 'Webkit' :
+                       ('MozTransform' in bodyStyle) ? 'Moz' :
+                       ('msTransform' in bodyStyle) ? 'ms' :
+                       ('OTransform' in bodyStyle) ? 'O' : '';
+
+    if (vendorPrefix + 'Perspective' in bodyStyle) {
+      // Modern browsers with 3D support, e.g. Webkit, IE10
+      return 'translate3d';
+    } else if (vendorPrefix + 'Transform' in bodyStyle) {
+      // Browsers without 3D support, e.g. IE9
+      return 'translate';
+    } else {
+      // Browsers without translate() support, e.g. IE7-8
+      return 'margin';
+    }
+  };
+
+  /**
+   * Helpers
+   */
+
+  function clamp(n, min, max) {
+    if (n < min) return min;
+    if (n > max) return max;
+    return n;
+  }
+
+  /**
+   * (Internal) converts a percentage (`0..1`) to a bar translateX
+   * percentage (`-100%..0%`).
+   */
+
+  function toBarPerc(n) {
+    return (-1 + n) * 100;
+  }
+
+
+  /**
+   * (Internal) returns the correct CSS for changing the bar's
+   * position given an n percentage, and speed and ease from Settings
+   */
+
+  function barPositionCSS(n, speed, ease) {
+    var barCSS;
+
+    if (Settings.positionUsing === 'translate3d') {
+      barCSS = { transform: 'translate3d('+toBarPerc(n)+'%,0,0)' };
+    } else if (Settings.positionUsing === 'translate') {
+      barCSS = { transform: 'translate('+toBarPerc(n)+'%,0)' };
+    } else {
+      barCSS = { 'margin-left': toBarPerc(n)+'%' };
+    }
+
+    barCSS.transition = 'all '+speed+'ms '+ease;
+
+    return barCSS;
+  }
+
+  /**
+   * (Internal) Queues a function to be executed.
+   */
+
+  var queue = (function() {
+    var pending = [];
+
+    function next() {
+      var fn = pending.shift();
+      if (fn) {
+        fn(next);
+      }
+    }
+
+    return function(fn) {
+      pending.push(fn);
+      if (pending.length == 1) next();
+    };
+  })();
+
+  /**
+   * (Internal) Applies css properties to an element, similar to the jQuery
+   * css method.
+   *
+   * While this helper does assist with vendor prefixed property names, it
+   * does not perform any manipulation of values prior to setting styles.
+   */
+
+  var css = (function() {
+    var cssPrefixes = [ 'Webkit', 'O', 'Moz', 'ms' ],
+        cssProps    = {};
+
+    function camelCase(string) {
+      return string.replace(/^-ms-/, 'ms-').replace(/-([\da-z])/gi, function(match, letter) {
+        return letter.toUpperCase();
+      });
+    }
+
+    function getVendorProp(name) {
+      var style = document.body.style;
+      if (name in style) return name;
+
+      var i = cssPrefixes.length,
+          capName = name.charAt(0).toUpperCase() + name.slice(1),
+          vendorName;
+      while (i--) {
+        vendorName = cssPrefixes[i] + capName;
+        if (vendorName in style) return vendorName;
+      }
+
+      return name;
+    }
+
+    function getStyleProp(name) {
+      name = camelCase(name);
+      return cssProps[name] || (cssProps[name] = getVendorProp(name));
+    }
+
+    function applyCss(element, prop, value) {
+      prop = getStyleProp(prop);
+      element.style[prop] = value;
+    }
+
+    return function(element, properties) {
+      var args = arguments,
+          prop,
+          value;
+
+      if (args.length == 2) {
+        for (prop in properties) {
+          value = properties[prop];
+          if (value !== undefined && properties.hasOwnProperty(prop)) applyCss(element, prop, value);
+        }
+      } else {
+        applyCss(element, args[1], args[2]);
+      }
+    }
+  })();
+
+  /**
+   * (Internal) Determines if an element or space separated list of class names contains a class name.
+   */
+
+  function hasClass(element, name) {
+    var list = typeof element == 'string' ? element : classList(element);
+    return list.indexOf(' ' + name + ' ') >= 0;
+  }
+
+  /**
+   * (Internal) Adds a class to an element.
+   */
+
+  function addClass(element, name) {
+    var oldList = classList(element),
+        newList = oldList + name;
+
+    if (hasClass(oldList, name)) return;
+
+    // Trim the opening space.
+    element.className = newList.substring(1);
+  }
+
+  /**
+   * (Internal) Removes a class from an element.
+   */
+
+  function removeClass(element, name) {
+    var oldList = classList(element),
+        newList;
+
+    if (!hasClass(element, name)) return;
+
+    // Replace the class name.
+    newList = oldList.replace(' ' + name + ' ', ' ');
+
+    // Trim the opening and closing spaces.
+    element.className = newList.substring(1, newList.length - 1);
+  }
+
+  /**
+   * (Internal) Gets a space separated list of the class names on the element.
+   * The list is wrapped with a single space on each end to facilitate finding
+   * matches within the list.
+   */
+
+  function classList(element) {
+    return (' ' + (element && element.className || '') + ' ').replace(/\s+/gi, ' ');
+  }
+
+  /**
+   * (Internal) Removes an element from the DOM.
+   */
+
+  function removeElement(element) {
+    element && element.parentNode && element.parentNode.removeChild(element);
+  }
+
+  return NProgress;
+});

src/blog/static/pygments/default.css

@@ -0,0 +1,293 @@
+.codehilite .hll {
+    background-color: #ffffcc
+}
+
+.codehilite {
+    background: #ffffff;
+}
+
+.codehilite .c {
+    color: #177500
+}
+
+/* Comment */
+.codehilite .err {
+    color: #000000
+}
+
+/* Error */
+.codehilite .k {
+    color: #A90D91
+}
+
+/* Keyword */
+.codehilite .l {
+    color: #1C01CE
+}
+
+/* Literal */
+.codehilite .n {
+    color: #000000
+}
+
+/* Name */
+.codehilite .o {
+    color: #000000
+}
+
+/* Operator */
+.codehilite .ch {
+    color: #177500
+}
+
+/* Comment.Hashbang */
+.codehilite .cm {
+    color: #177500
+}
+
+/* Comment.Multiline */
+.codehilite .cp {
+    color: #633820
+}
+
+/* Comment.Preproc */
+.codehilite .cpf {
+    color: #177500
+}
+
+/* Comment.PreprocFile */
+.codehilite .c1 {
+    color: #177500
+}
+
+/* Comment.Single */
+.codehilite .cs {
+    color: #177500
+}
+
+/* Comment.Special */
+.codehilite .kc {
+    color: #A90D91
+}
+
+/* Keyword.Constant */
+.codehilite .kd {
+    color: #A90D91
+}
+
+/* Keyword.Declaration */
+.codehilite .kn {
+    color: #A90D91
+}
+
+/* Keyword.Namespace */
+.codehilite .kp {
+    color: #A90D91
+}
+
+/* Keyword.Pseudo */
+.codehilite .kr {
+    color: #A90D91
+}
+
+/* Keyword.Reserved */
+.codehilite .kt {
+    color: #A90D91
+}
+
+/* Keyword.Type */
+.codehilite .ld {
+    color: #1C01CE
+}
+
+/* Literal.Date */
+.codehilite .m {
+    color: #1C01CE
+}
+
+/* Literal.Number */
+.codehilite .s {
+    color: #C41A16
+}
+
+/* Literal.String */
+.codehilite .na {
+    color: #836C28
+}
+
+/* Name.Attribute */
+.codehilite .nb {
+    color: #A90D91
+}
+
+/* Name.Builtin */
+.codehilite .nc {
+    color: #3F6E75
+}
+
+/* Name.Class */
+.codehilite .no {
+    color: #000000
+}
+
+/* Name.Constant */
+.codehilite .nd {
+    color: #000000
+}
+
+/* Name.Decorator */
+.codehilite .ni {
+    color: #000000
+}
+
+/* Name.Entity */
+.codehilite .ne {
+    color: #000000
+}
+
+/* Name.Exception */
+.codehilite .nf {
+    color: #000000
+}
+
+/* Name.Function */
+.codehilite .nl {
+    color: #000000
+}
+
+/* Name.Label */
+.codehilite .nn {
+    color: #000000
+}
+
+/* Name.Namespace */
+.codehilite .nx {
+    color: #000000
+}
+
+/* Name.Other */
+.codehilite .py {
+    color: #000000
+}
+
+/* Name.Property */
+.codehilite .nt {
+    color: #000000
+}
+
+/* Name.Tag */
+.codehilite .nv {
+    color: #000000
+}
+
+/* Name.Variable */
+.codehilite .ow {
+    color: #000000
+}
+
+/* Operator.Word */
+.codehilite .mb {
+    color: #1C01CE
+}
+
+/* Literal.Number.Bin */
+.codehilite .mf {
+    color: #1C01CE
+}
+
+/* Literal.Number.Float */
+.codehilite .mh {
+    color: #1C01CE
+}
+
+/* Literal.Number.Hex */
+.codehilite .mi {
+    color: #1C01CE
+}
+
+/* Literal.Number.Integer */
+.codehilite .mo {
+    color: #1C01CE
+}
+
+/* Literal.Number.Oct */
+.codehilite .sb {
+    color: #C41A16
+}
+
+/* Literal.String.Backtick */
+.codehilite .sc {
+    color: #2300CE
+}
+
+/* Literal.String.Char */
+.codehilite .sd {
+    color: #C41A16
+}
+
+/* Literal.String.Doc */
+.codehilite .s2 {
+    color: #C41A16
+}
+
+/* Literal.String.Double */
+.codehilite .se {
+    color: #C41A16
+}
+
+/* Literal.String.Escape */
+.codehilite .sh {
+    color: #C41A16
+}
+
+/* Literal.String.Heredoc */
+.codehilite .si {
+    color: #C41A16
+}
+
+/* Literal.String.Interpol */
+.codehilite .sx {
+    color: #C41A16
+}
+
+/* Literal.String.Other */
+.codehilite .sr {
+    color: #C41A16
+}
+
+/* Literal.String.Regex */
+.codehilite .s1 {
+    color: #C41A16
+}
+
+/* Literal.String.Single */
+.codehilite .ss {
+    color: #C41A16
+}
+
+/* Literal.String.Symbol */
+.codehilite .bp {
+    color: #5B269A
+}
+
+/* Name.Builtin.Pseudo */
+.codehilite .vc {
+    color: #000000
+}
+
+/* Name.Variable.Class */
+.codehilite .vg {
+    color: #000000
+}
+
+/* Name.Variable.Global */
+.codehilite .vi {
+    color: #000000
+}
+
+/* Name.Variable.Instance */
+.codehilite .il {
+    color: #1C01CE
+}
+
+/* Literal.Number.Integer.Long */

src/blog/templatetags/blog_tags.py

@@ -51,7 +51,75 @@ def datetimeformat(data):
 @register.filter()
 @stringfilter
 def custom_markdown(content):
-    return mark_safe(CommonMarkdown.get_markdown(content))
+    """
+    通用markdown过滤器，应用文章内容插件
+    主要用于文章内容处理
+    """
+    html_content = CommonMarkdown.get_markdown(content)
+    
+    # 然后应用插件过滤器优化HTML
+    from djangoblog.plugin_manage import hooks
+    from djangoblog.plugin_manage.hook_constants import ARTICLE_CONTENT_HOOK_NAME
+    optimized_html = hooks.apply_filters(ARTICLE_CONTENT_HOOK_NAME, html_content)
+    
+    return mark_safe(optimized_html)
+
+
+@register.filter()
+@stringfilter
+def sidebar_markdown(content):
+    html_content = CommonMarkdown.get_markdown(content)
+    return mark_safe(html_content)
+
+
+@register.simple_tag(takes_context=True)
+def render_article_content(context, article, is_summary=False):
+    """
+    渲染文章内容，包含完整的上下文信息供插件使用
+    
+    Args:
+        context: 模板上下文
+        article: 文章对象
+        is_summary: 是否为摘要模式（首页使用）
+    """
+    if not article or not hasattr(article, 'body'):
+        return ''
+    
+    # 先转换Markdown为HTML
+    html_content = CommonMarkdown.get_markdown(article.body)
+    
+    # 如果是摘要模式，先截断内容再应用插件
+    if is_summary:
+        # 截断HTML内容到合适的长度（约300字符）
+        from django.utils.html import strip_tags
+        from django.template.defaultfilters import truncatechars
+        
+        # 先去除HTML标签，截断纯文本，然后重新转换为HTML
+        plain_text = strip_tags(html_content)
+        truncated_text = truncatechars(plain_text, 300)
+        
+        # 重新转换截断后的文本为HTML（简化版，避免复杂的插件处理）
+        html_content = CommonMarkdown.get_markdown(truncated_text)
+    
+    # 然后应用插件过滤器，传递完整的上下文
+    from djangoblog.plugin_manage import hooks
+    from djangoblog.plugin_manage.hook_constants import ARTICLE_CONTENT_HOOK_NAME
+    
+    # 获取request对象
+    request = context.get('request')
+    
+    # 应用所有文章内容相关的插件
+    # 注意：摘要模式下某些插件（如版权声明）可能不适用
+    optimized_html = hooks.apply_filters(
+        ARTICLE_CONTENT_HOOK_NAME, 
+        html_content, 
+        article=article, 
+        request=request,
+        context=context,
+        is_summary=is_summary  # 传递摘要标志，插件可以据此调整行为
+    )
+    
+    return mark_safe(optimized_html)
 
 
 @register.simple_tag
@@ -292,38 +360,49 @@ def load_article_detail(article, isindex, user):
     }
 
 
-# return only the URL of the gravatar
-# TEMPLATE USE:  {{ email|gravatar_url:150 }}
+# 返回用户头像URL
+# 模板使用方法:  {{ email|gravatar_url:150 }}
 @register.filter
 def gravatar_url(email, size=40):
-    """获得gravatar头像"""
-    cachekey = 'gravatat/' + email
+    """获得用户头像 - 优先使用OAuth头像，否则使用默认头像"""
+    cachekey = 'avatar/' + email
     url = cache.get(cachekey)
     if url:
         return url
-    else:
-        usermodels = OAuthUser.objects.filter(email=email)
-        if usermodels:
-            o = list(filter(lambda x: x.picture is not None, usermodels))
-            if o:
-                return o[0].picture
-        email = email.encode('utf-8')
-
-        default = static('blog/img/avatar.png')
-
-        url = "https://www.gravatar.com/avatar/%s?%s" % (hashlib.md5(
-            email.lower()).hexdigest(), urllib.parse.urlencode({'d': default, 's': str(size)}))
-        cache.set(cachekey, url, 60 * 60 * 10)
-        logger.info('set gravatar cache.key:{key}'.format(key=cachekey))
-        return url
+    
+    # 检查OAuth用户是否有自定义头像
+    usermodels = OAuthUser.objects.filter(email=email)
+    if usermodels:
+        # 过滤出有头像的用户
+        users_with_picture = list(filter(lambda x: x.picture is not None, usermodels))
+        if users_with_picture:
+            # 获取默认头像路径用于比较
+            default_avatar_path = static('blog/img/avatar.png')
+            
+            # 优先选择非默认头像的用户，否则选择第一个
+            non_default_users = [u for u in users_with_picture if u.picture != default_avatar_path and not u.picture.endswith('/avatar.png')]
+            selected_user = non_default_users[0] if non_default_users else users_with_picture[0]
+            
+            url = selected_user.picture
+            cache.set(cachekey, url, 60 * 60 * 24)  # 缓存24小时
+            
+            avatar_type = 'non-default' if non_default_users else 'default'
+            logger.info('Using {} OAuth avatar for {} from {}'.format(avatar_type, email, selected_user.type))
+            return url
+    
+    # 使用默认头像
+    url = static('blog/img/avatar.png')
+    cache.set(cachekey, url, 60 * 60 * 24)  # 缓存24小时
+    logger.info('Using default avatar for {}'.format(email))
+    return url
 
 
 @register.filter
 def gravatar(email, size=40):
-    """获得gravatar头像"""
+    """获得用户头像HTML标签"""
     url = gravatar_url(email, size)
     return mark_safe(
-        '<img src="%s" height="%d" width="%d">' %
+        '<img src="%s" height="%d" width="%d" class="avatar" alt="用户头像">' %
         (url, size, size))
 
 
@@ -342,3 +421,134 @@ def query(qs, **kwargs):
 def addstr(arg1, arg2):
     """concatenate arg1 & arg2"""
     return str(arg1) + str(arg2)
+
+
+# === 插件系统模板标签 ===
+
+@register.simple_tag(takes_context=True)
+def render_plugin_widgets(context, position, **kwargs):
+    """
+    渲染指定位置的所有插件组件
+    
+    Args:
+        context: 模板上下文
+        position: 位置标识
+        **kwargs: 传递给插件的额外参数
+    
+    Returns:
+        按优先级排序的所有插件HTML内容
+    """
+    from djangoblog.plugin_manage.loader import get_loaded_plugins
+    
+    widgets = []
+    
+    for plugin in get_loaded_plugins():
+        try:
+            widget_data = plugin.render_position_widget(
+                position=position,
+                context=context,
+                **kwargs
+            )
+            if widget_data:
+                widgets.append(widget_data)
+        except Exception as e:
+            logger.error(f"Error rendering widget from plugin {plugin.PLUGIN_NAME}: {e}")
+    
+    # 按优先级排序（数字越小优先级越高）
+    widgets.sort(key=lambda x: x['priority'])
+    
+    # 合并HTML内容
+    html_parts = [widget['html'] for widget in widgets]
+    return mark_safe(''.join(html_parts))
+
+
+@register.simple_tag(takes_context=True)
+def plugin_head_resources(context):
+    """渲染所有插件的head资源（仅自定义HTML，CSS已集成到压缩系统）"""
+    from djangoblog.plugin_manage.loader import get_loaded_plugins
+    
+    resources = []
+    
+    for plugin in get_loaded_plugins():
+        try:
+            # 只处理自定义head HTML（CSS文件已通过压缩系统处理）
+            head_html = plugin.get_head_html(context)
+            if head_html:
+                resources.append(head_html)
+                
+        except Exception as e:
+            logger.error(f"Error loading head resources from plugin {plugin.PLUGIN_NAME}: {e}")
+    
+    return mark_safe('\n'.join(resources))
+
+
+@register.simple_tag(takes_context=True)
+def plugin_body_resources(context):
+    """渲染所有插件的body资源（仅自定义HTML，JS已集成到压缩系统）"""
+    from djangoblog.plugin_manage.loader import get_loaded_plugins
+    
+    resources = []
+    
+    for plugin in get_loaded_plugins():
+        try:
+            # 只处理自定义body HTML（JS文件已通过压缩系统处理）
+            body_html = plugin.get_body_html(context)
+            if body_html:
+                resources.append(body_html)
+                
+        except Exception as e:
+            logger.error(f"Error loading body resources from plugin {plugin.PLUGIN_NAME}: {e}")
+    
+    return mark_safe('\n'.join(resources))
+
+
+@register.inclusion_tag('plugins/css_includes.html')
+def plugin_compressed_css():
+    """插件CSS压缩包含模板"""
+    from djangoblog.plugin_manage.loader import get_loaded_plugins
+    
+    css_files = []
+    for plugin in get_loaded_plugins():
+        for css_file in plugin.get_css_files():
+            css_url = plugin.get_static_url(css_file)
+            css_files.append(css_url)
+    
+    return {'css_files': css_files}
+
+
+@register.inclusion_tag('plugins/js_includes.html')
+def plugin_compressed_js():
+    """插件JS压缩包含模板"""
+    from djangoblog.plugin_manage.loader import get_loaded_plugins
+    
+    js_files = []
+    for plugin in get_loaded_plugins():
+        for js_file in plugin.get_js_files():
+            js_url = plugin.get_static_url(js_file)
+            js_files.append(js_url)
+    
+    return {'js_files': js_files}
+
+
+
+
+@register.simple_tag(takes_context=True)
+def plugin_widget(context, plugin_name, widget_type='default', **kwargs):
+    """
+    渲染指定插件的组件
+    
+    使用方式：
+    {% plugin_widget 'article_recommendation' 'bottom' article=article count=5 %}
+    """
+    from djangoblog.plugin_manage.loader import get_plugin_by_slug
+    
+    plugin = get_plugin_by_slug(plugin_name)
+    if plugin and hasattr(plugin, 'render_template'):
+        try:
+            widget_context = {**context.flatten(), **kwargs}
+            template_name = f"{widget_type}.html"
+            return mark_safe(plugin.render_template(template_name, widget_context))
+        except Exception as e:
+            logger.error(f"Error rendering plugin widget {plugin_name}.{widget_type}: {e}")
+    
+    return ""

src/blog/urls.py

@@ -3,58 +3,71 @@ from django.views.decorators.cache import cache_page
 
 from . import views
 
-app_name = "blog"
+app_name = "blog" #zhq: 应用命名空间，用于URL反向解析
 urlpatterns = [
+#zhq: 首页路由 - 显示文章列表
     path(
         r'',
         views.IndexView.as_view(),
         name='index'),
+#zhq: 首页分页路由 - 支持分页浏览
     path(
         r'page/<int:page>/',
         views.IndexView.as_view(),
         name='index_page'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'article/<int:year>/<int:month>/<int:day>/<int:article_id>.html',
         views.ArticleDetailView.as_view(),
         name='detailbyid'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'category/<slug:category_name>.html',
         views.CategoryDetailView.as_view(),
         name='category_detail'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'category/<slug:category_name>/<int:page>.html',
         views.CategoryDetailView.as_view(),
         name='category_detail_page'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'author/<author_name>.html',
         views.AuthorDetailView.as_view(),
         name='author_detail'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'author/<author_name>/<int:page>.html',
         views.AuthorDetailView.as_view(),
         name='author_detail_page'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'tag/<slug:tag_name>.html',
         views.TagDetailView.as_view(),
         name='tag_detail'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         r'tag/<slug:tag_name>/<int:page>.html',
         views.TagDetailView.as_view(),
         name='tag_detail_page'),
+#zhq: 文章详情页路由 - 包含年月日信息用于SEO优化
     path(
         'archives.html',
         cache_page(
             60 * 60)(
             views.ArchivesView.as_view()),
         name='archives'),
+#zhq: 友情链接页路由 - 显示所有启用的友情链接
     path(
         'links.html',
         views.LinkListView.as_view(),
         name='links'),
+#zhq: 友情链接页路由 - 显示所有启用的友情链接
     path(
         r'upload',
         views.fileupload,
         name='upload'),
+# zhq: 缓存清理路由 - 手动清理系统缓存
     path(
         r'clean',
         views.clean_cache_view,

src/blog/views.py

@@ -23,7 +23,7 @@ from djangoblog.utils import cache, get_blog_setting, get_sha256
 
 logger = logging.getLogger(__name__)
 
-
+#zhq: 文章列表基类视图 - 提供通用的列表功能和缓存机制
 class ArticleListView(ListView):
     # template_name属性用于指定使用哪个模板进行渲染
     template_name = 'blog/article_index.html'
@@ -33,7 +33,7 @@ class ArticleListView(ListView):
 
     # 页面类型，分类目录或标签列表等
     page_type = ''
-    paginate_by = settings.PAGINATE_BY
+    paginate_by = settings.PAGINATE_BY  #zhq: 从配置获取分页大小
     page_kwarg = 'page'
     link_type = LinkShowType.L
 
@@ -42,6 +42,7 @@ class ArticleListView(ListView):
 
     @property
     def page_number(self):
+        # zhq: 获取当前页码，支持URL参数和GET参数
         page_kwarg = self.page_kwarg
         page = self.kwargs.get(
             page_kwarg) or self.request.GET.get(page_kwarg) or 1
@@ -88,7 +89,7 @@ class ArticleListView(ListView):
         kwargs['linktype'] = self.link_type
         return super(ArticleListView, self).get_context_data(**kwargs)
 
-
+ #zhq: 获取当前页码，支持URL参数和GET参数
 class IndexView(ArticleListView):
     '''
     首页
@@ -97,6 +98,7 @@ class IndexView(ArticleListView):
     link_type = LinkShowType.I
 
     def get_queryset_data(self):
+        # zhq: 获取已发布的普通文章
         article_list = Article.objects.filter(type='a', status='p')
         return article_list
 
@@ -104,7 +106,7 @@ class IndexView(ArticleListView):
         cache_key = 'index_{page}'.format(page=self.page_number)
         return cache_key
 
-
+#zhq: 文章详情页视图 - 显示单篇文章内容和评论
 class ArticleDetailView(DetailView):
     '''
     文章详情页面
@@ -117,6 +119,7 @@ class ArticleDetailView(DetailView):
     def get_context_data(self, **kwargs):
         comment_form = CommentForm()
 
+        # zhq: 获取文章评论并进行分页处理
         article_comments = self.object.comment_list()
         parent_comments = article_comments.filter(parent_comment=None)
         blog_setting = get_blog_setting()
@@ -135,6 +138,7 @@ class ArticleDetailView(DetailView):
         next_page = p_comments.next_page_number() if p_comments.has_next() else None
         prev_page = p_comments.previous_page_number() if p_comments.has_previous() else None
 
+        # zhq: 获取文章评论并进行分页处理
         if next_page:
             kwargs[
                 'comment_next_page_url'] = self.object.get_absolute_url() + f'?comment_page={next_page}#commentlist-container'
@@ -152,15 +156,16 @@ class ArticleDetailView(DetailView):
 
         context = super(ArticleDetailView, self).get_context_data(**kwargs)
         article = self.object
+        
+        # 触发文章详情加载钩子，让插件可以添加额外的上下文数据
+        from djangoblog.plugin_manage.hook_constants import ARTICLE_DETAIL_LOAD
+        hooks.run_action(ARTICLE_DETAIL_LOAD, article=article, context=context, request=self.request)
+        
         # Action Hook, 通知插件"文章详情已获取"
         hooks.run_action('after_article_body_get', article=article, request=self.request)
-        # # Filter Hook, 允许插件修改文章正文
-        article.body = hooks.apply_filters(ARTICLE_CONTENT_HOOK_NAME, article.body, article=article,
-                                           request=self.request)
-
         return context
 
-
+#zhq: 分类详情页视图 - 显示指定分类下的文章
 class CategoryDetailView(ArticleListView):
     '''
     分类目录列表
@@ -173,6 +178,7 @@ class CategoryDetailView(ArticleListView):
 
         categoryname = category.name
         self.categoryname = categoryname
+        # zhq: 获取分类及其所有子分类
         categorynames = list(
             map(lambda c: c.name, category.get_sub_categorys()))
         article_list = Article.objects.filter(
@@ -199,7 +205,7 @@ class CategoryDetailView(ArticleListView):
         kwargs['tag_name'] = categoryname
         return super(CategoryDetailView, self).get_context_data(**kwargs)
 
-
+#zhq: 作者详情页视图 - 显示指定作者的文章
 class AuthorDetailView(ArticleListView):
     '''
     作者详情页
@@ -225,7 +231,7 @@ class AuthorDetailView(ArticleListView):
         kwargs['tag_name'] = author_name
         return super(AuthorDetailView, self).get_context_data(**kwargs)
 
-
+#zhq: 标签详情页视图 - 显示指定标签的文章
 class TagDetailView(ArticleListView):
     '''
     标签列表页面
@@ -257,7 +263,7 @@ class TagDetailView(ArticleListView):
         kwargs['tag_name'] = tag_name
         return super(TagDetailView, self).get_context_data(**kwargs)
 
-
+#zhq: 文章归档页视图 - 显示所有文章的按时间归档
 class ArchivesView(ArticleListView):
     '''
     文章归档页面
@@ -274,7 +280,7 @@ class ArchivesView(ArticleListView):
         cache_key = 'archives'
         return cache_key
 
-
+#zhq: 友情链接页视图
 class LinkListView(ListView):
     model = Links
     template_name = 'blog/links_list.html'
@@ -282,7 +288,7 @@ class LinkListView(ListView):
     def get_queryset(self):
         return Links.objects.filter(is_enable=True)
 
-
+#zhq: Elasticsearch搜索视图
 class EsSearchView(SearchView):
     def get_context(self):
         paginator, page = self.build_page()
@@ -299,7 +305,7 @@ class EsSearchView(SearchView):
 
         return context
 
-
+#zhq: 文件上传视图 - 支持图片和其他文件上传
 @csrf_exempt
 def fileupload(request):
     """
@@ -308,6 +314,7 @@ def fileupload(request):
     :return:
     """
     if request.method == 'POST':
+        # zhq: 验证上传签名，确保安全性
         sign = request.GET.get('sign', None)
         if not sign:
             return HttpResponseForbidden()
@@ -322,6 +329,7 @@ def fileupload(request):
             base_dir = os.path.join(settings.STATICFILES, "files" if not isimage else "image", timestr)
             if not os.path.exists(base_dir):
                 os.makedirs(base_dir)
+                # zhq: 使用UUID生成唯一文件名，避免冲突
             savepath = os.path.normpath(os.path.join(base_dir, f"{uuid.uuid4().hex}{os.path.splitext(filename)[-1]}"))
             if not savepath.startswith(base_dir):
                 return HttpResponse("only for post")
@@ -329,6 +337,7 @@ def fileupload(request):
                 for chunk in request.FILES[filename].chunks():
                     wfile.write(chunk)
             if isimage:
+                # zhq: 对图片进行压缩优化
                 from PIL import Image
                 image = Image.open(savepath)
                 image.save(savepath, quality=20, optimize=True)
@@ -339,7 +348,7 @@ def fileupload(request):
     else:
         return HttpResponse("only for post")
 
-
+#zhq: 404错误页面视图
 def page_not_found_view(
         request,
         exception,
@@ -353,7 +362,7 @@ def page_not_found_view(
                    'statuscode': '404'},
                   status=404)
 
-
+#zhq: 500服务器错误页面视图
 def server_error_view(request, template_name='blog/error_page.html'):
     return render(request,
                   template_name,
@@ -361,7 +370,7 @@ def server_error_view(request, template_name='blog/error_page.html'):
                    'statuscode': '500'},
                   status=500)
 
-
+#zhq: 403权限拒绝页面视图
 def permission_denied_view(
         request,
         exception,
@@ -373,7 +382,7 @@ def permission_denied_view(
             'message': _('Sorry, you do not have permission to access this page?'),
             'statuscode': '403'}, status=403)
 
-
+zhq: 清理缓存视图
 def clean_cache_view(request):
     cache.clear()
     return HttpResponse('ok')

src/codecov.yml

@@ -0,0 +1,87 @@
+codecov:
+  require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+        informational: true
+    patch:
+      default:
+        target: auto
+        threshold: 1%
+        informational: true
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+comment:
+  layout: "reach,diff,flags,tree"
+  behavior: default
+  require_changes: no
+
+ignore:
+  # Django 相关
+  - "*/migrations/*"
+  - "manage.py"
+  - "*/settings.py"
+  - "*/wsgi.py"
+  - "*/asgi.py"
+  
+  # 测试相关
+  - "*/tests/*"
+  - "*/test_*.py"
+  - "*/*test*.py"
+  
+  # 静态文件和模板
+  - "*/static/*"
+  - "*/templates/*"
+  - "*/collectedstatic/*"
+  
+  # 国际化文件
+  - "*/locale/*"
+  - "**/*.po"
+  - "**/*.mo"
+  
+  # 文档和部署
+  - "*/docs/*"
+  - "*/deploy/*"
+  - "README*.md"
+  - "LICENSE"
+  - "Dockerfile"
+  - "docker-compose*.yml"
+  - "*.yaml"
+  - "*.yml"
+  
+  # 开发环境
+  - "*/venv/*"
+  - "*/__pycache__/*"
+  - "*.pyc"
+  - ".coverage"
+  - "coverage.xml"
+  
+  # 日志文件
+  - "*/logs/*"
+  - "*.log"
+  
+  # 特定文件
+  - "*/whoosh_cn_backend.py"  # 搜索后端
+  - "*/elasticsearch_backend.py"  # 搜索后端
+  - "*/MemcacheStorage.py"  # 缓存存储
+  - "*/robot.py"  # 机器人相关
+  
+  # 配置文件
+  - "codecov.yml"
+  - ".coveragerc"
+  - "requirements*.txt"

src/comments/admin.py

@@ -1,23 +1,38 @@
+#hz 评论模块的Django后台管理配置
+#hz 本模块配置了评论模型在Django管理后台的显示、过滤、搜索和批量操作功能
+
 from django.contrib import admin
 from django.urls import reverse
 from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 
 
+#hz 批量禁用评论的管理动作函数
+#hz 将选中的评论设置为不可见（is_enable=False）
 def disable_commentstatus(modeladmin, request, queryset):
+    #hz 批量更新选中评论的is_enable字段为False
     queryset.update(is_enable=False)
 
 
+#hz 批量启用评论的管理动作函数
+#hz 将选中的评论设置为可见（is_enable=True）
 def enable_commentstatus(modeladmin, request, queryset):
+    #hz 批量更新选中评论的is_enable字段为True
     queryset.update(is_enable=True)
 
 
+#hz 设置批量禁用评论动作的显示名称
 disable_commentstatus.short_description = _('Disable comments')
+#hz 设置批量启用评论动作的显示名称
 enable_commentstatus.short_description = _('Enable comments')
 
 
+#hz 评论模型的后台管理类
+#hz 配置评论在Django管理后台的显示方式、过滤选项、搜索字段和批量操作
 class CommentAdmin(admin.ModelAdmin):
+    #hz 每页显示的评论数量
     list_per_page = 20
+    #hz 列表页显示的字段列
     list_display = (
         'id',
         'body',
@@ -25,23 +40,45 @@ class CommentAdmin(admin.ModelAdmin):
         'link_to_article',
         'is_enable',
         'creation_time')
+    #hz 列表页可点击的字段链接（点击可进入编辑页面）
     list_display_links = ('id', 'body', 'is_enable')
+    #hz 列表页右侧的过滤选项，可按is_enable字段进行过滤
     list_filter = ('is_enable',)
+    #hz 编辑页面中排除的字段（不显示在编辑表单中）
+    #hz creation_time和last_modify_time通常由系统自动管理，不需要手动编辑
     exclude = ('creation_time', 'last_modify_time')
+    #hz 可用的批量操作动作列表
     actions = [disable_commentstatus, enable_commentstatus]
+    #hz 使用原始ID字段的选择器（用于外键字段，避免加载所有相关对象）
+    #hz 当关联对象数量很大时，使用raw_id_fields可以提升性能
+    raw_id_fields = ('author', 'article')
+    #hz 可搜索的字段列表，支持按评论正文内容进行搜索
+    search_fields = ('body',)
 
+    #hz 生成指向用户信息管理页面的链接
+    #hz 在列表页显示评论作者的可点击链接，点击后跳转到用户编辑页面
     def link_to_userinfo(self, obj):
+        #hz 获取作者对象的应用标签和模型名称
         info = (obj.author._meta.app_label, obj.author._meta.model_name)
+        #hz 生成用户编辑页面的URL
         link = reverse('admin:%s_%s_change' % info, args=(obj.author.id,))
+        #hz 返回HTML格式的链接，显示用户的昵称或邮箱
         return format_html(
             u'<a href="%s">%s</a>' %
             (link, obj.author.nickname if obj.author.nickname else obj.author.email))
 
+    #hz 生成指向文章管理页面的链接
+    #hz 在列表页显示评论关联文章的可点击链接，点击后跳转到文章编辑页面
     def link_to_article(self, obj):
+        #hz 获取文章对象的应用标签和模型名称
         info = (obj.article._meta.app_label, obj.article._meta.model_name)
+        #hz 生成文章编辑页面的URL
         link = reverse('admin:%s_%s_change' % info, args=(obj.article.id,))
+        #hz 返回HTML格式的链接，显示文章的标题
         return format_html(
             u'<a href="%s">%s</a>' % (link, obj.article.title))
 
+    #hz 设置link_to_userinfo字段在列表页的列标题
     link_to_userinfo.short_description = _('User')
+    #hz 设置link_to_article字段在列表页的列标题
     link_to_article.short_description = _('Article')

src/comments/apps.py

@@ -1,5 +1,11 @@
+#hz 评论模块的Django应用配置
+#hz 本模块定义了评论应用的配置类，用于Django应用的初始化和配置管理
+
 from django.apps import AppConfig
 
 
+#hz 评论应用的配置类
+#hz 继承自AppConfig，用于配置评论应用的基本信息和行为
 class CommentsConfig(AppConfig):
+    #hz 应用的完整Python路径，Django使用此路径来识别和定位应用
     name = 'comments'

src/comments/forms.py

@@ -1,13 +1,25 @@
+#hz 评论模块的表单定义
+#hz 本模块定义了评论提交表单，用于收集和处理用户提交的评论数据
+
 from django import forms
 from django.forms import ModelForm
 
 from .models import Comment
 
 
+#hz 评论表单类
+#hz 继承自ModelForm，用于创建和验证评论数据
 class CommentForm(ModelForm):
+    #hz 父评论ID字段，用于实现嵌套评论功能
+    #hz 使用HiddenInput隐藏输入框，用户不可见，通过JavaScript或后端逻辑设置
+    #hz required=False表示该字段不是必填项（顶级评论不需要父评论ID）
     parent_comment_id = forms.IntegerField(
         widget=forms.HiddenInput, required=False)
 
+    #hz 表单的元数据配置
     class Meta:
+        #hz 关联的模型类
         model = Comment
+        #hz 表单中包含的字段，只包含评论正文body字段
+        #hz 其他字段（如作者、文章、创建时间等）由视图逻辑自动设置
         fields = ['body']

src/comments/models.py

@@ -1,3 +1,6 @@
+#hz 评论模块的数据模型定义
+#hz 本模块定义了博客评论系统的核心数据模型Comment，支持评论的创建、管理以及嵌套评论功能
+
 from django.conf import settings
 from django.db import models
 from django.utils.timezone import now
@@ -8,32 +11,48 @@ from blog.models import Article
 
 # Create your models here.
 
+#hz 评论模型类
+#hz 用于存储博客文章的评论信息，支持评论的正文内容、作者、关联文章、父评论（支持嵌套评论）等字段
 class Comment(models.Model):
+    #hz 评论正文内容，最大长度为300字符
     body = models.TextField('正文', max_length=300)
+    #hz 评论创建时间，默认为当前时间
     creation_time = models.DateTimeField(_('creation time'), default=now)
+    #hz 评论最后修改时间，默认为当前时间
     last_modify_time = models.DateTimeField(_('last modify time'), default=now)
+    #hz 评论作者，关联到用户模型，使用级联删除（删除用户时同时删除该用户的所有评论）
     author = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         verbose_name=_('author'),
         on_delete=models.CASCADE)
+    #hz 评论关联的文章，关联到Article模型，使用级联删除（删除文章时同时删除该文章的所有评论）
     article = models.ForeignKey(
         Article,
         verbose_name=_('article'),
         on_delete=models.CASCADE)
+    #hz 父评论，支持嵌套评论功能，可以为空（表示顶级评论）
+    #hz 使用'self'实现自关联，允许评论回复其他评论
     parent_comment = models.ForeignKey(
         'self',
         verbose_name=_('parent comment'),
         blank=True,
         null=True,
         on_delete=models.CASCADE)
+    #hz 评论是否启用（显示），默认为False（需要审核后才能显示）
     is_enable = models.BooleanField(_('enable'),
                                     default=False, blank=False, null=False)
 
+    #hz 模型的元数据配置
     class Meta:
+        #hz 按ID降序排列，最新评论在前
         ordering = ['-id']
+        #hz 单数形式的模型名称
         verbose_name = _('comment')
+        #hz 复数形式的模型名称
         verbose_name_plural = verbose_name
+        #hz 获取最新记录时使用的字段
         get_latest_by = 'id'
 
+    #hz 对象的字符串表示方法，返回评论的正文内容
     def __str__(self):
         return self.body

src/comments/templatetags/comments_tags.py

@@ -1,30 +1,51 @@
+#hz 评论模块的Django模板标签
+#hz 本模块定义了评论相关的自定义模板标签，用于在模板中处理和显示评论数据
+
 from django import template
 
+#hz 注册模板标签库
 register = template.Library()
 
 
+#hz 解析评论树结构的模板标签
+#hz 获得当前评论的所有子评论列表（递归获取所有嵌套的子评论）
+#hz 用法: {% parse_commenttree article_comments comment as childcomments %}
 @register.simple_tag
 def parse_commenttree(commentlist, comment):
     """获得当前评论子评论的列表
         用法: {% parse_commenttree article_comments comment as childcomments %}
     """
+    #hz 存储所有子评论的列表
     datas = []
 
+    #hz 递归解析评论树的内部函数
+    #hz 从指定的评论开始，递归查找所有子评论（支持多级嵌套）
     def parse(c):
+        #hz 查找当前评论的所有直接子评论（父评论为c且已启用的评论）
         childs = commentlist.filter(parent_comment=c, is_enable=True)
+        #hz 遍历所有子评论
         for child in childs:
+            #hz 将子评论添加到结果列表
             datas.append(child)
+            #hz 递归解析子评论的子评论（实现多级嵌套评论的解析）
             parse(child)
 
+    #hz 从传入的评论开始解析评论树
     parse(comment)
+    #hz 返回所有子评论的列表
     return datas
 
 
+#hz 显示评论项的包含标签
+#hz 渲染评论项的模板，支持区分父评论和子评论的显示样式
 @register.inclusion_tag('comments/tags/comment_item.html')
 def show_comment_item(comment, ischild):
     """评论"""
+    #hz 设置评论的显示深度：如果是子评论（ischild=True），深度为1；否则深度为2
+    #hz 深度用于控制评论的缩进或样式，实现评论的层级显示效果
     depth = 1 if ischild else 2
+    #hz 返回传递给模板的上下文数据
     return {
-        'comment_item': comment,
-        'depth': depth
+        'comment_item': comment,  #hz 评论对象
+        'depth': depth  #hz 评论的显示深度
     }

src/comments/tests.py

@@ -1,3 +1,6 @@
+#hz 评论模块的单元测试
+#hz 本模块包含评论功能的单元测试用例，用于测试评论的创建、验证、嵌套评论和模板标签等功能
+
 from django.test import Client, RequestFactory, TransactionTestCase
 from django.urls import reverse
 
@@ -10,71 +13,102 @@ from djangoblog.utils import get_max_articleid_commentid
 
 # Create your tests here.
 
+#hz 评论功能测试类
+#hz 继承自TransactionTestCase，用于测试评论相关的功能，包括评论提交、审核、嵌套评论等
 class CommentsTest(TransactionTestCase):
+    #hz 测试用例的初始化方法
+    #hz 在每个测试方法执行前运行，用于设置测试环境和测试数据
     def setUp(self):
+        #hz 创建测试客户端，用于模拟HTTP请求
         self.client = Client()
+        #hz 创建请求工厂，用于创建请求对象
         self.factory = RequestFactory()
+        #hz 设置博客配置：启用评论审核功能
         from blog.models import BlogSettings
         value = BlogSettings()
         value.comment_need_review = True
         value.save()
 
+        #hz 创建测试用的超级用户
         self.user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
             password="liangliangyy1")
 
+    #hz 更新文章评论状态的辅助方法
+    #hz 将指定文章的所有评论设置为启用状态（用于测试中模拟审核通过）
     def update_article_comment_status(self, article):
+        #hz 获取文章的所有评论
         comments = article.comment_set.all()
+        #hz 遍历所有评论，将is_enable字段设置为True
         for comment in comments:
             comment.is_enable = True
             comment.save()
 
+    #hz 测试评论验证功能
+    #hz 测试评论的创建、审核、嵌套评论和模板标签等功能
     def test_validate_comment(self):
+        #hz 登录测试用户
         self.client.login(username='liangliangyy1', password='liangliangyy1')
 
+        #hz 创建测试用的分类
         category = Category()
         category.name = "categoryccc"
         category.save()
 
+        #hz 创建测试用的文章
         article = Article()
         article.title = "nicetitleccc"
         article.body = "nicecontentccc"
         article.author = self.user
         article.category = category
-        article.type = 'a'
-        article.status = 'p'
+        article.type = 'a'  #hz 文章类型
+        article.status = 'p'  #hz 文章状态：已发布
         article.save()
 
+        #hz 获取评论提交的URL
         comment_url = reverse(
             'comments:postcomment', kwargs={
                 'article_id': article.id})
 
+        #hz 测试提交第一条评论
         response = self.client.post(comment_url,
                                     {
                                         'body': '123ffffffffff'
                                     })
 
+        #hz 验证响应状态码为302（重定向）
         self.assertEqual(response.status_code, 302)
 
+        #hz 重新获取文章对象，检查评论列表
         article = Article.objects.get(pk=article.pk)
+        #hz 验证评论列表长度为0（因为评论需要审核，初始状态为未启用）
         self.assertEqual(len(article.comment_list()), 0)
+        #hz 更新评论状态为启用（模拟审核通过）
         self.update_article_comment_status(article)
 
+        #hz 验证评论列表长度为1（审核通过后可见）
         self.assertEqual(len(article.comment_list()), 1)
 
+        #hz 测试提交第二条评论
         response = self.client.post(comment_url,
                                     {
                                         'body': '123ffffffffff',
                                     })
 
+        #hz 验证响应状态码为302（重定向）
         self.assertEqual(response.status_code, 302)
 
+        #hz 重新获取文章对象，更新评论状态，验证评论数量
         article = Article.objects.get(pk=article.pk)
         self.update_article_comment_status(article)
+        #hz 验证评论列表长度为2
         self.assertEqual(len(article.comment_list()), 2)
+        #hz 获取第一条评论的ID，用于测试嵌套评论
         parent_comment_id = article.comment_list()[0].id
 
+        #hz 测试提交嵌套评论（回复评论）
+        #hz 评论内容包含Markdown格式，测试复杂内容的处理
         response = self.client.post(comment_url,
                                     {
                                         'body': '''
@@ -90,20 +124,32 @@ class CommentsTest(TransactionTestCase):
 
 
         ''',
-                                        'parent_comment_id': parent_comment_id
+                                        'parent_comment_id': parent_comment_id  #hz 指定父评论ID，创建嵌套评论
                                     })
 
+        #hz 验证响应状态码为302（重定向）
         self.assertEqual(response.status_code, 302)
+        #hz 更新评论状态为启用
         self.update_article_comment_status(article)
+        #hz 重新获取文章对象
         article = Article.objects.get(pk=article.pk)
+        #hz 验证评论列表长度为3（包含2条顶级评论和1条回复评论）
         self.assertEqual(len(article.comment_list()), 3)
+        #hz 获取父评论对象
         comment = Comment.objects.get(id=parent_comment_id)
+        #hz 测试评论树解析功能：解析父评论的所有子评论
         tree = parse_commenttree(article.comment_list(), comment)
+        #hz 验证子评论数量为1
         self.assertEqual(len(tree), 1)
+        #hz 测试评论项显示模板标签
         data = show_comment_item(comment, True)
+        #hz 验证返回数据不为空
         self.assertIsNotNone(data)
+        #hz 测试获取最大文章ID和评论ID的工具函数
         s = get_max_articleid_commentid()
+        #hz 验证返回结果不为空
         self.assertIsNotNone(s)
 
+        #hz 测试发送评论邮件功能
         from comments.utils import send_comment_email
         send_comment_email(comment)

src/comments/urls.py

@@ -1,9 +1,17 @@
+#hz 评论模块的URL路由配置
+#hz 本模块定义了评论相关的URL路由规则，将URL路径映射到对应的视图处理函数
+
 from django.urls import path
 
 from . import views
 
+#hz 应用命名空间，用于区分不同应用中同名的URL模式
 app_name = "comments"
+#hz URL模式列表，定义了评论模块的所有URL路由规则
 urlpatterns = [
+    #hz 评论提交路由
+    #hz 路径格式：/article/<文章ID>/postcomment
+    #hz 处理评论的提交请求，使用CommentPostView视图类处理GET和POST请求
     path(
         'article/<int:article_id>/postcomment',
         views.CommentPostView.as_view(),

src/comments/utils.py

@@ -1,3 +1,6 @@
+#hz 评论模块的工具函数
+#hz 本模块提供了评论相关的工具函数，主要包括发送评论通知邮件的功能
+
 import logging
 
 from django.utils.translation import gettext_lazy as _
@@ -5,13 +8,21 @@ from django.utils.translation import gettext_lazy as _
 from djangoblog.utils import get_current_site
 from djangoblog.utils import send_email
 
+#hz 获取当前模块的日志记录器，用于记录错误信息
 logger = logging.getLogger(__name__)
 
 
+#hz 发送评论通知邮件函数
+#hz 当用户提交评论后，向评论作者发送感谢邮件；如果是回复评论，则向被回复的用户发送通知邮件
 def send_comment_email(comment):
+    #hz 获取当前网站的域名
     site = get_current_site().domain
+    #hz 邮件主题
     subject = _('Thanks for your comment')
+    #hz 构建文章的完整URL地址
     article_url = f"https://{site}{comment.article.get_absolute_url()}"
+    #hz 构建发送给评论作者的邮件内容（感谢邮件）
+    #hz 包含文章链接和标题，感谢用户评论
     html_content = _("""<p>Thank you very much for your comments on this site</p>
                     You can visit <a href="%(article_url)s" rel="bookmark">%(article_title)s</a>
                     to review your comments,
@@ -19,10 +30,16 @@ def send_comment_email(comment):
                     <br />
                     If the link above cannot be opened, please copy this link to your browser.
                     %(article_url)s""") % {'article_url': article_url, 'article_title': comment.article.title}
+    #hz 获取评论作者的邮箱地址
     tomail = comment.author.email
+    #hz 向评论作者发送感谢邮件
     send_email([tomail], subject, html_content)
+    #hz 处理回复评论的情况：如果当前评论是回复其他评论，则向被回复的用户发送通知邮件
     try:
+        #hz 检查当前评论是否有父评论（是否为回复评论）
         if comment.parent_comment:
+            #hz 构建发送给被回复用户的邮件内容（回复通知邮件）
+            #hz 包含文章链接、标题和被回复的评论内容，通知用户有人回复了他们的评论
             html_content = _("""Your comment on <a href="%(article_url)s" rel="bookmark">%(article_title)s</a><br/> has 
                    received a reply. <br/> %(comment_body)s
                     <br/>   
@@ -32,7 +49,10 @@ def send_comment_email(comment):
                      %(article_url)s
                     """) % {'article_url': article_url, 'article_title': comment.article.title,
                             'comment_body': comment.parent_comment.body}
+            #hz 获取被回复评论的作者邮箱地址
             tomail = comment.parent_comment.author.email
+            #hz 向被回复的用户发送通知邮件
             send_email([tomail], subject, html_content)
+    #hz 捕获发送邮件过程中可能出现的异常，记录错误日志但不影响主流程
     except Exception as e:
         logger.error(e)

src/comments/views.py

@@ -1,3 +1,6 @@
+#hz 评论模块的视图处理
+#hz 本模块定义了评论提交相关的视图类，处理用户评论的提交、验证和保存逻辑
+
 # Create your views here.
 from django.core.exceptions import ValidationError
 from django.http import HttpResponseRedirect
@@ -12,52 +15,85 @@ from .forms import CommentForm
 from .models import Comment
 
 
+#hz 评论提交视图类
+#hz 继承自FormView，用于处理评论表单的提交和验证
 class CommentPostView(FormView):
+    #hz 使用的表单类
     form_class = CommentForm
+    #hz 渲染模板名称
     template_name = 'blog/article_detail.html'
 
+    #hz 请求分发方法，添加CSRF保护装饰器，防止跨站请求伪造攻击
     @method_decorator(csrf_protect)
     def dispatch(self, *args, **kwargs):
         return super(CommentPostView, self).dispatch(*args, **kwargs)
 
+    #hz 处理GET请求的方法
+    #hz 当用户通过GET方式访问评论提交URL时，重定向到文章详情页的评论区域
     def get(self, request, *args, **kwargs):
+        #hz 从URL参数中获取文章ID
         article_id = self.kwargs['article_id']
+        #hz 获取文章对象，如果不存在则返回404错误
         article = get_object_or_404(Article, pk=article_id)
+        #hz 获取文章的绝对URL
         url = article.get_absolute_url()
+        #hz 重定向到文章详情页的评论区域（通过锚点#comments定位）
         return HttpResponseRedirect(url + "#comments")
 
+    #hz 表单验证失败时的处理方法
+    #hz 当用户提交的评论表单验证失败时，重新渲染文章详情页并显示表单错误信息
     def form_invalid(self, form):
+        #hz 从URL参数中获取文章ID
         article_id = self.kwargs['article_id']
+        #hz 获取文章对象，如果不存在则返回404错误
         article = get_object_or_404(Article, pk=article_id)
 
+        #hz 返回包含表单和文章对象的响应，用于重新渲染页面并显示错误信息
         return self.render_to_response({
             'form': form,
             'article': article
         })
 
+    #hz 表单验证成功时的处理方法
+    #hz 提交的数据验证合法后的逻辑：保存评论、处理嵌套评论、设置审核状态等
     def form_valid(self, form):
         """提交的数据验证合法后的逻辑"""
+        #hz 获取当前登录用户
         user = self.request.user
+        #hz 获取用户对应的BlogUser对象
         author = BlogUser.objects.get(pk=user.pk)
+        #hz 从URL参数中获取文章ID
         article_id = self.kwargs['article_id']
+        #hz 获取文章对象，如果不存在则返回404错误
         article = get_object_or_404(Article, pk=article_id)
 
+        #hz 检查文章的评论状态和文章状态，如果评论已关闭或文章已关闭，则抛出验证错误
         if article.comment_status == 'c' or article.status == 'c':
             raise ValidationError("该文章评论已关闭.")
+        #hz 保存表单数据但不提交到数据库（commit=False），以便进一步处理
         comment = form.save(False)
+        #hz 设置评论关联的文章
         comment.article = article
+        #hz 获取博客设置，用于判断评论是否需要审核
         from djangoblog.utils import get_blog_setting
         settings = get_blog_setting()
+        #hz 如果博客设置中不需要审核评论，则直接启用评论（设置为可见）
         if not settings.comment_need_review:
             comment.is_enable = True
+        #hz 设置评论的作者
         comment.author = author
 
+        #hz 处理嵌套评论：如果表单中包含父评论ID，则设置评论的父评论
         if form.cleaned_data['parent_comment_id']:
+            #hz 获取父评论对象
             parent_comment = Comment.objects.get(
                 pk=form.cleaned_data['parent_comment_id'])
+            #hz 设置评论的父评论，实现评论回复功能
             comment.parent_comment = parent_comment
 
+        #hz 保存评论到数据库（commit=True）
         comment.save(True)
+        #hz 重定向到文章详情页并定位到新提交的评论位置（通过锚点定位）
         return HttpResponseRedirect(
             "%s#div-comment-%d" %
             (article.get_absolute_url(), comment.pk))

src/deploy/k8s/deployment.yaml

@@ -26,13 +26,13 @@ spec:
             name: djangoblog-env
         readinessProbe:
           httpGet:
-            path: /
+            path: /health/
             port: 8000
           initialDelaySeconds: 10
           periodSeconds: 30
         livenessProbe:
           httpGet:
-            path: /
+            path: /health/
             port: 8000
           initialDelaySeconds: 10
           periodSeconds: 30

src/djangoblog/plugin_manage/base_plugin.py

@@ -1,4 +1,8 @@
 import logging
+from pathlib import Path
+
+from django.template import TemplateDoesNotExist
+from django.template.loader import render_to_string
 
 logger = logging.getLogger(__name__)
 
@@ -8,13 +12,34 @@ class BasePlugin:
     PLUGIN_NAME = None
     PLUGIN_DESCRIPTION = None
     PLUGIN_VERSION = None
+    PLUGIN_AUTHOR = None
+
+    # 插件配置
+    SUPPORTED_POSITIONS = []  # 支持的显示位置
+    DEFAULT_PRIORITY = 100  # 默认优先级（数字越小优先级越高）
+    POSITION_PRIORITIES = {}  # 各位置的优先级 {'sidebar': 50, 'article_bottom': 80}
 
     def __init__(self):
         if not all([self.PLUGIN_NAME, self.PLUGIN_DESCRIPTION, self.PLUGIN_VERSION]):
             raise ValueError("Plugin metadata (PLUGIN_NAME, PLUGIN_DESCRIPTION, PLUGIN_VERSION) must be defined.")
+
+        # 设置插件路径
+        self.plugin_dir = self._get_plugin_directory()
+        self.plugin_slug = self._get_plugin_slug()
+
         self.init_plugin()
         self.register_hooks()
 
+    def _get_plugin_directory(self):
+        """获取插件目录路径"""
+        import inspect
+        plugin_file = inspect.getfile(self.__class__)
+        return Path(plugin_file).parent
+
+    def _get_plugin_slug(self):
+        """获取插件标识符（目录名）"""
+        return self.plugin_dir.name
+
     def init_plugin(self):
         """
         插件初始化逻辑
@@ -29,6 +54,129 @@ class BasePlugin:
         """
         pass
 
+    # === 位置渲染系统 ===
+    def render_position_widget(self, position, context, **kwargs):
+        """
+        根据位置渲染插件组件
+        
+        Args:
+            position: 位置标识
+            context: 模板上下文
+            **kwargs: 额外参数
+            
+        Returns:
+            dict: {'html': 'HTML内容', 'priority': 优先级} 或 None
+        """
+        if position not in self.SUPPORTED_POSITIONS:
+            return None
+
+        # 检查条件显示
+        if not self.should_display(position, context, **kwargs):
+            return None
+
+        # 调用具体的位置渲染方法
+        method_name = f'render_{position}_widget'
+        if hasattr(self, method_name):
+            html = getattr(self, method_name)(context, **kwargs)
+            if html:
+                priority = self.POSITION_PRIORITIES.get(position, self.DEFAULT_PRIORITY)
+                return {
+                    'html': html,
+                    'priority': priority,
+                    'plugin_name': self.PLUGIN_NAME
+                }
+
+        return None
+
+    def should_display(self, position, context, **kwargs):
+        """
+        判断插件是否应该在指定位置显示
+        子类可重写此方法实现条件显示逻辑
+        
+        Args:
+            position: 位置标识
+            context: 模板上下文
+            **kwargs: 额外参数
+            
+        Returns:
+            bool: 是否显示
+        """
+        return True
+
+    # === 各位置渲染方法 - 子类重写 ===
+    def render_sidebar_widget(self, context, **kwargs):
+        """渲染侧边栏组件"""
+        return None
+
+    def render_article_bottom_widget(self, context, **kwargs):
+        """渲染文章底部组件"""
+        return None
+
+    def render_article_top_widget(self, context, **kwargs):
+        """渲染文章顶部组件"""
+        return None
+
+    def render_header_widget(self, context, **kwargs):
+        """渲染页头组件"""
+        return None
+
+    def render_footer_widget(self, context, **kwargs):
+        """渲染页脚组件"""
+        return None
+
+    def render_comment_before_widget(self, context, **kwargs):
+        """渲染评论前组件"""
+        return None
+
+    def render_comment_after_widget(self, context, **kwargs):
+        """渲染评论后组件"""
+        return None
+
+    # === 模板系统 ===
+    def render_template(self, template_name, context=None):
+        """
+        渲染插件模板
+        
+        Args:
+            template_name: 模板文件名
+            context: 模板上下文
+            
+        Returns:
+            HTML字符串
+        """
+        if context is None:
+            context = {}
+
+        template_path = f"plugins/{self.plugin_slug}/{template_name}"
+
+        try:
+            return render_to_string(template_path, context)
+        except TemplateDoesNotExist:
+            logger.warning(f"Plugin template not found: {template_path}")
+            return ""
+
+    # === 静态资源系统 ===
+    def get_static_url(self, static_file):
+        """获取插件静态文件URL"""
+        from django.templatetags.static import static
+        return static(f"{self.plugin_slug}/static/{self.plugin_slug}/{static_file}")
+
+    def get_css_files(self):
+        """获取插件CSS文件列表"""
+        return []
+
+    def get_js_files(self):
+        """获取插件JavaScript文件列表"""
+        return []
+
+    def get_head_html(self, context=None):
+        """获取需要插入到<head>中的HTML内容"""
+        return ""
+
+    def get_body_html(self, context=None):
+        """获取需要插入到<body>底部的HTML内容"""
+        return ""
+
     def get_plugin_info(self):
         """
         获取插件信息
@@ -37,5 +185,10 @@ class BasePlugin:
         return {
             'name': self.PLUGIN_NAME,
             'description': self.PLUGIN_DESCRIPTION,
-            'version': self.PLUGIN_VERSION
+            'version': self.PLUGIN_VERSION,
+            'author': self.PLUGIN_AUTHOR,
+            'slug': self.plugin_slug,
+            'directory': str(self.plugin_dir),
+            'supported_positions': self.SUPPORTED_POSITIONS,
+            'priorities': self.POSITION_PRIORITIES
         }

src/djangoblog/plugin_manage/hook_constants.py

@@ -5,3 +5,18 @@ ARTICLE_DELETE = 'article_delete'
 
 ARTICLE_CONTENT_HOOK_NAME = "the_content"
 
+# 位置钩子常量
+POSITION_HOOKS = {
+    'article_top': 'article_top_widgets',
+    'article_bottom': 'article_bottom_widgets',
+    'sidebar': 'sidebar_widgets',
+    'header': 'header_widgets',
+    'footer': 'footer_widgets',
+    'comment_before': 'comment_before_widgets',
+    'comment_after': 'comment_after_widgets',
+}
+
+# 资源注入钩子
+HEAD_RESOURCES_HOOK = 'head_resources'
+BODY_RESOURCES_HOOK = 'body_resources'
+

src/djangoblog/plugin_manage/loader.py

@@ -4,16 +4,61 @@ from django.conf import settings
 
 logger = logging.getLogger(__name__)
 
+# 全局插件注册表
+_loaded_plugins = []
+
 def load_plugins():
     """
     Dynamically loads and initializes plugins from the 'plugins' directory.
     This function is intended to be called when the Django app registry is ready.
     """
+    global _loaded_plugins
+    _loaded_plugins = []
+    
     for plugin_name in settings.ACTIVE_PLUGINS:
         plugin_path = os.path.join(settings.PLUGINS_DIR, plugin_name)
         if os.path.isdir(plugin_path) and os.path.exists(os.path.join(plugin_path, 'plugin.py')):
             try:
-                __import__(f'plugins.{plugin_name}.plugin')
-                logger.info(f"Successfully loaded plugin: {plugin_name}")
+                # 导入插件模块
+                plugin_module = __import__(f'plugins.{plugin_name}.plugin', fromlist=['plugin'])
+                
+                # 获取插件实例
+                if hasattr(plugin_module, 'plugin'):
+                    plugin_instance = plugin_module.plugin
+                    _loaded_plugins.append(plugin_instance)
+                    logger.info(f"Successfully loaded plugin: {plugin_name} - {plugin_instance.PLUGIN_NAME}")
+                else:
+                    logger.warning(f"Plugin {plugin_name} does not have 'plugin' instance")
+                    
             except ImportError as e:
-                logger.error(f"Failed to import plugin: {plugin_name}", exc_info=e) 
+                logger.error(f"Failed to import plugin: {plugin_name}", exc_info=e)
+            except AttributeError as e:
+                logger.error(f"Failed to get plugin instance: {plugin_name}", exc_info=e)
+            except Exception as e:
+                logger.error(f"Unexpected error loading plugin: {plugin_name}", exc_info=e)
+
+def get_loaded_plugins():
+    """获取所有已加载的插件"""
+    return _loaded_plugins
+
+def get_plugin_by_name(plugin_name):
+    """根据名称获取插件"""
+    for plugin in _loaded_plugins:
+        if plugin.plugin_slug == plugin_name:
+            return plugin
+    return None
+
+def get_plugin_by_slug(plugin_slug):
+    """根据slug获取插件"""
+    for plugin in _loaded_plugins:
+        if plugin.plugin_slug == plugin_slug:
+            return plugin
+    return None
+
+def get_plugins_info():
+    """获取所有插件的信息"""
+    return [plugin.get_plugin_info() for plugin in _loaded_plugins]
+
+def get_plugins_by_position(position):
+    """获取支持指定位置的插件"""
+    return [plugin for plugin in _loaded_plugins if position in plugin.SUPPORTED_POSITIONS] 

src/djangoblog/settings.py

@@ -106,18 +106,44 @@ WSGI_APPLICATION = 'djangoblog.wsgi.application'
 # https://docs.djangoproject.com/en/1.10/ref/settings/#databases
 
 
+<<<<<<< HEAD
+if os.environ.get('DJANGO_DB', 'mysql') == 'sqlite':
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.sqlite3',
+            'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+        }
+    }
+else:
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.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 '0809',
+            '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'},
+        }
+    }
+=======
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': os.environ.get('DJANGO_MYSQL_DATABASE') or 'djangoblog',
         'USER': os.environ.get('DJANGO_MYSQL_USER') or 'root',
+<<<<<<< HEAD
+        'PASSWORD': os.environ.get('DJANGO_MYSQL_PASSWORD') or '0809',
+=======
         'PASSWORD': os.environ.get('DJANGO_MYSQL_PASSWORD') or 'root',
+>>>>>>> dd56ff6529a098d566ab2f63a4327c9176fc1a27
         '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'},
     }}
+>>>>>>> ff9fd39bdd141837237a8123ff2dc58c9bfa8e25
 
 # Password validation
 # https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators

src/djangoblog/urls.py

@@ -20,6 +20,8 @@ from django.contrib.sitemaps.views import sitemap
 from django.urls import path, include
 from django.urls import re_path
 from haystack.views import search_view_factory
+from django.http import JsonResponse
+import time
 
 from blog.views import EsSearchView
 from djangoblog.admin_site import admin_site
@@ -40,8 +42,20 @@ handler404 = 'blog.views.page_not_found_view'
 handler500 = 'blog.views.server_error_view'
 handle403 = 'blog.views.permission_denied_view'
 
+
+def health_check(request):
+    """
+    健康检查接口
+    简单返回服务健康状态
+    """
+    return JsonResponse({
+        'status': 'healthy',
+        'timestamp': time.time()
+    })
+
 urlpatterns = [
     path('i18n/', include('django.conf.urls.i18n')),
+    path('health/', health_check, name='health_check'),
 ]
 urlpatterns += i18n_patterns(
     re_path(r'^admin/', admin_site.urls),

src/djangoblog/utils.py

@@ -224,9 +224,49 @@ def get_resource_url():
 
 
 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']}
-
+                'h2', 'p', 'span', 'div']
+
+# 安全的class值白名单 - 只允许代码高亮相关的class
+ALLOWED_CLASSES = [
+    'codehilite', 'highlight', 'hll', 'c', 'err', 'k', 'l', 'n', 'o', 'p', 'cm', 'cp', 'c1', 'cs',
+    'gd', 'ge', 'gr', 'gh', 'gi', 'go', 'gp', 'gs', 'gu', 'gt', 'kc', 'kd', 'kn', 'kp', 'kr', 'kt',
+    'ld', 'm', 'mf', 'mh', 'mi', 'mo', 'na', 'nb', 'nc', 'no', 'nd', 'ni', 'ne', 'nf', 'nl', 'nn',
+    'nt', 'nv', 'ow', 'w', 'mb', 'mh', 'mi', 'mo', 'sb', 'sc', 'sd', 'se', 'sh', 'si', 'sx', 's2',
+    's1', 'ss', 'bp', 'vc', 'vg', 'vi', 'il'
+]
+
+def class_filter(tag, name, value):
+    """自定义class属性过滤器"""
+    if name == 'class':
+        # 只允许预定义的安全class值
+        allowed_classes = [cls for cls in value.split() if cls in ALLOWED_CLASSES]
+        return ' '.join(allowed_classes) if allowed_classes else False
+    return value
+
+# 安全的属性白名单
+ALLOWED_ATTRIBUTES = {
+    'a': ['href', 'title'], 
+    'abbr': ['title'], 
+    'acronym': ['title'],
+    'span': class_filter,
+    'div': class_filter,
+    'pre': class_filter,
+    'code': class_filter
+}
+
+# 安全的协议白名单 - 防止javascript:等危险协议
+ALLOWED_PROTOCOLS = ['http', 'https', 'mailto']
 
 def sanitize_html(html):
-    return bleach.clean(html, tags=ALLOWED_TAGS, attributes=ALLOWED_ATTRIBUTES)
+    """
+    安全的HTML清理函数
+    使用bleach库进行白名单过滤，防止XSS攻击
+    """
+    return bleach.clean(
+        html, 
+        tags=ALLOWED_TAGS, 
+        attributes=ALLOWED_ATTRIBUTES,
+        protocols=ALLOWED_PROTOCOLS,  # 限制允许的协议
+        strip=True,  # 移除不允许的标签而不是转义
+        strip_comments=True  # 移除HTML注释
+    )

src/plugins/article_copyright/plugin.py

@@ -22,6 +22,11 @@ class ArticleCopyrightPlugin(BasePlugin):
         article = kwargs.get('article')
         if not article:
             return content
+        
+        # 如果是摘要模式（首页），不添加版权声明
+        is_summary = kwargs.get('is_summary', False)
+        if is_summary:
+            return content
 
         copyright_info = f"\n<hr><p>本文由 {article.author.username} 原创，转载请注明出处。</p>"
         return content + copyright_info

src/plugins/article_recommendation/__init__.py

@@ -0,0 +1 @@
+# 文章推荐插件

src/plugins/article_recommendation/plugin.py

@@ -0,0 +1,205 @@
+import logging
+from djangoblog.plugin_manage.base_plugin import BasePlugin
+from djangoblog.plugin_manage import hooks
+from djangoblog.plugin_manage.hook_constants import ARTICLE_DETAIL_LOAD
+from blog.models import Article
+
+logger = logging.getLogger(__name__)
+
+
+class ArticleRecommendationPlugin(BasePlugin):
+    PLUGIN_NAME = '文章推荐'
+    PLUGIN_DESCRIPTION = '智能文章推荐系统，支持多位置展示'
+    PLUGIN_VERSION = '1.0.0'
+    PLUGIN_AUTHOR = 'liangliangyy'
+    
+    # 支持的位置
+    SUPPORTED_POSITIONS = ['article_bottom']
+    
+    # 各位置优先级
+    POSITION_PRIORITIES = {
+        'article_bottom': 80,  # 文章底部优先级
+    }
+    
+    # 插件配置
+    CONFIG = {
+        'article_bottom_count': 8,  # 文章底部推荐数量
+        'sidebar_count': 5,         # 侧边栏推荐数量
+        'enable_category_fallback': True,  # 启用分类回退
+        'enable_popular_fallback': True,   # 启用热门文章回退
+    }
+    
+    def register_hooks(self):
+        """注册钩子"""
+        hooks.register(ARTICLE_DETAIL_LOAD, self.on_article_detail_load)
+    
+    def on_article_detail_load(self, article, context, request, *args, **kwargs):
+        """文章详情页加载时的处理"""
+        # 可以在这里预加载推荐数据到context中
+        recommendations = self.get_recommendations(article)
+        context['article_recommendations'] = recommendations
+    
+    def should_display(self, position, context, **kwargs):
+        """条件显示逻辑"""
+        # 只在文章详情页底部显示
+        if position == 'article_bottom':
+            article = kwargs.get('article') or context.get('article')
+            # 检查是否有文章对象，以及是否不是索引页面
+            is_index = context.get('isindex', False) if hasattr(context, 'get') else False
+            return article is not None and not is_index
+            
+        return False
+    
+    def render_article_bottom_widget(self, context, **kwargs):
+        """渲染文章底部推荐"""
+        article = kwargs.get('article') or context.get('article')
+        if not article:
+            return None
+        
+        # 使用配置的数量，也可以通过kwargs覆盖
+        count = kwargs.get('count', self.CONFIG['article_bottom_count'])
+        recommendations = self.get_recommendations(article, count=count)
+        if not recommendations:
+            return None
+        
+        # 将RequestContext转换为普通字典
+        context_dict = {}
+        if hasattr(context, 'flatten'):
+            context_dict = context.flatten()
+        elif hasattr(context, 'dicts'):
+            # 合并所有上下文字典
+            for d in context.dicts:
+                context_dict.update(d)
+        
+        template_context = {
+            'recommendations': recommendations,
+            'article': article,
+            'title': '相关推荐',
+            **context_dict
+        }
+            
+        return self.render_template('bottom_widget.html', template_context)
+    
+    def render_sidebar_widget(self, context, **kwargs):
+        """渲染侧边栏推荐"""
+        article = context.get('article')
+        
+        # 使用配置的数量，也可以通过kwargs覆盖
+        count = kwargs.get('count', self.CONFIG['sidebar_count'])
+        
+        if article:
+            # 文章页面，显示相关文章
+            recommendations = self.get_recommendations(article, count=count)
+            title = '相关文章'
+        else:
+            # 其他页面，显示热门文章
+            recommendations = self.get_popular_articles(count=count)
+            title = '热门推荐'
+            
+        if not recommendations:
+            return None
+        
+        # 将RequestContext转换为普通字典
+        context_dict = {}
+        if hasattr(context, 'flatten'):
+            context_dict = context.flatten()
+        elif hasattr(context, 'dicts'):
+            # 合并所有上下文字典
+            for d in context.dicts:
+                context_dict.update(d)
+        
+        template_context = {
+            'recommendations': recommendations,
+            'title': title,
+            **context_dict
+        }
+            
+        return self.render_template('sidebar_widget.html', template_context)
+    
+    def get_css_files(self):
+        """返回CSS文件"""
+        return ['css/recommendation.css']
+    
+    def get_js_files(self):
+        """返回JS文件"""
+        return ['js/recommendation.js']
+    
+    def get_recommendations(self, article, count=5):
+        """获取推荐文章"""
+        if not article:
+            return []
+        
+        recommendations = []
+        
+        # 1. 基于标签的推荐
+        if article.tags.exists():
+            tag_ids = list(article.tags.values_list('id', flat=True))
+            tag_based = list(Article.objects.filter(
+                status='p',
+                tags__id__in=tag_ids
+            ).exclude(
+                id=article.id
+            ).exclude(
+                title__isnull=True
+            ).exclude(
+                title__exact=''
+            ).distinct().order_by('-views')[:count])
+            recommendations.extend(tag_based)
+        
+        # 2. 如果数量不够，基于分类推荐
+        if len(recommendations) < count and self.CONFIG['enable_category_fallback']:
+            needed = count - len(recommendations)
+            existing_ids = [r.id for r in recommendations] + [article.id]
+            
+            category_based = list(Article.objects.filter(
+                status='p',
+                category=article.category
+            ).exclude(
+                id__in=existing_ids
+            ).exclude(
+                title__isnull=True
+            ).exclude(
+                title__exact=''
+            ).order_by('-views')[:needed])
+            recommendations.extend(category_based)
+        
+        # 3. 如果还是不够，推荐热门文章
+        if len(recommendations) < count and self.CONFIG['enable_popular_fallback']:
+            needed = count - len(recommendations)
+            existing_ids = [r.id for r in recommendations] + [article.id]
+            
+            popular_articles = list(Article.objects.filter(
+                status='p'
+            ).exclude(
+                id__in=existing_ids
+            ).exclude(
+                title__isnull=True
+            ).exclude(
+                title__exact=''
+            ).order_by('-views')[:needed])
+            recommendations.extend(popular_articles)
+        
+        # 过滤掉无效的推荐
+        valid_recommendations = []
+        for rec in recommendations:
+            if rec.title and len(rec.title.strip()) > 0:
+                valid_recommendations.append(rec)
+            else:
+                logger.warning(f"过滤掉空标题文章: ID={rec.id}, 标题='{rec.title}'")
+        
+        # 调试：记录推荐结果
+        logger.info(f"原始推荐数量: {len(recommendations)}, 有效推荐数量: {len(valid_recommendations)}")
+        for i, rec in enumerate(valid_recommendations):
+            logger.info(f"推荐 {i+1}: ID={rec.id}, 标题='{rec.title}', 长度={len(rec.title)}")
+        
+        return valid_recommendations[:count]
+    
+    def get_popular_articles(self, count=3):
+        """获取热门文章"""
+        return list(Article.objects.filter(
+            status='p'
+        ).order_by('-views')[:count])
+
+
+# 实例化插件
+plugin = ArticleRecommendationPlugin()

src/plugins/article_recommendation/static/article_recommendation/css/recommendation.css

@@ -0,0 +1,166 @@
+/* 文章推荐插件样式 - 与网站风格保持一致 */
+
+/* 文章底部推荐样式 */
+.article-recommendations {
+    margin: 30px 0;
+    padding: 20px;
+    background: #fff;
+    border: 1px solid #e1e1e1;
+    border-radius: 3px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.recommendations-title {
+    margin: 0 0 15px 0;
+    font-size: 18px;
+    color: #444;
+    font-weight: bold;
+    padding-bottom: 8px;
+    border-bottom: 2px solid #21759b;
+    display: inline-block;
+}
+
+.recommendations-icon {
+    margin-right: 5px;
+    font-size: 16px;
+}
+
+.recommendations-grid {
+    display: grid;
+    gap: 15px;
+    grid-template-columns: 1fr;
+    margin-top: 15px;
+}
+
+.recommendation-card {
+    background: #fff;
+    border: 1px solid #e1e1e1;
+    border-radius: 3px;
+    transition: all 0.2s ease;
+    overflow: hidden;
+}
+
+.recommendation-card:hover {
+    border-color: #21759b;
+    box-shadow: 0 2px 5px rgba(33, 117, 155, 0.1);
+}
+
+.recommendation-link {
+    display: block;
+    padding: 15px;
+    text-decoration: none;
+    color: inherit;
+}
+
+.recommendation-title {
+    margin: 0 0 8px 0;
+    font-size: 15px;
+    font-weight: normal;
+    color: #444;
+    line-height: 1.4;
+    transition: color 0.2s ease;
+}
+
+.recommendation-card:hover .recommendation-title {
+    color: #21759b;
+}
+
+.recommendation-meta {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 12px;
+    color: #757575;
+}
+
+.recommendation-category {
+    background: #ebebeb;
+    color: #5e5e5e;
+    padding: 2px 6px;
+    border-radius: 2px;
+    font-size: 11px;
+    font-weight: normal;
+}
+
+.recommendation-date {
+    font-weight: normal;
+    color: #757575;
+}
+
+/* 侧边栏推荐样式 */
+.widget_recommendations {
+    margin-bottom: 20px;
+}
+
+.widget_recommendations .widget-title {
+    font-size: 16px;
+    font-weight: bold;
+    margin-bottom: 15px;
+    color: #333;
+    border-bottom: 2px solid #007cba;
+    padding-bottom: 5px;
+}
+
+.recommendations-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+
+.recommendations-list .recommendation-item {
+    padding: 8px 0;
+    border-bottom: 1px solid #eee;
+    background: none;
+    border: none;
+    border-radius: 0;
+}
+
+.recommendations-list .recommendation-item:last-child {
+    border-bottom: none;
+}
+
+.recommendations-list .recommendation-item a {
+    color: #333;
+    text-decoration: none;
+    font-size: 14px;
+    line-height: 1.4;
+    display: block;
+    margin-bottom: 4px;
+    transition: color 0.3s ease;
+}
+
+.recommendations-list .recommendation-item a:hover {
+    color: #007cba;
+}
+
+.recommendations-list .recommendation-meta {
+    font-size: 11px;
+    color: #999;
+    margin: 0;
+}
+
+.recommendations-list .recommendation-meta span {
+    margin-right: 10px;
+}
+
+/* 响应式设计 - 分栏显示 */
+@media (min-width: 768px) {
+    .recommendations-grid {
+        grid-template-columns: repeat(2, 1fr);
+        gap: 15px;
+    }
+}
+
+@media (min-width: 1024px) {
+    .recommendations-grid {
+        grid-template-columns: repeat(3, 1fr);
+        gap: 15px;
+    }
+}
+
+@media (min-width: 1200px) {
+    .recommendations-grid {
+        grid-template-columns: repeat(4, 1fr);
+        gap: 15px;
+    }
+}

src/plugins/article_recommendation/static/article_recommendation/js/recommendation.js

@@ -0,0 +1,93 @@
+/**
+ * 文章推荐插件JavaScript
+ */
+
+(function() {
+    'use strict';
+    
+    // 等待DOM加载完成
+    document.addEventListener('DOMContentLoaded', function() {
+        initRecommendations();
+    });
+    
+    function initRecommendations() {
+        // 添加点击统计
+        trackRecommendationClicks();
+        
+        // 懒加载优化（如果需要）
+        lazyLoadRecommendations();
+    }
+    
+    function trackRecommendationClicks() {
+        const recommendationLinks = document.querySelectorAll('.recommendation-item a');
+        
+        recommendationLinks.forEach(function(link) {
+            link.addEventListener('click', function(e) {
+                // 可以在这里添加点击统计逻辑
+                const articleTitle = this.textContent.trim();
+                const articleUrl = this.href;
+                
+                // 发送统计数据到后端（可选）
+                if (typeof gtag !== 'undefined') {
+                    gtag('event', 'click', {
+                        'event_category': 'recommendation',
+                        'event_label': articleTitle,
+                        'value': 1
+                    });
+                }
+                
+                console.log('Recommendation clicked:', articleTitle, articleUrl);
+            });
+        });
+    }
+    
+    function lazyLoadRecommendations() {
+        // 如果推荐内容很多，可以实现懒加载
+        const recommendationContainer = document.querySelector('.article-recommendations');
+        
+        if (!recommendationContainer) {
+            return;
+        }
+        
+        // 检查是否在视窗中
+        const observer = new IntersectionObserver(function(entries) {
+            entries.forEach(function(entry) {
+                if (entry.isIntersecting) {
+                    entry.target.classList.add('loaded');
+                    observer.unobserve(entry.target);
+                }
+            });
+        }, {
+            threshold: 0.1
+        });
+        
+        const recommendationItems = document.querySelectorAll('.recommendation-item');
+        recommendationItems.forEach(function(item) {
+            observer.observe(item);
+        });
+    }
+    
+    // 添加一些动画效果
+    function addAnimations() {
+        const recommendationItems = document.querySelectorAll('.recommendation-item');
+        
+        recommendationItems.forEach(function(item, index) {
+            item.style.opacity = '0';
+            item.style.transform = 'translateY(20px)';
+            item.style.transition = 'opacity 0.5s ease, transform 0.5s ease';
+            
+            setTimeout(function() {
+                item.style.opacity = '1';
+                item.style.transform = 'translateY(0)';
+            }, index * 100);
+        });
+    }
+    
+    // 如果需要，可以在这里添加更多功能
+    window.ArticleRecommendation = {
+        init: initRecommendations,
+        track: trackRecommendationClicks,
+        animate: addAnimations
+    };
+    
+})();

src/plugins/image_lazy_loading/__init__.py

@@ -0,0 +1 @@
+# Image Lazy Loading Plugin

src/plugins/image_lazy_loading/plugin.py

@@ -0,0 +1,182 @@
+import re
+import hashlib
+from urllib.parse import urlparse
+from djangoblog.plugin_manage.base_plugin import BasePlugin
+from djangoblog.plugin_manage import hooks
+from djangoblog.plugin_manage.hook_constants import ARTICLE_CONTENT_HOOK_NAME
+
+
+class ImageOptimizationPlugin(BasePlugin):
+    PLUGIN_NAME = '图片性能优化插件'
+    PLUGIN_DESCRIPTION = '自动为文章中的图片添加懒加载、异步解码等性能优化属性，显著提升页面加载速度。'
+    PLUGIN_VERSION = '1.0.0'
+    PLUGIN_AUTHOR = 'liangliangyy'
+
+    def __init__(self):
+        # 插件配置
+        self.config = {
+            'enable_lazy_loading': True,        # 启用懒加载
+            'enable_async_decoding': True,      # 启用异步解码
+            'add_loading_placeholder': True,    # 添加加载占位符
+            'optimize_external_images': True,   # 优化外部图片
+            'add_responsive_attributes': True,  # 添加响应式属性
+            'skip_first_image': True,          # 跳过第一张图片（LCP优化）
+        }
+        super().__init__()
+
+    def register_hooks(self):
+        hooks.register(ARTICLE_CONTENT_HOOK_NAME, self.optimize_images)
+
+    def optimize_images(self, content, *args, **kwargs):
+        """
+        优化文章中的图片标签
+        """
+        if not content:
+            return content
+
+        # 正则表达式匹配 img 标签
+        img_pattern = re.compile(
+            r'<img\s+([^>]*?)(?:\s*/)?>',
+            re.IGNORECASE | re.DOTALL
+        )
+
+        image_count = 0
+        
+        def replace_img_tag(match):
+            nonlocal image_count
+            image_count += 1
+            
+            # 获取原始属性
+            original_attrs = match.group(1)
+            
+            # 解析现有属性
+            attrs = self._parse_img_attributes(original_attrs)
+            
+            # 应用优化
+            optimized_attrs = self._apply_optimizations(attrs, image_count)
+            
+            # 重构 img 标签
+            return self._build_img_tag(optimized_attrs)
+
+        # 替换所有 img 标签
+        optimized_content = img_pattern.sub(replace_img_tag, content)
+        
+        return optimized_content
+
+    def _parse_img_attributes(self, attr_string):
+        """
+        解析 img 标签的属性
+        """
+        attrs = {}
+        
+        # 正则表达式匹配属性
+        attr_pattern = re.compile(r'(\w+)=(["\'])(.*?)\2')
+        
+        for match in attr_pattern.finditer(attr_string):
+            attr_name = match.group(1).lower()
+            attr_value = match.group(3)
+            attrs[attr_name] = attr_value
+            
+        return attrs
+
+    def _apply_optimizations(self, attrs, image_index):
+        """
+        应用各种图片优化
+        """
+        # 1. 懒加载优化（跳过第一张图片以优化LCP）
+        if self.config['enable_lazy_loading']:
+            if not (self.config['skip_first_image'] and image_index == 1):
+                if 'loading' not in attrs:
+                    attrs['loading'] = 'lazy'
+
+        # 2. 异步解码
+        if self.config['enable_async_decoding']:
+            if 'decoding' not in attrs:
+                attrs['decoding'] = 'async'
+
+        # 3. 添加样式优化
+        current_style = attrs.get('style', '')
+        
+        # 确保图片不会超出容器
+        if 'max-width' not in current_style:
+            if current_style and not current_style.endswith(';'):
+                current_style += ';'
+            current_style += 'max-width:100%;height:auto;'
+            attrs['style'] = current_style
+
+        # 4. 添加 alt 属性（SEO和可访问性）
+        if 'alt' not in attrs:
+            # 尝试从图片URL生成有意义的alt文本
+            src = attrs.get('src', '')
+            if src:
+                # 从文件名生成alt文本
+                filename = src.split('/')[-1].split('.')[0]
+                # 移除常见的无意义字符
+                clean_name = re.sub(r'[0-9a-f]{8,}', '', filename)  # 移除长hash
+                clean_name = re.sub(r'[_-]+', ' ', clean_name).strip()
+                attrs['alt'] = clean_name if clean_name else '文章图片'
+            else:
+                attrs['alt'] = '文章图片'
+
+        # 5. 外部图片优化
+        if self.config['optimize_external_images'] and 'src' in attrs:
+            src = attrs['src']
+            parsed_url = urlparse(src)
+            
+            # 如果是外部图片，添加 referrerpolicy
+            if parsed_url.netloc and parsed_url.netloc != self._get_current_domain():
+                attrs['referrerpolicy'] = 'no-referrer-when-downgrade'
+                # 为外部图片添加crossorigin属性以支持性能监控
+                if 'crossorigin' not in attrs:
+                    attrs['crossorigin'] = 'anonymous'
+
+        # 6. 响应式图片属性（如果配置启用）
+        if self.config['add_responsive_attributes']:
+            # 添加 sizes 属性（如果没有的话）
+            if 'sizes' not in attrs and 'srcset' not in attrs:
+                attrs['sizes'] = '(max-width: 768px) 100vw, (max-width: 1024px) 50vw, 33vw'
+
+        # 7. 添加图片唯一标识符用于性能追踪
+        if 'data-img-id' not in attrs and 'src' in attrs:
+            img_hash = hashlib.md5(attrs['src'].encode()).hexdigest()[:8]
+            attrs['data-img-id'] = f'img-{img_hash}'
+
+        # 8. 为第一张图片添加高优先级提示（LCP优化）
+        if image_index == 1 and self.config['skip_first_image']:
+            attrs['fetchpriority'] = 'high'
+            # 移除懒加载以确保快速加载
+            if 'loading' in attrs:
+                del attrs['loading']
+
+        return attrs
+
+    def _build_img_tag(self, attrs):
+        """
+        重新构建 img 标签
+        """
+        attr_strings = []
+        
+        # 确保 src 属性在最前面
+        if 'src' in attrs:
+            attr_strings.append(f'src="{attrs["src"]}"')
+            
+        # 添加其他属性
+        for key, value in attrs.items():
+            if key != 'src':  # src 已经添加过了
+                attr_strings.append(f'{key}="{value}"')
+        
+        return f'<img {" ".join(attr_strings)}>'
+
+    def _get_current_domain(self):
+        """
+        获取当前网站域名
+        """
+        try:
+            from djangoblog.utils import get_current_site
+            return get_current_site().domain
+        except:
+            return ''
+
+
+# 实例化插件
+plugin = ImageOptimizationPlugin()

src/plugins/reading_time/plugin.py

@@ -17,7 +17,15 @@ class ReadingTimePlugin(BasePlugin):
     def add_reading_time(self, content, *args, **kwargs):
         """
         计算阅读时间并添加到内容开头。
+        只在文章详情页显示，首页（文章列表页）不显示。
         """
+        # 检查是否为摘要模式（首页/文章列表页）
+        # 通过kwargs中的is_summary参数判断
+        is_summary = kwargs.get('is_summary', False)
+        if is_summary:
+            # 如果是摘要模式（首页），直接返回原内容，不添加阅读时间
+            return content
+        
         # 移除HTML标签和空白字符，以获得纯文本
         clean_content = re.sub(r'<[^>]*>', '', content)
         clean_content = clean_content.strip()