def create_app(config_object=None, db_name=None): # pragma: no cover
app = Flask(__name__)
from dotenv import load_dotenv
load_dotenv(".env")
if config_object is None:
app.config.from_object('config.BaseConfiguration')
else:
app.config.from_object(config_object)
if not app.logger.handlers:
stream_handler = StreamHandler()
app.logger.addHandler(stream_handler)
if app.debug:
app.logger.setLevel("DEBUG")
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
app.config["DEBUG_TB_PROFILER_ENABLED"] = os.environ.get(
"PROFILER", "False") == 'True'
app.config['RQ_DEFAULT_URL'] = os.environ.get("REDIS_URL")
else:
app.logger.setLevel("DEBUG")
RQ(app)
Bootstrap(app)
DebugToolbarExtension(app)
from chatbot.views import chatbot_bp
app.register_blueprint(chatbot_bp)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
db.init_app(app)
login_manager.init_app(app)
compress.init_app(app)
RQ(app)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
# from .main import main as main_blueprint
# app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
return app
def set_up_extensions(app):
csrf.init_app(app)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
compress.init_app(app)
RQ(app)
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
Config[config_name].init_app(app)
# Set up extensions
db.init_app(app)
RQ(app)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Register api blueprints
app.register_blueprint(api_v1)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .data import data as data_blueprint
app.register_blueprint(data_blueprint, url_prefix='/data')
from .request import request_blueprint
app.register_blueprint(request_blueprint, url_prefix='/request')
@app.after_request
def add_header(response):
response.cache_control.max_age = 0
return response
return app
def create_app(configfile=None):
app = Flask(__name__)
AppConfig(app)
Bootstrap(app)
sql_dir = os.path.join(basedir, 'tmp/')
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
sql_dir, 'user-login.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
REDIS_URL = 'http://localhost:6379'
urllib.parse.uses_netloc.append('redis')
url = urllib.parse.urlparse(REDIS_URL)
app.config['RQ_DEFAULT_HOST'] = url.hostname
app.config['RQ_DEFAULT_PORT'] = url.port
app.config['RQ_DEFAULT_PASSWORD'] = url.password
app.config['RQ_DEFAULT_DB'] = 0
# EAM : Set limit on the number of items in cache (RAM)
cache.init_app(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
assets_env.register('browser_js', browser_js)
assets_env.register('browser_css', browser_css)
assets_env.register('tabular_ensemble_js', tabular_ensemble_js)
assets_env.register('tabular_rs1_js', tabular_rs1_js)
assets_env.register('tabular_rs2_js', tabular_rs2_js)
assets_env.register('request_new_ensemble_js', request_new_ensemble_js)
assets_env.register('tabular_css', tabular_css)
with app.app_context():
from .frontend import frontend
#app.register_blueprint(frontend, url_prefix="/portal")
app.register_blueprint(frontend)
from .content import content
app.register_blueprint(content)
#app.register_blueprint(content, url_prefix="/portal")
app.json_encoder = MiniJSONEncoder
nav.init_app(app)
mail.init_app(app)
csrf.init_app(app)
db.init_app(app)
login_manager.init_app(app)
compress.init_app(app)
htmlmin.init_app(app)
RQ(app)
return app
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .volunteer import volunteer as volunteer_blueprint
app.register_blueprint(volunteer_blueprint, url_prefix='/volunteer')
from .staff import staff as staff_blueprint
app.register_blueprint(staff_blueprint, url_prefix='/staff')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# setup the celery client
celery = Celery(app, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
# Register Jinja template functions
from .template_utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .tools import tools as tools_blueprint
app.register_blueprint(tools_blueprint, url_prefix='/tools')
from .projects import projects as projects_blueprint
app.register_blueprint(projects_blueprint, url_prefix='/projects')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .inventory import inventory as inventory_blueprint
app.register_blueprint(inventory_blueprint, url_prefix='/inventory')
from .provisioning import provisioning as provisioning_blueprint
app.register_blueprint(provisioning_blueprint, url_prefix='/provisioning')
from .rtd import rtd as provisioning_rtd
app.register_blueprint(provisioning_rtd, url_prefix='/rtd')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# Set up extensions
bootstrap.init_app(app)
moment.init_app(app)
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .diary import diary as diary_blueprint
app.register_blueprint(diary_blueprint, url_prefix='/diary')
from .video import video as video_blueprint
app.register_blueprint(video_blueprint, url_prefix='/video')
from .survey import survey as survey_blueprint
app.register_blueprint(survey_blueprint, url_prefix='/survey')
return app
def create_app(config_name):
app = Flask(__name__)
with app.app_context():
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .adtributor import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .adtributor import contributor as contributor_blueprint
app.register_blueprint(contributor_blueprint,
url_prefix='/contributor')
db.app = app
return app
def create_app(config=None):
app = Flask(__name__)
# read .envs and configuration class
app = read_env(app, config)
# define logging patterns
app = setup_logger(app)
# register view blueprints
from project.home.views import app_blueprint
from project.user.views import user_blueprint
app.register_blueprint(app_blueprint)
app.register_blueprint(user_blueprint)
# setup apps
DebugToolbarExtension(app)
Bcrypt(app)
RQ(app)
basic_auth = BasicAuth(app)
db.init_app(app)
# register admin view
from project.user.models.user import User
from project.user.models.role import Role
from project.user.models.user_roles import UserRoles
from project.admin.views import ModelView, SuperSecretPage
from project.user.admin.views import UserView
admin = Admin(app, name='Admin Panel', template_mode='bootstrap3')
admin.add_view(UserView(User, db.session, basic_auth, endpoint="users"))
admin.add_view(ModelView(Role, db.session, basic_auth, endpoint="roles"))
admin.add_view(SuperSecretPage(name="Secret"))
# register api endpoints
from project.api.v1.user import User
api = Api(app, prefix='/api/v1/')
api.add_resource(User, 'users/', endpoint='api.v1.users')
# import custom login manager functions
from project.user.login_manager import load_user_from_request, load_user
login_manager = LoginManager(app)
login_manager.login_view = "user.login"
login_manager.user_loader(load_user)
login_manager.request_loader(load_user_from_request)
# default flashed messages category
login_manager.login_message_category = 'info'
login_manager.needs_refresh_message_category = 'info'
# jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
return app
def create_app(config_name, main=True):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
db.init_app(app)
db.sessionmaker(autoflush=False)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
socketio.init_app(app, message_queue=app.config['SOCKETIO_MESSAGE_QUEUE'])
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .SnEMechs import SnEMechs as SnEMechs_blueprint
app.register_blueprint(SnEMechs_blueprint,
url_prefix='/Sn_1+Sn_2+E1+E2+Mechanisms')
return app
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)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
from app.utils import register_template_utils
register_template_utils(app)
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
from app.main.views import main_blueprint
app.register_blueprint(main_blueprint)
from app.account.views import account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from app.admin.views import admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
csrf.init_app(app)
oauth.init_app(app)
RQ(app)
api = Api(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .api.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from app.api.docs import docs as docs_blueprint
app.register_blueprint(docs_blueprint)
from flasgger import APISpec, Schema, Swagger, fields
spec = APISpec(
title='REST API',
version='1.0.0',
plugins=[
'apispec.ext.flask',
'apispec.ext.marshmallow',
],
)
app.config['SWAGGER'] = {'title': 'REST API', 'uiversion': 3}
swagger = Swagger(app,
template={
'swagger': '3.0',
'info': {
'title': 'REST API',
'version': '1.0'
}
})
from app.api.v1.building import Building, BuildingList
building_view = Building.as_view('Building')
app.add_url_rule('/v1/buildings/<int:building_id>',
view_func=building_view)
building_list_view = BuildingList.as_view('BuildingList')
app.add_url_rule('/v1/buildings', view_func=building_list_view)
with app.test_request_context():
spec.add_path(view=building_view)
spec.add_path(view=building_list_view)
return app
from .models import db # NOQA
# Configure the app
coaster.app.init_app(app)
db.init_app(app)
db.app = app
migrate = Migrate(app, db)
app.geoip = None
if 'GEOIP_PATH' in app.config:
if not os.path.exists(app.config['GEOIP_PATH']):
app.logger.warn("GeoIP database missing at " +
app.config['GEOIP_PATH'])
else:
app.geoip = geoip2.database.Reader(app.config['GEOIP_PATH'])
RQ(app)
baseframe.init_app(app,
requires=[
'baseframe-bs3', 'jquery.autosize', 'jquery.liblink',
'jquery.wnumb', 'jquery.nouislider',
'baseframe-firasans', 'fontawesome>=4.3.0',
'bootstrap-multiselect', 'nprogress', 'ractive',
'jquery.appear', 'hammer'
])
# TinyMCE has to be loaded by itself, unminified, or it won't be able to find its assets
app.assets.register(
'js_tinymce',
assets.require('!jquery.js', 'tinymce.js>=4.0.0',
'jquery.tinymce.js>=4.0.0'))
app.assets.register(
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
#compress.init_app(app)
RQ(app)
migrate.init_app(app, db)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
import click
from app.models import Role, User
@app.cli.command("create_user")
@click.argument("name")
def create_super_user(name):
Role.insert_roles()
admin_query = Role.query.filter_by(name='Administrator')
if admin_query.first() is not None:
if User.query.filter_by(email='*****@*****.**').first() is None:
user = User(
first_name='Admin',
last_name='Account',
password='******',
confirmed=True,
email='*****@*****.**')
db.session.add(user)
db.session.commit()
print('Added administrator {}'.format(user.full_name()))
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
'''
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
'''
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .student import student as student_blueprint
app.register_blueprint(student_blueprint, url_prefix='/student')
from .professor import professor as professor_blueprint
app.register_blueprint(professor_blueprint, url_prefix='/professor')
return app
def create_app():
app = Flask(__name__)
app.config.from_object(config)
RQ(app)
return app
# from flask_login import LoginManager # login_manager = LoginManager() from flask_migrate import Migrate migrate = Migrate() from flask_cache import Cache cache = Cache() from flask_debugtoolbar import DebugToolbarExtension debug_toolbar = DebugToolbarExtension() from flask_bootstrap import Bootstrap bootstrap = Bootstrap() from rq_dashboard import RQDashboard from recruit_app.user.admin import check_if_admin rqDashboard = RQDashboard(auth_handler=check_if_admin) from flask_admin import Admin admin = Admin() from flask_mail import Mail mail = Mail() from flask_rq import RQ rq = RQ()
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
app.config['UPLOADED_IMAGES_DEST'] = '/home/ubuntu/flaskapp/flask-base/appstatic/photo/' if \
not os.environ.get('UPLOADED_IMAGES_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_IMAGES_DEST')
app.config['UPLOADED_DOCS_DEST'] = '/home/ubuntu/flaskapp/flask-base/appstatic/docs/' if \
not os.environ.get('UPLOADED_DOCS_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_DOCS_DEST')
app.config['docs'] = app.config['UPLOADED_DOCS_DEST']
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
configure_uploads(app, images)
configure_uploads(app, docs)
share.init_app(app)
CKEditor(app)
moment.init_app(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .api import blueprint as api_blueprint
app.register_blueprint(api_blueprint)
from .public import public as public_blueprint
app.register_blueprint(public_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .blog import blog as blog_blueprint
app.register_blueprint(blog_blueprint, url_prefix='/blog')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint)
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint)
from .bulk_resource import bulk_resource as bulk_resource_blueprint
app.register_blueprint(bulk_resource_blueprint)
from .descriptor import descriptor as descriptor_blueprint
app.register_blueprint(descriptor_blueprint)
from .single_resource import single_resource as single_resource_blueprint
app.register_blueprint(single_resource_blueprint)
from .suggestion import suggestion as suggestion_blueprint
app.register_blueprint(suggestion_blueprint)
from .contact import contact as contact_blueprint
app.register_blueprint(contact_blueprint)
@app.before_request
def br():
from flask import request
g.tlf = request.path[1:].split('/', 1)[0]
from .models import Locale
Locale.check_locale(g.tlf)
@app.after_request
def ar(response):
#if not tlf(g.tlf):
pass #abort(404)
return response
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .bulk_resource import bulk_resource as bulk_resource_blueprint
app.register_blueprint(bulk_resource_blueprint,
url_prefix='/bulk-resource')
from .descriptor import descriptor as descriptor_blueprint
app.register_blueprint(descriptor_blueprint, url_prefix='/descriptor')
from .single_resource import single_resource as single_resource_blueprint
app.register_blueprint(single_resource_blueprint,
url_prefix='/single-resource')
from .suggestion import suggestion as suggestion_blueprint
app.register_blueprint(suggestion_blueprint, url_prefix='/suggestion')
from .contact import contact as contact_blueprint
app.register_blueprint(contact_blueprint, url_prefix='/contact')
return app
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv("FLASK_CONFIG", "default")
app.config.from_object(Config[config_name])
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
configure_uploads(app, images)
configure_uploads(app, docs)
CKEditor(app)
share.init_app(app)
Bootstrap(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ["assets/styles", "assets/scripts"]
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register("app_css", app_css)
assets_env.register("app_js", app_js)
assets_env.register("vendor_css", vendor_css)
assets_env.register("vendor_js", vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config["SSL_DISABLE"]:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .public import public as public_blueprint
app.register_blueprint(public_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix="/account")
from .question import question as question_blueprint
app.register_blueprint(question_blueprint, url_prefix="/question")
from .answer import answer as answer_blueprint
app.register_blueprint(answer_blueprint, url_prefix="/answer")
from .project import project as project_blueprint
app.register_blueprint(project_blueprint, url_prefix="/project")
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix="/admin")
from .organisations import organisations as organisations_blueprint
app.register_blueprint(organisations_blueprint, url_prefix="/organisations")
from .blog import blog
app.register_blueprint(blog, url_prefix="/blog")
return app
def create_app(config_name):
app = Flask(__name__, static_folder='static')
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
csrf.init_app(app)
oauth.init_app(app)
oauthclient.init_app(app)
RQ(app)
db.app = app
cors = CORS(app,
resources={
r"/api/v1/*": {
"origins": "*"
},
r"/auth/oauth/*": {
"origins": "*"
}
})
api = Api(app)
babel.init_app(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not os.environ.get('SSL_DISABLE'):
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .api.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from app.api.docs import docs as docs_blueprint
app.register_blueprint(docs_blueprint)
from flasgger import APISpec, Schema, Swagger, fields
spec = APISpec(
title='Bhagavad Gita API',
version='1.0.0',
plugins=[
'apispec.ext.flask',
'apispec.ext.marshmallow',
],
)
app.config['SWAGGER'] = {'title': 'Bhagavad Gita API', 'uiversion': 3}
swagger = Swagger(app,
template={
'swagger': '2.0',
'info': {
'title': 'Bhagavad Gita API',
'version': '1.0'
}
})
from app.api.v1.verse import VerseList, VerseListByChapter, VerseByChapter
from app.api.v1.chapter import Chapter, ChapterList
verse_list_view = VerseList.as_view('VerseList')
app.add_url_rule('/api/v1/verses', view_func=verse_list_view)
verse_list_chapter_view = VerseListByChapter.as_view('VerseListChapter')
app.add_url_rule('/api/v1/chapters/<int:chapter_number>/verses',
view_func=verse_list_chapter_view)
verse_chapter_view = VerseByChapter.as_view('VerseChapter')
app.add_url_rule(
'/api/v1/chapters/<int:chapter_number>/verses/<string:verse_number>',
view_func=verse_chapter_view)
chapter_view = Chapter.as_view('Chapter')
app.add_url_rule('/api/v1/chapters/<int:chapter_number>',
view_func=chapter_view)
chapter_list_view = ChapterList.as_view('ChapterList')
app.add_url_rule('/api/v1/chapters', view_func=chapter_list_view)
def _force_https():
if not app.debug:
from flask import _request_ctx_stack
if _request_ctx_stack is not None:
reqctx = _request_ctx_stack.top
reqctx.url_adapter.url_scheme = 'https'
app.before_request(_force_https)
with app.test_request_context():
spec.add_path(view=verse_list_view)
spec.add_path(view=verse_list_chapter_view)
spec.add_path(view=verse_chapter_view)
spec.add_path(view=chapter_view)
spec.add_path(view=chapter_list_view)
return app
app.register_blueprint(lastuser_core.lastuser_core)
app.register_blueprint(lastuser_oauth.lastuser_oauth)
app.register_blueprint(lastuser_ui.lastuser_ui)
from . import views # NOQA
assets['lastuser-oauth.js'][version] = lastuser_oauth.lastuser_oauth_js,
assets['lastuser-oauth.css'][version] = lastuser_oauth.lastuser_oauth_css
# Configure the app
coaster.app.init_app(app)
db.init_app(app)
db.app = app # To make it work without an app context
migrate = Migrate(app, db)
RQ(app) # Pick up RQ configuration from the app
baseframe.init_app(app,
requires=['lastuser-oauth'],
ext_requires=[
'baseframe-bs3', 'fontawesome>=4.0.0', 'jquery.cookie',
'timezone'
])
lastuser_oauth.lastuser_oauth.init_app(app)
lastuser_oauth.mailclient.mail.init_app(app)
lastuser_oauth.views.login.oid.init_app(app)
# Register some login providers
if app.config.get('OAUTH_TWITTER_KEY') and app.config.get(
'OAUTH_TWITTER_SECRET'):
login_registry['twitter'] = providers.TwitterProvider(
import os
from flask import Flask
from flask_rq import RQ
app = Flask(__name__)
rq = RQ(app)
app.config['ghuser'] = os.environ.get('GH_USERNAME')
app.config['ghpassword'] = os.environ.get('GH_PASSWORD')
app.config['ghrepository'] = os.environ.get('GH_REPOSITORY')
app.config['RQ_DEFAULT_URL'] = os.environ.get('REDIS_URL', 'redis://')
app.config['ROLLBAR_ACCESS_TOKEN'] = os.environ.get('ROLLBAR_ACCESS_TOKEN')
import ghinbox.webhooks # noqa
import ghinbox.requestid # noqa
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
#'C:/Users/oem/Desktop/marketplace/marketplace/app/static/frontend/images/'
#'C:/Users/oem/Desktop/marketplace/marketplace/appstatic/docs/'
app.config['UPLOADED_IMAGES_DEST'] = basedir + 'static/frontend/images' if \
not os.environ.get('UPLOADED_IMAGES_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_IMAGES_DEST')
app.config['UPLOADED_DOCS_DEST'] = basedir + 'static/docs' if \
not os.environ.get('UPLOADED_DOCS_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_DOCS_DEST')
app.config['docs'] = app.config['UPLOADED_DOCS_DEST']
app.config['CKEDITOR_SERVE_LOCAL'] = True
app.config['CKEDITOR_HEIGHT'] = 400
app.config['CKEDITOR_FILE_UPLOADER'] = 'upload'
app.config['CKEDITOR_ENABLE_CSRF'] = True # if you want to enable CSRF protect, uncomment this line
app.config['UPLOADED_PATH'] = os.path.join(basedir, 'uploads')
#app.config['WHOOSH_BASE']='whoosh'
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
configure_uploads(app, (images))
configure_uploads(app, docs)
ckeditor = CKEditor(app)
share.init_app(app)
moment.init_app(app)
jwt.init_app(app)
sess.init_app(app)
whooshee.init_app(app)
# whooshee = Whooshee(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .blueprints.public import public as public_blueprint
app.register_blueprint(public_blueprint)
from .blueprints.seo_world import seo_world as seo_world_blueprint
app.register_blueprint(seo_world_blueprint)
from .blueprints.main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .blueprints.account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .blueprints.admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .blueprints.marketplace import marketplace as marketplace_blueprint
app.register_blueprint(marketplace_blueprint, url_prefix='/marketplace')
from .blueprints.organisations import organisations as organisations_blueprint
app.register_blueprint(organisations_blueprint, url_prefix='/organisations')
from .blueprints.sitemaps import sitemaps as sitemaps_blueprint
app.register_blueprint(sitemaps_blueprint)
from .blueprints.api import api as apis_blueprint
app.register_blueprint(apis_blueprint, url_prefix='/api')
# main_api.init_app(app)
app.jinja_env.globals.update(json_load=json_load, image_size=image_size, get_cart=get_cart)
@app.before_request
def before_request():
try:
session['cart_id']
except:
u = uuid.uuid4()
user_agent = request.headers.get('User-Agent')
if user_agent is not None:
user_agent = user_agent.encode('utf-8')
base = 'cart: {0}|{1}|{2}'.format(_get_remote_addr(), user_agent, u)
if str is bytes:
base = text_type(base, 'utf-8', errors='replace') # pragma: no cover
h = sha512()
h.update(base.encode('utf8'))
session['cart_id'] = h.hexdigest()
@app.cli.command()
def reindex():
with app.app_context():
whooshee.reindex()
@app.cli.command()
def routes():
"""'Display registered routes"""
rules = []
for rule in app.url_map.iter_rules():
methods = ','.join(sorted(rule.methods))
rules.append((rule.endpoint, methods, str(rule)))
sort_by_rule = operator.itemgetter(2)
for endpoint, methods, rule in sorted(rules, key=sort_by_rule):
route = '{:50s} {:25s} {}'.format(endpoint, methods, rule)
print(route)
@app.template_filter('product')
def product(o):
"""check if object is user"""
from app.models import MProduct
return o.__class__ == MProduct
return app
def create_app(config_name, url_prefix=""):
app = Flask(__name__,
static_url_path=url_prefix + "/static",
subdomain_matching=True)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# csrf.init_app(app)
CSRFProtect(app)
compress.init_app(app)
RQ(app)
# admin.init_app(app)
# admin.add_view(ModelView(User, db.session))
# admin.add_view(ModelView(OralHistory, db.session))
# jsglue.init_app(app, url_prefix=url_prefix)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
hypothesis_service = os.environ.get('HYPOTHESIS_SERVICE',
'http://localhost:5000')
hyp_client = HypothesisClient(
authority=os.environ['HYPOTHESIS_AUTHORITY'],
client_id=os.environ['HYPOTHESIS_CLIENT_ID'],
client_secret=os.environ['HYPOTHESIS_CLIENT_SECRET'],
jwt_client_id=os.environ['HYPOTHESIS_JWT_CLIENT_ID'],
jwt_client_secret=os.environ['HYPOTHESIS_JWT_CLIENT_SECRET'],
service=hypothesis_service)
app.hypothesis_client = hyp_client
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint, url_prefix=url_prefix)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint,
url_prefix=url_prefix + '/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix=url_prefix + '/admin')
from .experimental import experimental as experimental_blueprint
app.register_blueprint(experimental_blueprint,
url_prefix=url_prefix + '/experimental')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
app.config['OAUTH_CREDENTIALS'] = {
'google': {
'id': '767868202462-3v28oqcun0fnd0vc89uh7in4mbi7fg4o.apps.googleusercontent.com',
'secret': 'KfvqdFDqYYn9hXDFeC3BmImD'
},
'facebook': {
'id': '1357352657745486',
'secret': '52e5d34fef41614988fbd1a7e33deab2'
},
'twitter': {
'id': 'NzD4SB1S9Ulod1k1cqZGH5g6J ',
'secret': 'CLXzCpbe0NxY8mOzgBtgRNWJjltJth2urwR7EkBzr365EUNEWO'
}
}
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
moment.init_app(app)
ckeditor.init_app(app)
RQ(app)
babel.init_app(app)
photos = UploadSet('photos', IMAGES)
configure_uploads(app, photos)
patch_request_class(app)
app.config['CKEDITOR_ENABLE_CSRF'] = True
app.config['CKEDITOR_FILE_UPLOADER'] = '/admin/upload'
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
# assets_env.register('app_css', app_css)
# assets_env.register('app_js', app_js)
# assets_env.register('vendor_css', vendor_css)
# assets_env.register('vendor_js', vendor_js)
# assets_env.register('skye_css', vendor_css)
# assets_env.register('skye_js', vendor_js)
# Configure SSL if platform supports it
#if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
# from flask.ext.sslify import SSLify
# SSLify(app)
# # Create app blueprints
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
# customer blue_print
from .customer import customer as customer_blueprint
app.register_blueprint(customer_blueprint, url_prefix='/customer')
# home blue_print
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
# publisher blue_print
from .publisher import publisher as publisher_blueprint
app.register_blueprint(publisher_blueprint, url_prefix='/publisher')
# home blue_print
from .auth import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .social import social as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/social_login')
# csrf.exempt(api_blueprint)
return app
