def create_app(config_name):
app = Flask(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
config[config_name].init_app(app)
db.init_app(app)
ma.init_app(app)
jwt = JWTManager(app)
app.config['JWT_BLACKLIST_ENABLED'] = True
app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh']
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return RevokedToken.is_jti_blacklisted(jti)
from .api import api_blueprint
app.register_blueprint(api_blueprint)
@app.route('/')
def index():
return 'API Dock, a web application for managing and testing your APIs.'
return app
def create_app(config='production'):
app = Flask(__name__)
app.config.from_object(f'config.{configs[config]}')
app.config['JWT_SECRET_KEY'] = token_hex(16)
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = False
JWTManager(app)
db.init_app(app)
mg.init_app(app, db)
ma.init_app(app)
app.register_blueprint(bp_owner)
app.register_blueprint(bp_dogs)
app.register_blueprint(bp_home)
app.register_blueprint(bp_breed)
app.register_blueprint(bp_authorization)
app.register_blueprint(bp_message)
app.register_blueprint(bp_conversation)
app.register_blueprint(bp_like)
app.register_blueprint(bp_photo)
app.register_blueprint(bp_interest)
return app
def create_app(config='production'):
env = Env()
env.read_env()
app = Flask(__name__)
app.config.from_object(f'config.{configs[config]}')
JWTManager(app)
db.init_app(app)
mg.init_app(app, db)
ma.init_app(app)
app.register_blueprint(bp_owner)
app.register_blueprint(bp_dogs)
app.register_blueprint(bp_home)
app.register_blueprint(bp_breed)
app.register_blueprint(bp_authorization)
app.register_blueprint(bp_message)
app.register_blueprint(bp_conversation)
app.register_blueprint(bp_like)
app.register_blueprint(bp_photo)
app.register_blueprint(bp_interest)
return app
def create_app():
""" Initialize The Core Application """
# create app object
app = Flask(__name__)
# Environment configurations
APP_ROOT = os.path.join(os.path.dirname(__file__), "..")
dotenv_path = os.path.join(APP_ROOT, ".env")
load_dotenv(dotenv_path)
app.config.from_object('config.settings.' + os.environ.get('FLASK_ENV'))
# Initialize extensions
db.init_app(app)
ma.init_app(app)
api.init_app(app)
migrate.init_app(app, db)
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
gravatar.init_app(app)
jwt.init_app(app)
# Database
from app.models import users
from app.models.users import User
from app.models.posts import Post
with app.app_context():
# create DB tables
db.create_all()
db.session.commit()
# Small HTTP Error Handling
@app.errorhandler(404)
def not_found(error):
title = 'page not found'
return render_template('errors/404.html', title=title), 404
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
# Blueprints
# blueprint for non-auth parts of app
from app.views.home import home as home_blueprint
# blueprint for auth parts of app
from app.views.auth import auth as auth_blueprint
# Register Blueprints
app.register_blueprint(home_blueprint)
app.register_blueprint(auth_blueprint)
return app
def create_app(config_class=Config):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(config_class)
app.config.from_pyfile('config.py', silent=True)
from app.models import db, ma, migrate
db.init_app(app)
ma.init_app(app)
migrate.init_app(app, db)
from app.resources import api
api.init_app(app)
CORS(app)
return app
def create_app():
APP_ROOT = os.path.join(os.path.dirname(__file__), "..")
app = Flask(__name__, instance_path=os.path.join(APP_ROOT, "instance"))
# Environment configurations
APP_ROOT = os.path.join(os.path.dirname(__file__), "..")
dotenv_path = os.path.join(APP_ROOT, ".env")
load_dotenv(dotenv_path)
app.config.from_object('config.settings.' + os.environ.get('FLASK_ENV'))
# Initialize extensions
db.init_app(app)
ma.init_app(app)
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
migrate.init_app(app, db)
from app.models import Model
from app.models.Model import User, Task
with app.app_context():
# create DB tables
db.create_all()
# Small HTTP Error Handling
@app.errorhandler(404)
def not_found(error):
title = 'page not found'
return render_template('errors/404.html', title=title), 404
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
# blueprint for auth routes in our app
from app.views.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
# blueprint for non-auth parts of app
from app.views.home import home as home_blueprint
app.register_blueprint(home_blueprint)
# blueprint for tasks
from app.views.task import task as task_blueprint
app.register_blueprint(task_blueprint)
# blueprint for categories
from app.views.category import category as category_blueprint
app.register_blueprint(category_blueprint)
return app
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
from app.models import db, migrate, ma
db.init_app(app)
migrate.init_app(app, db)
ma.init_app(app)
from app.routes import api, cors
cors.init_app(app)
app.register_blueprint(api)
return app
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
# enter your email here
db.init_app(app)
ma.init_app(app)
mail.init_app(app)
with app.app_context():
db.create_all()
from app.user import user as userBluePrint
from app.tweet import status as statusBluePrint
app.register_blueprint(userBluePrint)
app.register_blueprint(statusBluePrint)
return app
migrate = Migrate()
mail = Mail()
# basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__)
CORS(app) ## enable CORS on all routes
app.config.from_object(app_config[env_name])
app.logger.info(f"\n \
######################################################### \n \
# ENV: {env_name} \n \
# DB_HOST: {app.config['DB_HOST']} \n \
# ENV: {env_name} \n \
######################################################### ")
# Set up extensions
from app.models import db, ma
db.init_app(app)
ma.init_app(app)
migrate.init_app(app, db)
mail.init_app(app)
# Set up logging
setup_logger(app)
from app.views import register_blueprint_view
register_blueprint_view(app)
from app.commands import register_commands
register_commands(app)
def create_app(root_path, minimal=False):
app_name = 'minimal_app' if minimal else __name__
app = Flask(app_name, root_path=root_path)
config = os.environ.get('CONFIG', default='config/dev.cfg')
secrets = os.environ.get('SECRETS', default='config/secret.cfg')
app.config.from_pyfile(os.path.abspath(config))
app.config.from_pyfile(os.path.abspath(secrets))
app.secret_key = app.secret_key.encode()
app.static_url_path = app.config.get('STATIC_FOLDER')
app.static_folder = os.path.join(app.root_path, app.static_url_path)
app.template_folder = os.path.join(app.root_path,
app.config.get('TEMPLATE_FOLDER'))
from app.models.event import Event
from app.models.grade import Grade
from app.models.lesson import Lesson
from app.models.period import Period
from app.models.relationships import UserGrade, UserLesson, UserSubject
from app.models.report import Report
from app.models.school import School
from app.models.session import Session
from app.models.subject import Subject
from app.models.time import Time
from app.models.user import User
from app.models import db
db.init_app(app)
if not minimal:
from app.blueprints.api import v1
from app.blueprints.api.v1 import user as user_api
from app.blueprints.api.v1 import lesson as lesson_api
from app.blueprints.api.v1 import session as session_api
from app.blueprints import auth
from app.blueprints import index
from app.blueprints import user as user
from app.models.enums import Locale
from app.models import ma
from app.i18n import babel, moment
import app.utils as utils
from app.utils.tasks import tasks
babel.init_app(app)
moment.init_app(app)
ma.init_app(app)
db.create_all(app=app)
@app.after_request
def call_after_request_callbacks(response):
for callback in getattr(g, 'after_request_callbacks', ()):
callback(response)
return response
@app.before_request
def auth_middleware():
sid = request.cookies.get('sid',
default='') or request.values.get('sid')
session_result = Session.verify(sid)
if session_result:
g.session = session_result
g.locale = g.session.user.locale.value
else:
g.session = None
g.locale = utils.get_best_locale().value
@utils.after_this_request
def set_cookie(response):
if g.session:
g.session.set_cookie(response)
@app.before_request
def config_middleware():
try:
g.school = db.session.query(School).filter(
School.id == 1).one()
except:
g.school = False
endpoints = [
'static', 'auth.config', None, 'school_api1.school_post',
'school_api1.school_put'
]
if request.endpoint not in endpoints:
app.logger.info('No school found. Redirect to config')
return redirect(url_for('auth.config', stage='school'))
@babel.localeselector
def get_locale():
return g.locale
# ------------
# API routes
# ------------
app.register_blueprint(v1.bp, url_prefix='/api/v1')
app.register_blueprint(user_api.bp, url_prefix='/api/v1/user')
app.register_blueprint(session_api.bp, url_prefix='/api/v1/session')
app.register_blueprint(lesson_api.bp, url_prefix='/api/v1/lesson')
# ------------
# Frontend
# ------------
app.register_blueprint(auth.bp)
app.register_blueprint(user.bp, url_prefix='/user')
app.register_blueprint(index.bp)
tasks.create_events()
return app, db
