# ch07 · 综合实例：简易博客系统

> 来源：教材配套 PPT《第七章 实例：简易博客系统.pptx》，共 149 页。本节只摘录**知识点与关键文字**，图取自 PPT 原页。

## 第 1 页 · 讲师：谢福财

- 讲师：谢福财
- Flask课程——
- **第七章**
- 实例：简易博客系统

![第1页图](media/ch07/slide01_img1.png)

## 第 2 页 · 理解如何根据项目需求设计

- 理解如何根据项目需求设计
- 相应模块
- 根据数据模型设计图完成
- 模型类的构建
- 完成简易博客系统的开发
- 学习目标

![第2页图](media/ch07/slide02_img1.png)

## 第 3 页 · 教学重点

- 教学重点
- 教学难点
- 博客系统是一个典型的开发入门案例，其中包含了用户验证、内容管理、数据关联等基本功能实现的综合应用。本章将会从项目设计开始，逐步完成各个模块的开发，最终实现一个完整的简易博客系统。
- 教学重难点

## 第 4 页 · 用户模块

- 用户模块
- 项目设计
- 入口模块
- 文章模块
- 小结
- 管理模块

## 第 5 页 · 项目设计

- 项目设计
- 01

## 第 6 页 · 项目设计

- 项目设计
- 在项目开发之前，需要了解项目需求；然后分析需求中所包含的功能，将各个功能划分到不同的模块，确立程序整体结构；接着分析各个模块所包含的功能，为需使用的数据模型设计具体结构。当项目设计完成之后，再将设计翻译成相应的代码实现。

## 第 7 页 · 项目设计

- 项目设计
- **1.1 项目需求**
- 一个简单的博客系统通常包含文章发布、文章分类、文章搜索、文章阅读量统计、文章留言、博客信息展示、友情链接展示等功能模块。
接下来将逐步完成以上功能的开发。

## 第 8 页 · 项目设计

- 项目设计
- **1.2 模块设计**
- 根据需求，可以分析出该系统的整体结构、功能模块架构，如下图所示。
- 该系统可以分成4个模块进行开发，各个模块负责各部分的内容。要注意的是，管理模块建立于其他模块之上（例如，先有用户模块，后有用户管理模块），接下来只要理解各个模块之间的关系，设计好相应的数据模型，最后为这些模块开发相应功能即可。

![第8页图](media/ch07/slide08_img1.jpg)

## 第 9 页 · 项目设计

- 项目设计
- **1.3 数据模型设计**
- 了解程序模块结构后，便要对模块所包含的功能中所使用的“对象”进行设计，建立数据模型，完成数据库的创建。为右图图所示为各个数据模型类的简要设计图，包含模型属性及各个模型之间的关系。
- 根据设计图所描述的结构完成各个数据模型类的定义后（可参考书本5.3.2、5.3.5小节），便可以使用Flask-Migrate生成数据库。数据库建立完成之后，便可以开始开发相应的模块、功能。

![第9页图](media/ch07/slide09_img1.png)

## 第 10 页 · 项目设计

- 项目设计
- **1.4 功能实现**
- 在接下来的功能代码实现中，模板页面文件将放置于“templates”（模板）目录中，而Python代码文件放置于“模块”目录中；这是约定俗成的规则。详细的项目结构可参考书本6.2节，模块初始化代码可参考书本6.3节。

## 第 11 页 · 入口模块

- 入口模块
- 02

## 第 12 页 · 入口模块

- 入口模块
- 入口模块是所有模块的基础之一，包含网站的首页，以及一些公共功能（如友情链接、网站设置）的实现。

## 第 13 页 · 入口模块

- 入口模块
- **2.1 数据模型定义**
- 友情链接模型的实现相当简单，它仅包含名称及其对应的链接（HTML中的<a>标签）。设定模型与友情链接模型在结构上基本一致，但“key”字段唯一，用于快速获取对应的设定值，“value”字段用于存储JSON数据对象（字符串格式，可与Python的基本数据类型相互转换）。数据模型图如下所示。

![第13页图](media/ch07/slide13_img1.png)

![第13页图](media/ch07/slide13_img2.png)

## 第 14 页 · 入口模块

- 入口模块
- 根据数据模型设计图，可定义以下模型，代码如下（portal/models.py）。
- from app import db
- from app.database import BaseModel
- class FriendLinkModel(db.Model, BaseModel):
- __tablename__ = 'friend_link'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- name = db.Column(db.VARCHAR)
- url = db.Column(db.VARCHAR)
- class SettingModel(db.Model, BaseModel):
- __tablename__ = 'setting'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- key = db.Column(db.VARCHAR, unique=True)
- value = db.Column(db.VARCHAR)

## 第 15 页 · 入口模块

- 入口模块
- **2.2 设定存取**
- 每一个页面中都会显示博客的名称及个性签名之类的内容。对这种用途很少、对象唯一的功能，不需要为其单独建立模型，只需将其作为一个设置项保存到数据库即可。所以首先需要建立设定项存取的方法。

## 第 16 页 · 入口模块

- 入口模块
- 以下是公共方法的代码实现（portal/common.py）。分为读取设定数据和保存设定数据。读取设定数据代码如下。
- import json
- from app import dh
- from app.portal.models import SettingModel
- # 读取设定数据
- def load_setting(key: str):
- item = SettingModel.query.filter_by(key=key).first()  # type: SettingModel
- if item is not None:
- return json.loads(item.value)
- return None
- item = SettingModel.query.filter_by(key=key).first()：这一行代码执行了一个数据库查询操作。它使用 SQLAlchemy 查询语言，从名为 "SettingModel" 的数据库模型中筛选出符合给定 "key" 的第一条记录，并将结果赋值给变量 "item"。
- if item is not None:这是一个条件语句，检查变量 "item" 是否不为空。如果存在符合条件的设置项记录，就执行以下操作。

## 第 17 页 · 入口模块

- 入口模块
- 保存设定数据代码如下。
- # 保存设定数据
- def save_setting(key: str, value):
- item = SettingModel.query.filter_by(key=key).first()  # type: SettingModel
- if item is None:
- item = SettingModel(key=key)
- item.value = json.dumps(value, ensure_ascii=False)
- dh.session.add(item)
- dh.session.commit()
- return False
- item.value = json.dumps(value, ensure_ascii=False)：将参数 "value" 转换为 JSON 格式的字符串，并将其赋值给 "item" 的 "value" 属性。这将把设置项的数据保存为 JSON 字符串。
- 接着就是把item对象添加到数据库会话中，再提交。

## 第 18 页 · 入口模块

- 入口模块
- 由于JSON可以很方便地将Python对象类型转换为str类型数据进行存取，所以使用JSON格式存储相关数据到数据库是一个很好的选择。
- 读取、保存设定数据的两个方法接下来需要在各个模板中使用，所以需要在应用中将其注册为全局对象，在应用“工厂”函数中添加以下粗体代码即可。
- def create_app(env):
     # ……其他应用初始化代码……
     # 从Python包中获取所有可以调用的对象并注册到模板全局变量，以便模板调用
     def register_all_callable_object_from_package(pkg, is_filter=False):
          for k in dir(pkg):
               f = getattr(pkg, k)
               if callable(f):
                     if is_filter:
                           app.add_template_filter(f)
                     else:
                           app.add_template_global(f)
 
     from app.portal import common as common_portal
     register_all_callable_object_from_package(common_portal)
- # ……其他应用初始化代码……

## 第 19 页 · 入口模块

- 入口模块
- **2.3 公共模板页面**
- 在博客系统中，很多页面都包含公共的部分，例如导航栏、友情链接、页尾等内容会在大部分页面中展示。显然，这些内容不会被重复编写，而是通过“模板包含、继承”的方式重复使用（参考书本3.2.6小节）。

## 第 20 页 · 入口模块

