Class Config(object):
    SECRET_KEY = os.urandom(32)
    POST_PER_PAGE = 5
    SQLACHEMY_COMMIT_ON_TEARDOWN = True
    ......
    
    @staticmethod
    def init_app(app)
        pass
# 然后继承这个类来表示不同开发状态
Class DefaultConfig(Config):
    '''默认配置，新增指定了DEBUG与否与数据库的位置'''
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///......data_default.sqlite'
    
Class DevelopmentConfig(Config):
    '''开发中配置'''
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///......data_dev.sqlite'
    
Class ProductionConfig(Config):
    '''生产环境的配置'''
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = 'sqlite:///......data_pro.sqlite'
    
# 最好用一个字典将其导出
config = {
    'development':DevelopmentConfig,
    'prodution':ProductionConfig,
    'default':DefaultConfig
}

from flask import Flask
from flask_sqlachemy import SQLAlchemy
from flask_mail import Mail
from flask_admin import Admin
from config import config # 在这里引入上一小节的config字典

db = SQLAlchemy()
mail = Mail()
admin = Admin()

def create_app(config_name):
    # 初始化 flask
    app = Flask(__name__)
    # from_object 函数可以直接将类中的属性转换成app配置 
    app.config.from_object(config[config_name])
    
    # 批量初始化插件
    db.init_app(app)
    admin.init_app(app)
    mail.init_app(app)
   
    # 同样可以批量引入并注册蓝图 
    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)
    
    return app
    
# 在manage.py文件里面动态的选择创建app
from app import create_app
app = create_app('default')

