def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
# from .api_1_0 import api as api_1_0_blueprint
# app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app.request_class = ProxiedRequest
db.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
from .urls import urls as url_blueprint
from .admin import admin as admin_blueprint
from .auth import auth as auth_blueprint
from .apartment import apartment as apartment_blueprint
from .strava import strava as strava_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(url_blueprint, url_prefix='/urls')
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(auth_blueprint, url_prefix='/auth')
app.register_blueprint(apartment_blueprint, url_prefix='/apartment')
app.register_blueprint(strava_blueprint, url_prefix='/strava')
if not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
global celeryapp
celeryapp = create_celery_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .uploads import uploads as uploads_blueprint
app.register_blueprint(uploads_blueprint, url_prefix='/uploads')
from .training import training as training_blueprint
app.register_blueprint(training_blueprint, url_prefix='/training')
return app, celeryapp
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('foo.log', 'a', 1 * 1024 * 1024 * 1024,
10)
file_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('microblog startup')
return app
def create_app(config_name):
# config_name = 'default'
app = Flask(__name__)
print config_name
'''first config is module and second one is dict
This(config['config_name') dict return a class-name as class-OBJ{obj created by from_object} and its variable... '''
app.config.from_object(config[config_name])
# class-name.method_name b'coz init_app is a @staticmethod
config[config_name].init_app(app)
'''intializing the extenisons'''
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
#xx = raw_input("inside create app")
# importing blueprint
from .main import main as main_blueprint
print main_blueprint.name
#xx = raw_input("inside create app impoted blueprint" )
app.register_blueprint(main_blueprint)
#xx = raw_input("inside create app after registration" )
''' Attaching auth blueprint to the application factory'''
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
babel.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
pagedown.init_app(app)
login_manager.init_app(app)
configure_uploads(app, photos)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .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')
return app
def create_app(config_name):
"""
创建应用，定义应用的配置，并且初始化应用的运行插件，最后将蓝本注册到应用。
"""
app = Flask(__name__)
# 配置
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# 插件
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
pagedown.init_app(app)
moment.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# 蓝本
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix="/auth")
from .api_0_1 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix="/api/v0.1")
return app
def create_app(package_name, package_path, settings_override=None):
"""Returns a :class:`Flask` application instance configured with common
functionality for the Overholt platform.
:param package_name: application package name
:param package_path: application package path
:param settings_override: a dictionary of settings to override
:param register_security_blueprint: flag to specify if the Flask-Security
Blueprint should be registered.
Defaults to `True`.
"""
app = Flask(package_name, instance_relative_config=True)
app.config.from_object('apollo.settings')
app.config.from_object(settings_override)
sentry.init_app(app)
babel.init_app(app)
db.init_app(app)
mail.init_app(app)
if app.config.get('FORCE_SSL'):
SSLify(app)
@babel.localeselector
def get_locale():
return request.accept_languages \
.best_match(app.config.get('LANGUAGES', {}).keys())
register_blueprints(app, package_name, package_path)
return app
def create_app(config_name):
app = Flask(__name__)
app.session_interface = session.RedisSessionInterface()
config = load_config()
app.config.from_object(config)
setup_connections(config)
mail.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from app.models import models
app.register_blueprint(models)
from app.controllers import controllers
app.register_blueprint(controllers)
from app.api import api
app.register_blueprint(api, url_prefix='/api')
app.secret_key = b'\xe2\x92*\x1b\x96F\xf2\xafh^\xfd\xcf\xde\xb4f\xbd\x0b\xdf\xa1@#\xd4\xb1\x9c'
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
babel.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .index import index_blueprint
app.register_blueprint(index_blueprint)
# Site Modules
from .site_auth import site_auth_blueprint
app.register_blueprint(site_auth_blueprint, url_prefix='/site_auth')
from .site_users import site_users_blueprint
app.register_blueprint(site_users_blueprint, url_prefix='/site_users')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# add route and error handler here
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
from .models import Post
whooshalchemy.whoosh_index(app, Post)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.url_map.converters['list'] = ListConverter
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
UPLOAD_FOLDER = os.path.join(APP_ROOT, 'static/uploads')
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
db = SQLAlchemy(app)
manager = Manager(app)
alchemydumps = AlchemyDumps(app, db)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .about import about as about_blueprint
app.register_blueprint(about_blueprint, url_prefix='/about')
from .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 .outputs import outputs as outputs_blueprint
app.register_blueprint(outputs_blueprint, url_prefix='/outputs')
from .resources import resources as resources_blueprint
app.register_blueprint(resources_blueprint, url_prefix='/resources')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api')
from .user_guide import user_guide as user_guide_blueprint
app.register_blueprint(user_guide_blueprint, url_prefix='/user-guide')
from .data_manage import data_manage as data_manage_blueprint
app.register_blueprint(data_manage_blueprint, url_prefix='/data-manage')
from .user_zone import user_zone as user_zone_blueprint
app.register_blueprint(user_zone_blueprint, url_prefix='/user-area')
from .outputs import outputs as outputs_blueprint
app.register_blueprint(outputs_blueprint, url_prefix='/outputs')
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)
moment.init_app(app)
rq.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(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 .task import task as task_blueprint
app.register_blueprint(task_blueprint, url_prefix='/task')
if config_name == 'production':
from app.jobs.doc_cache import doc_cache
# Create cron jobs
doc_cache.cron('0 0 12 * * *', 'cache_job')
@rq.exception_handler
def send_alert_to_ops(job, *exc_info):
print(job)
print(exc_info)
return app
def create_app(config_name):
"""Initialize the flask app with external configuration."""
## App ##
app = Flask(__name__, static_folder='static',
template_folder='templates')
## Config ##
app.config.from_object(config[config_name])
config[config_name].init_app(app)
## Database ##
db.init_app(app)
db.app = app
## Mail ##
mail = Mail()
mail.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
## Blueprints ##
register_blueprints(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name]) #将config中一个类的的配置直接导入程序，
#也就是变成app.config,这可能是不用导入config中其他类的原因，因为被这个方法实现了
config[config_name].init_app(
app) #暂时这样理解：这里的init_app和下面的那四个是不一样的，这里的是config类里定义的，
#但是作用都是完成初始化，即bootstrap = Bootstrap(app)，moment = Moment(app)等将app参数传到9-12行中的实例里，
#或者是完成将配置导入app的工作
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint) #蓝本在工厂函数 create_app() 中注册到程序上
from .auth import auth as auth_blueprint
app.register_blueprint(
auth_blueprint, url_prefix='/auth'
) #url_prefix是可选参数，将蓝本中所有路由都加上指定前缀，即变成/auth/login，URL变成http://localhost:5000/auth/login
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(config_name):
"""
Flask Application Factory that takes configuration settings and returns
a Flask application.
"""
# initalize instance of Flask application
app = Flask(__name__)
# import configuration settings into Flask application instance
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# initialize Flask extensions
db.init_app(app)
login_manager.init_app(app)
# redirect all http requests to https
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# register 'main' blueprint with Flask application
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
# register 'api' blueprint with Flask application
from .api import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api')
return app
def create_app(config=None):
app = Flask(__name__)
if config:
app.config.from_pyfile(os.path.abspath(config))
else:
app.config.from_envvar('CONFIG')
if not app.debug and not app.testing:
from flask.ext.sslify import SSLify
SSLify(app, permanent=True)
from raven.contrib.flask import Sentry
Sentry(app)
install_errorhandler(app)
register_blueprints(app)
cache.init_app(app)
db.init_app(app)
bcrypt.init_app(app)
s3.init_app(app)
init_extensions(app)
@app.route('/')
def index():
return redirect('https://github.com/devxoul/graygram-ios')
return app
def create_app(config_name):
from config import config
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config[u'SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main_blueprint, auth_blueprint, \
blog_blueprint, music_blueprint, movie_blueprint, photo_blueprint, files_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(auth_blueprint)
app.register_blueprint(blog_blueprint)
app.register_blueprint(photo_blueprint)
app.register_blueprint(files_blueprint)
app.register_blueprint(movie_blueprint)
app.register_blueprint(music_blueprint)
# from .api_1_0 import api as api_1_0_blueprint
# app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
from main import main as main_blueprint
app.register_blueprint(main_blueprint, url_prefix='/')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .conference import conference as conference_blueprint
app.register_blueprint(conference_blueprint, url_prefix='/conference')
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(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)
CORS(app)
cache.init_app(app, config=app.config)
app.cache = cache
# 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 .mauticor import mauticor as mauticor
app.register_blueprint(mauticor, url_prefix="/mauticor")
from .bookie import bookie as bookie
app.register_blueprint(bookie, url_prefix="/bookie")
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])
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)
app.jinja_env.globals.update(format_price=format_price)
# 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.config['sass_line_comments'] = False
assets_env.config['sass_debug_info'] = False
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
assets_env.register('guiders_js', guiders_js)
assets_env.register('images_png', images_png)
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_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 merchant import merchant as merchant_blueprint
app.register_blueprint(merchant_blueprint, url_prefix='/merchant')
from vendor import vendor as vendor_blueprint
app.register_blueprint(vendor_blueprint, url_prefix='/vendor')
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 register_extensions(app):
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
def create_app(config):
#create_structure()
# Define the WSGI application object
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 200 * 1024 * 1024 # 200MB
# Configurations
app.config.from_object(settings[config])
settings[config].init_app(app)
if not app.testing:
logo()
check_version()
check_configs()
if app.testing:
init_logging('info')
else:
init_logging('debug')
#log.setLevel(logging.DEBUG)
init_modules()
# Init All Flask Add-ons
bootstrap.init_app(app)
#pagedown.init_app(app)
db.init_app(app)
mail.init_app(app)
if app.config['USE_LDAP'] == 'yes':
# LDAP Login
# TODO : Test out LDAP
app.add_url_rule('/login', 'login', ldap.login, methods=['GET', 'POST'])
ldap.init_app(app)
else:
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
try:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
except ImportError:
from flask.ext.sslify import SSLify
raise MaliceDependencyError("Unable to import Flask-SSLify "
"(install with `pip install Flask-SSLify`)")
# Register blueprint(s)
from .malice import malice as malice_blueprint
app.register_blueprint(malice_blueprint)
from .mod_auth import mod_auth as auth_module
app.register_blueprint(auth_module, url_prefix='/auth')
# from app.mod_api.controller import mod_api as api_module
# app.register_blueprint(api_module, url_prefix='/api/v1')
return app
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
env.from_yaml(os.path.join(basedir, 'config.yml'))
celery.conf.update(BROKER_URL=app.config['REDIS_URL'],
CELERY_RESULT_BACKEND=app.config['REDIS_URL'])
#Adding logging capabilities.
if app.config['LOGGING'] == True:
import logging
logger = logging.getLogger('replicate')
logger.setLevel(logging.DEBUG)
log_directory = basedir + app.config['LOG_FILE_PTAH']
log_filename = log_directory + app.config['LOG_FILE']
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode='a+')
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
#app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info('Application Process Started')
#SSL
if not app.debug and not app.testing and app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# handle proxy server headers
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
db.init_app(app)
login_manager.init_app(app)
cache.init_app(app)
csrf.init_app(app)
redis_store.init_app(app)
from ooiservices.app.main import api as main_blueprint
app.register_blueprint(main_blueprint)
from ooiservices.app.uframe import uframe as uframe_blueprint
app.register_blueprint(uframe_blueprint, url_prefix='/uframe')
from ooiservices.app.redmine import redmine as redmine_blueprint
app.register_blueprint(redmine_blueprint, url_prefix='/redmine')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
if app.config['SSLIFY'] == 'enable':
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app(config_name):
"""
Flask Application Factory that takes configuration settings and returns
a Flask application.
"""
# initalize instance of Flask application
app = Flask(__name__)
# import configuration settings into Flask application instance
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# initialize Flask extensions
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# redirect all http requests to https
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# register 'main' blueprint with Flask application
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
# register 'auth' blueprint with Flask application
from .auth import auth as auth_blueprint
# the 'url_prefix' parameter means all routes defined in the blueprint will
# be registered with the prefix '/auth' (e.g., '/auth/login')
app.register_blueprint(auth_blueprint, url_prefix='/auth')
# register 'search' blueprint with Flask application
from .search import search as search_blueprint
# the 'url_prefix' parameter means all routes defined in the blueprint will
# be registered with the prefix '/search' (e.g., '/search/_prefetch')
app.register_blueprint(search_blueprint, url_prefix='/search')
# register 'api' blueprint with Flask application
from .api import api as api_blueprint
# the 'url_prefix' parameter means all routes defined in the blueprint will
# be registered with the prefix '/_api' (e.g., '/_api/relationships')
app.register_blueprint(api_blueprint, url_prefix='/_api')
return app