def create_app(config_name):
# 配置日志
setup_log(config_name)
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 初始化数据库
db.init_app(app)
# 初始化redis存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config["development"].REDIS_PORT,
decode_responses=True)
# 开启当前项目 CSRF 保护, 只做服务器验证功能
# 帮我们做了: 从cookie中取出随机值, 从表单中取出随机值, 然后进行校验, 并且响应校验结果
# 我们需要做: 1. 再界面加载的时候, 往cookie中添加一个csrf_token, 并且再表单中添加一个隐藏的csrf_token
CSRFProtect(app)
# 设置session保存位置
Session(app)
from info.utils.common import do_index_class
# 添加自定义过滤器 什么时候使用过滤器,什么时候导入上面的
app.add_template_filter(do_index_class, "index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(e):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
@app.after_request
def after_request(response):
# 生成随机的csrf_token值
csrf_token = generate_csrf()
# 设置一个cookie
response.set_cookie("csrf_token", csrf_token)
return response
# 注册蓝图
# 首页蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
# 注册图片验证码蓝图
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
# 新闻详情页蓝图
from info.modules.news import news_blu
app.register_blueprint(news_blu)
# 个人档案页蓝图
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
# 管理员登录页蓝图
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu)
return app
def get_app(config_name):
# 根据开发环境设置日志等级
setUpLogging(configs[config_name].LOGGING_LEVEL)
app = Flask(__name__)
app.config.from_object(configs[config_name])
db.init_app(app)
global redis_store
redis_store = redis.StrictRedis(host=configs[config_name].REDIS_HOST,
port=configs[config_name].REDIS_PORT)
CSRFProtect(app)
Session(app)
app.url_map.converters['re'] = RegexConverter
# 哪里注册蓝图就在哪里使用蓝图,避免某些变量还没存在就导入
from api_1_0 import api
app.register_blueprint(api, url_prefix='/api/1.0')
from web_html import html_blue
app.register_blueprint(html_blue)
return app
def create_app(config_name):
app = Flask(__name__)
config = Config_dict[config_name]
#调用日志方法
log_file(config.LEVEL)
app.config.from_object(config)
db.init_app(app)
global redis_store
redis_store = redis.StrictRedis(host=Config.REDIS_HOST,
port=Config.REDIS_PORT,
decode_responses=True)
Session(app)
#开启CSRF保护之后,会对[POST,'PUT','PATCH','DELETE]类型的请求方法做校验
#获取cookie中的csrfToken,获取headers请求头里的csrfToken做校验
#开发者需要手动设置cookie和headers中的csrfToken
#设置CSRF程序保护
CSRFProtect(app)
#首页蓝图注册app
from info.modules.index import index_blu
app.register_blueprint(index_blu)
#验证蓝图注册app
from info.modules.passport.views import passport_blu
app.register_blueprint(passport_blu)
#设置请求钩子afterrequest,每次请求完成之后,都会走该钩子装饰的方法
@app.after_request
def after_request(resp):
#由CSRFProtect提供的一个generate_csrf方法生成csrf_token
csrf_token = generate_csrf()
resp.set_cookie("csrf_token", csrf_token)
return resp
#将过滤器添加到模板过滤器当中
app.add_template_filter(do_index_filter, "index_filter")
return app
def creat_app(ms="ts"):
global db, rs
app = Flask(__name__)
app.config.from_object(zd[ms])
db = SQLAlchemy(app=app)
rs = StrictRedis(host=zd[ms].REDIS_HOST, port=zd[ms].REDIS_PORT)
Session(app=app)
app.add_template_filter(djpmglq, name='cssxz')
# print(zd[ms].DEBUG)
#scrf 开启
CSRFProtect(app)
from csh import models
#开启日志
setup_log()
# @app.errorhandler(404)
# def cwxd(e):
# return render_template('news/404.html')
@app.after_request
def szscrf(resp):
token = generate_csrf()
# session['field_name']=token
# resp.headers['X-CSRFToken'] = token
resp.set_cookie('X-CSRFToken', token)
return resp
# @app.after_request
# def after_request(response):
# from flask_wtf.csrf import generate_csrf
# token = generate_csrf()
#
# response.set_cookie('csrf_token', token)
#
# return response
return app, db
def creat_app(config_name):
# 配置日志,并且传入配置名字,以便能获取到指定配置所对应的日志等级
setup_log(config_name)
# 创建Flask对象
app = Flask(__name__)
# 1.加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 3.初始化 redis 存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST, port=config[config_name].REDIS_PORT,decode_responses=True)
# 4.开启当前项目的 CSRF 保护,只做服务器验证功能(所有的请求都会经过before_request请求勾子)
CSRFProtect(app)
# 5.设置session保存指定位置
Session(app)
# 添加自定义过滤器
from info.utils.common import do_index_class
app.add_template_filter(do_index_class ,"index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(e):
user = g.user
data = {"user" : user.to_dict() if user else None}
return render_template("news/404.html",data=data)
@app.after_request
def after_request(response):
# 生成随机的csrf_token的值
csrf_token = generate_csrf()
# 设置一个cookie
response.set_cookie("csrf_token",csrf_token)
return response
# 注册蓝图
# 什么时候用什么时候导入:index_blu(避免循环导入)
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu,url_prefix="/admin")
return app
def cread_info(ms='ts'):
app = Flask(__name__)
app.config.from_object(zd[ms])
# 初始化
db = SQLAlchemy(app=app)
rs = StrictRedis(host=zd[ms].REDIS_HOST, port=zd[ms].REDIS_PORT)
Session(app=app)
#scrf 开启
CSRFProtect(app)
setup_log(zd[ms]) #日志
return app, db
def create_app(config_name):
# 配置日志,并且传入配置名字，以便能获取到指定配置所对应的日志等级
setup_log(config_name)
# 创建Flask对象
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化 redis 存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启当前项目 CSRF 保护，只做服务器验证功能
# 帮我们做了：从cookie中取出随机值，从表单中取出随机，然后进行校验，并且响应校验结果
# 我们需要做：1. 在返回响应的时候，往cookie中添加一个csrf_token，2. 并且在表单中添加一个隐藏的csrf_token
# 而我们现在登录或者注册不是使用的表单，而是使用 ajax 请求，所以我们需要在 ajax 请求的时候带上 csrf_token 这个随机值就可以了
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
# 初始化数据库
# 在Flask很多扩展里面都可以先初始化扩展的对象，然后再去调用 init_app 方法去初始化
from info.utils.common import do_index_class
# 添加自定义过滤器
app.add_template_filter(do_index_class, "index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_fount(e):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
# 向cookie中设置csrf_token
@app.after_request
def after_request(response):
# 生成随机的csrf_token的值
csrf_token = generate_csrf()
# 设置一个cookie
response.set_cookie("csrf_token", csrf_token)
return response
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blue
app.register_blueprint(passport_blue)
return app
def create_app(config_name):
# 配置日志
setup_logging(config_name)
# 创建Flask对象
app = Flask(__name__)
# 加载项目配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化redis
global redis_sr
redis_sr = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启CSRF保护
CSRFProtect(app)
# 初始化session
Session(app)
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(err):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template("news/404.html", data=data)
@app.after_request
def after_request(response):
# 生成csrf_token并存储到cookie中
csrf_token = generate_csrf()
response.set_cookie("csrf_token", csrf_token)
return response
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu)
return app
def create_app(config_name):
setup_log(config_name)
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 帮我们做了：从cookie中取出随机值，从表单中取出随机，然后进行校验，并且响应校验结果
# 我们需要做：1. 在返回响应的时候，往cookie中添加一个csrf_token，2. 并且在表单中添加一个隐藏的csrf_token
# 而我们现在登录或者注册不是使用的表单，而是使用 ajax 请求，所以我们需要在 ajax 请求的时候带上 csrf_token 这个随机值就可以了
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(e):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template("news/404.html", data=data)
@app.after_request
def after_request(response):
# 生成随机的csrf_token的值
csrf_token = generate_csrf()
# 设置一个cookie
response.set_cookie("csrf_token", csrf_token)
return response
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu, url_prefix="/admin")
return app
def create_app(config):
# 配置日志
setup_log(config)
app = Flask(__name__)
app.config.from_object(config_dict[config])
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=constants.REDIS_HOST,
port=constants.REDIS_PORT,
decode_responses=True)
CSRFProtect(app)
Session(app)
return app
def create_app(config_name):
# 配置日志，并且传入配置名字，一边获取到指定配置所对应的日志等级
setup_log(config_name)
# 逻辑业务(需要哪些辅助工具)
app = Flask(__name__)
# 加载配置(从配置对象中加载)
app.config.from_object(config[config_name])
# 通过app初始化将app中的数据库参数传递到db里面
db.init_app(app)
# 初始化redis存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启当前项目CSRF保护，只做服务器验证功能
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
# 初始化数据库 在Flask很多扩展里面都可以先初始化扩展的对象，然后再去调用init_app方法去初始化
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_fount(e):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
@app.after_request
def after_request(response):
csrf_token = generate_csrf()
response.set_cookie("csrf_token", csrf_token)
return response
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu, url_prefix="/admin")
return app
def create_app(config_name):
setup_log(config_name)
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
CSRFProtect(app)
Session(app)
from info.utils.common import do_index_class
#添加自定义过滤器
app.add_template_filter(do_index_class, "index_class")
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(e):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
@app.after_request
def after_request(response):
# 调用函数生成 csrf_token
csrf_token = generate_csrf()
# 通过 cookie 将值传给前端
response.set_cookie("csrf_token", csrf_token)
return response
#注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu, url_prefix='/admin')
return app
def creat_app(config_name):
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化redis存储对象
redise_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT)
# 开启当前项目CSRF保护
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
return app
def create_app(config_name):
# setup_log(config_name)
app = Flask(__name__, )
app.config.from_object(config[config_name])
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
CSRFProtect(app)
# 帮我们做了， 从cookie中取出随机值，从表单中取出随机值，然后进行校验
# 但是没做表单和cookie中设置值 在响应中设置afert_response
# 所以我们需要在cookie中csrf_token, 在表单中加入隐藏标签
Session(app)
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
@app.after_request
def after_request(response):
csrf_token = generate_csrf()
response.set_cookie("csrf_token", csrf_token)
return response
# from info.utils.common import do_index_class
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import detail_blu
app.register_blueprint(detail_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu)
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def page_not_found(_):
user = g.user
data = {"user_info": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
return app
def create_app(config_name):
set_log(config_name)
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
global redis_stroe
redis_stroe = StrictRedis(host=config[config_name].REDIS_PORT,
port=config[config_name].REDIS_PORT,
decode_responses=True)
Session(app)
# csrf 保护 需要手动设置csrf_touken
CSRFProtect(app)
from .modules.index.views import index_blu
app.register_blueprint(index_blu)
return app
def create_app(class_name):
app = Flask(__name__)
config_class = config_maps.get(class_name)
app.config.from_object(config_class) # 数据库最先加载
db.init_app(app)
global redis_store
redis_store = redis.StrictRedis(host='127.0.0.1',
port=6379,
decode_responses=True)
Session(app)
CSRFProtect(app)
@app.after_request
def after_request(response):
csrf_token = generate_csrf()
response.set_cookie('csrf_token', csrf_token)
return response
@app.errorhandler(404)
@user_login_data
def page_not_found(_):
user = g.user
data = {'user_info': user.to_dict() if user else None}
return render_template('news/404.html', data=data)
from info.utils.common import do_index
# 添加一个模板过滤器
app.add_template_filter(do_index, 'indexClass')
from info.admin import admin_blue
app.register_blueprint(admin_blue)
from info.user import profile_blue
app.register_blueprint(profile_blue)
from info.index import index_blue
app.register_blueprint(index_blue) # 要注册方法.
from info.passport import passport_blue
app.register_blueprint(passport_blue) # 要注册方法.
from info.news import news_blue
app.register_blueprint(news_blue)
return app
def create_app(u_selected_config):
app = Flask(__name__)
set_up_log(u_selected_config)
app.config.from_object(seleceted_config[u_selected_config])
app.add_template_filter(do_index_class, "indexClass")
@app.after_request
def after_request(response):
# 调用函数生成 csrf_token
csrf_token = generate_csrf()
# 通过 cookie 将值传给前端
response.set_cookie("csrf_token", csrf_token)
return response
CSRFProtect(app)
Session(app)
db.init_app(app)
# db = SQLAlchemy(app)
# @app.errorhandler(404)
# @check_user
# def page_notfound(e):
# user=g.user
# data={
# 'user':user.to_dict()
# }
# return render_template('others/404.html',data=data)
global redis_store
redis_store = redis.StrictRedis(host=My_config.REDIS_HOST,
port=My_config.REDIS_PORT)
from info.moduls.index import index_
from info.moduls.passport import passport_
from info.moduls.news import news_blu
from info.moduls.profile import profile_blu
from info.moduls.admin import admin_blu
app.register_blueprint(profile_blu)
app.register_blueprint(index_)
app.register_blueprint(passport_)
app.register_blueprint(news_blu)
app.register_blueprint(admin_blu)
return app
def create_app(config_name):
app = Flask(__name__)
config = config_dict.get(config_name)
app.config.from_object(config)
db = SQLAlchemy(app, "db")
db.init_app(app)
global redis_store
redis_store = redis.StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT)
Session(app)
CSRFProtect(app)
app.url_map.converters["re"] = RegexConverter
from ihome.api_1_0 import api
app.register_blueprint(api)
from ihome.web_html import web_html
app.register_blueprint(web_html)
return app
def create_app(config_name):
# 配置日志
setup_log(config_name)
# 创建flsk对象
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化redis存储对象
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT)
# 开启当前项目csrf保护，只做服务器验证功能
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
# 注册蓝图
app.register_blueprint(index_blu)
return app
def creat_app(config_name):
# 配置日志, 并且传入配置名字, 以便能获取到指定配置所对应的日志等级
setup_log(config_name)
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
# 用来存储redis数据
global redis_store
redis_store = redis.StrictRedis(host=config[config_name].REDIS_HOST, port=config[config_name].REDIS_PORT)
# 配置CSRF
CSRFProtect(app)
Session(app)
# 注册蓝图
app.register_blueprint(index_blu)
return app
def create_app(config_name):
# 配置日志,并且传入配置名字，以便能获取到指定配置所对应的日志等级
setup_log(config_name)
# 创建Flask对象
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化 redis 存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启当前项目 CSRF 保护，只做服务器验证功能
# CSRFProtect(app)
# 帮我们做了：从cookie中取出随机值，从表单中取出随机，然后进行校验，并且响应校验结果
# 我们需要做：1. 在返回响应的时候，往cookie中添加一个csrf_token，2. 并且在表单中添加一个隐藏的csrf_token
# 而我们现在登录或者注册不是使用的表单，而是使用 ajax 请求，所以我们需要在 ajax 请求的时候带上 csrf_token 这个随机值就可以了
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
@app.after_request
def after_request(response):
# 生成随机的csrf_token的值
csrf_token = generate_csrf()
# 设置一个cookie
response.set_cookie("csrf_token", csrf_token)
return response
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
return app
def create_app(config_name):
# 配置日志，并且传入配置名字，以便能获取到指定配置锁对应的日志等级
setup_log(config_name)
# 创建flask对象
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初试化
db.init_app(app)
# 初始化redis存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT)
# 开启当前项目 CSRF 保护，只做服务器验证功能
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
# 注册蓝图
from day02.info.modules.views import index_blu
app.register_blueprint(index_blu)
return app
def create_app(config_name):
setup_log(config_name)
"""通过传入不同的配置名字，初始化其对应配置的应用实例"""
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT)
CSRFProtect(app)
Session(app)
from info.modules.index import index_blu
app.register_blueprint(index_blu)
return app
def create_app(env_name):
app = Flask(__name__)
# 使用db,关联app
db.init_app(app)
# 加载配置信息
config = config_dict[env_name]
app.config.from_object(config)
# 创建redis对象
global redis_store
redis_store = redis.StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT, decode_responses=True)
# 设置csrf对app进行保护
CSRFProtect(app)
# 初始化Session
Session(app)
return app
def Create_app(config):
app = Flask(__name__)
# 配置app
app.config.from_object(config)
db.init_app(app)
# 注册蓝图
app.register_blueprint(views_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(admin_blueprint)
CSRFProtect(app)
Session(app)
import logging
from logging.handlers import RotatingFileHandler
# 设置日志的记录等级
logging.basicConfig(level=logging.DEBUG) # 调试debug级
# 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
file_log_handler = RotatingFileHandler(config.BASE_DIR + "/logs/xjzx.log",
maxBytes=1024 * 1024 * 100,
backupCount=10)
# 创建日志记录的格式 日志等级 输入日志信息的文件名 行数 日志信息
formatter = logging.Formatter(
'%(levelname)s %(filename)s:%(lineno)d %(message)s')
# 为刚创建的日志记录器设置日志记录格式
file_log_handler.setFormatter(formatter)
# 为全局的日志工具对象（flask app使用的）添加日志记录器
logging.getLogger().addHandler(file_log_handler)
app.logger_xjzx = logging
# 配置redis
host, port, redis_db = app.config.get('REDIS_HOST'), app.config.get(
'REDIS_PORT'), app.config.get('REDIS_DB')
app.redis_client = redis.StrictRedis(host=host, port=port, db=redis_db)
# 处理404错误
@app.errorhandler(404)
def e404(e):
return render_template('news/404.html')
return app
def create_app(config_name):
setup_log(config_name)
app = Flask(__name__)
app.config.from_object(config[config_name])
# db = SQLAlchemy(app)
db.init_app(app)
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启csrf保护,已经做了校验功能
CSRFProtect(app)
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
@app.after_request
def after_request(response):
csrf_token = generate_csrf()
response.set_cookie("csrf_token", csrf_token)
return response
# 在app注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
from info.modules.news import news_blu
app.register_blueprint(news_blu)
from info.modules.profile import profile_blu
app.register_blueprint(profile_blu)
from info.modules.admin import admin_blu
app.register_blueprint(admin_blu)
# 设置session保存位置
Session(app)
return app
def get_app(config_name):
app = Flask(__name__)
# 加载配置参数
app.config.from_object(configs[config_name])
# 创建链接到mysql数据库的对象
# db = SQLAlchemy(app)
# 第二步：建立app与mysql的连接
db.init_app(app)
# 创建连接到redis数据库的对象
redis_store = redis.StrictRedis(host=configs[config_name].REDIS_HOST,
port=configs[config_name].REDIS_PORT)
# 开启CSRF保护:flask需要自己讲csrf_token写入到浏览器的cookie
CSRFProtect(app)
# 使用flask_session将session数据写入到redis数据库
Session(app)
return app
def create_app(config_name):
"""通过传入不同的配置名字，初始化其对应配置的应用实例"""
setup_log(config_name) # 配置项目日志
app = Flask(__name__)
app.config.from_object(config[config_name]) # 配置，是config.py文件中的字典config
db.init_app(app) # 配置数据库
global redis_store
redis_store = redis.StrictRedis(
host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT) # 配置redis
CSRFProtect(app) # 开启csrf保护
Session(app) # 设置session保存位置
# 注册蓝图
from info.modules.index import index_blu
app.register_blueprint(index_blu)
# 注册passport蓝图
from info.modules.passport import passport_blu
app.register_blueprint(passport_blu)
return app
# 设置需要过期
SESSION_PERMANENT = False
# 设置过期时间
PERMANENT_SESSION_LIFETIME = 86400 * 2
app = Flask(__name__)
# 加载配置
app.config.from_object(Config)
# 初始化数据库
db = SQLAlchemy(app)
# 初始化redis存储对象
redis_store = StrictRedis(host=Config.REDIS_HOST, port=Config.REDIS_PORT)
# 开启当前项目CSRF保护,只做服务器验证功能
CSRFProtect(app)
# 设置session保存指定位置
Session(app)
manager = Manager(app)
@app.route('/')
def index():
session['name'] = 'itheima'
return 'hello world!333'
if __name__ == '__main__':
manager.run()
from flask.ext.session import Session
from flask.ext.wtf import CSRFProtect
from flask.ext.sqlalchemy import SQLAlchemy
from flask.helpers import make_response
from config import config_dict
from ihome.utils.commons import RegexConverter
db = SQLAlchemy()
#创建redis对象
redis_store = None
#创建csrf对象
csrf = CSRFProtect()
#log日志记录功能(产生一些文件专门用来记录调试,访问信息)
#使用log文件进行记录日志信息的时候,有四种级别
# debug < info < warn < error
# 设置日志的记录等级
logging.basicConfig(level=logging.DEBUG) # 调试debug级
# 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
file_log_handler = RotatingFileHandler("logs/log",
maxBytes=1024 * 1024 * 100,
backupCount=10)
# 创建日志记录的格式 日志等级 输入日志信息的文件名 行数 日志信息
formatter = logging.Formatter(
'%(levelname)s %(filename)s:%(lineno)d %(message)s')
# 为刚创建的日志记录器设置日志记录格式
