├── .gitignore
├── .travis.yml
├── Makefile
├── Procfile
├── README.md
├── app
    ├── __init__.py
    ├── api_v1_0
    │   ├── __init__.py
    │   ├── authentication.py
    │   ├── errors.py
    │   └── models.py
    ├── auth
    │   ├── __init__.py
    │   ├── forms.py
    │   └── views.py
    ├── decorators.py
    ├── email.py
    ├── main
    │   ├── __init__.py
    │   ├── errors.py
    │   ├── forms.py
    │   └── views.py
    ├── models.py
    ├── static
    │   ├── fav.ico
    │   └── styles.css
    ├── templates
    │   ├── 403.html
    │   ├── 404.html
    │   ├── 500.html
    │   ├── _comments.html
    │   ├── _posts.html
    │   ├── auth
    │   │   ├── change_password.html
    │   │   ├── email
    │   │   │   └── confirm.html
    │   │   ├── login.html
    │   │   ├── register.html
    │   │   └── unconfirmed.html
    │   ├── base.html
    │   ├── edit_post.html
    │   ├── edit_profile.html
    │   ├── followers.html
    │   ├── index.html
    │   ├── moderate.html
    │   ├── post.html
    │   ├── search_user.html
    │   └── user.html
    └── tests
    │   ├── __init__.py
    │   ├── test_api.py
    │   ├── test_basics.py
    │   └── test_client.py
├── config.py
├── data-dev.sqlite
├── data-test-empty.sqlite
├── data-test-full.sqlite
├── images
    ├── jianweibo.png
    ├── mobile-0.gif
    ├── mobile-1.gif
    ├── mobile-2.png
    ├── pc-0.gif
    ├── pc-1.gif
    └── pc-2.png
├── manage.py
├── migrations
    ├── README
    ├── alembic.ini
    ├── env.py
    ├── script.py.mako
    └── versions
    │   └── 7604c020c763_init_database.py
├── requirements.txt
└── test.sh


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Byte-compiled / optimized / DLL files
 2 | __pycache__/
 3 | *.py[cod]
 4 | *$py.class
 5 | 
 6 | # C extensions
 7 | *.so
 8 | .idea
 9 | # Distribution / packaging
10 | .Python
11 | .coverage
12 | data-prod.sqlite
13 | env/
14 | build/
15 | develop-eggs/
16 | dist/
17 | downloads/
18 | eggs/
19 | .eggs/
20 | lib/
21 | lib64/
22 | parts/
23 | sdist/
24 | var/
25 | *.egg-info/
26 | .installed.cfg
27 | *.egg
28 | 
29 | # PyInstaller
30 | #  Usually these files are written by a python script from a template
31 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
32 | *.manifest
33 | *.spec
34 | 
35 | # Installer logs
36 | pip-log.txt
37 | pip-delete-this-directory.txt
38 | 
39 | # Unit test / coverage reports
40 | htmlcov/
41 | .tox/
42 | .coverage
43 | .coverage.*
44 | .cache
45 | nosetests.xml
46 | coverage.xml
47 | *,cover
48 | .hypothesis/
49 | 
50 | # Translations
51 | *.mo
52 | *.pot
53 | 
54 | # Django stuff:
55 | *.log
56 | local_settings.py
57 | 
58 | # Flask stuff:
59 | instance/
60 | .webassets-cache
61 | 
62 | # Scrapy stuff:
63 | .scrapy
64 | 
65 | # Sphinx documentation
66 | docs/_build/
67 | 
68 | # PyBuilder
69 | target/
70 | 
71 | # IPython Notebook
72 | .ipynb_checkpoints
73 | 
74 | # pyenv
75 | .python-version
76 | 
77 | # celery beat schedule file
78 | celerybeat-schedule
79 | 
80 | # dotenv
81 | .env
82 | 
83 | # virtualenv
84 | venv/
85 | ENV/
86 | 
87 | # Spyder project settings
88 | .spyderproject
89 | 
90 | # Rope project settings
91 | .ropeproject
92 | *~
93 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | language: python
 3 | notifications:
 4 |   email:
 5 |     recipients:
 6 |       - chenjiandongx@qq.com
 7 |     on_success: always # default: change
 8 |     on_failure: always # default: always
 9 | python:
10 |   - 3.6
11 |   - 3.5
12 |   - 3.4
13 | before_install:
14 |   - pip install -r requirements.txt
15 | script:
16 |   - make tests
17 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | all: tests
2 | 
3 | tests:
4 | 	bash test.sh
5 | 


