def statistic_function():
csrf = CsrfProtect()
csrf.init_app(app) #fixing the post request problem: csrf is missing!
query = []
bookMaker = []
query = takeMatchID()
bookMaker = takeBookmaker()
return render_template('statistics.html', query=query, bookMaker=bookMaker)
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)
# 设置session保存指定位置
Session(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, url_prefix='/passport')
# 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():
app = Flask(__name__, static_folder='public')
CsrfProtect(app)
env = os.environ.get('TOGETHER_ENV', 'dev')
app.config.from_object('together.settings.{}Config'.format(
env.capitalize()))
app.config['ENV'] = env
from together.models import db, migrate, login_manager
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
from together.meta import meta
app.register_blueprint(meta, url_prefix='/')
from together.api import api, json_user
api.init_app(app)
app.context_processor(json_user)
from together.assets import assets_env
assets_env.init_app(app)
return app
def _register_extensions(app):
db.init_app(app)
sec.init_app(app)
mail.init_app(app)
toolbar = DebugToolbarExtension(app)
CsrfProtect(app)
Funnel(app)
def create_app(testing=False):
app = Flask(__name__)
try:
app.config.from_object('config')
except:
app.config.from_object('configdist')
if testing:
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.json_encoder = ExtensibleJSONEncoder
app.secret_key = app.config['SECRET_KEY']
app.register_blueprint(user_bp)
csrf = CsrfProtect()
csrf.init_app(app)
# Initialize login manager
login_manager.init_app(app)
# Assets bundles: js, jsx, css
env = Environment(app)
root = os.path.dirname(os.path.abspath(__file__)) + '/../'
env.load_path = [
root + 'node_modules',
root + 'client/style'
]
env.register('css', css)
@app.teardown_appcontext
def shutdown_session(response):
database.session.remove()
@app.route('/')
@app.route('/<path:path>')
def index(path=None):
"""Main route for the single page app"""
data = dict(
user=anonymous_user_data,
alerts=[]
)
if current_user.is_authenticated():
data['user'] = current_user
return render_template('index.html', app_data=dumps(data))
return app
def create_app(instance_path=None, debug=False, test=False):
use_instances = False
if instance_path is not None:
use_instances = True
app = Flask(__name__,
instance_relative_config=use_instances,
instance_path=instance_path,
template_folder="views",
static_path='/static',
static_url_path='/static')
app.debug = debug
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
app.config.from_object('app.config')
app.config.from_pyfile('config.py')
if not test:
CsrfProtect(app)
assets = Environment(app)
css_bundle = Bundle('less/main.less',
output='css/main.css',
filters='less')
assets.register('css', css_bundle)
js_bundle = Bundle('js/main.js', output="main.min.js", filters="rjsmin")
assets.register('js', js_bundle)
email = FlaskMailgunMessage(app)
@app.route('/', methods=['GET', 'POST'])
def index():
form = ApplicationForm()
if form.validate_on_submit():
if form.squirrel.data:
# ANTI SPAM YO
app.logger.info('SECRET SQUIRREL')
return redirect(url_for('index'))
form_data = "name: {}\nemail: {}\nphone: {}\n\n".format(
form.name.data, form.email.data, form.phone.data)
app.logger.info(form_data)
# send the email
email.send(form_data)
flash(app.config['THANKS_FLASH'])
return redirect(url_for('index'))
return render_template('index.jade', form=form)
return app
def get_app(name):
csrf = CsrfProtect()
app = Flask(name)
# todo: make in an env var
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'app.db')
app.config['SECRET_KEY'] = key
app.config['WTF_CSRF_SECRET_KEY'] = key
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = email
app.config['MAIL_PASSWORD'] = password
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
app.config['PROPAGATE_EXCEPTIONS'] = True
app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024 * 1024
db = SQLAlchemy(app)
csrf.init_app(app)
return db, app
def init_app():
CsrfProtect(app)
toolbar = DebugToolbarExtension(app)
app.jinja_env.lstrip_blocks = True
app.jinja_env.trim_blocks = True
# webassets
assets_env = Environment(app)
# Import a module / component using its blueprint handler variable (mod_auth)
# from app.mod_auth.controllers import mod_auth as auth_module
# Register blueprint(s)
app.register_blueprint(university)
def create_app(config_name=None):
from .views import web
from .apiv1 import apiv1
app = Flask(DEFAULT_APP_NAME)
app.register_blueprint(web)
app.register_blueprint(apiv1, url_prefix='/api/v1')
app.config.from_object('venus.settings')
if config_name:
app.config.from_pyfile(config_name)
csrf_protect = CsrfProtect(app)
restapi.init_app(app)
restapi.decorators = [csrf_protect.exempt]
db.init_app(app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object(config)
#set server-side session if redis is valid
if utilRedis.isValid():
app.session_interface = RedisSessionInterface(
redis=utilRedis.redis_client)
# csrf ajax
CsrfProtect(app)
db.init_app(app)
babel.init_app(app)
moment.init_app(app)
cache.init_app(app)
mail.init_app(app)
return app
def create_app(config=None):
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
Gemoji.init_app(app)
themes.init_themes(app)
configure_modules(app)
config_error_handlers(app)
configure_flasklogin(app)
config_before_request(app)
# configure_uploads(app, (photos, ))
patch_request_class(app) # 16M limit
CsrfProtect(app)
configure_identity(app)
return app
def create_app():
app = Flask(__name__, static_folder='public')
app.environment = os.getenv('NEWAUTH_ENV', 'Dev')
if app.environment != 'Test':
CsrfProtect(app)
app.config.from_object('newauth.settings.{}Config'.format(app.environment))
from newauth.models import db, migrate, Message, redis, login_manager
from newauth.models.enums import CharacterStatus, GroupType
db.init_app(app)
migrate.init_app(app, db)
redis.init_app(app)
login_manager.init_app(app)
from newauth.blueprints import AccountView, RegisterView, GroupsView
AccountView.register(app)
RegisterView.register(app)
GroupsView.register(app)
from newauth.assets import assets_env
assets_env.init_app(app)
from newauth.utils import humanize, format_datetime, pluralize
app.jinja_env.filters['humanize'] = humanize
app.jinja_env.filters['format_datetime'] = format_datetime
app.jinja_env.filters['pluralize'] = pluralize
app.jinja_env.globals['GroupType'] = GroupType
# Initialize NewAuth plugins
from newauth.plugins.sync.ldap import LDAPSync
LDAPSync(app)
@app.context_processor
def inject_globals():
return {
'Message': Message,
'CharacterStatus': CharacterStatus,
'GroupType': GroupType
}
return app
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
# flask_sqlalchemy
# import ipdb; ipdb.set_trace()
db.init_app(app)
# flask_redis
redis_cli.init_app(app)
# flask_migrate
Migrate(app, db)
# flask_debug
if app.config.get('DEBUG'):
DebugToolbarExtension(app)
# flask_login
login_manager = LoginManager(app)
login_manager.user_loader(load_user)
login_manager.login_view = 'user_view.login'
# flask_principal
Principal(app)
identity_loaded.connect_via(app)(_on_identity_loaded)
# flask_wtf csrf
csrf = CsrfProtect()
csrf.init_app(app)
app.before_request(check_csrf(csrf))
# flask_babel
Babel(app)
# flask_limiter
limiter.init_app(app)
# flask_qiniu
qiniu.init_app(app)
# flask_admin
admin.init_app(app)
# register blueprint
app.register_blueprint(content_bp)
app.register_blueprint(user_bp)
app.register_blueprint(user_api_bp)
# import ipdb; ipdb.set_trace()
app.register_blueprint(book_bp)
app.register_blueprint(book_api_bp)
app.register_blueprint(user_util_api_bp)
app.register_blueprint(media_bp)
app.register_blueprint(online_course_bp)
# register subscriber
user_connect(app)
# register home page
app.add_url_rule('/', 'index', index)
with open(os.path.join(os.getcwd(), 'youjiao/static/assets.json.py'), 'r') as assets:
app.assets = json.load(assets)
return app
from flask import Flask
from flask_wtf import CsrfProtect
csrf = CsrfProtect()
app = Flask(__name__)
#app.config.from_object('settings_for_testing')
app.config.from_object('settings')
csrf.init_app(app)
import views
def create_app():
app = Flask(__name__)
app.config.from_object(youjiao_config)
# flask_sqlalchemy
# import ipdb; ipdb.set_trace()
db.init_app(app)
# flask_redis
redis_cli.init_app(app)
# flask_debug
if app.config.get('DEBUG'):
DebugToolbarExtension(app)
# flask_login
login_manager.user_loader(load_user)
login_manager.login_view = 'user_view.login'
login_manager.init_app(app)
# flask_jwt
jwt.init_app(app)
# flask_principal
Principal(app)
identity_loaded.connect_via(app)(_on_identity_loaded)
# flask_wtf csrf
csrf = CsrfProtect()
csrf.init_app(app)
app.before_request(check_csrf(csrf))
# flask_babel
Babel(app)
# flask_limiter
limiter.init_app(app)
# flask_qiniu
flask_qiniu.init_app(app)
# flask_admin
admin.init_app(app)
# register blueprint
app.register_blueprint(content_bp)
app.register_blueprint(user_bp)
app.register_blueprint(user_api_bp)
# import ipdb; ipdb.set_trace()
app.register_blueprint(book_bp)
app.register_blueprint(book_api_bp)
app.register_blueprint(user_util_api_bp)
app.register_blueprint(media_bp)
app.register_blueprint(online_course_bp)
# register subscriber
user_connect(app)
# register home page
app.add_url_rule('/', 'index', index)
with open(os.path.join(os.getcwd(), 'youjiao/static/assets.json.py'),
'r') as assets:
app.assets = json.load(assets)
return app
'''
Created on Dec 30, 2014
@author: lenovo
'''
from flask import Flask
from flask_mongoengine import MongoEngine
from flask_wtf import CsrfProtect
from celery import Celery
DEFAULT_APP_NAME = 'venuscms'
dbs = MongoEngine()
app = Flask(DEFAULT_APP_NAME)
#celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
#celery.conf.update(app.config)
csrf_protect = CsrfProtect(app)
app.config.from_object('cms.settings')
from flask_heroku import Heroku
from flask_wtf import CsrfProtect
from .views.site import site
__title__ = 'ExplainToMe'
__license__ = 'Apache Software License Version 2.0'
app = Flask(__name__)
app.register_blueprint(site)
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY',
'v8iqZjndP7dtZuqnkttGgqlszSEDWnI8')
app.config.from_object(os.getenv('APP_SETTINGS',
'config.DevelopmentConfig'))
@app.template_filter()
def datetimefilter(value, format='%Y/%m/%d %H:%M'):
p = parser()
dt = p.parse(value)
return dt.strftime(format)
app.jinja_env.filters['datetimefilter'] = datetimefilter
cors = CORS(app)
bootstrap = Bootstrap(app)
heroku = Heroku(app)
csrfprotect = CsrfProtect(app)
from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from flask_login import LoginManager
from flask_wtf import CsrfProtect
app = Flask(__name__)
app.config.from_object(
'config') #Aplicar configurações feitas no arquivo (sem o .py)
db = SQLAlchemy(app)
migrate = Migrate(app, db) #Responsável pelas alterações realizadas no db
manager = Manager(app)
manager.add_command(
'db',
MigrateCommand) #Responsável pelos comandos que vou dar para a aplicação
loginManager = LoginManager()
loginManager.init_app(app)
csfr = CsrfProtect(app)
from app.models import tables
from app.controllers import routes
import os
from flask import Flask, session, render_template, redirect, url_for
from flask_dance.consumer import oauth_authorized
from flask_dance.contrib.google import make_google_blueprint, google
from werkzeug.utils import secure_filename
from flask_wtf import CsrfProtect
from form_classes import CatInformation
from google_sheets import find_permission, input_data, return_database
import config
CSRF = CsrfProtect()
# Don't warn when Google changes scope on us
os.environ["OAUTHLIB_RELAX_TOKEN_SCOPE"] = "1"
GOOGLE_CLIENT_ID = config.OAUTH_CONFIG['GOOGLE_CLIENT_ID']
GOOGLE_CLIENT_SECRET = config.OAUTH_CONFIG['GOOGLE_CLIENT_SECRET']
STATIC_URL_PATH = '/static'
APP = Flask(__name__, static_url_path=STATIC_URL_PATH)
APP.config['SECRET_KEY'] = 'cats'
GOOGLE_BP = make_google_blueprint(
client_id=GOOGLE_CLIENT_ID,
client_secret=GOOGLE_CLIENT_SECRET,
scope=["https://www.googleapis.com/auth/userinfo.email"],
authorized_url='/oauth2callback'
)
APP.register_blueprint(GOOGLE_BP)
@oauth_authorized.connect_via(GOOGLE_BP)
''' Example working with sessions. '''
from flask import Flask
from flask import render_template as rt
from flask import request
from flask import make_response
from flask import session
from flask import redirect
from flask import url_for
from flask_wtf import CsrfProtect
import forms
app = Flask(__name__)
app.secret_key = 'my_secret_key'
csrf = CsrfProtect(app)
@app.route('/')
def index():
custom_cookie = request.cookies.get('custom_cookie', 'Undefined')
print(custom_cookie)
if 'username' in session:
username = session['username']
print(username)
my_title = 'Flask Curse'
return rt('index_form.html', title=my_title)
@app.route('/comment', methods=['GET', 'POST'])
def comment():
my_comment_form = forms.CommentForm(request.form)
if request.method == 'POST' and my_comment_form.validate():
print('Username: {}\nE-mail: {}\nComment: {}'.format(
# -*- coding: utf-8 -*-
from flask import Flask
from promua_test_app.views import *
from flask_wtf import CsrfProtect
import __config as config
app = Flask(__name__)
# configure app
app.config.from_object(config)
# setup extensions
csrf_protect = CsrfProtect()
# init extensions
csrf_protect.init_app(app)
login_manager.init_app(app)
# setup static and templates
app.template_folder = "promua_test_app/templates"
app.static_folder = "promua_test_app/static"
# register handlers
app.before_request(before_request)
app.teardown_appcontext(teardown_app_context)
# register views
IndexView.register(app)
UserView.register(app)
if __name__ == '__main__':
app.run()
def create_app(config=None):
"""Create the Flask app instance that is used throughout the application.
Args:
config: Path to configuration file as a string or an object with config
directives.
Returns:
Application object (instance of flask.Flask).
"""
# Setup the Flask app and load the config.
app = Flask(
__name__, template_folder=u'ui/templates', static_folder=u'ui/static')
if not config:
config = u'/etc/timesketch.conf'
if isinstance(config, unicode):
os.environ[u'TIMESKETCH_SETTINGS'] = config
try:
app.config.from_envvar(u'TIMESKETCH_SETTINGS')
except IOError:
sys.stderr.write(
u'Config file {0} does not exist.\n'.format(config))
sys.exit()
else:
app.config.from_object(config)
# Make sure that SECRET_KEY is configured.
if not app.config[u'SECRET_KEY']:
sys.stderr.write(u'ERROR: Secret key not present. '
u'Please update your configuration.\n'
u'To generate a key you can use openssl:\n\n'
u'$ openssl rand -base64 32\n\n')
sys.exit()
# Setup the database.
configure_engine(app.config[u'SQLALCHEMY_DATABASE_URI'])
db = init_db()
# Alembic migration support:
# http://alembic.zzzcomputing.com/en/latest/
migrate = Migrate()
migrate.init_app(app, db)
# Register blueprints. Blueprints are a way to organize your Flask
# Flask application. See this for more information:
# http://flask.pocoo.org/docs/latest/blueprints/
app.register_blueprint(user_views)
app.register_blueprint(home_views)
app.register_blueprint(sketch_views)
app.register_blueprint(story_views)
# Setup URL routes for the API.
api_v1 = Api(app, prefix=u'/api/v1')
api_v1.add_resource(SketchListResource, u'/sketches/')
api_v1.add_resource(SketchResource, u'/sketches/<int:sketch_id>/')
api_v1.add_resource(
AggregationResource, u'/sketches/<int:sketch_id>/aggregation/')
api_v1.add_resource(ExploreResource, u'/sketches/<int:sketch_id>/explore/')
api_v1.add_resource(EventResource, u'/sketches/<int:sketch_id>/event/')
api_v1.add_resource(
EventAnnotationResource, u'/sketches/<int:sketch_id>/event/annotate/')
api_v1.add_resource(ViewListResource, u'/sketches/<int:sketch_id>/views/')
api_v1.add_resource(
ViewResource, u'/sketches/<int:sketch_id>/views/<int:view_id>/')
api_v1.add_resource(UploadFileResource, u'/upload/')
api_v1.add_resource(TaskResource, u'/tasks/')
api_v1.add_resource(
StoryListResource, u'/sketches/<int:sketch_id>/stories/')
api_v1.add_resource(
StoryResource, u'/sketches/<int:sketch_id>/stories/<int:story_id>/')
# Register error handlers
# pylint: disable=unused-variable
@app.errorhandler(ApiHTTPError)
def handle_api_http_error(error):
"""Error handler for API HTTP errors.
Returns:
HTTP response object (instance of flask.wrappers.Response)
"""
return error.build_response()
# Setup the login manager.
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = u'user_views.login'
# This is used by the flask_login extension.
# pylint: disable=unused-variable
@login_manager.user_loader
def load_user(user_id):
"""Based on a user_id (database primary key for a user) this function
loads a user from the database. It is used by the Flask-Login extension
to setup up the session for the user.
Args:
user_id: Integer primary key for the user.
Returns:
A user object (Instance of timesketch.models.user.User).
"""
return User.query.get(user_id)
# Setup CSRF protection for the whole application
CsrfProtect(app)
return app
from flask import Flask
from flask_wtf import CsrfProtect
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config.DevelopmentConfig')
app.config.from_pyfile('config.py')
db = SQLAlchemy(app) # Inicializando el Database handler SQLAlchemy
csrf = CsrfProtect(app) # Creando una instancia para CSRF para mi formulario
from app import views
# coding:utf-8
from flask import Flask, request
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, current_user
from config import config
from flask_babel import Babel
from flask_wtf import CsrfProtect
babel = Babel() # 全球化
bootstrap = Bootstrap() # 模板继承和装饰
db = SQLAlchemy() # 数据库
crsf = CsrfProtect()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'author.login'
# 指定login页面
def create_app(config_name='default'):
app = Flask(__name__)
app.config.from_object(config[config_name])
babel.init_app(app)
db.init_app(app)
bootstrap.init_app(app)
login_manager.init_app(app)
crsf.init_app(app)
from author import author as author_blueprint
""" The module used to define various forms """
from datetime import datetime
from flask_wtf import CsrfProtect, Form
from wtforms import StringField, validators, HiddenField
from tweeter import application
from flask import flash
CsrfProtect(application)
class AddKeyWordForm(Form):
"""Add new keyword"""
streams = StringField('KeyWord', validators=[validators.Required()])
class EditKeyWordForm(AddKeyWordForm):
"""Edits the keywords"""
id = HiddenField("keyword_id", validators=[validators.Optional()])
class StatisticsForm(EditKeyWordForm):
"""To get the statistics of a keyword"""
from_time = StringField('From Time', validators=[validators.Required()])
to_time = StringField('To Time', validators=[validators.Required()])
def validate(self):
try:
f_time = datetime.strptime(self.from_time.data, "%H:%M")
t_time = datetime.strptime(self.to_time.data, "%H:%M")
if not f_time < t_time:
flash("Error: The From time and To time is in wrong order")
from flask_login import LoginManager
from flask_bcrypt import Bcrypt
from flask_restful import Api
from flask_wtf import CsrfProtect
login_manager = LoginManager()
bcrypt = Bcrypt()
csrf_protect = CsrfProtect()
api = Api()
def init_extensions(app):
# password encryption
bcrypt.init_app(app)
# flask-login
login_manager.init_app(app)
login_manager.login_view = "auth.login"
# csrf protection
csrf_protect.init_app(app)
# api
api.decorators = [csrf_protect.exempt]
api.init_app(app)
@login_manager.user_loader
def load_user(user_id):
from .auth.models import User
from flask import Flask, render_template, flash, request, redirect, url_for
import redis
from flask_wtf import FlaskForm, CsrfProtect
from wtforms import *
from flask_zurb_foundation import Foundation
from flask_classy import FlaskView, route
app = Flask(__name__)
Foundation(app)
app.config['SECRET_KEY'] = 'redis_app'
csrf = CsrfProtect()
csrf.init_app(app)
r = redis.StrictRedis(host='127.0.0.1',
port=6379,
db=0,
charset="utf-8",
decode_responses=True)
class QuestionForm(FlaskForm):
title = StringField('Title Question')
question = TextAreaField('Question')
author = StringField('Author Name')
submit = SubmitField(' ')
class ApplicationViews(FlaskView):
route_base = '/'
@route('/', methods=['GET', 'POST'])
from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from flask_wtf import CsrfProtect
import forms
app = Flask(__name__)
app.secret_key = 'my_secret_key'
crsf = CsrfProtect(app)
@app.route('/', methods=['GET', 'POST'])
def index():
custom_cookie = request.cookies.get('customer_cookie', 'Undefined')
print(custom_cookie)
title = 'Index'
return render_template('index.html', title=title)
@app.route('/login')
def login():
login_form = forms.LoginForm()
return render_template('login_form.html.j2', form=login_form)
@app.route('/cookie')
def cookie():
response = make_response(render_template('cookie.html.j2'))
response.set_cookie('customer_cookie', 'Fede')
from helper import date_format
#Aqui esteas dos es para el enviar mensajes al correo electronico pero no me funciona porque ay q configurarlo bn
#AQUI REVISAR LAS CONFIGURACIONES BN PARA Q EJECUTE
from flask_mail import Mail
from flask_mail import Message
from models import db #Aqui importamos nuestra conexion
from models import User #Aqui importamos el modelo User
from models import Comment #Aqui importamos el model Comment
app = Flask(__name__)
#Aqui con app.config.from_object() vamos a ser q nuestro servidor tenga esta configuraciones
app.config.from_object(DevelopmentConfig)
csrf = CsrfProtect(
) #Y aqui le decimos q nuestros csrf este en nuestra aplicacion pero no le pasamos nuestra varible de aplicacion
mail = Mail() #Aqui creamos una instancia de la clase Mail
#Aqui con el decorrador errorhandler() va a ser el q nos indentifique los errores en este caso el 404
@app.errorhandler(404)
def page_not_found(error): #Esta funcion resive como parametro un error
#Aqui sencillamente retornamos a una html sencillo y despues le pasamos y eh indicamos a python el tipo de error q ocurrio
return render_template("404.html"), 404
#Aqui sencillamente esta funcion se va a ejecutar siempre oosea de primer lugar antes q se ejecute otra funcion
@app.before_request
def before_request():
#Aqui sencillamente vemos si no ay una session y comprobamos si la ruta expecificado es a la q se accede
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_assets import Environment
from flask_wtf import CsrfProtect
from flask_compress import Compress
from flask_rq import RQ
from config import config
from app.assets import app_css, app_js, vendor_css, vendor_js
basedir = os.path.abspath(os.path.dirname(__file__))
mail = Mail()
db = SQLAlchemy()
csrf = CsrfProtect()
compress = Compress()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'account.login'
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
config[config_name].init_app(app)
mail.init_app(app)
from flask import render_template
from flask_wtf import CsrfProtect # injections protect with token
from flask import make_response # this type of response allow us setting cookies
from flask import session # we can save session data
from flask import url_for
from flask import redirect
# import forms.py
import forms
import loginform
# instance a flask app named app, with __name__ and te folder views for templates as parameters
app = Flask(__name__, template_folder='views')
app.secret_key = 'my_secret_key_app' # key of token
Csrf = CsrfProtect(app) # protect app
# root can with get parameter get1 as parameter of the template index
@app.route('/')
def index():
custom_cookie = request.cookies.get('custom_cookie', 'undefined')
print(custom_cookie)
get1 = request.args.get('get1', 'No name insert')
# this route implements forms for comments with a object comment_form
comment_form = forms.CommentForm()
return render_template('index.html', name=get1, form=comment_form)
# route param with sub route num which type is int, and default value 'no se ingreso num', parameter params and a
# string variable hola, the template receive them as parameter to can show them into view
from flask import Flask, render_template, redirect, url_for, flash, session
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from forms import UserForm, LoginForm
from flask_wtf import CsrfProtect
from flask_login import LoginManager, UserMixin, login_user, logout_user, login_required
import os
app = Flask(__name__)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"
CsrfProtect(app)
bcrypt = Bcrypt(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/flask_fishes'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SECRET_KEY"] = os.environ.get('SECRET')
db = SQLAlchemy(app)
#models
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text(), nullable=False, unique=True)
password = db.Column(db.Text(), nullable=False)
def create_app():
app = Flask(__name__, static_folder='public')
app.environment = os.getenv('WILLOW_ENV', 'Dev')
if app.environment != 'Test':
CsrfProtect(app)
app.config.from_object('willow.settings.{}Config'.format(app.environment))
from willow.models import db, user_datastore
from flask.ext.security import Security
from flask.ext.security.forms import RegisterForm
db.init_app(app)
Security(app, user_datastore, confirm_register_form=RegisterForm)
mail.init_app(app)
# import plugins
app.loaded_plugins = {}
app.admin_user_hooks = []
app.dashboard_hooks = []
app.character_hooks = []
app.navbar = {
'admin': [
(
'',
'Venue',
'admin.AdminVenueView:index',
),
(
'',
'Chapter',
'admin.AdminChapterView:index',
),
(
'',
'Roles',
'admin.AdminRoleView:index',
),
],
'extra': [
(
'',
'Character Generator',
'chargen.ChargenView:index',
),
],
}
for plugin in app.config['PLUGINS']:
imported_plugin = import_string(plugin)()
imported_plugin.init_app(app)
app.loaded_plugins[plugin] = imported_plugin
if imported_plugin.has_models:
with app.app_context():
for model in imported_plugin.model_names:
impmodel = import_string(model)
if not impmodel.__table__.exists(db.engine):
impmodel.__table__.create(db.engine)
from willow.assets import assets_env
assets_env.init_app(app)
# import blueprints
# Note that plugins should do this automatically,
# this is for internal blueprints.
from willow.blueprints import admin_blueprint, chargen_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(chargen_blueprint, url_prefix='/chargen')
# import naked views
from willow.views import DashboardView
DashboardView.register(app)
@app.route('/')
def home():
return render_template('willow/home.html')
@app.context_processor
def inject_globals():
return {
'hooks': {
'admin_user_hooks': app.admin_user_hooks,
'dashboard_hooks': app.dashboard_hooks
},
'navbar': app.navbar
}
@app.before_request
def check_session():
if session.get('ip') != request.remote_addr:
session.clear()
session['ip'] = request.remote_addr
flash('Session expired, please login.')
return redirect(url_for_security('login'))
@app.before_request
def check_profile():
user = session.get('id')
if user and user.is_authenticated():
if not user.profile:
return redirect(url_for('CreateProfileView:index'))
return app
