install_logging = True
logging.basicConfig(level=logging.NOTSET)
else:
install_logging = False
naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
db = SQLAlchemy(metadata=MetaData(naming_convention=naming_convention))
cache = Cache()
csrf = CsrfProtect()
migrate = Migrate()
manager = VersioningManager(options={'strategy': 'subquery'})
make_versioned(manager=manager, plugins=[FlaskPlugin()])
mail = Mail()
cdn = CDN()
login_manager = LoginManager()
assets = Environment()
toolbar = DebugToolbarExtension()
assets.register(
'css_main',
Bundle('css/main.scss',
output='gen/main-packed.css',
depends='css/*.scss',
filters='pyscss,cssmin'))
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
''' 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(
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)
'''
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')
# -*- coding: utf-8 -*-
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
# 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
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, 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)
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
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
""" 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 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 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_bootstrap import Bootstrap
from flask_wtf import Form, CsrfProtect
from acitoolkit.acitoolkitlib import Credentials
from acitoolkit.acisession import Session, CredentialsError
from requests import Timeout, ConnectionError
# Create application
from Forms import FeedbackForm, CredentialsForm, ResetForm
from aciConSearch import FlowSpec, SearchDb, ProtocolFilter
# start the flask application and tell it the static folder is called 'static'
app = Flask(__name__, static_folder='static')
# todo: need to validate the secrete key
app.config['SECRET_KEY'] = 'Dnit7qz7mfcP0YuelDrF8vLFvk0snhwP'
app.config['CSRF_ENABLED'] = True
CsrfProtect(app)
bootstrap = Bootstrap(app)
# Create the ACI Search Database
sdb = SearchDb()
class APICArgs(object):
"""
Class to hold the Arguments of the APIC
"""
def __init__(self, ipaddr, username, secure, password):
self.login = username
self.password = password
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