--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: gunicorn manage:app --workers=4


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 基于 Python Flask 的微博系统
  2 | 
  3 | [![Build Status](https://travis-ci.org/chenjiandongx/jianweibo.svg?branch=master)](https://travis-ci.org/chenjiandongx/jianweibo)
  4 | 
  5 | ![jianweibo](https://github.com/chenjiandongx/jianweibo/blob/master/images/jianweibo.png)
  6 | 
  7 | 简微博已部署在 heroku，[https://jianweibo.herokuapp.com/](https://jianweibo.herokuapp.com/)，欢迎前往体验
  8 | 
  9 | 开发环境：Windows10 + Python3
 10 | 
 11 | ### PC 端
 12 | 
 13 | 首页
 14 | 
 15 | ![pc-0](https://github.com/chenjiandongx/jianweibo/blob/master/images/pc-0.gif)
 16 | 
 17 | 个人信息页
 18 | 
 19 | ![pc-1](https://github.com/chenjiandongx/jianweibo/blob/master/images/pc-1.gif)
 20 | 
 21 | 注册
 22 | 
 23 | ![pc-2](https://github.com/chenjiandongx/jianweibo/blob/master/images/pc-2.png)
 24 | 
 25 | 
 26 | ### 移动端
 27 | 
 28 | 首页
 29 | 
 30 | ![mobile-0](https://github.com/chenjiandongx/jianweibo/blob/master/images/mobile-0.gif)
 31 | 
 32 | 个人信息页
 33 | 
 34 | ![mobile-1](https://github.com/chenjiandongx/jianweibo/blob/master/images/mobile-1.gif)
 35 | 
 36 | 注册
 37 | 
 38 | ![mobile-2](https://github.com/chenjiandongx/jianweibo/blob/master/images/mobile-2.png)
 39 | 
 40 | 得益于 [flask-boostrap](https://github.com/mbr/flask-bootstrap)，自适应 PC 端和移动端。不过毕竟免费，部署在 Heroku 速度一般吧。
 41 | 
 42 | 
 43 | ## 项目介绍
 44 | 
 45 | [Flask](https://github.com/pallets/flask) 是基于 Pyhton 的 Web 开发框架，我觉得它的最大特点就是自由，框架本身提供了必备的所有内容，然后更多的功能的实现更依赖于第三方插件。也就是说，当你不满足现有的解决方案的时候你甚至可以给自己的 Web 项目动手写个增强插件来。
 46 | 
 47 | 了解一个框架最好的方法就是动手实现一个项目，这个项目基本上是参照 [Flask Web Development
 48 | Developing Web Applications with Python](http://shop.oreilly.com/product/0636920031116.do) 这本书一行一行码出来的，不过对很多东西进行了修改。作者在 Github 上有这本书源码对应的仓库 [https://github.com/miguelgrinberg/flasky](https://github.com/miguelgrinberg/flasky)。
 49 | 
 50 | 不过说句实在的，这本书项目还是有些大大小小的 bug，而且有些地方其实是可以优化代码的。当你自己一行一行码出来就会知道了。直接签出源码仓库运行会发现直接就报错的 -_-! 世上无难事，只要有 Google。
 51 | 
 52 | ## 插件
 53 | 项目使用的第三方插件
 54 | 
 55 | * [Flask-Bootstrap](https://github.com/mbr/flask-bootstrap)
 56 | * [Flask-HTTPAuth](https://github.com/miguelgrinberg/Flask-HTTPAuth)
 57 | * [Flask-Login](https://github.com/maxcountryman/flask-login)
 58 | * [Flask-Mail](https://github.com/mattupstate/flask-mail)
 59 | * [Flask-Migrate](https://github.com/miguelgrinberg/Flask-Migrate)
 60 | * [Flask-RESTful](https://github.com/flask-restful/flask-restful)
 61 | * [Flask-Script](https://github.com/smurfix/flask-script)
 62 | * [Flask-SQLAlchemy](https://github.com/mitsuhiko/flask-sqlalchemy)
 63 | * [Flask-SSLify](https://github.com/kennethreitz/flask-sslify)
 64 | * [Flask-WTF](https://github.com/lepture/flask-wtf)
 65 | 
 66 | 
 67 | ## RESTful API
 68 | 
 69 | RESTful 部分是使用了 [flask-restful](https://github.com/flask-restful/flask-restful) 插件来完成的。下面是使用 [httpie](https://github.com/jakubroztocil/httpie) 在终端下的测试结果
 70 | 
 71 | ### 评论
 72 | 获取全部评论信息：https://jianweibo.herokuapp.com/api/v1.0/comment
 73 | ```
 74 | $ http https://jianweibo.herokuapp.com/api/v1.0/comment
 75 | HTTP/1.1 200 OK
 76 | Connection: keep-alive
 77 | Content-Length: 325
 78 | Content-Type: application/json
 79 | Date: Tue, 26 Sep 2017 14:57:59 GMT
 80 | Server: gunicorn/19.7.1
 81 | Via: 1.1 vegur
 82 | 
 83 | {
 84 |     "comment": [
 85 |         {
 86 |             "authorID": 1,
 87 |             "post": "Interesting",
 88 |             "postID": 203,
 89 |             "postTime": "Mon, 25 Sep 2017 14:19:40 GMT"
 90 |         },
 91 |         {
 92 |             "authorID": 1,
 93 |             "post": "Interesting",
 94 |             "postID": 203,
 95 |             "postTime": "Mon, 25 Sep 2017 14:19:31 GMT"
 96 |         }
 97 |     ],
 98 |     "totalCommentsCount": 2
 99 | }
100 | ```
101 | 
102 | 获取单条评论信息：https://jianweibo.herokuapp.com/api/v1.0/comment/<int:id>
103 | ```
104 | $ http https://jianweibo.herokuapp.com/api/v1.0/comment/1
105 | HTTP/1.1 200 OK
106 | Connection: keep-alive
107 | Content-Length: 112
108 | Content-Type: application/json
109 | Date: Tue, 26 Sep 2017 14:59:37 GMT
110 | Server: gunicorn/19.7.1
111 | Via: 1.1 vegur
112 | 
113 | {
114 |     "authorID": 1,
115 |     "post": "Interesting",
116 |     "postID": 203,
117 |     "postTime": "Mon, 25 Sep 2017 14:19:31 GMT"
118 | }
119 | 
120 | ```
121 | 
122 | ### 微博
123 | 获取全部微博信息：https://jianweibo.herokuapp.com/api/v1.0/post
124 | ```
125 | $ http https://jianweibo.herokuapp.com/api/v1.0/post
126 | Connection: keep-alive
127 | Content-Length: 3674
128 | Content-Type: application/json
129 | Date: Tue, 26 Sep 2017 15:00:31 GMT
130 | Server: gunicorn/19.7.1
131 | Via: 1.1 vegur
132 | 
133 | {
134 |     "post": [
135 |         {
136 |             "authorID": 7,
137 |             "posTime": "Tue, 19 Sep 2017 00:00:00 GMT",
138 |             "post": "Cras in purus eu magna vulputate luctus. Proin interdum mauris non ligula pellentesque ultrices."
139 |         },
140 |         {
141 |             "authorID": 72,
142 |             "posTime": "Sat, 16 Sep 2017 00:00:00 GMT",
143 |             "post": "Maecenas leo odio, condimentum id, luctus nec, molestie sed, justo. Duis mattis egestas metus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec pharetra, magna vestibulum aliquet ultrices, erat tortor sollicitudin mi, sit amet lobortis sapien sapien non mi."
144 |         },
145 |         {
146 |             "authorID": 54,
147 |             "posTime": "Wed, 20 Sep 2017 00:00:00 GMT",
148 |             "post": "Proin at turpis a pede posuere nonummy. Nunc rhoncus dui vel sem. Duis aliquam convallis nunc."
149 |         },
150 |         {
151 |             "authorID": 8,
152 |             "posTime": "Tue, 05 Sep 2017 00:00:00 GMT",
153 |             "post": "Aenean lectus. Praesent lectus. Lorem ipsum dolor sit amet, consectetuer adipiscing elit."
154 |         },
155 |     .....   # 内容太多，省略后面部分
156 | }
157 | ```
158 | 
159 | 获取单条微博信息：https://jianweibo.herokuapp.com/api/v1.0/post/<int:id>
160 | ```
161 | $ http https://jianweibo.herokuapp.com/api/v1.0/post/2
162 | HTTP/1.1 200 OK
163 | Connection: keep-alive
164 | Content-Length: 385
165 | Content-Type: application/json
166 | Date: Tue, 26 Sep 2017 15:01:57 GMT
167 | Server: gunicorn/19.7.1
168 | Via: 1.1 vegur
169 | 
170 | {
171 |     "authorID": 72,
172 |     "posTime": "Sat, 16 Sep 2017 00:00:00 GMT",
173 |     "post": "Maecenas leo odio, condimentum id, luctus nec, molestie sed, justo. Duis mattis egestas metus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec pharetra, magna vestibulum aliquet ultrices, erat tortor sollicitudin mi, sit amet lobortis sapien sapien non mi."
174 | }
175 | 
176 | ```
177 | 
178 | 发布微博：需要登录用户
179 | ```
180 | $ http https://jianweibo.herokuapp.com/api/v1.0/post --auth <your-email>:<your-password>  post="xxxxx"
181 | HTTP/1.1 200 OK
182 | Connection: keep-alive
183 | Content-Length: 16
184 | Content-Type: application/json
185 | Date: Tue, 26 Sep 2017 15:34:08 GMT
186 | Server: gunicorn/19.7.1
187 | Via: 1.1 vegur
188 | 
189 | {
190 |     "status": 200
191 | }
192 | ```
193 | 
194 | ### 用户
195 | 获取全部用户信息：https://jianweibo.herokuapp.com/api/v1.0/user
196 | ```
197 | $ http https://jianweibo.herokuapp.com/api/v1.0/user
198 | HTTP/1.1 200 OK
199 | Connection: keep-alive
200 | Content-Length: 1025
201 | Content-Type: application/json
202 | Date: Tue, 26 Sep 2017 15:03:57 GMT
203 | Server: gunicorn/19.7.1
204 | Via: 1.1 vegur
205 | 
206 | [
207 |     {
208 |         "id": 7,
209 |         "username": "helen"
210 |     },
211 |     {
212 |         "id": 8,
213 |         "username": "joyce"
214 |     },
215 |     {
216 |         "id": 3,
217 |         "username": "fred"
218 |     },
219 |     {
220 |         "id": 4,
221 |         "username": "marilyn"
222 |     },
223 |     {
224 |         "id": 9,
225 |         "username": "jean"
226 |     },
227 |     {
228 |         "id": 5,
229 |         "username": "ruth"
230 |     },
231 |     {
232 |         "id": 6,
233 |         "username": "maria"
234 |     },
235 |     .....   # 内容太多，省略后面部分
236 | }
237 | ```
238 | 
239 | 获取单个用户信息：https://jianweibo.herokuapp.com/api/v1.0/user/<int:id>
240 | ```
241 | $ http https://jianweibo.herokuapp.com/api/v1.0/user/5
242 | HTTP/1.1 200 OK
243 | Connection: keep-alive
244 | Content-Length: 159
245 | Content-Type: application/json
246 | Date: Tue, 26 Sep 2017 15:05:35 GMT
247 | Server: gunicorn/19.7.1
248 | Via: 1.1 vegur
249 | 
250 | {
251 |     "lastSeen": "Sun, 24 Sep 2017 16:46:13 GMT",
252 |     "memberSince": "Fri, 22 Sep 2017 00:00:00 GMT",
253 |     "postCount": 0,
254 |     "posts": [],
255 |     "username": "ruth"
256 | }
257 | ```
258 | 
259 | ### 令牌
260 | 通过密码获取令牌，然后就可采用令牌登录，不用提交密码
261 | ```
262 | $ http https://jianweibo.herokuapp.com/api/v1.0/token --auth <your-email>:<your-password>
263 | ```
264 | 
265 | 
266 | ## 运行程序
267 | 新建虚拟环境
268 | 
269 | ``` shell
270 | $ virtualenv venv
271 | # Windows
272 | $ cd venv/Scripts
273 | $ activate
274 | # Linux/MacOs
275 | $ ./venv/Scripts/activate
276 | ```
277 | 
278 | **请确保以后所有的操作都在虚拟环境中运行**
279 | 
280 | ``` shell
281 | $ git clone https://github.com/chenjiandongx/jianweibo.git
282 | $ cd jianweibo
283 | $ pip install -r requirements.txt
284 | $ export FLASK_MODE=default    # Windwos 下使用  set FLASK_MODE=default
285 | $ python manage.py runserver
286 | ```
287 | 打开 http://127.0.0.1:5000/ 就可以看到程序已经在本地跑起来了
288 | 
289 | 
290 | ## nose 测试
291 | ``` shell
292 | $ cd app
293 | $ nosetests --with-coverage --cover-package=tests --verbosity=2
294 | 
295 | 测试获取全部评论信息 ... ok
296 | 测试获取全部微博信息 ... ok
297 | 测试获取全部用户信息 ... ok
298 | 测试获取指定评论信息 ... ok
299 | 测试获取指定微博信息 ... ok
300 | 测试获取指定用户信息 ... ok
301 | 测试实例已经启动 ... ok
302 | 测试使用`TESTING-EMPTY`配置 ... ok
303 | 测试首页 ... ok
304 | 测试注册，登录，登出 ... ok
305 | 
306 | Name                            Stmts   Miss  Cover
307 | ---------------------------------------------------
308 | __init__.py                        31      2    94%
309 | api_v1_0\__init__.py                3      0   100%
310 | api_v1_0\authentication.py         23     11    52%
311 | api_v1_0\errors.py                  5      2    60%
312 | api_v1_0\models.py                 75     14    81%
313 | auth\__init__.py                    3      0   100%
314 | auth\forms.py                      25      2    92%
315 | auth\views.py                      72     23    68%
316 | decorators.py                      14      3    79%
317 | email.py                           14      0   100%
318 | main\__init__.py                    7      0   100%
319 | main\errors.py                     16     11    31%
320 | main\forms.py                      37      5    86%
321 | main\views.py                     200    148    26%
322 | models.py                         181     47    74%
323 | tests\__init__.py                   0      0   100%
324 | tests\test_api.py                  37      0   100%
325 | tests\test_basics.py               17      0   100%
326 | tests\test_client.py               35      0   100%
327 | D:\Python\jianweibo\config.py      37      6    84%
328 | ---------------------------------------------------
329 | TOTAL                             832    274    67%
330 | ----------------------------------------------------------------------
331 | Ran 10 tests in 7.344s
332 | 
333 | OK
334 | 
335 | ```
336 | **代码覆盖主要还是关注 tests 部分**
337 | 


--------------------------------------------------------------------------------
/app/__init__.py:
--------------------------------------------------------------------------------
 1 | from flask import Flask
 2 | from flask_bootstrap import Bootstrap
 3 | from flask_mail import Mail
 4 | from flask_sqlalchemy import SQLAlchemy
 5 | from flask_login import LoginManager
 6 | 
 7 | from config import config
 8 | 
 9 | 
10 | bootstrap = Bootstrap()
11 | db = SQLAlchemy()
12 | mail = Mail()
13 | 
14 | login_manager = LoginManager()
15 | login_manager.session_protection = 'strong'
16 | login_manager.login_view = 'auth.login'
17 | 
18 | 
19 | def create_app(config_name):
20 |     """ 工厂函数，用于创建 app 实例
21 | 
22 |     :param config_name: 配置类型
23 |     :return: app 实例
24 |     """
25 |     app = Flask(__name__, static_folder='static')
26 |     app.config.from_object(config[config_name])
27 | 
28 |     bootstrap.init_app(app)
29 |     db.init_app(app)
30 |     mail.init_app(app)
31 |     login_manager.init_app(app)
32 | 
33 |     if app.config.get('SSL_DISABLE', None):
34 |         from flask_sslify import SSLify
35 |         sslify = SSLify(app)
36 |     from .main import main as main_buleprint            # 注册 main 蓝图
37 |     from .auth import auth as auth_buleprint            # 注册 auth 蓝图
38 |     from .api_v1_0 import api as api_v1_0_buleprint     # 注册 api_v1.0 蓝图
39 |     app.register_blueprint(main_buleprint)
40 |     app.register_blueprint(auth_buleprint, url_prefix='/auth')  # 所有 url 使用 auth 前缀
41 |     app.register_blueprint(api_v1_0_buleprint, url_prefix='/api/v1.0')
42 | 
43 |     return app
44 | 
45 | 
46 | from app import models
47 | from app.main import views
48 | 


--------------------------------------------------------------------------------
/app/api_v1_0/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint
2 | 
3 | api = Blueprint('api', __name__)
4 | 
5 | from . import models
6 | 


--------------------------------------------------------------------------------
/app/api_v1_0/authentication.py:
--------------------------------------------------------------------------------
 1 | from flask import g
 2 | from flask_httpauth import HTTPBasicAuth
 3 | 
 4 | from ..models import User, AnonymousUser
 5 | from . import api
 6 | 
 7 | auth = HTTPBasicAuth()
 8 | 
 9 | 
10 | @auth.verify_password
11 | def verify_password(email_or_token, password):
12 |     # 没有参数视为匿名用户
13 |     if email_or_token == "":
14 |         g.current_user = AnonymousUser()
15 |         return True
16 |     # 只有一个参数，将该参数视为 token
17 |     if password == "":
18 |         g.current_user = User.verify_auth_token(email_or_token)
19 |         g.token_used = True     # 使用 token 验证
20 |         return g.current_user is not None
21 |     # 两个参数使用邮箱和密码验证
22 |     user = User.query.filter_by(email=email_or_token).first()
23 |     if not user:
24 |         return False
25 |     g.current_user = user
26 |     g.token_used = False        # 使用邮箱和密码验证
27 |     return user.verify_password(password)
28 | 
29 | 
30 | @api.before_request
31 | @auth.login_required
32 | def before_request():
33 |     # 确认账户已验证
34 |     if not g.current_user.is_anonymous and not g.current_user.confirmed:
35 |         return 'Unconfirmed account\n'
36 | 


--------------------------------------------------------------------------------
/app/api_v1_0/errors.py:
--------------------------------------------------------------------------------
 1 | 
 2 | class Error:
 3 |     @property
 4 |     def page_not_found(self):
 5 |         return {'error': 'page not found'}
 6 | 
 7 |     @property
 8 |     def internal_server_error(self):
 9 |         return {'error': 'internal server error'}
10 | 


--------------------------------------------------------------------------------
/app/api_v1_0/models.py:
--------------------------------------------------------------------------------
  1 | from flask import jsonify, g, request
  2 | from flask_restful import Resource, Api, reqparse
  3 | 
  4 | from ..models import User, Post, Comment
  5 | from .. import db
  6 | from .errors import Error
  7 | from .authentication import auth
  8 | from . import api
  9 | 
 10 | 
 11 | restful_api = Api(api)
 12 | 
 13 | 
 14 | class UserByIdApi(Resource):
 15 |     """
 16 |     RESTful API:
 17 |         通过 id 获取用户
 18 |     """
 19 |     def get(self, id):
 20 |         user = User.query.filter_by(id=id).first()
 21 |         if user is None:
 22 |             return Error.page_not_found
 23 |         posts = Post.query.filter_by(author_id=id).all()
 24 |         return jsonify(user.to_json([post.body for post in posts]))
 25 | 
 26 | 
 27 | class UserApi(Resource):
 28 |     """
 29 |     RESTful API:
 30 |         获取所有用户
 31 |     """
 32 | 
 33 |     def get(self):
 34 |         page = request.args.get('page', 1, type=int)
 35 |         pagination = User.query.paginate(page, error_out=False)
 36 |         users = pagination.items
 37 |         if users is None:
 38 |             return Error.page_not_found
 39 |         userslst = [
 40 |             {'username': user.username, 'id': user.id} for user in users]
 41 |         userslst.append({'totalUsersCount': pagination.total})
 42 |         return jsonify(userslst)
 43 | 
 44 | 
 45 | class PostByIdApi(Resource):
 46 |     """
 47 |     RESTful API:
 48 |         通过 id 获取微博
 49 |     """
 50 | 
 51 |     def get(self, id):
 52 |         post = Post.query.filter_by(id=id).first()
 53 |         if post is None:
 54 |             return Error.page_not_found
 55 |         return jsonify(post.to_json())
 56 | 
 57 | 
 58 | class PostApi(Resource):
 59 |     """
 60 |     RESTful API:
 61 |         获取所有微博以及发布微博
 62 |     """
 63 | 
 64 |     def __init__(self):
 65 |         self.parser = reqparse.RequestParser()
 66 |         self.parser.add_argument('post', type=str, required=True,
 67 |                                    help='No post provided', location='json')
 68 |         super().__init__()
 69 | 
 70 |     def get(self):
 71 |         page = request.args.get('page', 1, type=int)
 72 |         pagination = Post.query.paginate(page, error_out=False)
 73 |         posts = pagination.items
 74 |         if posts is None:
 75 |             return Error.page_not_found
 76 |         return jsonify(
 77 |             {'post': [post.to_json() for post in posts]})
 78 | 
 79 |     # 发布微博需登录状态
 80 |     @auth.login_required
 81 |     def post(self):
 82 |         args = self.parser.parse_args()
 83 |         post = Post(body=args['post'], author=g.current_user)
 84 |         db.session.add(post)
 85 |         db.session.commit()
 86 |         return {'status': 200}
 87 | 
 88 | 
 89 | class CommentByIdApi(Resource):
 90 |     """
 91 |     RESTful API:
 92 |         通过 id 获取评论
 93 |     """
 94 | 
 95 |     def get(self, id):
 96 |         comment = Comment.query.filter_by(id=id).first()
 97 |         if comment is None:
 98 |             return Error.page_not_found
 99 |         return jsonify(comment.to_json())
100 | 
101 | 
102 | class CommentApi(Resource):
103 |     """
104 |     RESTful API:
105 |         获取所有评论
106 |     """
107 | 
108 |     def get(self):
109 |         page = request.args.get('page', 1, type=int)
110 |         pagination = Comment.query.paginate(page, error_out=False)
111 |         comments = pagination.items
112 |         if comments is None:
113 |             return Error.page_not_found
114 |         return jsonify({
115 |             'comment': [comment.to_json() for comment in comments],
116 |             'totalCommentsCount': pagination.total
117 |         })
118 | 
119 | 
120 | class TokenApi(Resource):
121 |     """
122 |     RESTful API:
123 |         生成验证令牌
124 |     """
125 |     @auth.login_required
126 |     def get(self):
127 |         if g.current_user.is_anonymous or g.token_used:
128 |             return False
129 |         return jsonify({
130 |             'token': g.current_user.generate_auth_token(expiration=3600).decode('utf-8'),
131 |             'expiration': 3600
132 |         })
133 | 
134 | 
135 | restful_api.add_resource(UserByIdApi, '/user/<int:id>')
136 | restful_api.add_resource(UserApi, '/user')
137 | restful_api.add_resource(PostByIdApi, '/post/<int:id>')
138 | restful_api.add_resource(PostApi, '/post')
139 | restful_api.add_resource(CommentByIdApi, '/comment/<int:id>')
140 | restful_api.add_resource(CommentApi, '/comment')
141 | restful_api.add_resource(TokenApi, '/token')
142 | 


--------------------------------------------------------------------------------
/app/auth/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint
2 | 
3 | auth = Blueprint('auth', __name__)
4 | 
5 | from . import views
6 | 


--------------------------------------------------------------------------------
/app/auth/forms.py:
--------------------------------------------------------------------------------
 1 | from flask_wtf import FlaskForm
 2 | from wtforms import StringField, PasswordField, BooleanField, SubmitField
 3 | from wtforms.validators import (DataRequired, Length, Email,
 4 |                                 EqualTo, ValidationError)
 5 | 
 6 | from ..models import User
 7 | 
 8 | 
 9 | class LoginForm(FlaskForm):
10 |     """
11 |     登录表单
12 |     """
13 |     email = StringField('邮箱',
14 |                         validators=[DataRequired(), Length(1, 64), Email()])
15 |     password = PasswordField('密码', validators=[DataRequired()])
16 |     remember_me = BooleanField('保持登录状态')
17 |     submit = SubmitField('登录')
18 | 
19 | 
20 | class RegistrationForm(FlaskForm):
21 |     """
22 |     注册表单
23 |     """
24 |     email = StringField('邮箱',
25 |                         validators=[DataRequired(), Length(1, 64), Email()])
26 |     username = StringField('用户名',
27 |                            validators=[DataRequired(), Length(1, 16)])
28 |     password = PasswordField('密码',
29 |                              validators=[DataRequired(), Length(4, 20),
30 |                                          EqualTo('password_confirm',
31 |                                                  message='两次输入密码不一致')])
32 |     password_confirm = PasswordField('密码确认',
33 |                                      validators=[DataRequired(), Length(4, 20)])
34 |     submit = SubmitField('注册')
35 | 
36 |     def validate_email(self, field):
37 |         """ 验证邮箱是否已被注册。实际上是一个魔法方法。源码中是这样描述的：
38 |             Validates the form by calling `validate` on each field, passing any
39 |         extra `Form.validate_<fieldname>` validators to the field validator.
40 | 
41 |         :param field: 表单邮箱数据
42 |         """
43 |         if User.query.filter_by(email=field.data).first():
44 |             raise ValidationError('该邮箱已被注册')
45 | 
46 |     def validate_username(self, field):
47 |         """ 验证用户名是否已被使用。如上，同为魔法方法。
48 | 
49 |         :param field: 表单用户名数据
50 |         """
51 |         if User.query.filter_by(username=field.data).first():
52 |             raise ValidationError('该用户名已被使用')
53 | 
54 | 
55 | class ChangePasswordForm(FlaskForm):
56 |     """
57 |     修改密码表单
58 |     """
59 |     old_password = PasswordField('原密码',
60 |                                  validators=[DataRequired()])
61 |     new_password = PasswordField('新密码',
62 |                                  validators=[DataRequired(), Length(4, 20)])
63 |     submit = SubmitField('提交')
64 | 


--------------------------------------------------------------------------------
/app/auth/views.py:
--------------------------------------------------------------------------------
  1 | from flask import render_template, redirect, request, url_for, flash
  2 | from flask_login import login_user, logout_user, login_required, current_user
  3 | 
  4 | from . import auth
  5 | from .. import db
  6 | from ..models import User
  7 | from ..email import send_mail
  8 | from .forms import LoginForm, RegistrationForm, ChangePasswordForm
  9 | 
 10 | 
 11 | @auth.route('/login', methods=['GET', 'POST'])
 12 | def login():
 13 |     """ 登录账户
 14 |     """
 15 |     form = LoginForm()
 16 |     if form.validate_on_submit():
 17 |         user = User.query.filter_by(email=form.email.data).first()
 18 |         if user is not None and user.verify_password(form.password.data):
 19 |             login_user(user, form.remember_me.data)
 20 |             return redirect(request.args.get('next') or url_for('main.index'))
 21 |         flash('密码或账户错误')
 22 |     return render_template('auth/login.html', form=form)
 23 | 
 24 | 
 25 | @auth.route('/logout')
 26 | @login_required
 27 | def logout():
 28 |     """ 登出账户
 29 |     """
 30 |     logout_user()
 31 |     flash('您已退出登录')
 32 |     return redirect(url_for('main.index'))
 33 | 
 34 | 
 35 | @auth.route('/register', methods=['GET', 'POST'])
 36 | def register():
 37 |     """ 注册账户
 38 |     """
 39 |     form = RegistrationForm()
 40 |     if form.validate_on_submit():
 41 |         user = User(email=form.email.data,
 42 |                     username=form.username.data,
 43 |                     password=form.password.data)
 44 |         db.session.add(user)
 45 |         db.session.commit()
 46 |         token = user.generate_confirmation_token()
 47 |         send_mail(user.email,
 48 |                   '确认您的账户',
 49 |                   template='auth/email/confirm.html',
 50 |                   user=user,
 51 |                   token=token)
 52 |         # 自己关注自己，就可以在关注着微博列表中看到自己的微博
 53 |         u = User.query.filter_by(email=form.email.data).first()
 54 |         u.set_follow(u)
 55 |         db.session.add(user)
 56 |         db.session.commit()
 57 |         return redirect(url_for('auth.unconfirmed'))
 58 |     return render_template('auth/register.html', form=form)
 59 | 
 60 | 
 61 | @auth.before_app_request
 62 | def before_request():
 63 |     """ 登录预处理
 64 |     """
 65 |     if current_user.is_authenticated:
 66 |         current_user.update_last_seen()
 67 |         if not current_user.confirmed and request.endpoint[:5] != 'auth.':
 68 |             return redirect(url_for('auth.unconfirmed'))
 69 | 
 70 | 
 71 | @auth.route('/confirm/<token>')
 72 | @login_required
 73 | def confirm(token):
 74 |     """ 账户验证
 75 | 
 76 |     :param token: 令牌
 77 |     """
 78 |     if current_user.confirmed:
 79 |         return redirect(url_for('main.index'))
 80 |     if current_user.confirm(token):
 81 |         flash('您已经确认过您的账户了！')
 82 |     else:
 83 |         flash('确认链接无效或已过期！')
 84 |     return redirect(url_for('main.index'))
 85 | 
 86 | 
 87 | @auth.route('/unconfirmed')
 88 | def unconfirmed():
 89 |     """ 账户未确认
 90 |     账户注册以后会立即跳转到这里
 91 |     """
 92 |     return render_template('auth/unconfirmed.html')
 93 | 
 94 | 
 95 | @auth.route('/confirm')
 96 | @login_required
 97 | def resend_confirmation():
 98 |     """ 账户再确认
 99 |     """
100 |     token = current_user.generate_confirmation_token()
101 |     send_mail(current_user.email,
102 |               '确认您的账户',
103 |               template='auth/email/confirm.html',
104 |               user=current_user,
105 |               token=token)
106 |     flash('新的确认邮件已发送至您的邮箱')
107 |     return redirect(url_for('main.index'))
108 | 
109 | 
110 | @auth.route('/change-password/<username>', methods=['GET', 'POST'])
111 | @login_required
112 | def change_password(username):
113 |     form = ChangePasswordForm()
114 |     _user = User.query.filter_by(username=username).first()
115 |     if _user is None:
116 |         flash('该用户不存在')
117 |         return redirect(url_for('main.index'))
118 |     if current_user == _user and form.validate_on_submit():
119 |         if not _user.verify_password(form.old_password.data):
120 |             flash('原密码错误')
121 |             return redirect(url_for('auth.change_password', username=username))
122 |         _user.password = form.new_password.data
123 |         db.session.add(_user)
124 |         db.session.commit()
125 |         flash('密码修改成功')
126 |     return render_template('auth/change_password.html', form=form)
127 | 


--------------------------------------------------------------------------------
/app/decorators.py:
--------------------------------------------------------------------------------
 1 | from functools import wraps
 2 | 
 3 | from flask import abort
 4 | from flask_login import current_user
 5 | 
 6 | from .models import Permission
 7 | 
 8 | 
 9 | def permission_required(permission):
10 |     """ 权限验证装饰器
11 | 
12 |     :param permission: 指定权限
13 |     :return: 装饰器
14 |     """
15 |     def decorator(f):
16 |         @wraps(f)
17 |         def inner(*args, **kwargs):
18 |             if not current_user.can(permission):
19 |                 abort(403)
20 |             return f(*args, **kwargs)
21 |         return inner
22 |     return decorator
23 | 
24 | 
25 | def admin_required(f):
26 |     """ 管理员权限验证
27 | 
28 |     :param f: 视图方法
29 |     :return: 装饰器
30 |     """
31 |     return permission_required(Permission.ADMINISTER)(f)
32 | 


--------------------------------------------------------------------------------
/app/email.py:
--------------------------------------------------------------------------------
 1 | from threading import Thread
 2 | 
 3 | from flask import current_app, render_template
 4 | from flask_mail import Message
 5 | 
 6 | from . import mail
 7 | 
 8 | 
 9 | def send_async_email(app, msg):
10 |     with app.app_context():     # 确保程序上下文被激活
11 |         mail.send(msg)
12 | 
13 | 
14 | def send_mail(to, subject, template, **kwargs):
15 |     """ 使用新线程异步发送邮箱
16 | 
17 |     :param to: 收件人
18 |     :param subject: 主题
19 |     :param template: 邮件模板
20 |     :param kwargs:
21 |     :return: 执行线程
22 |     """
23 |     app = current_app._get_current_object()
24 |     msg = Message(app.config['FLASK_MAIL_SUBJECT_PREFIX'] + subject,
25 |                   sender=app.config['FLASK_MAIL_SENDER'],
26 |                   recipients=[to])
27 |     msg.html = render_template(template, **kwargs)
28 |     thread = Thread(target=send_async_email, args=[app, msg])
29 |     thread.start()
30 |     return thread
31 | 


--------------------------------------------------------------------------------
/app/main/__init__.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint
 2 | from flask_login import current_user
 3 | 
 4 | from ..models import Permission
 5 | 
 6 | main = Blueprint('main', __name__)
 7 | 
 8 | 
 9 | @main.app_context_processor
10 | def inject_global_variable():
11 |     """ 注入全局变量，在 jinja2 模板中可用
12 |     """
13 |     return dict(Permission=Permission,
14 |                 current_user=current_user)
15 | 
16 | 
17 | from . import views, errors     # 避免循环导入模块
18 | 


--------------------------------------------------------------------------------
/app/main/errors.py:
--------------------------------------------------------------------------------
 1 | from flask import render_template, request, jsonify
 2 | from . import main
 3 | 
 4 | 
 5 | @main.app_errorhandler(404)
 6 | def page_not_found(e):
 7 |     """ 使用 app_errorhandler 注册全局 404（网页未找到） 错误处理
 8 | 
 9 |     :param e: 接收异常
10 |     """
11 |     if request.accept_mimetypes.accept_json and not request.accept_mimetypes.accept_html:
12 |         resp = jsonify({'error': 'page not found'})
13 |         resp.status_code = 404
14 |         return resp
15 |     return render_template('404.html'), 404
16 | 
17 | 
18 | @main.app_errorhandler(403)
19 | def forbidden(e):
20 |     """ 使用 app_errorhandler 注册全局 403（禁止访问） 错误处理
21 | 
22 |     :param e: 接收异常
23 |     """
24 |     return render_template('403.html'), 403
25 | 
26 | 
27 | @main.app_errorhandler(500)
28 | def internal_server_error(e):
29 |     """ 使用 app_errorhandler 注册全局 500（网络错误） 错误处理
30 | 
31 |     :param e: 接收异常
32 |     """
33 |     if request.accept_mimetypes.accept_json and not request.accept_mimetypes.accept_html:
34 |         resp = jsonify({'error': 'internal server error'})
35 |         resp.status_code = 500
36 |         return resp
37 |     return render_template('500.html'), 500
38 | 


--------------------------------------------------------------------------------
/app/main/forms.py:
--------------------------------------------------------------------------------
 1 | from flask_wtf import FlaskForm
 2 | from wtforms import (StringField, SubmitField, TextAreaField,
 3 |                      BooleanField, SelectField, ValidationError)
 4 | from wtforms.validators import DataRequired, Length
 5 | 
 6 | from ..models import Role, User
 7 | 
 8 | 
 9 | class PostForm(FlaskForm):
10 |     """
11 |     微博发布表单
12 |     """
13 |     body = TextAreaField('此刻的感想？', validators=[DataRequired()])
14 |     submit = SubmitField('发布')
15 | 
16 | 
17 | class CommentForm(FlaskForm):
18 |     """
19 |     评论表单
20 |     """
21 |     body = TextAreaField('', validators=[DataRequired()])
22 |     submit = SubmitField('确认')
23 | 
24 | 
25 | class EditProfileForm(FlaskForm):
26 |     """
27 |     用户编辑个人信息表单
28 |     """
29 |     username = StringField('用户名',
30 |                            validators=[DataRequired(), Length(1, 16)])
31 |     realname = StringField('真实姓名', validators=[Length(0, 16)])
32 |     sex = SelectField('性别', choices=[('男', '男'), ('女', '女')], coerce=str)
33 |     location = StringField('地区', validators=[Length(0, 64)])
34 |     confirmed = BooleanField('保持登陆')
35 |     about_me = TextAreaField('个人简介')
36 |     submit = SubmitField('提交')
37 | 
38 | 
39 | class EditProfileAdminForm(FlaskForm):
40 |     """
41 |     管理员编辑个人信息表单
42 |     """
43 |     username = StringField('用户名',
44 |                            validators=[DataRequired(), Length(1, 16)])
45 |     realname = StringField('真实姓名', validators=[Length(0, 16)])
46 |     sex = SelectField('性别', choices=[('男', '男'), ('女', '女')], coerce=str)
47 |     location = StringField('地区', validators=[Length(0, 64)])
48 |     confirmed = BooleanField('保持登陆')
49 |     role = SelectField('角色', coerce=int)
50 |     about_me = TextAreaField('个人简介')
51 |     submit = SubmitField('提交')
52 | 
53 |     def __init__(self, user, *args, **kwargs):
54 |         super().__init__(*args, **kwargs)
55 |         # 下拉角色选择列表
56 |         self.role.choices = [(role.id, role.name)
57 |                              for role in Role.query.order_by(Role.name).all()]
58 |         self.user = user
59 | 
60 |     def validate_username(self, filed):
61 |         """ 验证用户名是否已被使用。魔法方法
62 | 
63 |         :param filed: 用户名数据
64 |         """
65 |         if filed.data != self.user.username and \
66 |                 User.query.filter_by(username=filed.data).first():
67 |             raise ValidationError('该用户名已被使用')
68 | 
69 | 
70 | class SearchUserForm(FlaskForm):
71 |     """
72 |     搜索用户表单
73 |     """
74 |     username = StringField('用户名', validators=[Length(0, 16)])
75 |     submit = SubmitField('搜索')
76 | 


--------------------------------------------------------------------------------
/app/main/views.py:
--------------------------------------------------------------------------------
  1 | from flask import (render_template, redirect, url_for, current_app,
  2 |                    abort, flash, request, make_response)
  3 | from flask_login import login_required, current_user
  4 | 
  5 | from . import main
  6 | from .forms import (PostForm, EditProfileForm, EditProfileAdminForm,
  7 |                     CommentForm, SearchUserForm)
  8 | from .. import db
  9 | from ..decorators import admin_required, permission_required
 10 | from ..models import User, Role, Post, Permission, Comment
 11 | 
 12 | 
 13 | @main.route('/', methods=['GET', 'POST'])
 14 | def index():
 15 |     """ 视图首页，发表微博
 16 |     """
 17 |     form = PostForm()
 18 |     if form.validate_on_submit() and current_user.can(Permission.WRITE_ARTICLES):
 19 |         _post = Post(body=form.body.data,
 20 |                      author=current_user._get_current_object())
 21 |         db.session.add(_post)
 22 |         db.session.commit()
 23 |         return redirect(url_for('main.index'))
 24 |     _show_followed = False
 25 |     if current_user.is_authenticated:
 26 |         _show_followed = bool(request.cookies.get('show_followed', ''))
 27 |     if _show_followed:
 28 |         query = current_user.followed_posts
 29 |     else:
 30 |         query = Post.query
 31 | 
 32 |     page = request.args.get('page', 1, type=int)        # 默认为第 1 页
 33 |     pagination = query.order_by(Post.timestamp.desc()).paginate(
 34 |         page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
 35 |         error_out=False)
 36 |     posts = pagination.items
 37 |     return render_template('index.html',
 38 |                            form=form,
 39 |                            posts=posts,
 40 |                            pagination=pagination)
 41 | 
 42 | 
 43 | @main.route('/all')
 44 | @login_required
 45 | def show_all():
 46 |     """ 显示所有用户微博
 47 |     """
 48 |     resp = make_response(redirect(url_for('.index')))
 49 |     resp.set_cookie('show_followed', '', max_age=30*24*60*60)
 50 |     return resp
 51 | 
 52 | 
 53 | @main.route('/followed')
 54 | @login_required
 55 | def show_followed():
 56 |     """ 仅显示关注着微博
 57 |     """
 58 |     resp = make_response(redirect(url_for('.index')))
 59 |     resp.set_cookie('show_followed', '1', max_age=30*24*60*60)
 60 |     return resp
 61 | 
 62 | 
 63 | @main.route('/user/<username>')
 64 | def user(username):
 65 |     """ 查看指定用户信息
 66 | 
 67 |     :param username: 指定用户
 68 |     """
 69 |     _user = User.query.filter_by(username=username).first()
 70 |     if _user is None:
 71 |         abort(404)
 72 |     page = request.args.get('page', 1, type=int)
 73 |     pagination = _user.posts.order_by(Post.timestamp.desc()).paginate(
 74 |         page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
 75 |         error_out=False)
 76 |     posts = pagination.items
 77 |     return render_template('user.html',
 78 |                            posts=posts,
 79 |                            user=_user,
 80 |                            pagination=pagination)
 81 | 
 82 | 
 83 | @main.route('/post/<int:id>', methods=['GET', 'POST'])
 84 | def post(id):
 85 |     """ 发表评论
 86 | 
 87 |     :param id: 微博 id
 88 |     """
 89 |     _post = Post.query.get_or_404(id)
 90 |     form = CommentForm()
 91 |     if form.validate_on_submit():
 92 |         comment = Comment(body=form.body.data,
 93 |                           post=_post,
 94 |                           author=current_user._get_current_object())
 95 |         # comment 的 author 字段不能直接设置为 current_user，因为这个变量是上下文代理
 96 |         # 对象。真正的 User 对象要使用 current_user._get_current_object() 获取
 97 |         db.session.add(comment)
 98 |         db.session.commit()
 99 |         flash('您已经成功提交评论')
100 |         return redirect(url_for('.post', id=_post.id, page=-1))
101 |     page = request.args.get('page', 1, type=int)
102 |     if page == -1:
103 |         page = (_post.comments.count() - 1) / \
104 |                current_app.config['FLASK_POSTS_PER_PAGE'] + 1        # 20 为每页评论条数
105 |     pagination = _post.comments.order_by(Comment.timestamp.asc()).paginate(
106 |         page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
107 |         error_out=False)
108 |     comments = pagination.items
109 |     return render_template("post.html",
110 |                            posts=[_post],
111 |                            form=form,
112 |                            pagination=pagination,
113 |                            comments=comments)
114 | 
115 | 
116 | @main.route('/edit/<int:id>', methods=['GET', 'POST'])
117 | @login_required
118 | def edit(id):
119 |     """ 更新微博
120 | 
121 |     :param id: 微博 id
122 |     """
123 |     _post = Post.query.get_or_404(id)
124 |     if current_user != _post.author and not current_user.can(Permission.ADMINISTER):
125 |         abort(403)
126 |     form = PostForm()
127 |     if form.validate_on_submit():
128 |         _post.body = form.body.data
129 |         db.session.add(_post)
130 |         db.session.commit()
131 |         flash("微博已经更新")
132 |         return redirect(url_for('.post', id=_post.id))
133 |     form.body.data = _post.body
134 |     return render_template('edit_post.html', form=form)
135 | 
136 | 
137 | @main.route('/delete/<int:id>', methods=['GET', 'POST'])
138 | @login_required
139 | def delete(id):
140 |     """ 删除指定微博
141 | 
142 |     :param id: 微博 id
143 |     """
144 |     _post = Post.query.get_or_404(id)
145 |     if current_user != _post.author and not current_user.can(Permission.ADMINISTER):
146 |         abort(403)
147 |     db.session.delete(_post)
148 |     db.session.commit()
149 |     flash('您已删除该微博')
150 |     return redirect(url_for('.index'))
151 | 
152 | 
153 | @main.route('/edit-profile', methods=['GET', 'POST'])
154 | @login_required
155 | def edit_profile():
156 |     """ 用户编辑资料
157 |     """
158 |     form = EditProfileForm()
159 |     if form.validate_on_submit():
160 |         if form.username.data != current_user.username and \
161 |                 User.query.filter_by(username=form.username.data).first():
162 |             flash('该用户名已被使用')
163 |             return redirect(url_for('.edit_profile'))
164 |         current_user.username = form.username.data
165 |         current_user.realname = form.realname.data
166 |         current_user.location = form.location.data
167 |         current_user.about_me = form.about_me.data
168 |         current_user.sex = form.sex.data
169 |         db.session.add(current_user)
170 |         db.session.commit()
171 |         flash('您已经更新了个人资料')
172 |         return redirect(url_for('main.user', username=current_user.username))
173 |     form.username.data = current_user.username
174 |     form.realname.data = current_user.realname
175 |     form.location.data = current_user.location
176 |     form.about_me.data = current_user.about_me
177 |     form.sex.data = current_user.sex
178 |     return render_template('edit_profile.html', form=form)
179 | 
180 | 
181 | @main.route('/edit-profile/<int:id>', methods=['GET', 'POST'])
182 | @login_required
183 | @admin_required
184 | def edit_profile_admin(id):
185 |     """ 管理员编辑资料
186 | 
187 |     :param id: 用户 id
188 |     """
189 |     _user = User.query.get_or_404(id)
190 |     form = EditProfileAdminForm(user=_user)
191 |     if form.validate_on_submit():
192 |         _user.username = form.username.data
193 |         _user.realname = form.realname.data
194 |         _user.confirmed = form.confirmed.data
195 |         _user.role = Role.query.get(form.role.data)
196 |         _user.location = form.location.data
197 |         _user.about_me = form.about_me.data
198 |         db.session.add(_user)
199 |         db.session.commit()
200 |         flash('资料已更新')
201 |         return redirect(url_for('main.user', username=_user.username))
202 |     form.username.data = _user.username
203 |     form.confirmed.data = _user.confirmed
204 |     form.role.data = _user.role_id
205 |     form.realname.data = _user.realname
206 |     form.location.data = _user.location
207 |     form.about_me = _user.about_me
208 |     return render_template('edit_profile.html', form=form)
209 | 
210 | 
211 | @main.route('/follow/<username>')
212 | @login_required
213 | @permission_required(Permission.FOLLOW)
214 | def follow(username):
215 |     """ 关注指定用户
216 | 
217 |     :param username: 指定用户名
218 |     """
219 |     _user = User.query.filter_by(username=username).first()
220 |     if _user is None:
221 |         flash('该用户不存在')
222 |         return redirect(url_for('main.index'))
223 |     if current_user.is_following(_user):
224 |         flash('您已经关注了该用户')
225 |         return redirect(url_for('main.user', username=username))
226 |     current_user.set_follow(_user)
227 |     flash('您关注了该用户')
228 |     return redirect(url_for('main.user', username=username))
229 | 
230 | 
231 | @main.route('/unfollow/<username>')
232 | @login_required
233 | @permission_required(Permission.FOLLOW)
234 | def unfollow(username):
235 |     """ 取消关注指定用户
236 | 
237 |     :param username: 指定用户名
238 |     """
239 |     _user = User.query.filter_by(username=username).first()
240 |     if user is None:
241 |         flash('该用户不存在')
242 |         return redirect(url_for('main.index'))
243 |     if current_user.is_following(_user):
244 |         current_user.set_unfollow(_user)
245 |         flash('您已取消关注该用户')
246 |         return redirect(url_for('main.user', username=username))
247 |     return redirect(url_for('main.user', username=username))
248 | 
249 | 
250 | @main.route('/followers/<username>')
251 | def followers(username):
252 |     """ 查看指定用户关注者名单
253 | 
254 |     :param username: 指定用户名
255 |     """
256 |     _user = User.query.filter_by(username=username).first()
257 |     if _user is None:
258 |         flash('该用户不存在')
259 |         return redirect(url_for('main.index'))
260 |     page = request.args.get('page', 1, type=int)
261 |     pagination = _user.followers.paginate(
262 |         page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
263 |         error_out=False)
264 |     follows = [{'user': item.follower, 'timestamp': item.timestamp}
265 |                for item in pagination.items]
266 |     return render_template('followers.html',
267 |                            user=_user,
268 |                            title="粉丝",
269 |                            pagination=pagination,
270 |                            follows=follows)
271 | 
272 | 
273 | @main.route('/followed-by/<username>')
274 | def followed_by(username):
275 |     """ 查看指定用户被关注者名单
276 | 
277 |     :param username: 指定用户名
278 |     """
279 |     _user = User.query.filter_by(username=username).first()
280 |     if _user is None:
281 |         flash('该用户不存在')
282 |         return redirect(url_for('main.index'))
283 |     page = request.args.get('page', 1, type=int)
284 |     pagination = _user.followed.paginate(
285 |         page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
286 |         error_out=False)
287 |     follows = [{'user': item.followed, 'timestamp': item.timestamp}
288 |                for item in pagination.items]
289 |     return render_template('followers.html',
290 |                            user=_user,
291 |                            title="关注",
292 |                            pagination=pagination,
293 |                            follows=follows)
294 | 
295 | 
296 | @main.route('/moderate')
297 | @login_required
298 | @permission_required(Permission.MODERATE_COMMENTS)
299 | def moderate():
300 |     """ 评论管理
301 |     """
302 |     page = request.args.get('page', 1, type=int)
303 |     pagination = Comment.query.order_by(Comment.timestamp.desc()).paginate(
304 |         page=page, per_page=current_app.config['FLASK_POSTS_PER_PAGE'],
305 |         error_out=False)
306 |     comments = pagination.items
307 |     return render_template('moderate.html',
308 |                            comments=comments,
309 |                            pagination=pagination,
310 |                            page=page)
311 | 
312 | 
313 | @main.route('/moderate/enable/<int:id>')
314 | @login_required
315 | @permission_required(Permission.MODERATE_COMMENTS)
316 | def moderate_enable(id):
317 |     """ 恢复已屏蔽评论
318 | 
319 |     :param id: 评论 id
320 |     """
321 |     comment = Comment.query.get_or_404(id)
322 |     comment.disabled = False
323 |     db.session.add(comment)
324 |     db.session.commit()
325 |     return redirect(url_for('main.moderate',
326 |                             page=request.args.get('page', 1, type=int)))
327 | 
328 | 
329 | @main.route('/moderate/disable/<int:id>')
330 | @login_required
331 | @permission_required(Permission.MODERATE_COMMENTS)
332 | def moderate_disable(id):
333 |     """ 屏蔽评论
334 | 
335 |     :param id: 评论 id
336 |     """
337 |     comment = Comment.query.get_or_404(id)
338 |     comment.disabled = True
339 |     db.session.add(comment)
340 |     db.session.commit()
341 |     return redirect(url_for('main.moderate',
342 |                             page=request.args.get('page', 1, type=int)))
343 | 
344 | 
345 | @main.route('/search-user', methods=['GET', 'POST'])
346 | def search_user():
347 |     """ 搜索用户
348 |     """
349 |     form = SearchUserForm()
350 |     if form.validate_on_submit():
351 |         _user = User.query.filter_by(username=form.username.data).first()
352 |         if _user is None:
353 |             flash('该用户不存在')
354 |             return redirect(url_for('main.search_user'))
355 |         return redirect(url_for('main.user', username=form.username.data))
356 |     return render_template('search_user.html', form=form)
357 | 


--------------------------------------------------------------------------------
/app/models.py:
--------------------------------------------------------------------------------
  1 | from datetime import datetime
  2 | import hashlib
  3 | 
  4 | from werkzeug.security import generate_password_hash, check_password_hash
  5 | 
  6 | from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
  7 | from flask_login import UserMixin, AnonymousUserMixin
  8 | from flask import current_app, request
  9 | from . import db, login_manager
 10 | 
 11 | 
 12 | class Role(db.Model):
 13 |     """
 14 |     角色模型，三种角色类型 <普通用户 User> <协管员 Moderator> <管理员 Administrator>
 15 |     """
 16 |     __tablename__ = 'roles'     # 数据库表名
 17 | 
 18 |     id = db.Column(db.Integer, primary_key=True)                    # 角色 id
 19 |     name = db.Column(db.String, unique=True)                        # 角色名
 20 |     default = db.Column(db.Boolean, default=False, index=True)      # 角色属性是否默认，默认为`普通用户`
 21 |     permissions = db.Column(db.Integer)                             # 角色权限
 22 |     users = db.relationship('User', backref='role', lazy='dynamic') # 用户
 23 | 
 24 |     @staticmethod
 25 |     def update_roles():
 26 |         """ 静态方法，为用户指定角色
 27 |         如若以后权限更改，则直接执行这个函数即可
 28 | 
 29 |         # 0x00 -> 匿名：未登录用户，在程序中只有阅读权限
 30 |         # 0x07 -> 用户：具有发布文章，发表评论和关注其他用户的权限，这是新用户默认的角色
 31 |         # 0x0f -> 协管员：增加审查不当评论的权限
 32 |         # 0xff -> 管理员：具有所有权限，包括修改其他用户所属角色的权限
 33 |         """
 34 |         roles = {
 35 |             'User': (Permission.FOLLOW |
 36 |                      Permission.COMMENT |
 37 |                      Permission.WRITE_ARTICLES, True),
 38 |             'Moderator': (Permission.FOLLOW |
 39 |                           Permission.COMMENT |
 40 |                           Permission.WRITE_ARTICLES |
 41 |                           Permission.MODERATE_COMMENTS, False),
 42 |             'Administrator': (0xff, False)
 43 |         }
 44 |         for r in roles:
 45 |             role = Role.query.filter_by(name=r).first()
 46 |             if role is None:
 47 |                 role = Role(name=r)
 48 |             role.permissions = roles[r][0]
 49 |             role.default = roles[r][1]          # 默认为普通用户
 50 |             db.session.add(role)                # 更新数据库
 51 |         db.session.commit()
 52 | 
 53 |     def __repr__(self):
 54 |         return '<Role {}>'.format(self.name)
 55 | 
 56 | 
 57 | class Follow(db.Model):
 58 |     """
 59 |     关注者/被关注者模型
 60 |     """
 61 |     __tablename = 'follows'     # 数据库表名
 62 | 
 63 |     # 用户关注的人 id
 64 |     follower_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
 65 |     # 用户粉丝 id
 66 |     followed_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
 67 |     # 关注时间
 68 |     timestamp = db.Column(db.DateTime, default=datetime.utcnow)
 69 | 
 70 | 
 71 | class User(UserMixin, db.Model):
 72 |     """
 73 |     用户模型
 74 |     """
 75 |     def __init__(self, **kwargs):
 76 |         super().__init__(**kwargs)
 77 | 
 78 |         if not self.role:
 79 |             # 确定管理员
 80 |             if self.email == current_app.config['FLASK_ADMIN']:
 81 |                 self.role = Role.query.filter_by(permissions=0xff).first()
 82 |             # 如果没有赋予角色则设置为`普通用户`
 83 |             else:
 84 |                 self.role = Role.query.filter_by(default=True).first()
 85 |         # 根据用户邮箱确定头像哈希值
 86 |         if self.email is not None and self.avatar_hash is None:
 87 |             self.avatar_hash = hashlib.md5(self.email.encode('utf-8')).hexdigest()
 88 | 
 89 |     __tablename__ = 'users'     # 数据库表名
 90 | 
 91 |     id = db.Column(db.Integer, primary_key=True)                        # 用户 id
 92 |     email = db.Column(db.String(64), unique=True, index=True)           # 邮箱
 93 |     username = db.Column(db.String, unique=True, index=True)            # 用户名
 94 |     realname = db.Column(db.String(64))                                 # 真实姓名
 95 |     sex = db.Column(db.String, default='男')                            # 性别
 96 |     password_hash = db.Column(db.String(128))                           # 密码哈希值
 97 |     role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))          # 角色 id
 98 |     confirmed = db.Column(db.Boolean, default=False)                    # 是否保持登录
 99 |     location = db.Column(db.String(64))                                 # 地区
100 |     about_me = db.Column(db.Text())                                     # 个人简介
101 |     member_since = db.Column(db.DateTime, default=datetime.utcnow)      # 注册时间
102 |     last_seen = db.Column(db.DateTime, default=datetime.utcnow)         # 最新登录时间
103 |     avatar_hash = db.Column(db.String(32))                              # 头像哈希值
104 |     posts = db.relationship('Post', backref='author', lazy='dynamic')   # 微博<关系>
105 | 
106 |     # 用户关注的人<关系>
107 |     followed = db.relationship('Follow',
108 |                                foreign_keys=[Follow.follower_id],       # 在 Follow 模型中自引用
109 |                                backref=db.backref('follower', lazy='joined'),   # join 立即加载所有相关对象
110 |                                lazy='dynamic',
111 |                                cascade='all, delete-orphan')            # 删除所有记录
112 |     # 用户的粉丝<关系>
113 |     followers = db.relationship('Follow',
114 |                                 foreign_keys=[Follow.followed_id],      # 在 Follow 模型中自引用
115 |                                 backref=db.backref('followed', lazy='joined'),  # join 立即加载所有相关对象
116 |                                 lazy='dynamic',
117 |                                 cascade='all, delete-orphan')           # 删除所有记录
118 |     # 微博的评论<关系>
119 |     comments = db.relationship('Comment',
120 |                                backref='author',
121 |                                lazy='dynamic')
122 | 
123 |     def set_follow(self, user):
124 |         """ 设置关注用户
125 | 
126 |         :param user: 指定用户
127 |         """
128 |         if not self.is_following(user):
129 |             f = Follow(follower=self, followed=user)
130 |             db.session.add(f)
131 | 
132 |     def set_unfollow(self, user):
133 |         """ 设置取消关注用户
134 | 
135 |         :param user: 指定用户
136 |         """
137 |         f = self.followed.filter_by(followed_id=user.id).first()
138 |         if f:
139 |             # 从 follows 表中删除该关注关系
140 |             db.session.delete(f)
141 | 
142 |     def is_following(self, user):
143 |         """ 是否关注某用户
144 | 
145 |         :param user: 指定用户
146 |         :return: 已关注返回 True，反之返回 False
147 |         """
148 |         if self.followed.filter_by(followed_id=user.id).first():
149 |             return True
150 |         return False
151 | 
152 |     def is_followed_by(self, user):
153 |         """ 是否被某用户关注
154 | 
155 |         :param user: 指定用户
156 |         :return: 已关注返回 True，反之返回 False
157 |         """
158 |         if self.followers.filter_by(follower_id=user.id).first():
159 |             return True
160 |         return False
161 | 
162 |     @property
163 |     def followed_posts(self):
164 |         """查询关注者微博列表，使用了联结操作，通过 user.id 链接 follow, post 两个数据表
165 | 
166 |         :return: 关注者微博列表
167 |         """
168 |         return Post.query.join(
169 |             Follow, Follow.followed_id == Post.author_id).filter(
170 |             Follow.follower_id == self.id)
171 | 
172 |     @property
173 |     def password(self):
174 |         """ 密码属性不可被访问
175 |         """
176 |         raise AttributeError('密码不可访问')
177 | 
178 |     @password.setter
179 |     def password(self, password):
180 |         """ 密码属性可写不可读
181 | 
182 |         :param password: 用户密码
183 |         """
184 |         self.password_hash = generate_password_hash(password)
185 | 
186 |     def verify_password(self, password):
187 |         """ 密码验证
188 | 
189 |         :param password: 用户密码
190 |         :return: 验证成功返回 True，反之返回 False
191 |         """
192 |         return check_password_hash(self.password_hash, password)
193 | 
194 |     def generate_confirmation_token(self, expiration=3600):
195 |         """ 生成用于确认身份的密令
196 | 
197 |         :param expiration: 密令有效时间，单位秒
198 |         :return: 验证密令
199 |         """
200 |         s = Serializer(current_app.config['SECRET_KEY'], expiration)
201 |         return s.dumps({'confirm': self.id})
202 | 
203 |     def confirm(self, token):
204 |         """ 利用密令确认账户
205 | 
206 |         :param token: 验证密令
207 |         :return:
208 |         """
209 |         s = Serializer(current_app.config['SECRET_KEY'])
210 |         try:
211 |             data = s.loads(token)   # 解密密令
212 |         except:
213 |             return False
214 |         if data.get('confirm') != self.id:
215 |             return False
216 |         self.confirmed = True       # 一旦成功确认 confirmed 属性设置为 True
217 |         db.session.add(self)
218 |         return True
219 | 
220 |     def generate_auth_token(self, expiration):
221 |         s = Serializer(current_app.config['SECRET_KEY'],
222 |                        expires_in=expiration)
223 |         return s.dumps({'id': self.id})
224 | 
225 |     @staticmethod
226 |     def verify_auth_token(token):
227 |         s = Serializer(current_app.config['SECRET_KEY'])
228 |         try:
229 |             data = s.loads(token)
230 |         except:
231 |             return None
232 |         return User.query.get(data['id'])
233 | 
234 |     def can(self, permissions):
235 |         """ 权限判断
236 |         利用逻辑运算符 &，如果经过 & 运算后仍为原先权限常量值，即确定用于拥有该权限。
237 | 
238 |         :param permissions: 指定权限
239 |         :return: 验证成功返回 True，反之返回 False
240 |         """
241 |         return self.role is not None and \
242 |                (self.role.permissions & permissions) == permissions
243 | 
244 |     @property
245 |     def is_administrator(self):
246 |         """ 判断是否为管理员
247 | 
248 |         :return: 是管理员返回 True，反之返回 False
249 |         """
250 |         return self.can(Permission.ADMINISTER)
251 | 
252 |     def update_last_seen(self):
253 |         """ 更新用于最近一次登录时间
254 |         """
255 |         self.last_seen = datetime.utcnow()
256 |         db.session.add(self)
257 | 
258 |     def gravatar(self, size=100, default='identicon', rating='g'):
259 |         """ 利用哈希值生成头像
260 | 
261 |         :param size: 头像大小
262 |         :param default:
263 |         :param rating:
264 |         :return: 头像链接
265 |         """
266 |         if request.is_secure:       # https 类型
267 |             url = 'https://secure.gravatar.com/avatar'
268 |         else:                       # http 类型
269 |             url = 'http://www.gravatar.com/avatar'
270 |         _hash = self.avatar_hash or hashlib.md5(
271 |             self.email.encode('utf-8')).hexdigest()
272 |         return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
273 |             url=url, hash=_hash, size=size, default=default, rating=rating)
274 | 
275 |     @staticmethod
276 |     def generate_fake_users(count=100):
277 |         from sqlalchemy.exc import  IntegrityError
278 |         from random import seed
279 |         import forgery_py
280 | 
281 |         seed()      # 随机数种子
282 |         for i in range(count):
283 |             _email = forgery_py.internet.email_address()
284 |             u = User(
285 |                 email=_email,
286 |                 username=forgery_py.internet.user_name(),
287 |                 password=forgery_py.lorem_ipsum.word(),
288 |                 about_me=forgery_py.lorem_ipsum.sentence(),
289 |                 confirmed=True,
290 |                 avatar_hash=hashlib.md5(_email.encode('utf-8')).hexdigest(),
291 |                 member_since=forgery_py.date.date(True),
292 |             )
293 |             db.session.add(u)
294 |             try:
295 |                 db.session.commit()
296 |             except IntegrityError:
297 |                 db.session.rollback()
298 | 
299 |     def to_json(self, posts):
300 |         return {
301 |             'username': self.username,
302 |             'memberSince': self.member_since,
303 |             'lastSeen': self.last_seen,
304 |             'postCount': self.posts.count(),
305 |             'posts': posts
306 |         }
307 | 
308 |     def __repr__(self):
309 |         return '<User {}>'.format(self.username)
310 | 
311 | 
312 | class AnonymousUser(AnonymousUserMixin):
313 |     """
314 |     匿名用户（游客）模型
315 |     """
316 |     def can(self, permissions):
317 |         """ 游客没有任何权限
318 | 
319 |         :param permissions: 指定权限
320 |         :return: 无任何权限
321 |         """
322 |         return False
323 | 
324 |     @property
325 |     def is_administrator(self):
326 |         """ 判断是或否为管理员
327 | 
328 |         :return: 非管理员
329 |         """
330 |         return False
331 | 
332 | 
333 | login_manager.anonymous_user = AnonymousUser    # 将未登录用户赋予游客模型
334 | 
335 | 
336 | @login_manager.user_loader
337 | def load_user(user_id):
338 |     """ Flask-Login 回调函数，用于指定标识符加载用户
339 | 
340 |     :param user_id: 用户 id
341 |     :return: 查询到的用户对象
342 |     """
343 |     return User.query.get(int(user_id))
344 | 
345 | 
346 | class Post(db.Model):
347 |     """
348 |     微博模型
349 |     """
350 |     __tablename__ = 'posts'     # 数据库表名
351 | 
352 |     id = db.Column(db.Integer, primary_key=True)                                # 微博 id
353 |     body = db.Column(db.Text)                                                   # 微博内容
354 |     timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)     # 发布时间
355 |     author_id = db.Column(db.Integer, db.ForeignKey('users.id'))                # 作者 id
356 |     comments = db.relationship('Comment', backref='post', lazy='dynamic')       # 评论
357 | 
358 |     @staticmethod
359 |     def generate_fake_posts(count=100):
360 |         from random import seed, randint
361 |         import forgery_py
362 | 
363 |         seed()
364 |         user_count = User.query.count()
365 |         for i in range(count):
366 |             u = User.query.offset(randint(0, user_count - 1)).first()
367 |             p = Post(
368 |                 body=forgery_py.lorem_ipsum.sentences(randint(1, 3)),
369 |                 timestamp=forgery_py.date.date(True),
370 |                 author=u
371 |             )
372 |             db.session.add(p)
373 |             db.session.commit()
374 | 
375 |     def to_json(self):
376 |         return {
377 |             'posTime': self.timestamp,
378 |             'post': self.body,
379 |             'authorID': self.author_id
380 |         }
381 | 
382 | 
383 | class Comment(db.Model):
384 |     """
385 |     评论模型
386 |     """
387 |     __tablename__ = 'comments'      # 数据库表名
388 | 
389 |     id = db.Column(db.Integer, primary_key=True)                                # 评论 id
390 |     body = db.Column(db.Text)                                                   # 评论内容
391 |     timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)     # 评论时间
392 |     disabled = db.Column(db.Boolean)                                            # 是否被屏蔽
393 |     author_id = db.Column(db.Integer, db.ForeignKey('users.id'))                # 作者 id
394 |     post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))                  # 微博 id
395 | 
396 |     def to_json(self):
397 |         return {
398 |             'postTime': self.timestamp,
399 |             'post': self.body,
400 |             'postID': self.post_id,
401 |             'authorID': self.author_id
402 |         }
403 | 
404 | 
405 | class Permission:
406 |     """
407 |     权限类，用于指定权限常量。当常量组合时可以构造不同身份权限。
408 |     """
409 |     FOLLOW = 0x01               # 关注其他用户
410 |     COMMENT = 0x02              # 在他人撰写的文章中发表评论
411 |     WRITE_ARTICLES = 0x04       # 写原创文章
412 |     MODERATE_COMMENTS = 0x08    # 查处他人发表的不当评论
413 |     ADMINISTER = 0x80           # 管理网站
414 | 


--------------------------------------------------------------------------------
/app/static/fav.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/app/static/fav.ico


--------------------------------------------------------------------------------
/app/static/styles.css:
--------------------------------------------------------------------------------
 1 | .profile-thumbnail {
 2 |     position: absolute;
 3 | }
 4 | .profile-avatar {
 5 |     display: block;
 6 |     margin: 0 auto;
 7 | }
 8 | div.post-tabs {
 9 |     margin-top: 16px;
10 | }
11 | ul.posts {
12 |     list-style-type: none;
13 |     padding: 0px;
14 |     margin: 16px 0px 0px 0px;
15 |     border-top: 1px solid #e0e0e0;
16 | }
17 | div.post-tabs ul.posts {
18 |     margin: 0px;
19 |     border-top: none;
20 | }
21 | ul.posts li.post {
22 |     padding: 8px;
23 |     border-bottom: 1px solid #e0e0e0;
24 | }
25 | ul.posts li.post:hover {
26 |     background-color: #f0f0f0;
27 | }
28 | div.post-date {
29 |     float: right;
30 | }
31 | div.post-author {
32 |     font-weight: bold;
33 | }
34 | div.post-thumbnail {
35 |     position: absolute;
36 | }
37 | div.post-content {
38 |     margin-left: 48px;
39 |     min-height: 48px;
40 | }
41 | div.post-footer {
42 |     text-align: right;
43 | }
44 | ul.comments {
45 |     list-style-type: none;
46 |     padding: 0px;
47 |     margin: 16px 0px 0px 0px;
48 | }
49 | ul.comments li.comment {
50 |     margin-left: 32px;
51 |     padding: 8px;
52 |     border-bottom: 1px solid #e0e0e0;
53 | }
54 | ul.comments li.comment:nth-child(1) {
55 |     border-top: 1px solid #e0e0e0;
56 | }
57 | ul.comments li.comment:hover {
58 |     background-color: #f0f0f0;
59 | }
60 | div.comment-date {
61 |     float: right;
62 | }
63 | div.comment-author {
64 |     font-weight: bold;
65 | }
66 | div.comment-thumbnail {
67 |     position: absolute;
68 | }
69 | div.comment-content {
70 |     margin-left: 48px;
71 |     min-height: 48px;
72 | }
73 | div.comment-form {
74 |     margin: 16px 0px 16px 32px;
75 | }
76 | div.pagination {
77 |     width: 100%;
78 |     text-align: right;
79 |     padding: 0px;
80 |     margin: 0px;
81 | }
82 | .post-body h1 {
83 |     font-size: 130%;
84 | }
85 | .post-body h2 {
86 |     font-size: 120%;
87 | }
88 | .post-body h3 {
89 |     font-size: 110%;
90 | }
91 | .table.followers tr {
92 |     border-bottom: 1px solid #e0e0e0;
93 | }
94 | 


--------------------------------------------------------------------------------
/app/templates/403.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | 
3 | {% block title %}简微博 - 禁止访问{% endblock %}
4 | 
5 | {% block page_content %}
6 | <div class="page-header">
7 |     <h1>禁止访问</h1>
8 | </div>
9 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/404.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% block title %}简微博 - 网页未找到{% endblock %}
3 | 
4 | {% block page_content %}
5 | <div class="page-header">
6 |     <h1>网页走丢啦</h1>
7 | </div>
8 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/500.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}简微博 - 网络异常{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <div class="page-header">
 7 |     <h1>网络异常</h1>
 8 | </div>
 9 | {% endblock %}
10 | 


--------------------------------------------------------------------------------
/app/templates/_comments.html:
--------------------------------------------------------------------------------
 1 | <ul class="comments">
 2 |     {% for comment in comments %}
 3 |         <li class="comment">
 4 |             <div class="comment-thumbnail">
 5 |                 <a href="{{ url_for('.user', username=comment.author.username) }}">
 6 |                     <img class="img-rounded profile-thumbnail" src="{{ comment.author.gravatar(size=40) }}">
 7 |                 </a>
 8 |             </div>
 9 |             <div class="comment-content">
10 |                 <div class="comment-date">{{ comment.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}</div>
11 |                 <div class="comment-author">
12 |                     <a href="{{ url_for('.user', username=comment.author.username) }}">{{ comment.author.username }}</a>
13 |                 </div>
14 |                 <div class="comment-body">
15 |                     {% if comment.disabled %}
16 |                         <p><i>该评论已经被管理员屏蔽</i></p>
17 |                     {% endif %}
18 |                     {% if moderate or not comment.disabled %}
19 |                         {{ comment.body }}
20 |                     {% endif %}
21 |                 </div>
22 |                 {% if moderate %}
23 |                     <br>
24 |                     {% if comment.disabled %}
25 |                         <a class="btn btn-default btn-xs" href="{{ url_for('.moderate_enable', id=comment.id, page=page) }}">
26 |                             恢复评论
27 |                         </a>
28 |                     {% else %}
29 |                         <a class="btn btn-danger btn-xs" href="{{ url_for('.moderate_disable', id=comment.id, page=page) }}">
30 |                             屏蔽评论
31 |                         </a>
32 |                     {% endif %}
33 |                 {% endif %}
34 |             </div>
35 |         </li>
36 |     {% endfor %}
37 | </ul>
38 | 


--------------------------------------------------------------------------------
/app/templates/_posts.html:
--------------------------------------------------------------------------------
 1 | <ul class="posts">
 2 |     {% for post in posts %}
 3 |         <li class="post">
 4 |             <div class="profile-thumbnail">
 5 |                 <a href="{{ url_for('.user', username=post.author.username) }}">
 6 |                     <img class="img-rounded profile-thumbnail" src="{{ post.author.gravatar(size=40) }}">
 7 |                 </a>
 8 |             </div>
 9 |             <div class="post-content">
10 |                 <div class="post-date">{{ post.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}</div>
11 |                 <div class="post-author">
12 |                     <a href="{{ url_for('.user', username=post.author.username) }}">
13 |                         {{ post.author.username }}
14 |                     </a>
15 |                 </div>
16 |                 <div class="post-body">{{ post.body }}</div>
17 |             </div>
18 |             <div class="post-footer">
19 |                 <a href="{{ url_for('.post', id=post.id) }}">
20 |                     <span class="label label-default">详细</span>
21 |                 </a>
22 |                 {% if current_user.is_authenticated %}
23 |                     {% if current_user == post.author %}
24 |                         <a href="{{ url_for('.edit', id=post.id) }}"><span class="label label-primary">编辑</span> </a>
25 |                         <a href="{{ url_for('.post', id=post.id) }}">
26 |                             <span class="label label-primary">{{ post.comments.count() }} 评论</span>
27 |                         </a>
28 |                         <a href="{{ url_for('.delete', id=post.id) }}"><span class="label label-primary">删除</span> </a>
29 |                     {% elif current_user.is_administrator %}
30 |                         <a href="{{ url_for('.edit', id=post.id) }}"><span class="label label-danger">编辑[管理员]</span> </a>
31 |                         <a href="{{ url_for('.post', id=post.id) }}">
32 |                             <span class="label label-danger">{{ post.comments.count() }} 评论</span>
33 |                         </a>
34 |                         <a href="{{ url_for('.delete', id=post.id) }}"><span class="label label-danger">删除[管理员]</span> </a>
35 |                     {% endif %}
36 |                 {% endif %}
37 |             </div>
38 |         </li>
39 |     {% endfor %}
40 | </ul>


--------------------------------------------------------------------------------
/app/templates/auth/change_password.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 修改密码{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 | <div class="page-header">
 8 |     <h1>修改密码</h1>
 9 | </div>
10 | <div class="col-md-4">
11 |     {{ wtf.quick_form(form) }}
12 | </div>
13 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/auth/email/confirm.html:
--------------------------------------------------------------------------------
 1 | <h1>
 2 |     亲爱的 {{ user.username }},
 3 | </h1>
 4 | <h3>
 5 |     欢迎来到 <b>简微博</b>!
 6 | </h3>
 7 | <p>
 8 |     请确认您的账户<a href="{{ url_for('auth.confirm', token=token, _external=True) }}">点击这里</a>.
 9 | </p>
10 | 
11 | <p>感谢您的支持和理解</p>
12 | <p>来自：简微博团队</p>
13 | <p><small>您可以放心访问该链接，不会追踪您的任何信息</small></p>


--------------------------------------------------------------------------------
/app/templates/auth/login.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 登录{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 | <div class="page-header">
 8 |     <h1>登录</h1>
 9 | </div>
10 | <div class="col-md-4">
11 |     {{ wtf.quick_form(form) }}
12 | </div>
13 | {% endblock %}
14 | 


--------------------------------------------------------------------------------
/app/templates/auth/register.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 注册{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 | <div class="page-header">
 8 |     <h1>注册</h1>
 9 | </div>
10 | <div class="col-md-4">
11 |     {{ wtf.quick_form(form) }}
12 | </div>
13 | {% endblock %}
14 | 


--------------------------------------------------------------------------------
/app/templates/auth/unconfirmed.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}简微博 - 账户确认{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <div class="page-header">
 7 |     <h1>
 8 |         亲爱的 {{ current_user.username }}!
 9 |     </h1>
10 |     <h3>您目前还没有确认您的账户</h3>
11 |     <p>
12 |         在登录本网站之前您应先确认您的账户。
13 |         请检查您的收件箱，我们已将确认邮件发送至您的邮箱了！
14 |     </p>
15 |     <p>
16 |         是否需要重新发送一次？
17 |         <a href="{{ url_for('auth.resend_confirmation') }}">需要请点击</a>
18 |     </p>
19 | </div>
20 | {% endblock %}
21 | 


--------------------------------------------------------------------------------
/app/templates/base.html:
--------------------------------------------------------------------------------
 1 | {% extends "bootstrap/base.html" %}
 2 | 
 3 | {% block title %}简微博{% endblock %}
 4 | 
 5 | {% block head %}
 6 |     {{super()}}
 7 |     <link rel="icon" href="{{ url_for('static', filename='fav.ico')}}" type="image/x-coin">
 8 |     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles.css') }}">
 9 | {% endblock %}
10 | 
11 | {% block navbar %}
12 |     <div class="navbar navbar-default" role="navigation">
13 |         <div class="container">
14 |             <div class="navbar-header">
15 |                 <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
16 |                     <span class="sr-only">Toggle navigation</span>
17 |                     <span class="icon-bar"></span>
18 |                     <span class="icon-bar"></span>
19 |                     <span class="icon-bar"></span>
20 |                 </button>
21 |                 <a class="navbar-brand" href="/">简微博</a>
22 |             </div>
23 |             <div class="navbar-collapse collapse">
24 |                 <ul class="nav navbar-nav">
25 |                     <li><a href="/">首页</a> </li>
26 |                     <li><a href="{{ url_for('main.search_user') }}">搜索</a> </li>
27 |                     {% if current_user.can(Permission.MODERATE_COMMENTS) %}
28 |                         <li><a href="{{ url_for('main.moderate') }}">评论管理</a></li>
29 |                     {% endif %}
30 |                 </ul>
31 |                 <ul class="nav navbar-nav navbar-right">
32 |                     {% if current_user.is_authenticated %}
33 |                         <li class="dropdown">
34 |                             <a href="#" class="dropdown-toggle" data-toggle="dropdown">
35 |                                 <img src="{{ current_user.gravatar(size=18) }}">  {{ current_user.username }}<b class="caret"></b>
36 |                             </a>
37 |                             <ul class="dropdown-menu">
38 |                                 <li><a href="{{ url_for('main.user', username=current_user.username) }}">我的</a> </li>
39 |                                 <li><a href="{{ url_for('auth.change_password', username=current_user.username) }}">账户</a> </li>
40 |                                 <li><a href="{{ url_for('auth.logout') }}">登出</a></li>
41 |                             </ul>
42 |                         </li>
43 |                     {% else %}
44 |                         <li><a href="{{ url_for('auth.login') }}">登陆</a></li>
45 |                         <li><a href="{{ url_for('auth.register') }}">注册</a> </li>
46 |                     {% endif %}
47 |                 </ul>
48 |             </div>
49 |         </div>
50 |     </div>
51 | {% endblock %}
52 | 
53 | {% block content %}
54 |     <div class="container">
55 |         {% for message in get_flashed_messages() %}
56 |             <div class="alert alert-warning">
57 |                 <button type="button" class="close" data-dismiss="alert">&times;</button>
58 |                 {{ message }}
59 |             </div>
60 |         {% endfor %}
61 |         {% block page_content %}{% endblock %}
62 |     </div>
63 |     <footer class="footer"><br></footer>
64 | {% endblock %}
65 | 


--------------------------------------------------------------------------------
/app/templates/edit_post.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 编辑微博{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 |     <div class="page-header">
 8 |         <h1>编辑微博</h1>
 9 |     </div>
10 |     <div>
11 |         {{ wtf.quick_form(form) }}
12 |     </div>
13 | {% endblock %}
14 | 


--------------------------------------------------------------------------------
/app/templates/edit_profile.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 编辑资料{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 | <div class="page-header">
 8 |     <h1>编辑资料</h1>
 9 | </div>
10 | <div class="col-md-4">
11 |     {{ wtf.quick_form(form) }}
12 | </div>
13 | {% endblock %}
14 | 


--------------------------------------------------------------------------------
/app/templates/followers.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "bootstrap/pagination.html" import render_pagination %}
 3 | 
 4 | {% block title %}简微博 - {{ title }} {{ user.username }}{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 |     <div class="page-header">
 8 |         <h1>{{ title }}</h1>
 9 |     </div>
10 |     <table class="table table-hover followers">
11 |         <thead><tr><th>用户</th><th>关注时间</th></tr></thead>
12 |         {% for follow in follows %}
13 |             {% if follow.user != user %}
14 |                 <tr>
15 |                     <td>
16 |                         <a href="{{ url_for('.user', username=follow.user.username) }}">
17 |                             <img class="img-rounded" src="{{ follow.user.gravatar(size=32) }}">
18 |                             {{ follow.user.username }}
19 |                         </a>
20 |                     </td>
21 |                     <td>{{ follow.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}</td>
22 |                 </tr>
23 |             {% endif %}
24 |         {% endfor %}
25 |     </table>
26 |     <div class="pagination">
27 |         {{ render_pagination(pagination, 'main.followers', username=user.username) }}
28 |     </div>
29 | {% endblock %}
30 | 


--------------------------------------------------------------------------------
/app/templates/index.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | {% from "bootstrap/pagination.html" import render_pagination %}
 4 | 
 5 | {% block page_content %}
 6 |     <div class="page-header">
 7 |         <h1>您好, {% if current_user.is_authenticated %}{{ current_user.username }}{% else %}陌生人{% endif %}!</h1>
 8 |     </div>
 9 |     <div>
10 |         {% if current_user.can(Permission.WRITE_ARTICLES) %}
11 |             {{ wtf.quick_form(form, button_map={'submit': 'primary'}) }}
12 |         {% endif %}
13 |     </div>
14 |     <div class="post-tabs">
15 |         <ul class="nav nav-tabs">
16 |             <li {% if not show_followed %} class="active"{% endif %}>
17 |                 <a href="{{ url_for('.show_all') }}">全部</a>
18 |             </li>
19 |             {% if current_user.is_authenticated %}
20 |                 <li {% if show_followed %} class="active"{% endif %}>
21 |                     <a href="{{ url_for('.show_followed') }}">我关注的人</a>
22 |                 </li>
23 |             {% endif %}
24 |         </ul>
25 |         {% include '_posts.html' %}
26 |     </div>
27 |     <div class="pagination">
28 |         {{ render_pagination(pagination, '.index') }}
29 |     </div>
30 | {% endblock %}}


--------------------------------------------------------------------------------
/app/templates/moderate.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "bootstrap/pagination.html" import render_pagination %}
 3 | 
 4 | {% block title %}简微博 - 评论管理{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 |     <div class="page-header">
 8 |         <h1>评论管理</h1>
 9 |     </div>
10 |     {% set moderate=True %}
11 |     {% include "_comments.html" %}
12 |     {% if pagination %}
13 |         <div class="pagination">
14 |             {{ render_pagination(pagination, '.moderate') }}
15 |         </div>
16 |     {% endif %}
17 | {% endblock %}
18 | 


--------------------------------------------------------------------------------
/app/templates/post.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | {% from "bootstrap/pagination.html" import render_pagination %}
 4 | 
 5 | {% block title %}简微博 - 发布微博{% endblock %}
 6 | 
 7 | {% block page_content %}
 8 |     {% include "_posts.html" %}
 9 |     <h3 id="comments">评论</h3>
10 |     {% if current_user.can(Permission.COMMENT) %}
11 |         <div class="comment-form">
12 |             {{ wtf.quick_form(form, button_map={'submit': 'primary'}) }}
13 |         </div>
14 |     {% endif %}
15 |     {% include '_comments.html' %}
16 |     {% if pagination %}
17 |         <div class="pagination">
18 |             {{ render_pagination(pagination, '.post', fragment='#comments', id=posts[0].id) }}
19 |         </div>
20 |     {% endif %}
21 | {% endblock %}
22 | 


--------------------------------------------------------------------------------
/app/templates/search_user.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}简微博 - 搜索用户{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 |     <div class="page-header">
 8 |         <h1>搜索用户</h1>
 9 |     </div>
10 |     <div class="col-md-4">
11 |         {{ wtf.quick_form(form, button_map={'submit': 'primary'}) }}
12 |     </div>
13 | {% endblock %}
14 | 


--------------------------------------------------------------------------------
/app/templates/user.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "bootstrap/pagination.html" import render_pagination %}
 3 | 
 4 | {% block page_content %}
 5 |     <div class="page-header">
 6 |         <img class="img-rounded profile-avatar" src="{{ user.gravatar(size=220) }}">
 7 |         <div class="profile-header">
 8 |             <h1>{{ user.username }}</h1>
 9 |             <p>性别: {{ user.sex }}</p>
10 |             {% if user.location %}
11 |                 <p>地区: {{ user.location }}</p>
12 |             {% endif %}
13 |             {% if user.about_me %}<p>{{ user.about_me }}</p>{% endif %}
14 |                 <p>账户注册时间 {{ user.member_since.strftime('%Y-%m-%d %H:%M:%S') }}</p>
15 |                 <p>上次登录时间 {{ user.last_seen.strftime('%Y-%m-%d %H:%M:%S') }}</p>
16 |             {% if current_user.is_administrator %}
17 |             <a class="btn btn-danger" href="{{ url_for('.edit_profile_admin', id=user.id) }}">编辑资料</a>
18 |             {% elif user == current_user %}
19 |                 <a class="btn btn-primary" href="{{ url_for('.edit_profile') }}">编辑资料</a>
20 |             {% endif %}
21 |             {% if current_user.can(Permission.FOLLOW) and user != current_user %}
22 |                 {% if not current_user.is_following(user) %}
23 |                     <a href="{{ url_for('.follow', username=user.username) }}" class="btn btn-primary">关注</a>
24 |                 {% else %}
25 |                     <a href="{{ url_for('.unfollow', username=user.username) }}" class="btn btn-default">取消关注</a>
26 |                 {% endif %}
27 |             {% endif %}
28 |             <a href="{{ url_for('.followers', username=user.username) }}">
29 |                 粉丝: <span class="badge">{{ user.followers.count() - 1 }}</span>
30 |             </a>
31 |             <a href="{{ url_for('.followed_by', username=user.username) }}">
32 |                 关注: <span class="badge">{{ user.followed.count() - 1 }}</span>
33 |             </a>
34 |         {% if current_user.is_authenticated and user != current_user and user.is_following(current_user) %}
35 |             | <span class="label label-default">已关注</span>
36 |         {% endif %}
37 |         </div>
38 |     </div>
39 |     <h3>微博：{{ user.username }}</h3>
40 |     {% include "_posts.html" %}
41 |     <div class="pagination">
42 |         {{ render_pagination(pagination, '.index', username=user.username) }}
43 |     </div>
44 | {% endblock %}
45 | 


--------------------------------------------------------------------------------
/app/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/app/tests/__init__.py


--------------------------------------------------------------------------------
/app/tests/test_api.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | import json
 3 | 
 4 | from app import create_app
 5 | 
 6 | 
 7 | class RestfulApiTestCase(unittest.TestCase):
 8 | 
 9 |     def setUp(self):
10 |         self.app = create_app('testing-full')
11 |         self.app_context = self.app.app_context()
12 |         self.app_context.push()
13 |         self.client = self.app.test_client(use_cookies=True)
14 | 
15 |     def tearDown(self):
16 |         self.app_context.pop()
17 | 
18 |     def test_get_all_users(self):
19 |         """ 测试获取全部用户信息
20 |         """
21 |         resp = self.client.get('/api/v1.0/user')
22 |         j = json.loads(resp.get_data(as_text=True))
23 |         self.assertTrue(j[1]['id'] == 2)
24 |         self.assertTrue(j[1]['username'] == 'Admin')
25 | 
26 |     def test_get_user(self):
27 |         """ 测试获取指定用户信息
28 |         """
29 |         resp = self.client.get('/api/v1.0/user/2')
30 |         j = json.loads(resp.get_data(as_text=True))
31 |         self.assertTrue(j['username'] == 'Admin')
32 | 
33 |     def test_get_all_posts(self):
34 |         """ 测试获取全部微博信息
35 |         """
36 |         resp = self.client.get('/api/v1.0/post')
37 |         j = json.loads(resp.get_data(as_text=True))
38 |         self.assertTrue(len(j['post']) == 20)
39 | 
40 |     def test_get_post(self):
41 |         """ 测试获取指定微博信息
42 |         """
43 |         resp = self.client.get('/api/v1.0/post/1')
44 |         j = json.loads(resp.get_data(as_text=True))
45 |         self.assertTrue(j['authorID'] == 92)
46 | 
47 |     def test_get_all_comments(self):
48 |         """ 测试获取全部评论信息"""
49 |         resp = self.client.get('/api/v1.0/comment')
50 |         j = json.loads(resp.get_data(as_text=True))
51 |         self.assertTrue(j['totalCommentsCount'] == 1)
52 | 
53 |     def test_get_comment(self):
54 |         """ 测试获取指定评论信息"""
55 |         resp = self.client.get('/api/v1.0/comment/1')
56 |         j = json.loads(resp.get_data(as_text=True))
57 |         self.assertTrue(j['authorID'] == 1)
58 |         self.assertTrue(j['post'] == '777？')
59 | 


--------------------------------------------------------------------------------
/app/tests/test_basics.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | 
 3 | from flask import current_app
 4 | from app import create_app, db
 5 | 
 6 | 
 7 | class BasicsTestCase(unittest.TestCase):
 8 | 
 9 |     def setUp(self):
10 |         self.app = create_app('testing-empty')
11 |         self.app_context = self.app.app_context()
12 |         self.app_context.push()
13 |         db.create_all()
14 | 
15 |     def tearDown(self):
16 |         db.session.remove()
17 |         db.drop_all()
18 |         self.app_context.pop()
19 | 
20 |     def test_app_exists(self):
21 |         """ 测试实例已经启动
22 |         """
23 |         self.assertFalse(current_app is None)
24 | 
25 |     def test_app_is_testing(self):
26 |         """ 测试使用`TESTING-EMPTY`配置
27 |         """
28 |         self.assertTrue(current_app.config['TESTING'])
29 | 


--------------------------------------------------------------------------------
/app/tests/test_client.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | 
 3 | from app import create_app, db
 4 | from app.models import User, Role
 5 | 
 6 | 
 7 | class FlaskClientTestCase(unittest.TestCase):
 8 | 
 9 |     def setUp(self):
10 |         self.app = create_app('testing-empty')
11 |         self.app_context = self.app.app_context()
12 |         self.app_context.push()
13 |         db.create_all()
14 |         Role.update_roles()
15 |         self.client = self.app.test_client(use_cookies=True)
16 | 
17 |     def tearDown(self):
18 |         db.session.remove()
19 |         db.drop_all()
20 |         self.app_context.pop()
21 | 
22 |     def test_home_page(self):
23 |         """ 测试首页
24 |         """
25 |         resp = self.client.get('/')
26 |         resp_data = resp.get_data(as_text=True)
27 |         self.assertTrue('您好, 陌生人' in resp_data)
28 | 
29 |     def test_register_login_logout(self):
30 |         """ 测试注册，登录，登出
31 |         """
32 |         # 测试注册
33 |         resp = self.client.post('/auth/register', data={
34 |             'email': 'chenjiandongx@qq.com',
35 |             'username': 'Admin',
36 |             'password': 'default',
37 |             'password_confirm': 'default'
38 |         })
39 |         self.assertTrue(resp.status_code == 302)    # 302 代表重定向
40 | 
41 |         # 测试登录
42 |         resp = self.client.post('/auth/login', data={
43 |             'email': 'chenjiandongx@qq.com',
44 |             'password': 'default',
45 |         }, follow_redirects=True)
46 |         resp_data = resp.get_data(as_text=True)
47 |         self.assertTrue('您目前还没有确认您的账户' in resp_data)
48 | 
49 |         # 使用令牌验证用户
50 |         user = User.query.filter_by(email='chenjiandongx@qq.com').first()
51 |         token = user.generate_confirmation_token().decode('utf-8')
52 |         resp = self.client.get('/auth/confirm/' + token, follow_redirects=True)
53 |         resp_data = resp.get_data(as_text=True)
54 |         self.assertTrue('您好, Admin' in resp_data)
55 |         self.assertTrue('您已经确认过您的账户了' in resp_data)
56 | 
57 |         # 退出登录
58 |         resp = self.client.get('/auth/logout', follow_redirects=True)
59 |         resp_data = resp.get_data(as_text=True)
60 |         self.assertTrue('您好, 陌生人' in resp_data)
61 |         self.assertTrue('您已退出登录' in resp_data)
62 | 


--------------------------------------------------------------------------------
/config.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | here = os.path.abspath(os.path.dirname(__file__))
 3 | 
 4 | 
 5 | class Config:
 6 |     """
 7 |     配置基类
 8 |     """
 9 |     SECRET_KEY = '#+^aOjdlPHFD09)&*2P3JR-0CFE)&H12EAa;OPFG=0'
10 |     SQLALCHEMY_COMMIT_ON_TEARDOWN = True
11 |     SQLALCHEMY_TRACK_MODIFICATIONS = False
12 |     FLASK_ADMIN = 'chenjiandongx@qq.com'
13 |     FLASK_POSTS_PER_PAGE = 15
14 |     MAIL_USE_SSL = True
15 |     MAIL_SERVER = 'smtp.qq.com'
16 |     MAIL_PORT = 465
17 |     MAIL_USERNAME = os.environ.get('MAIL_USERNAME')
18 |     MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')
19 |     FLASK_MAIL_SENDER = '简微博团队<chenjiandongx@qq.com>'
20 |     FLASK_MAIL_SUBJECT_PREFIX = '[简微博]'
21 | 
22 | 
23 | class DevelopmentConfig(Config):
24 |     """
25 |     开发状态
26 |     """
27 |     DEBUG = True
28 |     SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(here, 'data-dev.sqlite')
29 | 
30 | 
31 | class TestingEmptyConfig(Config):
32 |     """
33 |     测试状态：数据库无数据
34 |     """
35 |     TESTING = True
36 |     WTF_CSRF_ENABLED = False
37 |     SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(here, 'data-test-empty.sqlite')
38 | 
39 | 
40 | class TestingFullConfig(TestingEmptyConfig):
41 |     """
42 |     测试状态：数据库有数据
43 |     """
44 |     SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(here, 'data-test-full.sqlite')
45 | 
46 | 
47 | class ProductionConfig(Config):
48 |     """
49 |     生产状态
50 |     """
51 |     SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(here, 'data-prod.sqlite')
52 | 
53 | 
54 | class HerokuConfig(Config):
55 |     """
56 |     Heroku平台配置
57 |     """
58 |     SSL_DISABLE = False     # 启动 SLL 安全检查
59 |     SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')
60 | 
61 |     @classmethod
62 |     def init_app(cls, app):
63 |         # 将日志输出到 stderr
64 |         import logging
65 |         file_handler = logging.StreamHandler()
66 |         file_handler.setLevel(logging.WARNING)
67 |         app.logger.addHandler(file_handler)
68 |         # 处理代理服务器首部。在 Heroku 中，客户端没有直接托管程序，而是连接反向服务
69 |         # 代理器，最后把请求重定向到程序上。这种连接方式中，只在代理服务器中运行 SSL 模式。
70 |         from werkzeug.contrib.fixers import ProxyFix
71 |         app.wsgi_app = ProxyFix(app.wsgi_app)
72 | 
73 | 
74 | config = {
75 |     'development': DevelopmentConfig,
76 |     'testing-empty': TestingEmptyConfig,
77 |     'testing-full': TestingFullConfig,
78 |     'production': ProductionConfig,
79 |     'heroku': HerokuConfig,
80 |     'default': DevelopmentConfig
81 | }
82 | 


--------------------------------------------------------------------------------
/data-dev.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/data-dev.sqlite


--------------------------------------------------------------------------------
/data-test-empty.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/data-test-empty.sqlite


--------------------------------------------------------------------------------
/data-test-full.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/data-test-full.sqlite


--------------------------------------------------------------------------------
/images/jianweibo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/jianweibo.png


--------------------------------------------------------------------------------
/images/mobile-0.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/mobile-0.gif


--------------------------------------------------------------------------------
/images/mobile-1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/mobile-1.gif


--------------------------------------------------------------------------------
/images/mobile-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/mobile-2.png


--------------------------------------------------------------------------------
/images/pc-0.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/pc-0.gif


--------------------------------------------------------------------------------
/images/pc-1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/pc-1.gif


--------------------------------------------------------------------------------
/images/pc-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenjiandongx/jianweibo/ae8690f7bd64c060a76c7936e5dcc35ff065713a/images/pc-2.png


--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | from app import create_app, db
 4 | from app.models import User, Role, Post
 5 | from flask_script import Manager, Shell
 6 | from flask_migrate import Migrate, MigrateCommand
 7 | 
 8 | CONFIGURE_MODE = os.environ.get('FLASK_MODE') or 'heroku'
 9 | 
10 | app = create_app(CONFIGURE_MODE)
11 | manager = Manager(app)
12 | migrate = Migrate(app, db)
13 | 
14 | 
15 | def make_shell_context():
16 |     # 启动 shell 时导入所需模块
17 |     return dict(app=app, db=db, User=User, Role=Role, Post=Post)
18 | 
19 | 
20 | manager.add_command('shell', Shell(make_context=make_shell_context))
21 | manager.add_command('db', MigrateCommand)
22 | 
23 | 
24 | @manager.command
25 | def deploy():
26 |     """ 部署命令
27 |     """
28 |     from flask_migrate import upgrade
29 |     upgrade()
30 | 
31 | 
32 | if __name__ == "__main__":
33 |     manager.run()
34 | 


--------------------------------------------------------------------------------
/migrations/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration.


--------------------------------------------------------------------------------
/migrations/alembic.ini:
--------------------------------------------------------------------------------
 1 | # A generic, single database configuration.
 2 | 
 3 | [alembic]
 4 | # template used to generate migration files
 5 | # file_template = %%(rev)s_%%(slug)s
 6 | 
 7 | # set to 'true' to run the environment during
 8 | # the 'revision' command, regardless of autogenerate
 9 | # revision_environment = false
10 | 
11 | 
12 | # Logging configuration
13 | [loggers]
14 | keys = root,sqlalchemy,alembic
15 | 
16 | [handlers]
17 | keys = console
18 | 
19 | [formatters]
20 | keys = generic
21 | 
22 | [logger_root]
23 | level = WARN
24 | handlers = console
25 | qualname =
26 | 
27 | [logger_sqlalchemy]
28 | level = WARN
29 | handlers =
30 | qualname = sqlalchemy.engine
31 | 
32 | [logger_alembic]
33 | level = INFO
34 | handlers =
35 | qualname = alembic
36 | 
37 | [handler_console]
38 | class = StreamHandler
39 | args = (sys.stderr,)
40 | level = NOTSET
41 | formatter = generic
42 | 
43 | [formatter_generic]
44 | format = %(levelname)-5.5s [%(name)s] %(message)s
45 | datefmt = %H:%M:%S
46 | 


--------------------------------------------------------------------------------
/migrations/env.py:
--------------------------------------------------------------------------------
 1 | from __future__ import with_statement
 2 | from alembic import context
 3 | from sqlalchemy import engine_from_config, pool
 4 | from logging.config import fileConfig
 5 | import logging
 6 | 
 7 | # this is the Alembic Config object, which provides
 8 | # access to the values within the .ini file in use.
 9 | config = context.config
10 | 
11 | # Interpret the config file for Python logging.
12 | # This line sets up loggers basically.
13 | fileConfig(config.config_file_name)
14 | logger = logging.getLogger('alembic.env')
15 | 
16 | # add your model's MetaData object here
17 | # for 'autogenerate' support
18 | # from myapp import mymodel
19 | # target_metadata = mymodel.Base.metadata
20 | from flask import current_app
21 | config.set_main_option('sqlalchemy.url',
22 |                        current_app.config.get('SQLALCHEMY_DATABASE_URI'))
23 | target_metadata = current_app.extensions['migrate'].db.metadata
24 | 
25 | # other values from the config, defined by the needs of env.py,
26 | # can be acquired:
27 | # my_important_option = config.get_main_option("my_important_option")
28 | # ... etc.
29 | 
30 | 
31 | def run_migrations_offline():
32 |     """Run migrations in 'offline' mode.
33 | 
34 |     This configures the context with just a URL
35 |     and not an Engine, though an Engine is acceptable
36 |     here as well.  By skipping the Engine creation
37 |     we don't even need a DBAPI to be available.
38 | 
39 |     Calls to context.execute() here emit the given string to the
40 |     script output.
41 | 
42 |     """
43 |     url = config.get_main_option("sqlalchemy.url")
44 |     context.configure(url=url)
45 | 
46 |     with context.begin_transaction():
47 |         context.run_migrations()
48 | 
49 | 
50 | def run_migrations_online():
51 |     """Run migrations in 'online' mode.
52 | 
53 |     In this scenario we need to create an Engine
54 |     and associate a connection with the context.
55 | 
56 |     """
57 | 
58 |     # this callback is used to prevent an auto-migration from being generated
59 |     # when there are no changes to the schema
60 |     # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
61 |     def process_revision_directives(context, revision, directives):
62 |         if getattr(config.cmd_opts, 'autogenerate', False):
63 |             script = directives[0]
64 |             if script.upgrade_ops.is_empty():
65 |                 directives[:] = []
66 |                 logger.info('No changes in schema detected.')
67 | 
68 |     engine = engine_from_config(config.get_section(config.config_ini_section),
69 |                                 prefix='sqlalchemy.',
70 |                                 poolclass=pool.NullPool)
71 | 
72 |     connection = engine.connect()
73 |     context.configure(connection=connection,
74 |                       target_metadata=target_metadata,
75 |                       process_revision_directives=process_revision_directives,
76 |                       **current_app.extensions['migrate'].configure_args)
77 | 
78 |     try:
79 |         with context.begin_transaction():
80 |             context.run_migrations()
81 |     finally:
82 |         connection.close()
83 | 
84 | if context.is_offline_mode():
85 |     run_migrations_offline()
86 | else:
87 |     run_migrations_online()
88 | 


--------------------------------------------------------------------------------
/migrations/script.py.mako:
--------------------------------------------------------------------------------
 1 | """${message}
 2 | 
 3 | Revision ID: ${up_revision}
 4 | Revises: ${down_revision | comma,n}
 5 | Create Date: ${create_date}
 6 | 
 7 | """
 8 | from alembic import op
 9 | import sqlalchemy as sa
10 | ${imports if imports else ""}
11 | 
12 | # revision identifiers, used by Alembic.
13 | revision = ${repr(up_revision)}
14 | down_revision = ${repr(down_revision)}
15 | branch_labels = ${repr(branch_labels)}
16 | depends_on = ${repr(depends_on)}
17 | 
18 | 
19 | def upgrade():
20 |     ${upgrades if upgrades else "pass"}
21 | 
22 | 
23 | def downgrade():
24 |     ${downgrades if downgrades else "pass"}
25 | 


--------------------------------------------------------------------------------
/migrations/versions/7604c020c763_init_database.py:
--------------------------------------------------------------------------------
 1 | """init database
 2 | 
 3 | Revision ID: 7604c020c763
 4 | Revises: 
 5 | Create Date: 2017-09-25 00:25:29.089178
 6 | 
 7 | """
 8 | from alembic import op
 9 | import sqlalchemy as sa
10 | 
11 | 
12 | # revision identifiers, used by Alembic.
13 | revision = '7604c020c763'
14 | down_revision = None
15 | branch_labels = None
16 | depends_on = None
17 | 
18 | 
19 | def upgrade():
20 |     # ### commands auto generated by Alembic - please adjust! ###
21 |     op.create_table('roles',
22 |     sa.Column('id', sa.Integer(), nullable=False),
23 |     sa.Column('name', sa.String(), nullable=True),
24 |     sa.Column('default', sa.Boolean(), nullable=True),
25 |     sa.Column('permissions', sa.Integer(), nullable=True),
26 |     sa.PrimaryKeyConstraint('id'),
27 |     sa.UniqueConstraint('name')
28 |     )
29 |     op.create_index(op.f('ix_roles_default'), 'roles', ['default'], unique=False)
30 |     op.create_table('users',
31 |     sa.Column('id', sa.Integer(), nullable=False),
32 |     sa.Column('email', sa.String(length=64), nullable=True),
33 |     sa.Column('username', sa.String(), nullable=True),
34 |     sa.Column('realname', sa.String(length=64), nullable=True),
35 |     sa.Column('sex', sa.String(), nullable=True),
36 |     sa.Column('password_hash', sa.String(length=128), nullable=True),
37 |     sa.Column('role_id', sa.Integer(), nullable=True),
38 |     sa.Column('confirmed', sa.Boolean(), nullable=True),
39 |     sa.Column('location', sa.String(length=64), nullable=True),
40 |     sa.Column('about_me', sa.Text(), nullable=True),
41 |     sa.Column('member_since', sa.DateTime(), nullable=True),
42 |     sa.Column('last_seen', sa.DateTime(), nullable=True),
43 |     sa.Column('avatar_hash', sa.String(length=32), nullable=True),
44 |     sa.ForeignKeyConstraint(['role_id'], ['roles.id'], ),
45 |     sa.PrimaryKeyConstraint('id')
46 |     )
47 |     op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
48 |     op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
49 |     op.create_table('follow',
50 |     sa.Column('follower_id', sa.Integer(), nullable=False),
51 |     sa.Column('followed_id', sa.Integer(), nullable=False),
52 |     sa.Column('timestamp', sa.DateTime(), nullable=True),
53 |     sa.ForeignKeyConstraint(['followed_id'], ['users.id'], ),
54 |     sa.ForeignKeyConstraint(['follower_id'], ['users.id'], ),
55 |     sa.PrimaryKeyConstraint('follower_id', 'followed_id')
56 |     )
57 |     op.create_table('posts',
58 |     sa.Column('id', sa.Integer(), nullable=False),
59 |     sa.Column('body', sa.Text(), nullable=True),
60 |     sa.Column('timestamp', sa.DateTime(), nullable=True),
61 |     sa.Column('author_id', sa.Integer(), nullable=True),
62 |     sa.ForeignKeyConstraint(['author_id'], ['users.id'], ),
63 |     sa.PrimaryKeyConstraint('id')
64 |     )
65 |     op.create_index(op.f('ix_posts_timestamp'), 'posts', ['timestamp'], unique=False)
66 |     op.create_table('comments',
67 |     sa.Column('id', sa.Integer(), nullable=False),
68 |     sa.Column('body', sa.Text(), nullable=True),
69 |     sa.Column('timestamp', sa.DateTime(), nullable=True),
70 |     sa.Column('disabled', sa.Boolean(), nullable=True),
71 |     sa.Column('author_id', sa.Integer(), nullable=True),
72 |     sa.Column('post_id', sa.Integer(), nullable=True),
73 |     sa.ForeignKeyConstraint(['author_id'], ['users.id'], ),
74 |     sa.ForeignKeyConstraint(['post_id'], ['posts.id'], ),
75 |     sa.PrimaryKeyConstraint('id')
76 |     )
77 |     op.create_index(op.f('ix_comments_timestamp'), 'comments', ['timestamp'], unique=False)
78 |     # ### end Alembic commands ###
79 | 
80 | 
81 | def downgrade():
82 |     # ### commands auto generated by Alembic - please adjust! ###
83 |     op.drop_index(op.f('ix_comments_timestamp'), table_name='comments')
84 |     op.drop_table('comments')
85 |     op.drop_index(op.f('ix_posts_timestamp'), table_name='posts')
86 |     op.drop_table('posts')
87 |     op.drop_table('follow')
88 |     op.drop_index(op.f('ix_users_username'), table_name='users')
89 |     op.drop_index(op.f('ix_users_email'), table_name='users')
90 |     op.drop_table('users')
91 |     op.drop_index(op.f('ix_roles_default'), table_name='roles')
92 |     op.drop_table('roles')
93 |     # ### end Alembic commands ###
94 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | alembic==0.9.5
 2 | aniso8601==1.3.0
 3 | blinker==1.4
 4 | certifi==2017.7.27.1
 5 | chardet==3.0.4
 6 | click==6.7
 7 | colorama==0.3.9
 8 | dominate==2.3.1
 9 | Flask==0.12.2
10 | Flask-Bootstrap==3.3.7.1
11 | Flask-HTTPAuth==3.2.3
12 | Flask-Login==0.4.0
13 | Flask-Mail==0.9.1
14 | Flask-Migrate==2.1.1
15 | Flask-RESTful==0.3.6
16 | Flask-Script==2.0.6
17 | Flask-SQLAlchemy==2.2
18 | Flask-SSLify==0.1.5
19 | Flask-WTF==0.14.2
20 | ForgeryPy==0.1
21 | gunicorn==19.7.1
22 | httpie==0.9.9
23 | idna==2.6
24 | itsdangerous==0.24
25 | Jinja2==2.9.6
26 | Mako==1.0.7
27 | MarkupSafe==1.0
28 | nose==1.3.7
29 | psycopg2==2.7.3.1
30 | Pygments==2.2.0
31 | python-dateutil==2.6.1
32 | python-editor==1.0.3
33 | pytz==2017.2
34 | requests==2.18.4
35 | six==1.11.0
36 | SQLAlchemy==1.1.14
37 | urllib3==1.22
38 | visitor==0.1.3
39 | Werkzeug==0.12.2
40 | WTForms==2.1


--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
1 | cd app
2 | nosetests --with-coverage --cover-package tests --verbosity=2
3 | 
4 | 


--------------------------------------------------------------------------------