# 在app包根目录下新建一个Model.py文件
from app import db # 此db就是sqlalchemy初始化后的对象
Class Post(db.Model):
    ''' 定义了主键id，标题title，主体body'''
    __tablename__ = 'posts'
    id = db.Column(db.Integer,primary_key = True
    title = db.Column(db.String(200))
    body = db.Column(db.Text)

# 其实主要是jinja2的使用，在app下新建一个文件夹叫templates，在文件夹下面新建一个HTML文件，Posts.html
{% for post in posts %}
    <div class="posts">
    <h2> {{ post.title }} </h2>
    <p> {{ post.body }} </p>
    </div>
{% endfor %}

from flask import Blueprint,render_template
from Model import Post 
# 注册一个蓝图
main = Blueprint('main',__name__)
# 指定访问路径为'/posts'
@main.route('/posts')
def posts()
    posts= Post.query.all()
    render_template('Posts.html',posts=posts)

# 下面是render即渲染函数，文章的正文在新建的时候用此函数来渲染成html

import markdown
def markdown_render(text,codehilite=True):
    exts =[
        'abbr', 'attr_list', 'def_list', 'sane_lists', 'fenced_code',
        'tables', 'toc', 'wikilinks',
    ]

    if codehilite:
        # exts.append('codehilite(guess_lang=True,linenums=True)')
        exts.append('codehilite(guess_lang=True)')

    return Markup(markdown.markdown(
        text,
        extensions=exts,
        safe_mode=False,
    ))

# style可以选择pygments里面不同的风格
from pygments.formatters.html import HtmlFormatter
def pygments_style_defs(style='default'):
    formatter = HtmlFormatter(style=style)
    return formatter.get_style_defs('.codehilite')

# 然后定义需要引用的css文件路径，在这里选的是`monokai`风格的语法高亮
@main.route('/pygments.css')
def pygments_css():
    return pygments_style_defs('monokai'),200,{'Content-Type':'text/css'}

# 所有的标签的集合
@main.route('/tags',methods=['GET','POST'])
def tags_posts():
    tags = Tag.query.all()
    return render_template('tags.html',tags=tags)

# 单个标签路径
@main.route('/tags/<name>',methods=['GET','POST'])
def tag(name):
    tag = Tag.query.filter_by(name=name).first()
    return render_template('result.html',item=tag)

from collections import defaultdict
@main.route('/categories',methods=['GET','POST'])
def categories_posts():
    posts = Post.query.all()
    d=defaultdict(list) # 默认的item类型为list
    for p in posts:
        d[p.category].append(p)
    return render_template('categories.html',d=d)

@main.route('/sitemap.xml/', methods=['GET']) # 这里的路径看起来像是访问一个文件一样
def sitemap_xml():
 
    urlset = []
    # 此网站的信息
    urlset.append(dict(
        loc=url_for('main.index', _external=True), # 设置_external参数，返回此网站主页的绝对链接
        lastmod=datetime.date.today().isoformat(),
        changefreq='weekly',
        priority=1, # 设置重要等级
    ))
    # 每个栏目以字典形式存入
    for category in Category.query.all():
        urlset.append(dict(
            loc=category.link,
            changefreq='weekly',
            priority=0.8,
        ))
    # 每篇文章同理以字典的形式存入
    for post in Post.query.all():
        url = post.link
        modified_time = post.modified_time.date().isoformat()
        urlset.append(dict(
            loc=url,
            lastmod=modified_time,
            changefreq='monthly',
            priority=0.5,
        ))

    sitemap_xml = render_template('sitemap.xml', urlset=urlset) # jijia2同样支持xml形式。
    res = make_response(sitemap_xml)
    res.headers['Content-type'] = 'application/xml; charset=utf-8' # 注意设置头信息为xml。
    return res

import db,Post
import app # flask应用实例
from flask_admin import Admin 
from flask_admin.contrib.sqla import ModelView

class PostAdmin(ModelView):
    pass
 
admin = Admin(name="xx")
admin.init_app(app)
# 以下进行view的注册。
admin.add_view(PostAdmin(Post, db.session, name='文章'))

class PostAdmin(ModelView):

    # 是否允许创建/编辑/删除Post实例
    can_create = True
    can_edit = True
    can_delete = True

    # 防止csrf攻击，设置默认Form
    from_base_class = SecureForm

    # 设置哪些列可以呈现/被搜索/可直接编辑/可筛选
    column_list = ('title','category','pub_time','published')
    column_searchable_list = ('title',)
    column_editable_list = ('title','slug')
    column_filters = ('category',)

    # 设置查看的权限，如果没有设置可能会导致后台泄露
    def is_accessible(self):
        return current_user.is_administrator()

    # 指定当没有权限时会返回到哪个界面
    def inaccessible_callback(self, name, **kwargs):
        return redirect(url_for('main.index', page=1)'

from flask_assets import Bundle, Environment
from webassets.filter import get_filter

# 用字典接收多个实例
# 其中filters是分别有jsmin和cssmin，需要使用pip来安装
# output 是输出文件位置，相对与static 文件夹而言
bundles ={
    'all_js': Bundle(
        'js/jquery-2.1.4.min.js',
        'vendor/semantic/dist/semantic.min.js',
        filters='jsmin',
        output='js/all.min.js'),

    'all_css': Bundle(
        'vendor/semantic/dist/semantic.min.css',
        filters='cssmin',
        output='css/all.min.css'),
}
def init_app(app):
    webassets =Environment(app)
    webassets.register(bundles)

# 初始化，app是一个flask实例
import flask_whooshalchemyplus
flask_whooshalchemyplus.init_app(app)
# 设置生成索引的位置
WHOOSH_BASE = os.path.join(somedir,'search.db') 
# 在文章类处指定可以被搜索字段
class Post(db.Model):
    __searchable__= ['body','title','slug']
    ......
# 手动生成索引
from flask_whooshalchemyplus import whoosh_index
whoosh_index(app,Post)
# 最终就可以用下面的方法进行全文搜索，query是一个关键词
posts = Post.query.whoosh_search(query).all()

from jieba.analyse import ChineseAnalyzer
class Post(db.Model):
    __analyzer__=ChineseAnalyzer()
    ......

# 定义表单
class SearchForm(Form):
    search = StringField('Search',validators=[Required()])

# 在请求发生前把表单赋给g
@main.before_app_request
def before_request():
    g.search_form = SearchForm()

# 接收搜索结果的视图函数
@main.route('/search_results',methods=['GET','POST'])
def search_results(**kw):
    query=g.search_form.search.data # 这里获取搜索框的内容
    results = Post.query.whoosh_search(query).all()
    return render_template('search.html',query=query,results=results)

from werkzeug.contrib.atom import AtomFeed
# 访问feed就能获取xml
@main.route('/feed/')
def feed():
    site_name = 'Lonely Code'

    feed = AtomFeed(
        "%s Recent" % site_name,
        feed_url=request.url,
        url=request.url_root,
    )

    posts = Post.query.order_by(Post.pub_time.desc()).limit(15).all()

    for post in posts:
        feed.add(post.title,
                 url=post.link,
                 content_type='html',
                 content=post.body_html,
                 updated=post.modified_time,
                 published=post.pub_time,
                 author=post.author.username,
                 summary=post.summary or '')
    return feed.get_response()

# paginate 接收三个参数，分别为当前的页数，每页有多少个item，当找不到的当前页的时候是否要选择抛出404错误。
    posts = Post.query.order_by(Post.pub_time.desc()).paginate(page,10,False)