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