- 入口模块
- 以下是前台基准页的代码实现（common/base.html）。分为Flask-Bootstrap提供的基准页，同时加载系统设置、信息设置、导航栏、页尾这几块来说。首先是继承基准页的信息，代码如下。
- {# 前台基准模板，加载了站点设置与博客信息设置 #}
 
{% extends 'bootstrap/base.html' %}
 
{% import 'bootstrap/utils.html' as utils %}
 
{% set site_setting = load_setting('site_setting') %}
{% set info_setting = load_setting('info_setting') %}
- 前面两行代码是继承之前的bootstrap的base模板，以及导入utils模板，并且重命名
- 后两行代码分别用于从数据库中加载站点设置和博客信息设置，并将它们存储在变量 "site_setting" 和 "info_setting" 中。这些设置数据将在模板中用于动态渲染页面内容。

## 第 21 页 · 入口模块

- 入口模块
- 以下是前台基准页的代码实现（common/base.html）。以下是导航栏，尾页等内容（大部分页面会用到）。
- {% block navbar %}
- {# 加载导航栏 #}
- {% include 'common/nav.html' %}
- {% endblock %}
- {% block styles %}
- {{ super() }}
- <link href="{{ url_for('static', filename='blog.css') }}" rel= "stylesheet">
- {% endblock %}
- {% block content %}
- <div class="container" style="margin-bottom: 16px; padding-top: 72px;">
- {{ utils.flashed_messages() }}
- {% block content_inner %}{% endblock %}
- </div>
- {# 网页尾部内容，根据站点设置生成 #}
- <footer class="blog-footer">
- <p>{{ site_setting.site_footer }}</p>
- <p><a href="#">回到顶端</a></p>
- </footer>
- {% endblock %}

## 第 22 页 · 入口模块

- 入口模块
- 界面样式基于Bootstrap官方样例修改而成，由于本章主要内容为Flask应用的功能实现，故样式等静态资源请同学们自行参阅本书提供的样例代码。

## 第 23 页 · 入口模块

- 入口模块
- 导航栏的结构较为复杂，所以会分成好几块给大家讲解一下。以下是导航栏模板页的代码实现（common/nav.html）。
- <nav class="navbar navbar-inverse navbar-static-top" style="position: fixed; width: 100%;">
- ...中间代码省略...
- </nav>
- 这是 <nav> 元素的开始标签，表示一个导航栏。导航栏的样式由多个类定义，这些类通常来自于前端框架（比如 Bootstrap）。这里的类包括：
- navbar：表示这是一个导航栏元素。
- navbar-inverse：指定了导航栏的颜色方案，这里是一个深色背景的导航栏。
- navbar-static-top：将导航栏固定在页面的顶部。
- 另外，style 属性设置了一些内联样式，其中 position: fixed; 让导航栏固定在页面上，而 width: 100%; 让导航栏占满整个页面宽度。

## 第 24 页 · 入口模块

- 入口模块
- 以下是导航栏模板页的代码实现（common/nav.html）。
- <div class="navbar-header">
- {# 该按钮用于伸缩菜单，在小型设备（如手机）中使用 #}
- <button type="button" class="navbar-toggle collapsed" data- toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls= "navbar">
- <span class="sr-only">Toggle navigation</span>
- <span class="icon-bar"></span>
- <span class="icon-bar"></span>
- <span class="icon-bar"></span>
- </button>
- {# 导航栏左侧网站名称 #}
- <a class="navbar-brand" href="/">{{ site_setting.site_ name }}</a>
- </div>
- 这是一个标准的小型设备上显示一个可伸缩菜单按钮和网站名称的部分代码。点击按钮时，它会触发导航栏菜单的展开或折叠，以提供更好的移动设备用户体验。具体的参数可以去https://v3.bootcss.com/components/#navbar 这里去查看导航栏的写法。

## 第 25 页 · 入口模块

- 入口模块
- 以下是导航栏模板页的代码实现（common/nav.html）。
- <div id="navbar" class="collapse navbar-collapse">
- ...中间代码省略...
- </div>
- 这是一个导航栏的折叠容器，为了放后面的菜单内容。

## 第 26 页 · 入口模块

- 入口模块
- 以下是导航栏模板页的代码实现（common/nav.html）。
- <ul class="nav navbar-nav">
- <li class="dropdown">
- <a href="{{ url_for('article.list_all') }}">所有文章</a>
- </li>
- </ul>
- {# 加载文章分类菜单 #}
- {% include 'common/nav_menu/category.html' %}
- {# 加载用户菜单 #}
- {% include 'common/nav_menu/user.html' %}
- ul这一块代码是写了一个下拉子菜单。
- 接着后面两个就是引入两个模板文件，以生成文章分类的子菜单和用户相关的菜单项。

## 第 27 页 · 入口模块

- 入口模块
- 以下是导航栏模板页的代码实现（common/nav.html）。
- {# 如果用户是管理员，则显示后台管理菜单 #}
- {% if current_user.is_admin %}
- <ul class="nav navbar-nav navbar-right">
- <li class="dropdown">
- <a href="{{ url_for('admin.index') }}">后台管理</a>
- </li>
- </ul>
- {% endif %}
- 紧接着是把管理员的后台管理菜单也写了进来，用了个if来判断是否是管理员的身份。

## 第 28 页 · 入口模块

- 入口模块
- 以下是导航栏模板页的代码实现（common/nav.html）。
- {# 搜索栏代码 #}
- <form class="navbar-form navbar-right" action="{{ url_ for('article.search') }}">
- <label>
- <input name="keyword" type="text" class="form- control"placeholder="Search..."
- value="{% if request.endpoint == 'article. search'%}{{ request.args.keyword }}{% endif %}">
- </label>
- </form>
- value="{% if request.endpoint == 'article.search'%}{{ request.args.keyword }}{% endif %}"：根据当前请求的端点（endpoint）来动态设置输入框的值。如果请求的端点是 'article.search'，则输入框会显示搜索关键字，否则为空。

## 第 29 页 · 入口模块

- 入口模块
- 导航栏的结构较为复杂，为便于展示，上面采用模板包含方式引入结构较为复杂的菜单项。
- 引入的是文章分类菜单(category.html)和用户菜单(user.html)，下面是文章分类菜单的代码实现（common/nav_menu/category.html）。
- {# 文章分类菜单代码 #}
- <ul class="nav navbar-nav">
- <li class="dropdown">
- <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true"
- aria-expanded="true">
- 文章分类
- <span class="caret"></span></a>
- <ul class="dropdown-menu">
- {% for category in CategoryModel.query.all() %}
- <li><a href="{{ url_for('article.category', name= category.name) }}">{{ category.name }}</a>
- </li>
- {% endfor %}
- </ul>
- </li>
- </ul>

## 第 30 页 · 入口模块

- 入口模块
- 下面是用户菜单的代码实现（common/nav_menu/user.html）。
- {# 用户菜单代码 #}
- <ul class="nav navbar-nav navbar-right">
- <li class="dropdown">
- {% if current_user.is_anonymous %}
- {# 如果用户没有登录，则显示游客用的菜单 #}
- <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="true">
- 游客
- <span class="caret"></span></a>
- <ul class="dropdown-menu">
- <li><a href="{{ url_for('user.login') }}">登录</a></li>
- <li><a href="{{ url_for('user.register') }}">注册</a></li>
- </ul>
- {% else %}
- {# 登录以后显示用户名 #}
- <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="true">
- {{ current_user.info.nickname or current_user.username }}
- <span class="caret"></span></a>
- <ul class="dropdown-menu">
- <li><a href="{{ url_for('user.edit') }}">用户信息</a></li>
- <li class="divider"></li>
- <li><a href="{{ url_for('user.logout') }}">注销</a></li>
- </ul>
- {% endif %}
- </li>
- </ul>

## 第 31 页 · 入口模块

- 入口模块
- 前台基准页看似简单，实际上是由上述各个部分的内容一点点组合而成的，在基准页完成以后，每一个前台页面都基于基准页进行开发。
- 下面是前台表单页面的代码实现（common/form.html）。
- {% extends common/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}{{ title }}{% endblock %}
- {% block content_inner %}
- {{ wtf.quick_form(form) }}
- {% endblock %}
- 此页面将在接下来的用户模块等其他页面中多次使用。

## 第 32 页 · 入口模块

- 入口模块
- **2.4 文章分类、友情链接展示**
- 文章分类、友情链接将于各个页面的右侧进行展示，所以也是作为公共模板页面存在。下面会分开两个页面来讲解。

## 第 33 页 · 入口模块

- 入口模块
- 以下是右侧栏模板页的代码实现（common/right.py）。接下来将会在需要展示右侧栏的页面中包含这个文件。
- {# 博客右侧栏，包含“关于”部分内容、文章分类、友情链接 #}
<div class="col-sm-3 col-sm-offset-1 blog-sidebar">
     <div class="sidebar-module sidebar-module-inset">
          <h4>关于</h4>
          <p>{{ info_setting.about }}</p>
     </div>
     <div class="sidebar-module sidebar-module-inset">
          <h4>文章分类</h4>
          <ol class="list-unstyled">
               {% for item in CategoryModel.query.all() %}
                    <li><a href="{{ url_for('article.category', name= item.name) }}">{{ item.name }}</a></li>
               {% endfor %}
          </ol>
     </div>
     <div class="sidebar-module sidebar-module-inset">
          <h4>友情链接</h4>
          <ol class="list-unstyled">
               {% for item in FriendLinkModel.query.all() %}
                    <!-- target="_blank" 可以实现单击链接打开新页面的功能 -->
                    <li><a href="{{ item.url }}" target="_blank"> {{ item.name }}</a></li>
               {% endfor %}
          </ol>
     </div>
</div>

## 第 34 页 · 入口模块

- 入口模块
- **2.5 博客信息展示（首页）**
- 博客信息展示这个功能仅在首页中可见。首页需要根据“系统设置”中提供的参数，展示一定数量的文章，此时便需要用到公共方法中的load_setting()，然后根据数量从文章模型获取相应的数据。

## 第 35 页 · 入口模块

- 入口模块
- 以下是视图函数的代码实现（portal/views.py）。
- from flask import render_template
- from app.article.models import ArticleModel
- from app.portal.common import load_setting
- from . import portal
- @portal.route('/')
- def index():
- site_setting = load_setting('site_setting')
- home_per_page = site_setting.get('home_per_page', 10)
- articles = ArticleModel.query.order_by(ArticleModel.id.desc()). limit(home_per_page).all()
- return render_template('portal/index.html', articles=articles)

## 第 36 页 · 入口模块

- 入口模块
- 由于首页仅展示最新的几篇文章，所以只需要根据id倒序排列获取文章并注入模板页中即可。
- 以下是模板页面的代码实现（portal/index.html）。
- {% extends 'common/base.html' %}
- {% import 'article/macros.html' as macros %}
- {% block title %}首页{% endblock %}
- {% block content_inner %}
- <div class="container">
- <div class="row">
- <div class="col-sm-8 blog-main">
- {# 首页的博客头部信息 #}
- <div class="blog-header">
- <h1 class="blog-title">{{ info_setting.title }}</h1>
- <p class="lead blog-description">{{ info_setting. description }}</p>
- </div>
- {# 根据首页文章列表生成相应的HTML结构 #}
- {{ macros.generate_articles(articles) }}
- </div>
- {% include 'common/right.html' %}
- </div>
- </div>
- {% endblock %}

## 第 37 页 · 入口模块

- 入口模块
- 博客首页完成后的效果如下图所示。
- 首页继承了公共模板前台基准页，引入了文章模块中的宏指令（后续介绍），以及公共模板中的右侧栏部分（用于展示“关于”内容、文章分类、友情链接），接下来将逐步进行分析。

![第37页图](media/ch07/slide37_img1.png)

## 第 38 页 · 入口模块

- 入口模块
- **2.6 实现CKEditor上传功能**
- CKEditor是一个富文本编辑器（可参考书本4.4节），在本项目的前台、后台中都会用到（后续介绍）。为便于开发，将其代码于入口模块实现。

## 第 39 页 · 入口模块

- 入口模块
- 以下是配置文件的代码实现（config.py）。
- import os
- basedir = os.path.abspath(os.path.dirname(__file__))
- # 配置类基类，用于定义一些固定的参数
- class Config:
- SECRET_KEY = 'Chapter7'
- SQLALCHEMY_TRACK_MODIFICATIONS = False
- # CKEditor配置项
- CKEDITOR_SERVE_LOCAL = True
- CKEDITOR_FILE_UPLOADER = 'portal.upload'
- UPLOADED_PATH = os.path.join(basedir, 'uploads')
- # 可在初始化时执行自定义操作
- @staticmethod
- def init_app(app):
- pass
- 此处仅展示配置类基类，其他内容可参考书本6.1节。

## 第 40 页 · 入口模块

- 入口模块
- 以下是视图函数的代码实现（portal/views.py）。
- #省略引入代码。
- # CKEditor，用于获取上传的文件
- @portal.route('/files/<filename>')
- def uploaded_files(filename):
- path = current_app.config['UPLOADED_PATH']
- return send_from_directory(path, filename)
- # CKEditor，用于上传文件
- @portal.route('/upload', methods=['POST'])
- def upload():
- f = request.files.get('upload')
- extension = f.filename.split('.')[1].lower()
- if extension not in ['jpg', 'gif', 'png', 'jpeg']:
- return upload_fail(message='Image only!')
- f.save(os.path.join(current_app.config['UPLOADED_PATH'], f.filename))
- url = url_for('portal.uploaded_files', filename=f.filename)
- return upload_success(url=url)

## 第 41 页 · 入口模块

- 入口模块
- 最后只要在配置文件（config.py）中添加CKEditor的相关配置即可，相关代码如下。
- import os
- basedir = os.path.abspath(os.path.dirname(__file__))
- # 配置类基类，用于定义一些固定的参数
- class Config:
- SECRET_KEY = 'Chapter7'
- SQLALCHEMY_TRACK_MODIFICATIONS = False
- # CKEditor配置项
- CKEDITOR_SERVE_LOCAL = True
- CKEDITOR_FILE_UPLOADER = 'portal.upload'
- UPLOADED_PATH = os.path.join(basedir, 'uploads')
- # 可在初始化时执行自定义操作
- @staticmethod
- def init_app(app):
- pass

## 第 42 页 · 用户模块

- 用户模块
- 03

## 第 43 页 · 用户模块

- 用户模块
- 在一个网站中，用户模块往往是最重要的基础模块之一，主要用于对用户进行认证，认证通过的用户才可以使用相关功能。用户模块需要实现注册、登录、注销，以及用户信息查看、编辑功能。由于文章留言需要用户登录后才能使用，所以用户模块也被文章模块所依赖。数据模型图如下所示。

![第43页图](media/ch07/slide43_img1.png)

## 第 44 页 · 用户模块

- 用户模块
- **3.1 数据模型定义**
- 根据数据模型设计图，可定义以下模型，代码如下（user/models.py）。代码较多，分用户模型和用户信息模型，用户模型代码如下。
- from app import db
- from app.database import BaseModel
- class UserModel(db.Model, BaseModel):
- __tablename__ = 'user'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- info = db.relationship('UserInfoModel', backref='user', uselist=False, cascade='all')
- articles = db.relationship('ArticleModel', backref='author', uselist=True)
- comments = db.relationship('CommentModel', backref='author', uselist=True)

## 第 45 页 · 用户模块

- 用户模块
- 根据数据模型设计图，可定义以下模型，代码如下（user/models.py）。代码较多，分用户模型和用户信息模型，用户信息模型代码如下。
- class UserInfoModel(db.Model, BaseModel):
- __tablename__ = 'user_info'
- user: UserModel
- user_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), primary_key=True)
- nickname = db.Column(db.VARCHAR)
- phone = db.Column(db.VARCHAR)
- email = db.Column(db.VARCHAR)
- introduce = db.Column(db.TEXT)

## 第 46 页 · 用户模块

- 用户模块
- **3.2 注册功能**
- 注册功能相当简单，在之前的例子中也曾出现过，实际上就是“添加数据”的操作，只需要定义一个合适的表单类，然后将表单数据传递给用户模型进行添加即可。

## 第 47 页 · 用户模块

- 用户模块
- 以下是表单类的代码实现（user/forms.py）。
- from flask_wtf import FlaskForm
- from wtforms import StringField, PasswordField, SubmitField, TextAreaField, BooleanField
- from wtforms.validators import DataRequired, Optional, Regexp, Email
- class RegisterForm(FlaskForm):
- username = StringField(label='用户名', validators=[DataRequired()])
- password = PasswordField(label='密码', validators=[DataRequired()])
- # 此处使用11位数字的正则表达式检测手机号
- phone = StringField(label='手机号', validators=[Optional(), Regexp(r'\d{11}')])
- email = StringField(label='邮箱', validators=[Optional(), Email()])
- introduce = TextAreaField(label='自我介绍')
- submit = SubmitField(label='注册')

## 第 48 页 · 用户模块

- 用户模块
- 以下是视图函数的代码实现（user/views.py）。
- #省略顶部引入代码..
- @user.route('/register', methods=['GET', 'POST'])
- def register():
- form = RegisterForm()
- if request.method == 'POST' and form.validate_on_submit():
- item = UserModel(
- username=form.username.data,
- password=form.password.data,
- info=UserInfoModel(
- phone=form.phone.data,
- email=form.email.data,
- introduce=form.introduce.data,
- ),
- )
- try:
- dh.session.add(item)
- dh.session.commit()
- flash('注册成功', 'success')
- return redirect('/user/login')
- except Exception as e:
- flash('注册失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('common/form.html', form=form, title='用户注册')

## 第 49 页 · 用户模块

- 用户模块
- 注册功能完成后的效果如下图所示。

![第49页图](media/ch07/slide49_img1.png)

## 第 50 页 · 用户模块

- 用户模块
- **3.3 登录、注销功能**
- 登录功能只需要根据表单中所提供的账号密码在数据库中查询，找到相应用户然后使用Flask-Login提供的login_user()建立会话即可，而注销则使用logout_user()清除会话数据即可（可参考书本6.4节）。

## 第 51 页 · 用户模块

- 用户模块
- 以下是表单类的代码实现（user/forms.py）。
- class LoginForm(FlaskForm):
      username = StringField(label='用户名', validators=[DataRequired()])
      password = PasswordField(label='密码', validators=[DataRequired()])
      remember = BooleanField(label='记住登录状态')
      submit = SubmitField(label='登录')

## 第 52 页 · 用户模块

- 用户模块
- 以下是视图函数的代码实现（user/views.py）。代码有点多，分两部分，一个是登录的视图函数，一个是登出的视图函数，登出的视图函数代码如下。
- @user.route('/logout')
- @login_required
- def logout():
- if logout_user():
- flash('注销成功', 'success')
- return redirect('/user/login')
- @login_required 装饰器：这是 Flask-Login 提供的装饰器，用于限制只有已登录的用户才能执行该路由。如果用户未登录，将被重定向到登录页面。
- if logout_user(): logout_user() 是 Flask-Login 提供的函数，用于注销当前用户。如果用户成功注销，它会返回 True，否则返回 False。

## 第 53 页 · 用户模块

- 用户模块
- 登录的视图函数代码如下。
- @user.route('/login', methods=['GET', 'POST'])
- def login():
- form = LoginForm()
- if request.method == 'POST' and form.validate_on_submit():
- try:
- item = UserModel.query.filter_by(username=form.username.data, password=form.password.data).first()
- if item is not None:
- login_user(item, form.remember.data)
- flash('登录成功', 'success')
- next_path = request.args.get('next', request.path)
- return redirect(next_path)
- else:
- raise Exception('用户名或密码错误')
- except Exception as e:
- flash('登录失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('common/form.html', form=form, title='用户登录')
- 让用户输入用户名和密码，并在数据库中查找匹配的用户记录，并根据查找结果进行相应的操作。

## 第 54 页 · 用户模块

- 用户模块
- 登录功能完成后的效果如下图所示。

![第54页图](media/ch07/slide54_img1.png)

## 第 55 页 · 用户模块

- 用户模块
- **3.4 用户信息功能**
- 用户信息功能的实现也同样简单，实际上是“查询数据”与“修改数据”操作。查看用户信息只需要根据链接中所包含的“id”，查询相应用户信息，“注入变量”到模板页面中显示即可；而编辑用户信息则通过get_current_user()获取当前用户对象，然后修改数据即可。

## 第 56 页 · 用户模块

- 用户模块
- 以下是表单类的代码实现（user/forms.py）。
- class UserInfoEditForm(FlaskForm):
      password = PasswordField(label='密码', description='留空则不改变密码')
      nickname = StringField(label='昵称')
      phone = StringField(label='手机号', validators=[Optional(), Regexp(r'\d{11}')])
      email = StringField(label='邮箱', validators=[Optional(), Email()])
      introduce = TextAreaField(label='自我介绍')
      submit = SubmitField(label='编辑')

## 第 57 页 · 用户模块

- 用户模块
- 以下是视图函数的代码实现（user/views.py）。分查看和编辑两个视图函数来讲解。查看的视图函数代码如下。
- @user.route('/<int:id>')
- def view(id: int):
- try:
- item = UserModel.query.get(id)  # type: UserModel
- if item is not None:
- return render_template('user/view.html', item=item)
- else:
- return abort(404)
- except Exception as e:
- flash('查看用户 - %s' % e, 'danger')
- return abort(404)
- <int:id> 是一个动态参数，表示用户的唯一标识符（通常是用户的ID）。这意味着我们可以通过访问 /user/1、/user/2 等路径来查看不同用户的详细信息。
- 然后使用 UserModel 模型类的 query 属性，通过用户的ID从数据库中获取用户对象。
- 再进行一个用户的匹配。根据匹配结果展示不同的内容。

## 第 58 页 · 用户模块

- 用户模块
- 编辑的视图函数代码如下。由于内容有五项可编辑，这里就展示一项，其他大家根据书上代码补全即可。
- @user.route('/edit', methods=['GET', 'POST'])
- @login_required
- def edit():
- form = UserInfoEditForm()
- try:
- item = get_current_user()
- if request.method == 'POST' and form.validate_on_submit():
- if form.password.data != '':
- item.password = form.password.data
- ...省略代码
- dh.session.add(item)
- dh.session.commit()
- flash('编辑成功', 'success')
- return redirect('/user/edit')
- else:
- form.password.data = item.password
- ...省略代码
- return render_template('common/form.html', form=form, title='用户信息编辑')
- except Exception as e:
- flash('编辑失败 - %s' % e, 'danger')
- return abort(500)

## 第 59 页 · 用户模块

- 用户模块
- 以下是用户信息查看模板页面的代码（user/view.html）。
- {# 用户信息展示页 #}
- {% extends 'common/base.html' %}
- {% block title %}查看用户{% endblock %}
- {% block content_inner %}
- <table class="table">
- <tr>
- <th>名称</th>
- <td>{{ item.info.nickname or item.username }}</td>
- </tr>
- <tr>
- <th>手机号</th>
- <td>{{ item.info.phone }}</td>
- </tr>
- <tr>
- <th>邮箱</th>
- <td>{{ item.info.email }}</td>
- </tr>
- <tr>
- <th>介绍</th>
- <td>{{ item.info.introduce }}</td>
- </tr>
- </table>
- {% endblock %}

## 第 60 页 · 用户模块

- 用户模块
- 用户信息编辑页面的效果如下图所示。

![第60页图](media/ch07/slide60_img1.png)

## 第 61 页 · 文章模块

- 文章模块
- 04

## 第 62 页 · 文章模块

- 文章模块
- 文章模块是整个博客系统中最重要的模块。文章模块需要实现分页显示文章列表、按分类显示文章、搜索文章、文章留言几个核心功能。其列表显示功能被首页所依赖。数据模型图如下所示。

![第62页图](media/ch07/slide62_img1.png)

## 第 63 页 · 文章模块

- 文章模块
- **4.1 数据模型定义**
- 根据数据模型设计图，可定义以下模型，代码如下（article/models.py）。内容较多，分成ArticleModel、CommentModel、CategoryModel来演示。

## 第 64 页 · 文章模块

- 文章模块
- CategoryModel的代码如下所示。
- class CategoryModel(db.Model, BaseModel):
      __tablename__ = 'category'
 
      id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
      name = db.Column(db.VARCHAR, unique=True)
 
      articles = db.relationship('ArticleModel', backref='category', uselist=True)  # type: List[ArticleModel]

## 第 65 页 · 文章模块

- 文章模块
- ArticleModel的代码如下所示。
- class ArticleModel(db.Model, BaseModel):
- __tablename__ = 'article'
- author: UserModel
- category: CategoryModel
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- author_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), index=True)
- category_id = db.Column(db.INTEGER, db.ForeignKey(CategoryModel.id), index=True)
- title = db.Column(db.VARCHAR, index=True)
- content = db.Column(db.VARCHAR)
- create_time = db.Column(db.INTEGER, index=True)
- update_time = db.Column(db.INTEGER, index=True)
- view_count = db.Column(db.INTEGER, default=0)
- comments = db.relationship('CommentModel', backref='article', uselist=True,
- cascade='all')
- # type: List[CommentModel]

## 第 66 页 · 文章模块

- 文章模块
- CommentModel的代码如下所示。
- class CommentModel(db.Model, BaseModel):
- __tablename__ = 'comment'
- author: UserModel
- article: ArticleModel
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- author_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), index=True)
- article_id = db.Column(db.INTEGER, db.ForeignKey(ArticleModel.id), index=True)
- content = db.Column(db.VARCHAR)
- create_time = db.Column(db.INTEGER, index=True)

## 第 67 页 · 文章模块

- 文章模块
- **4.2 文章生成宏指令**
- 在博客系统中，文章会在各个页面中显示，如首页、文章列表页、文章查看页等。此时便需要建立宏指令，对单个文章对象生成相应的HTML结构，或者根据多个文章对象组成的列表，生成文章列表的HTML结构，以便在各个页面中重复使用。

## 第 68 页 · 文章模块

- 文章模块
- 以下是宏指令模板的代码实现（article/macros.html）。分为生成单个文章的HTML结构和生成多个HTML结构来讲解。生成单个文章的HTML结构的代码如下所示。
- {# 生成单个文章的HTML结构 #}
- {% macro generate_article(article, is_full=True) %}
- ...省略代码
  {% endmacro %}
- 这是定义 Jinja2 宏的语法。generate_article 是宏的名称，它接受两个参数：article 是文章对象，is_full 是一个可选参数，用于确定是否要显示完整的文章内容。

## 第 69 页 · 文章模块

- 文章模块
- 生成单个文章的HTML结构的代码如下所示。
- <div class="blog-post">
- <h2 class="blog-post-title">
- {% if is_full %}  {{ article.title }}
- {% else %}
- <a href="{{ url_for('article.view', id=article.id) }}">  {{ article.title }} </a>
- {% endif %}
- </h2>
- <p class="blog-post-meta">
- 于 {{ article.create_time | convert_time }} 由 {% if article.author %}
- <a href="{{ url_for('user.view', id=article.author_id) }}">
- {{ article.author.username }}
- </a>
- {% else %}未知作者{% endif %}
- 发布，最后更新于 {{ article.update_time | convert_time }}。
- 阅读量：{{ article.view_count }}
- </p>
- <p>
- {% if is_full %}
- {# 默认情况下为确保内容安全，Jinja2会对数据进行HTML实体转义 #}
- {{ article.content | safe }}
- {% else %}
- {# 使用truncate过滤器对内容进行截断 #}
- {{ article.content | safe | striptags | truncate }}
- {% endif %}
- </p>
- </div>

## 第 70 页 · 文章模块

- 文章模块
- 生成多个文章的HTML结构的代码如下所示。
- {# 生成多个文章的HTML结构 #}
- {% macro generate_articles(articles) %}
- {% for article in articles %}
- {{ generate_article(article, False) }}
- {% endfor %}
- {# 如果内容为空，则添加提示信息 #}
- {% if not articles %}
- <p>emmmm，作者偷懒啦，并没有添加文章。</p>
- {% endif %}
- {% endmacro %}
- 在前面定义好了这个宏，所以在后面写生成多个文章的HTML结构代码就可以直接拿来用，以简洁的方式生成多篇文章的 HTML 结构，包括文章标题、作者、发布时间等信息。只需要把generate_article(article, True)改成generate_article(article, False)就好。

## 第 71 页 · 文章模块

- 文章模块
- **4.3 最新文章列表、搜索**
- 最新文章列表与搜索功能实际上就是从数据库中获取相应数据并排序，最终展示出来的页面为分页文章列表（可参考书本5.3.6小节）。

## 第 72 页 · 文章模块

- 文章模块
- 以下是视图函数的代码实现（article/views.py）。分为搜索视图和最新文章列表来展示。最新文章列表代码如下。
- from flask import render_template, request, redirect
- from sqlalchemy import or_
- from app.portal.common import load_setting
- from . import article
- from .models import ArticleModel
- @article.route('/article/list_all')
- def list_all():
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('list_all_per_page', 5)
- pagination = ArticleModel.query.order_by(ArticleModel.id.desc()). paginate(None, per_page)
- return render_template('article/list.html', pagination=pagination, title='所有文章')
- pagination 这行代码使用 SQLAlchemy 查询所有文章，并按照文章 ID 降序排列。然后，使用 paginate 函数分页获取文章，其中 None 表示获取所有文章，per_page 表示每页显示的文章数量。分页后的结果存储在 pagination 变量中。
- list_all路由处理函数是一个文章列表页面，它加载了站点设置以确定每页显示的文章数量，然后查询文章并进行分页，最后渲染 HTML 模板以显示文章列表。

## 第 73 页 · 文章模块

- 文章模块
- 搜索视图函数代码如下。
- @article.route('/article/search')
- def search():
- keyword = request.args.get('keyword', '')
- if keyword == '':
- return redirect('/')
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('search_per_page', 5)
- pagination = ArticleModel.query.order_by(ArticleModel.id.desc()). filter(
- or_(ArticleModel.title.contains(keyword), ArticleModel.content. contains(keyword))
- ).paginate(None, per_page)
- return render_template('article/list.html', pagination=pagination, title='"%s" 的搜索结果' % keyword)
- pagination 这行代码使用 SQLAlchemy 构建查询，查询文章标题或内容中包含搜索关键字的文章。然后，按照文章 ID 降序排列，并使用 paginate 函数分页获取搜索结果，其中 None 表示获取所有结果，per_page 表示每页显示的搜索结果数量。分页后的结果存储在 pagination 变量中。
- search路由处理函数是一个文章搜索页面，通过提供关键字来搜索包含该关键字的文章，并将结果以分页列表的形式显示在页面上。如果用户未提供关键字，则会重定向到根目录。

## 第 74 页 · 文章模块

- 文章模块
- 以上两个视图函数由于结果都是分页文章列表，所以可以使用相同的模板页面，将网页标题作为变量进行注入。以下是模板页面的代码实现（article/list.html）。
- {% import 'article/macros.html' as macros %}
- {% import 'bootstrap/pagination.html' as pagi %}
- {% block title %}{{ title }}{% endblock %}
- {% block content_inner %}
- <div class="container">
- <div class="row">
- <div class="col-sm-8 blog-main">
- <div class="blog-header">
- <h1 class="blog-title">{{ title }}</h1>
- </div>
- {{ macros.generate_articles(pagination.items) }}
- {{ pagi.render_pagination(pagination) }}
- </div>
- {% include 'common/right.html' %}
- </div>
- </div>
- {% endblock %}
- 在入口模块构建好的前台基准页在这里便体现出作用了：一个文章列表页面，只需要关注其本身的实现，其他公共内容只要通过包含或者继承的方式引入即可，大幅度降低了开发难度。

## 第 75 页 · 文章模块

- 文章模块
- 文章列表完成后的效果如下图所示。
- 所有文章页

![第75页图](media/ch07/slide75_img1.png)

## 第 76 页 · 文章模块

- 文章模块
- 文章列表完成后的效果如下图所示。
- 搜索结果页

![第76页图](media/ch07/slide76_img1.png)

## 第 77 页 · 文章模块

- 文章模块
- **4.4 文章分类**
- 文章分类功能的实现只需要根据URL中所包含的名称查找相应的分类对象，最后将分类对象所关联的文章注入模板页面中显示即可。其本质仍是文章列表的实现，所以使用之前编写好的“article/list.html”模板页面即可。

## 第 78 页 · 文章模块

- 文章模块
- 以下是视图函数的代码实现（article/views.py）。
- from flask import render_template, abort, flash
- from app.portal.common import load_setting
- from . import article
- from .models import ArticleModel, CategoryModel
- @article.route('/category/<name>')
- def category(name: str):
- item = CategoryModel.query.filter_by(name=name).first()  # type: CategoryModel
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('category_per_page', 5)
- pagination = ArticleModel.query.order_by(ArticleModel.id.desc()). filter_by(category_id=item.id).paginate(None, per_page)
- if item is not None:
- return render_template('article/list.html', pagination=pagination, title=item.name)      else:
- flash('分类不存在', 'danger')
- return abort(404)
- 和之前的视图函数思路大同小异。本质上都是从数据库去查找对应的记录，只需要把URL中提取出来的参数放到数据库里去查询，根据查询的结果去执行不同的结果。

## 第 79 页 · 文章模块

- 文章模块
- 文章分类页完成后的效果如下图所示。
- 文章分类页

![第79页图](media/ch07/slide79_img1.png)

## 第 80 页 · 文章模块

- 文章模块
- **4.5 文章查看、阅读量统计、文章留言**
- 查看文章时，通常可以看到阅读量及文章留言，这3个功能都在一个页面中实现。由于功能代码篇幅较长，接下来将分为两部分进行演示。

## 第 81 页 · 文章模块

- 文章模块
- 首先是文章查看部分（article/views.py）。代码如下所示。
- #省略引入部分代码...
- @article.route('/article/<int:id>')
- def view(id: int):
- form = CommentForm()
- item = ArticleModel.query.get(id)  # type: ArticleModel
- if item is not None:
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('comment_per_page', 5)
- pagination = CommentModel.query.filter_by(article_id=id). paginate(None, per_page)
- article_view_count(item)
- return render_template('article/view.html', item=item, pagination=pagination, form=form)
- else:
- flash('文章不存在', 'danger')
- return abort(404)
- view路由处理函数实现了查看单篇文章的详细内容和评论的功能。用户可以通过提供文章的唯一标识（ID）来查看文章，如果文章不存在，则会显示一条警告消息并返回 HTTP 404 错误。同时，用户可以在页面下方查看文章的评论，以及使用评论表单发表自己的评论。
- 在文章查看时使用到了article_view_count()，该方法实现于文章模块公共方法当中。

## 第 82 页 · 文章模块

- 文章模块
- 以下是模块公共方法的代码实现（article/common.py）。
- from flask import session
- from app import dh
- from app.article.models import ArticleModel
- # 文章阅读统计更新
- def article_view_count(item: ArticleModel):
- # 获取会话中阅读过的文章id列表
- article_view_ids = session.get('article_view_ids', [])
- if item.id not in article_view_ids:
- # 将文章id添加到会话中阅读过的文章id列表
- article_view_ids.append(item.id)
- session['article_view_ids'] = article_view_ids
- # 更新访问数
- item.view_count += 1
- dh.session.add(item)
- dh.session.commit()
- article_view_ids = session.get('article_view_ids', [])：首先，从用户会话中获取名为 article_view_ids 的列表，用于存储用户已阅读的文章ID。如果该列表不存在，则默认为空列表。
- 通过使用用户会话来存储已阅读文章的ID列表，可以避免重复计数。当用户阅读一篇文章时，如果该文章的ID不在列表中，就会将ID添加到列表中，并增加文章的访问次数。这样可以统计每篇文章的实际阅读次数。

## 第 83 页 · 文章模块

- 文章模块
- 以下是模板页面的代码实现（article/view.html）。
- {# 文章浏览页面 #}
- #省略引入Bootstrap代码...
- {% block content_inner %}
- <div class="container">
- <div class="row">
- <div class="col-sm-8 blog-main">
- {{ macros.generate_article(item) }}
- {# 博客留言内容展示 #}
- <div class="row">
- {{ macros.generate_comments(pagination.items) }}
- {# 渲染分页按钮HTML结构 #}
- {{ pagi.render_pagination(pagination) }}
- </div>
- {# 生成留言表单 #}
- <div class="row" style="margin-bottom: 32px">
- {{ wtf.quick_form(form, action=url_for('article. comment',id=item.id)) }}
- {{ ckeditor.load() }}
- {{ ckeditor.config(name='content', height=128) }}
- </div>
- </div>
- {% include 'common/right.html' %}
- </div>
- </div>
- {% endblock %}

## 第 84 页 · 文章模块

- 文章模块
- 在上一个ppt为止，查看文章功能便实现了，接下来是文章留言的部分。
- 接着是生成留言列表的宏指令代码（article/macros.html）。分成单个文章留言和多个文章留言，生成留言列表的宏指令与生成文章列表所使用的宏指令结构相似，仅仅是生成的HTML结构与数据不一样。

## 第 85 页 · 文章模块

- 文章模块
- 生成单个文章留言代码如下。
- {# 生成单个文章留言 #}
- {% macro generate_comment(comment) %}
- <div class="row blog-comment">
- <div class="col-xs-9">
- <h4>
- <a href="{{ url_for('user.view', id=comment.author_id) }}">
- {% if comment.author %}
- {{ comment.author.info.nickname or comment.author. username }}
- {% else %}
- 未知用户
- {% endif %}
- </a>：
- </h4>
- </div>
- <div class="col-xs-3">
- <h5>{{ comment.create_time | convert_time }}</h5>
- </div>
- <div class="col-xs-12">
- {{ comment.content | safe }}
- </div>
- </div>
- {% endmacro %}
- 可以看到宏指令结构非常相似，就是具体的HTML内容用到了Bootstrap的内容。

## 第 86 页 · 文章模块

- 文章模块
- 生成多个文章留言代码如下。
- {# 生成多个文章留言 #}
- {% macro generate_comments(comments) %}
- {% for comment in comments %}
- {{ generate_comment(comment) }}
- {% endfor %}
- {% if not comments %}
- <p style="text-align: center">暂时没有留言</p>
- {% endif %}
- {% endmacro %}

## 第 87 页 · 文章模块

- 文章模块
- 以下是留言功能表单类的代码实现（article/forms.py）。
- from flask_ckeditor import CKEditorField
- from flask_wtf import FlaskForm
- from wtforms import SubmitField
- from wtforms.validators import DataRequired
- class CommentForm(FlaskForm):
- content = CKEditorField(label='留言内容', validators=[DataRequired()])
- submit = SubmitField(label='添加')
- 该表单类相当简单，仅包含一个内容输入表单项。

## 第 88 页 · 文章模块

- 文章模块
- 以下是视图函数的代码实现（留言部分）（article/views.py）。
- @article.route('/article/<int:id>', methods=['POST'])
- @login_required
- def comment(id: int):
- form = CommentForm()
- item = ArticleModel.query.get(id)  # type: ArticleModel
- if item is not None:
- if form.validate_on_submit():
- now = time.time()
- item = CommentModel(
- author_id=get_current_user().id,
- article_id=id,
- content=form.content.data,
- create_time=now)
- dh.session.add(item)
- dh.session.commit()
- else:
- flash('提交留言失败', 'danger')
- abort(500)
- else:
- flash('文章不存在', 'danger')
- return abort(404)
- return redirect(url_for('article.view', id=id))
- 由于留言功能需要登录后才能使用，所以仅需要用“login_required”装饰器进行装饰即可。获取到当前用户之后，便可以将留言与用户进行关联。

## 第 89 页 · 文章模块

- 文章模块
- 文章查看页面完成后的效果如下图所示。
- 文章查看页面

![第89页图](media/ch07/slide89_img1.png)

## 第 90 页 · 模块管理

- 模块管理
- 05

## 第 91 页 · 模块管理

- 模块管理
- 管理模块（即后台）用于管理整个博客系统的数据，管理员可以在里面编辑博客的信息、修改相关设置、添加文章、编辑用户等。

## 第 92 页 · 模块管理

- 模块管理
- **5.1 后台基本实现**
- 1．定义蓝图
- 管理模块包含多个子模块，如用户管理、文章管理、入口管理。可参考书本6.3.2小节定义相关蓝图。
- 以下是蓝图代码实现（admin/__init__.py）。
- from flask import Blueprint
- from .common import *
- admin = Blueprint('admin', __name__)
- from .article import article as admin_article
- from .portal import portal as admin_portal
- from .user import user as admin_user
- from .friend_link import friend_link as admin_friend_link
- from . import views

## 第 93 页 · 模块管理

- 模块管理
- 后台页面都需要管理员登录才可以访问。可参考书本6.4.4小节实现管理员认证访问的装饰器。
- 2．管理员认证访问
- 以下是装饰器的代码实现（admin/common.py）。
- from functools import wraps
- from flask import abort, flash
- from flask_login import login_required
- from app.user.common import get_current_user
- def admin_required(func):
- @wraps(func)
- def decorated_view(*args, **kwargs):
- if not get_current_user().is_admin:
- flash('拒绝访问', 'danger')
- return abort(403)
- return func(*args, **kwargs)
- return login_required(decorated_view)

## 第 94 页 · 模块管理

- 模块管理
- 后台基准页与前台基准页不同的地方有：去除页尾、全页面显示、添加左侧菜单栏。
- 3．后台基准页

## 第 95 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/base.html）。代码如下。
- {# 后台基准模板，结构上与前台基准模板差异不大 #}
- {% extends 'bootstrap/base.html' %}
- {% import 'bootstrap/utils.html' as utils %}
- {% set site_setting = load_setting('site_setting') %}
- {% set info_setting = load_setting('info_setting') %}
- {% block navbar %}
- {# 加载导航栏 #}
- {% include 'common/nav.html' %}
- {% endblock %}
- {% block styles %}
- {{ super() }}
- <link href="{{ url_for('static', filename='admin/dashboard.css') }}" rel="stylesheet">
- {% endblock %}
- {% block content %}
- <div class="container-fluid" style="padding-top: 72px;">
- <div class="row">
- {# 加载后台页面左边菜单栏 #}
- {% include 'admin/left.html' %}
- <div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2 main">
- {{ utils.flashed_messages() }}
- {% block content_inner %}{% endblock %}
- </div>
- </div>
- </div>
- {% endblock %}

## 第 96 页 · 模块管理

- 模块管理
- **5.2 用户管理**
- 当管理员要对用户进行操作时，首先需要从列表中找到相应的用户，单击“编辑”链接可以修改用户的信息，单击“删除”链接可以删除相应的用户。这便是用户模块管理最基本的使用流程。

## 第 97 页 · 模块管理

- 模块管理
- 1．用户列表
- 用户列表的实现与前台的文章列表类似，同样是从数据库中查询数据再渲染到相应视图模板当中。其模板页面继承于上一小节中的后台基准页。

## 第 98 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/user/views.py）。
- from flask import render_template, redirect, flash, abort, request
- from app import dh
- from app.portal.common import load_setting
- from app.user.models import UserModel
- from . import user
- from .forms import UserEditForm
- from .. import admin_required
- @user.route('/')
- @user.route('/index')
- @admin_required
- def index():
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('admin_per_page', 20)
- pagination = UserModel.query.paginate(None, per_page)
- return render_template('admin/user/index.html', pagination=pagination)
- 通过 @admin_required 装饰器来决定只有管理员才能访问这个页面，然后在管理员用户列表页面显示用户信息，每页显示的用户数量由站点设置中的配置决定

## 第 99 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/user/index.html）。
- #省略引入代码
- {% block content_inner %}
- <ul id="tab" class="nav nav-tabs">
- <li class="active"><a href="{{ url_for('admin.user.index') }}">用户列表</a></li>
- </ul>
- <table class="table">
- <tr>
- <th>id</th>
- .....省略5行代码
- <th>操作</th>
- </tr>
- {% for item in pagination.items %}
- <tr>
- <td>{{ item.id }}</td>
- .....省略5行代码
- <td>
- <a href="{{ url_for('admin.user.edit', id=item.id) }}">编辑</a>
- <a href="{{ url_for('admin.user.delete', id=item.id) }}">删除</a>
- </td>
- </tr>
- {% endfor %}
- </table>
- {{ pagi.render_pagination(pagination) }}
- {% endblock %}
- 用户列表“操作”列中的“编辑”“删除”链接，通过id属性来传递管理员所操作的用户id到各个功能页面中。

## 第 100 页 · 模块管理

- 模块管理
- 用户列表页面完成后的效果如下图所示。
- 用户列表页面

![第100页图](media/ch07/slide100_img1.png)

## 第 101 页 · 模块管理

- 模块管理
- 2．编辑用户
- 用户编辑功能要通过用户列表页面实现。在打开用户编辑页面时，系统根据用户列表页中提供的“id”获取相应用户的信息，并将其信息展示在用户编辑表单中。当管理员编辑完并单击“编辑”链接后，系统将新的信息保存到数据库。

## 第 102 页 · 模块管理

- 模块管理
- 以下是表单类的代码实现（admin/user/forms.py）。
- from flask_wtf import FlaskForm
- from wtforms import StringField, PasswordField, TextAreaField, SubmitField, BooleanField
- from wtforms.validators import DataRequired, Optional, Regexp, Email
- class UserEditForm(FlaskForm):
- username = StringField(label='用户名', validators=[DataRequired()])
- password = PasswordField(label='密码', description='留空则不改变密码')
- is_admin = BooleanField(label='是否为管理员')
- nickname = StringField(label='昵称')
- # 此处使用11位数字的正则表达式检测手机号
- phone = StringField(label='手机号', validators=[Optional(), Regexp(r'\d{11}')])
- email = StringField(label='邮箱', validators=[Optional(), Email()])
- introduce = TextAreaField(label='自我介绍')
- submit = SubmitField(label='编辑')
- 还是一个简单的表单，大家要注意不要漏引入依赖，关于手机的正则表达式大家也可以自行上网去搜索测试。

## 第 103 页 · 模块管理

- 模块管理
- 以下是表单类的代码实现（admin/user/forms.py）。
- from flask_wtf import FlaskForm
- from wtforms import StringField, PasswordField, TextAreaField, SubmitField, BooleanField
- from wtforms.validators import DataRequired, Optional, Regexp, Email
- class UserEditForm(FlaskForm):
- username = StringField(label='用户名', validators=[DataRequired()])
- password = PasswordField(label='密码', description='留空则不改变密码')
- is_admin = BooleanField(label='是否为管理员')
- nickname = StringField(label='昵称')
- # 此处使用11位数字的正则表达式检测手机号
- phone = StringField(label='手机号', validators=[Optional(), Regexp(r'\d{11}')])
- email = StringField(label='邮箱', validators=[Optional(), Email()])
- introduce = TextAreaField(label='自我介绍')
- submit = SubmitField(label='编辑')
- 还是一个简单的表单，大家要注意不要漏引入依赖，关于手机的正则表达式大家也可以自行上网去搜索测试。

## 第 104 页 · 模块管理

- 模块管理
- 此处编辑功能的视图函数（admin/user/views.py）中判断的内容字段过多，过于冗余，故不显示所有的具体代码，只展示大概内容，字段的判断，以及flash闪现消息就不写出来，大家根据书上内容去补充。
- @user.route('/edit/<int:id>', methods=['GET', 'POST'])
@admin_required
def edit(id: int):
     form = UserEditForm()
     try:
          item = UserModel.query.get(id)  # type: UserModel
          if item is None:
- return abort(404)
          if request.method == 'POST' and form.validate_on_submit():
                if form.password.data != '':
                      item.password = form.password.data
- 省略6行代码
                dh.session.add(item)
                dh.session.commit()
                return redirect('/admin/user/index')
          else:
                form.username.data = item.username
               省略6行代码
                return render_template('admin/user/edit.html', form=form)
     except Exception as e:
          return abort(500)

## 第 105 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/user/edit.html）。
- {% extends 'admin/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}用户编辑{% endblock %}
- {% block content_inner %}
- <ul id="tab" class="nav nav-tabs">
- <li><a href="{{ url_for('admin.user.index') }}">用户列表</a></li>
- <li class="active"><a href="{{ url_for(request.endpoint, **request.view_args) }}">编辑用户</a></li>
- </ul>
- <br>
- {{ wtf.quick_form(form) }}
- {% endblock %}

## 第 106 页 · 模块管理

- 模块管理
- 用户编辑页面完成后的效果如下图所示。
- 用户编辑页面

![第106页图](media/ch07/slide106_img1.png)

## 第 107 页 · 模块管理

- 模块管理
- 3．删除用户
- 用户删除功能与编辑功能一致，通过用户列表页面实现。当管理员单击“删除”链接时，根据用户列表页中所提供的“id”获取相应用户，并将用户从数据库中删除。

## 第 108 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/user/views.py）。
- @user.route('/delete/<int:id>')
- @admin_required
- def delete(id: int):
- try:
- item = UserModel.query.get(id)  # type: UserModel
- if item is not None:
- dh.session.delete(item)
- dh.session.commit()
- flash('删除成功')
- return redirect('/admin/user/index')
- else:
- flash('用户不存在', 'danger')
- return abort(404)
- except Exception as e:
- flash('删除失败 - %s' % e, 'danger')
- return abort(500)
- 删除操作完成之后只需要展示操作结果即可，使用闪现消息是最理想的方案。

## 第 109 页 · 模块管理

- 模块管理
- **5.3 文章管理**
- 文章管理模块与用户管理模块都是用于管理数据库对象的，只是相应数据模型所包含的属性不同，但本质上是一致的。

## 第 110 页 · 模块管理

- 模块管理
- 1．文章列表
- 以下是文章列表功能视图函数的代码实现（admin/article/views.py）。
- #省略引入模块代码
 
@article.route('/')
@article.route('/index')
@admin_required
def index():
     site_setting = load_setting('site_setting')  # type: dict
     per_page = site_setting.get('admin_per_page', 20)
     pagination = ArticleModel.query.paginate(None, per_page)
 
    return render_template('admin/article/index.html', pagination= pagination)
- 也是通过 @admin_required 装饰器来实现的对用户管理员身份的判别，然后就是去设置这个页面要显示多少条信息。

## 第 111 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/article/index.html）。由于字段过多，这里就减少字段来展示代码。
- <ul id="tab" class="nav nav-tabs">
- <li class="active"><a href="{{ url_for('admin.article.index') }}">文章列表</a></li>
- <li><a href="{{ url_for('admin.article.add') }}">添加文章</a></li>
- </ul>
- 这一段代码就是页面效果的切换按钮，用来展示文章列表和添加文章列表的内容切换的。

## 第 112 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/article/index.html）。由于字段过多，这里就减少字段来展示代码，只显示id和操作字段的内容，其他字段代码从书上7.5.3小节去补全。
- <table class="table">
- <tr>
- <th>id</th>
- <th>操作</th>
- </tr>
- {% for item in pagination.items %}
- <tr>
- <td>{{ item.id }}</td>
- <td>
- <a href="{{ url_for('admin.article.edit', id=item. id) }}">编辑</a>
- <a href="{{ url_for('admin.article.delete', id=item. id) }}">删除</a>
- </td>
- </tr>
- {% endfor %}
- </table>
- {{ pagi.render_pagination(pagination) }}
- 这一段代码页面显示的数据内容，用table表单来循环实现，以及用Flask-Bootstrap 提供的 render_pagination 函数来渲染分页控件。这里只是简略的代码，大家不要忘记引入依赖。

## 第 113 页 · 模块管理

- 模块管理
- 文章列表页面完成后的效果如下图所示。
- 文章列表页面

![第113页图](media/ch07/slide113_img1.png)

## 第 114 页 · 模块管理

- 模块管理
- 2．添加文章
- 以下是添加文章功能表单类的代码实现（admin/article/forms.py）。
- from flask_ckeditor import CKEditorField
- from flask_wtf import FlaskForm
- from wtforms import StringField, SubmitField
- from wtforms.validators import DataRequired
- class ArticleAddForm(FlaskForm):
- title = StringField(label='文章标题', validators=[DataRequired()])
- category = StringField(label='文章分类', validators=[DataRequired()])
- content = CKEditorField(label='文章内容', validators=[DataRequired()])
- submit = SubmitField(label='添加')
- 用不同的表单控件来组合成一个表单，来提交信息。接着就是处理视图函数，再去实现模板页面，后面基本都是按照这个思路去写代码。

## 第 115 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/article/views.py）
- @article.route('/add', methods=['GET', 'POST'])
- @admin_required
- def add():
- form = ArticleAddForm()
- if request.method == 'POST' and form.validate_on_submit():
- now = int(time.time())
- item = ArticleModel(
- author_id=get_current_user().id,
- title=form.title.data,
- content=form.content.data,
- create_time=now,
- update_time=now,
- )
- item.category = get_category(form.category.data)
- try:
- dh.session.add(item)
- dh.session.commit()
- flash('添加成功', 'success')
- return redirect('/admin/article/index')
- except Exception as e:
- flash('添加失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('admin/article/add.html', form=form)
- 和之前添加用户的思路一样，不同的点只是在提交的时候，考虑传递什么样的数据给数据库。

## 第 116 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/article/add.html）。
- {% extends 'admin/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}添加文章{% endblock %}
- {% block content_inner %}
- <ul id="tab" class="nav nav-tabs">
- <li><a href="{{ url_for('admin.article.index') }}">文章列表</a></li>
- <li class="active"><a href="{{ url_for('admin.article.add') }}">添加文章</a></li>
- </ul>
- <br>
- {{ wtf.quick_form(form) }}
- {{ ckeditor.load() }}
- {{ ckeditor.config(name='content', height=320) }}
- {% endblock %}
- 首先还是引入依赖，然后就写具体内容，和上面文章列表的思路一致，就是展示的内容不同，用到了WTF-Form表单。

## 第 117 页 · 模块管理

- 模块管理
- 3．编辑文章
- 以下是编辑文章功能表单类的代码实现（admin/article/forms.py）。
- class ArticleEditForm(ArticleAddForm):
- submit = SubmitField(label='编辑')

## 第 118 页 · 模块管理

- 模块管理
- 此处编辑功能的视图函数（admin/article/views.py）。中判断的内容字段过多，过于冗余，故不显示所有的具体代码，只展示大概内容，字段的判断，以及flash闪现消息就不写出来，大家根据书上内容去补充。
- @article.route('/edit/<int:id>', methods=['GET', 'POST'])
- @admin_required
- def edit(id: int):
- form = ArticleEditForm()
      try:
- item = ArticleModel.query.get(id)  # type: ArticleModel
- if item is None:
- return abort(404)
- if request.method == 'POST' and form.validate_on_submit():
- now = time.time()
- 省略4行代码
- dh.session.add(item)
- dh.session.commit()
- return redirect('/admin/article/index')
- else:
- form.title.data = item.title
- 省略2行代码
- return render_template('admin/article/edit.html', form=form)
- except Exception as e:
- flash('编辑失败 - %s' % e, 'danger')
- return abort(500)

## 第 119 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/article/edit.html）。
- {% extends 'admin/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}编辑文章{% endblock %}
- {% block content_inner %}
- <ul id="tab" class="nav nav-tabs">
- <li><a href="{{ url_for('admin.article.index') }}">文章列表</a></li>
- <li><a href="{{ url_for('admin.article.add') }}">添加文章</a></li>
- <li class="active"><a href="{{ url_for(request.endpoint, **request.view_args) }}">编辑文章</a></li>
- </ul>
- <br>
- {{ wtf.quick_form(form) }}
- {{ ckeditor.load() }}
- {{ ckeditor.config(name='content', height=320) }}
- {% endblock %}
- 首先还是引入依赖，然后就写具体内容，和前面文章列表的思路一致，就是展示的内容不同，依旧用到了WTF-Form表单。

## 第 120 页 · 模块管理

- 模块管理
- 文章编辑页面完成后的效果如下图所示。
- 文章编辑页面

![第120页图](media/ch07/slide120_img1.png)

## 第 121 页 · 模块管理

- 模块管理
- 4．删除文章
- 删除文章与编辑功能一致，通过文章列表页面实现。当管理员单击“删除”链接时，根据文章列表页中所提供的“id”获取相应用户，并将文章从数据库中删除。

## 第 122 页 · 模块管理

- 模块管理
- 以下是删除文章功能视图函数的代码实现（admin/article/views.py）。
- @article.route('/delete/<int:id>')
- @admin_required
- def delete(id: int):
- try:
- item = ArticleModel.query.get(id)  # type: ArticleModel
- if item is not None:
- dh.session.delete(item)
- dh.session.commit()
- flash('删除成功')
- return redirect('/admin/article/index')
- else:
- return abort(404)
- except Exception as e:
- flash('删除失败 - %s' % e, 'danger')
- return abort(500)

## 第 123 页 · 模块管理

- 模块管理
- **5.4 友情链接管理**
- 友情链接管理模块与用户管理模块都是用于管理数据库对象的，只是相应数据模型所包含的属性不同，但本质上是一致的。

## 第 124 页 · 模块管理

- 模块管理
- 1．友情链接列表
- 以下是友情链接列表功能视图函数的代码实现（admin/friend_link/views.py）。
- from flask import render_template, request, flash, redirect, abort
- from app import dh
- from app.admin import admin_required
- from app.portal.common import load_setting
- from app.portal.models import FriendLinkModel
- from . import friend_link
- from .forms import *
- @friend_link.route('/')
- @friend_link.route('/index')
- @admin_required
- def index():
- site_setting = load_setting('site_setting')  # type: dict
- per_page = site_setting.get('admin_per_page', 20)
- pagination = FriendLinkModel.query.paginate(None, per_page)
- return render_template('admin/friend_link/index.html', pagination= pagination)
- 到这里已经算是依葫芦画瓢，按照之前的思路，去写视图函数就好，接着就到模板页面。

## 第 125 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/friend_link/index.html）。和之前的文章列表内容相似，只需要做出一些的修改即可。
- <ul id="tab" class="nav nav-tabs">
- <li class="active"><a href="{{ url_for('admin.friend_link. index') }}">友情链接列表</a></li>
- <li><a href="{{ url_for('admin.friend_link.add') }}">添加友情链接</a></li>
- </ul>
- 这一段代码就是页面效果的切换按钮，用来展示友情链接列表和添加友情链接的内容切换的。

## 第 126 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/friend_link/index.html）。和之前的文章列表内容相似，只需要做出一些的修改即可。只显示id和操作字段的内容，其他字段代码从书上7.5.4小节去补全。
- <table class="table">
- <tr>
- <th>id</th>
- <th>操作</th>
- </tr>
- {% for item in pagination.items %}
- <tr>
- <td>{{ item.id }}</td>
- <td>
- <a href="{{ url_for('admin.friend_link.edit', id=item.id) }}">编辑</a>
- <a href="{{ url_for('admin.friend_link.delete', id=item.id) }}">删除</a>
- </td>
- </tr>
- {% endfor %}
- </table>
- {{ pagi.render_pagination(pagination) }}
- 这一段代码页面显示的数据内容，用table表单来循环实现，以及用Flask-Bootstrap 提供的 render_pagination 函数来渲染分页控件。这里只是简略的代码，大家不要忘记引入依赖。

## 第 127 页 · 模块管理

- 模块管理
- 友情链接列表页面完成后的效果如下图所示。
- 友情链接列表页面

![第127页图](media/ch07/slide127_img1.png)

## 第 128 页 · 模块管理

- 模块管理
- 2．添加友情链接
- 以下是添加友情链接功能表单类的代码实现（admin/friend_link/forms.py）。
- from flask_wtf import FlaskForm
- from wtforms import StringField, SubmitField
- from wtforms.validators import DataRequired
- class FriendLinkAddForm(FlaskForm):
- name = StringField(label='名称', validators=[DataRequired()])
- url = StringField(label='链接', validators=[DataRequired()])
- submit = SubmitField(label='添加')
- 到这里按照之前的思路，先写表单，在写视图函数，最后写模板页面，三步走就好。

## 第 129 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/friend_link/views.py）。
- @friend_link.route('/add', methods=['GET', 'POST'])
- @admin_required
- def add():
- form = FriendLinkAddForm()
- if request.method == 'POST' and form.validate_on_submit():
- item = FriendLinkModel(
- name=form.name.data,
- url=form.url.data,
- )
- try:
- dh.session.add(item)
- dh.session.commit()
- flash('添加成功', 'success')
- return redirect('/admin/friend_link/index')
- except Exception as e:
- flash('添加失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('admin/friend_link/add.html', form=form)
- 这里的模板页面和之前的添加文章的是一样的，所以在7.5.3小节的add.html上修改复用就好。

## 第 130 页 · 模块管理

- 模块管理
- 友情链接添加页面完成后的效果如下图所示。
- 友情链接添加页面

![第130页图](media/ch07/slide130_img1.png)

## 第 131 页 · 模块管理

- 模块管理
- 3．编辑友情链接
- 以下是编辑友情链接功能表单类的代码实现（admin/friend_link/forms.py）。
- class FriendLinkEditForm(FriendLinkAddForm):
- submit = SubmitField(label='编辑')
- 到这里按照之前的思路，先写表单，在写视图函数，最后写模板页面，三步走就好。

## 第 132 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/friend_link/views.py）。和之前思路相同，只是用的数据模型不同。
- @friend_link.route('/edit/<int:id>', methods=['GET', 'POST'])
- @admin_required
- def edit(id: int):
- form = FriendLinkEditForm()
- try:
- item = FriendLinkModel.query.get(id)  # type: FriendLinkModel
- if item is None:
- return abort(404)
- if request.method == 'POST' and form.validate_on_submit():
- item.name = form.name.data
- item.url = form.url.data
- dh.session.add(item)
- dh.session.commit()
- flash('编辑成功', 'success')
- return redirect('/admin/friend_link/index')
- else:
- form.name.data = item.name
- form.url.data = item.url
- return render_template('admin/friend_link/edit.html', form=form)
- except Exception as e:
- flash('编辑失败 - %s' % e, 'danger')
- return abort(500)

## 第 133 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/friend_link/edit.html）。
- {% extends 'admin/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}编辑友情链接{% endblock %}
- {% block content_inner %}
- <ul id="tab" class="nav nav-tabs">
- <li><a href="{{ url_for('admin.friend_link.index') }}">友情链接列表</a></li>
- <li><a href="{{ url_for('admin.friend_link.add') }}">添加友情链接</a></li>
- <li class="active"><a href="{{ url_for(request.endpoint, **request.view_args) }}">编辑友情链接</a></li>
- </ul>
- <br>
- {{ wtf.quick_form(form) }}
- {% endblock %}

## 第 134 页 · 模块管理

- 模块管理
- 友情链接编辑页面完成后的效果如下图所示。
- 友情链接编辑页面

![第134页图](media/ch07/slide134_img1.png)

## 第 135 页 · 模块管理

- 模块管理
- 4．删除友情链接
- 以下是删除友情链接功能视图函数的代码实现（admin/friend_link/views.py）。
- @friend_link.route('/delete/<int:id>')
- @admin_required
- def delete(id: int):
- try:
- item = FriendLinkModel.query.get(id)  # type: FriendLinkModel
- if item is not None:
- dh.session.delete(item)
- dh.session.commit()
- flash('删除成功')
- return redirect('/admin/friend_link/index')
- else:
- return abort(404)
- except Exception as e:
- flash('删除失败 - %s' % e, 'danger')
- return abort(500)

## 第 136 页 · 模块管理

- 模块管理
- **5.5 博客设置**
- 在这个博客系统里，总有一些功能需要根据用户的偏好进行调整，例如，网站名称、页尾内容、每个页面展示的对象数量等；又或者是博客中的信息需要编辑，例如，博客首页的标题、描述，以及“关于”信息。

## 第 137 页 · 模块管理

- 模块管理
- 1．博客系统设置
- 以下是博客系统设置功能的表单类的代码实现（admin/portal/forms.py）。
- from flask_wtf import FlaskForm
- from wtforms import StringField, SubmitField, TextAreaField, IntegerField
- from wtforms.validators import DataRequired
- class SystemSettingForm(FlaskForm):
- site_name = StringField(label='网站名称', validators= [DataRequired()])
- site_footer = TextAreaField(label='网站页尾', validators= [DataRequired()])
- admin_per_page = IntegerField(label='后台管理项目每页项目数', validators=[DataRequired()], default=25)
- home_per_page = IntegerField(label='首页文章数', validators= [DataRequired()], default=3)
- category_per_page = IntegerField(label='分类页每页文章数', validators= [DataRequired()], default=5)
- list_all_per_page = IntegerField(label='所有文章页每页文章数', validators= [DataRequired()], default=5)
- search_per_page = IntegerField(label='搜索结果页每页文章数', validators= [DataRequired()], default=5)
- comment_per_page = IntegerField(label='文章页每页留言数', validators= [DataRequired()], default=5)
- submit = SubmitField(label='保存')

## 第 138 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/portal/views.py）。分成写数据进表单，从表单导出数据，管理博客系统设置，三个方面来展示。首先是写数据进表单。代码如下所示。
- def _setting_inject_form(setting: dict, form):
- # 此函数用于将设置中的数据注入表单中
- if setting is not None:
- for k, v in setting.items():
- if hasattr(form, k):
- getattr(form, k).data = v
- 在编辑系统设置的页面中，将已保存的设置数据加载到表单中，以便用户在表单中看到当前的设置，并可以在此基础上进行修改和保存。

## 第 139 页 · 模块管理

- 模块管理
- 从表单导出数据函数，代码如下所示。
- def _form_export_setting(form: FlaskForm):
- # 此函数用于从表单中导出设定数据
- setting = form.data.copy()
- setting.pop('submit')
- setting.pop('csrf_token')
- return setting
- 这个函数的作用是将用户在表单中输入的数据提取出来，以便将其保存到数据库中或执行其他操作。

## 第 140 页 · 模块管理

- 模块管理
- 管理博客系统设置，代码如下所示。
- @portal.route('/site_setting', methods=['GET', 'POST'])
- def site_setting():
- form = SystemSettingForm()
- if request.method == 'POST' and form.validate_on_submit():
- try:
- setting = _form_export_setting(form)
- save_setting('site_setting', setting)
- flash('保存成功', 'success')
- return redirect(request.path)
- except Exception as e:
- flash('保存失败 - %s' % e, 'danger')
- return abort(500)
- else:
- setting = load_setting('site_setting')
- _setting_inject_form(setting, form)
- return render_template('admin/portal/setting.html', form=form, title='博客系统设置')
- 这个函数的作用是调用前面两个函数，把用户输入的设置数据导出为字典，然后存进数据库里面，最后用一个页面来展示出来，作为博客系统设置的页面。

## 第 141 页 · 模块管理

- 模块管理
- 以下是模板页面的代码实现（admin/portal/settings.html）。
- {% extends 'admin/base.html' %}
- {% import 'bootstrap/wtf.html' as wtf %}
- {% block title %}{{ title }}{% endblock %}
- {% block content_inner %}
- {{ wtf.quick_form(form) }}
- {% endblock %}

## 第 142 页 · 模块管理

- 模块管理
- 博客系统设置页面完成后的效果如下图所示。
- 博客系统设置页面

![第142页图](media/ch07/slide142_img1.png)

## 第 143 页 · 模块管理

- 模块管理
- 2．博客信息设置
- 博客信息设置与系统设置在逻辑上是一致的，仅是表单类结构不同及所修改的设置项不同。信息设置与系统设置使用相同的视图模板页面。

## 第 144 页 · 模块管理

- 模块管理
- 以下是表单类的代码实现（admin/portal/forms.py）。
- class InfoSettingForm(FlaskForm):
- title = StringField(label='博客标题', validators=[DataRequired()])
- description = StringField(label='博客描述', validators= [DataRequired()])
- about = TextAreaField(label='"关于"信息')
- submit = SubmitField(label='保存')

## 第 145 页 · 模块管理

- 模块管理
- 以下是视图函数的代码实现（admin/portal/views.py）。
- @portal.route('/info_setting', methods=['GET', 'POST'])
- def info_setting():
- form = InfoSettingForm()
- if request.method == 'POST' and form.validate_on_submit():
- try:
- setting = _form_export_setting(form)
- save_setting('info_setting', setting)
- flash('保存成功', 'success')
- return redirect(request.path)
- except Exception as e:
- flash('保存失败 - %s' % e, 'danger')
- return abort(500)
- else:
- setting = load_setting('info_setting')  # type: dict
- _setting_inject_form(setting, form)
- return render_template('admin/portal/setting.html', form=form, title='博客信息设置')

## 第 146 页 · 模块管理

- 模块管理
- 博客信息设置页面完成后的效果如下图所示。
- 博客信息设置页面

![第146页图](media/ch07/slide146_img1.png)

## 第 147 页 · 小结

- 小结
- 06

## 第 148 页 · 小结

- 小结
- 本章引导各位读者完成了一个简易博客系统，其中所使用到的知识点涉及了Flask的方方面面。完成此系统后，读者已具备开发简单应用的能力。

## 第 149 页 · 谢谢聆听

- 谢谢聆听
