def init_ext(app):
app.config['SECRET_KEY'] = '110'
Session(app=app)
app.register_blueprint(blueprint=blue)
db.init_app(app=app)
migrate = Migrate()
migrate.init_app(app=app,db=db)
def init_ext(app):
# session
app.config['SECRET_KEY'] = '119'
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_KEY_PREFIX'] = 'python1905'
Session(app=app)
# sqlalchemy
db.init_app(app=app)
# migrate
migrate = Migrate()
migrate.init_app(app=app, db=db)
# flask-bootstrap
Bootstrap(app=app)
# flask-debugtoolbar
# app.debug = True
# debugtoolbar = DebugToolbarExtension()
# debugtoolbar.init_app(app=app)
# flask-cache
# 如果cache在方法内 那么导包是不可以的 需要将这个遍历防到方法外
# cache = Cache(config={'CACHE_TYPE':'redis'})
# 如果报错 ImportError: No module named 'flask.ext'
# 解决方法：（1）打开site-packages
# (2) flask-cache下的jinja2ext.py
# (3) 修改from flask.ext.cache import make_template_fragment_key为
# from flask_cache import make_template_fragment_key
cache.init_app(app=app)
def create_app(config_class='development'):
''' Method to initalize app and it's api routes.
'''
app = Flask(__name__, root_path='insurance_api/')
app.config.from_object(config_settings[config_class])
jwt = JWTManager(app)
api = Api(app)
from insurance_api.resources import (Registration, Login, Questionaire,
Secret)
from insurance_api.models import db
db.init_app(app)
migrate = Migrate()
migrate.init_app(app, db)
api.add_resource(Registration, '/registration')
api.add_resource(Login, '/login')
api.add_resource(Questionaire, '/questionaire')
api.add_resource(Secret, '/secret')
@app.errorhandler(ValidationError)
def handle_bad_request(e):
return e.messages, 422
return app
def init_db(app):
with app.app_context():
db.init_app(app)
db.create_all()
migrate = Migrate(app, db)
migrate.init_app(app, db)
def create_app():
# initializing the app
print("\n[INITIALIZING THE APP...]")
from src.main import App
app = App(instance_path=add_sys_paths()[0])
print("\n[INITIALIZING THE DATABASE...]")
db.init_app(app=app)
# migrating Models to DB
from flask_migrate import Migrate
print("\n\n[MIGRATING THE DATABASE...]")
migrate = Migrate()
with app.app_context():
# allow dropping column for sqlite
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
# importing all model (tables) is needed for flask-migrate to detect changes
from main.modules.user import user_model
from main.modules.project import project_model
print('\n\n[NEW APP RETURNED...]')
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
# init all extensions with app
db.init_app(app)
crypt.init_app(app)
login_manger.init_app(app)
mail.init_app(app)
# Admin panel
admin.init_app(app)
# init migrating database
# use flask cli to run: flask db init or pipenv run python manage.py db init
# to create migrations folder
migrate = Migrate()
migrate.init_app(app, db)
# import all blueprints here
from blog.users.routes import users
from blog.posts.routes import posts
from blog.main.routes import main
from blog.errors.handlers import errors
# import admin blueprint
from blog.admin import admin_bp
# then run these blueprints
app.register_blueprint(users)
app.register_blueprint(posts)
app.register_blueprint(main)
app.register_blueprint(errors)
# add admin blueprint
app.register_blueprint(admin_bp)
return app
def create_app(test_config=None):
# todo: setup app.logger
logger.info(f'ENV: {ENV}')
app = Flask(__name__, instance_relative_config=False)
CORS(app, resources=r'/api/*')
logging.getLogger('flask_cors').level = logging.DEBUG
conf = test_config if test_config else Config
app.config.from_object(conf)
db.init_app(app)
mirgate = Migrate()
mirgate.init_app(app, db)
bcrypt.init_app(app)
jwt.init_app(app)
app.register_blueprint(auth_blueprint, url_prefix='/api')
app.register_blueprint(instruction_document_blueprint,
url_prefix='/api/instruction-documents')
app.register_blueprint(files_blueprint, url_prefix='/api/files')
app.register_error_handler(
Exception, error_response
) # todo: err hanlding in error_response -> blueprint register default error_response
app.before_request(check_json_content_type)
with app.app_context():
create_default_groups()
return app
def init_app(app):
print("INIT: DATABASE")
db.init_app(app)
# add new models here
from . import users, posts, tweet
migrate = Migrate()
migrate.init_app(app, db)
def create_test_app():
migrate = Migrate()
db = SQLAlchemy()
login = LoginManager()
login.login_view = 'auth.login'
login.login_message = 'Please log in to access this page.'
bootstrap = Bootstrap()
babel = Babel()
app = Flask(__name__)
app.config.from_object(Config)
migrate.init_app(app, db)
login.init_app(app)
bootstrap.init_app(app)
babel.init_app(app)
from {{cookiecutter.project_slug}}.errors import bp as errors_bp # noqa: E402
app.register_blueprint(errors_bp)
from {{cookiecutter.project_slug}}.auth import bp as auth_bp # noqa: E402
app.register_blueprint(auth_bp, url_prefix='/auth')
from {{cookiecutter.project_slug}}.main import bp as main_bp # noqa: E402
app.register_blueprint(main_bp)
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
bcrypt.init_app(app)
migrate = Migrate(app, db)
migrate.init_app(app)
login_manager.init_app(app)
csrf_token.init_app(app)
from acsystem.user.routes import users
from acsystem.company.routes import company
from acsystem.main.routes import main
from acsystem.customer.routes import customers
from acsystem.supplier.routes import suppliers
from acsystem.groupledger.routes import groupledgers
from acsystem.product.routes import products
from acsystem.transactions.routes import transactions
from acsystem.tax.routes import taxes
app.register_blueprint(users)
app.register_blueprint(company)
app.register_blueprint(main)
app.register_blueprint(customers)
app.register_blueprint(suppliers)
app.register_blueprint(groupledgers)
app.register_blueprint(products)
app.register_blueprint(transactions)
app.register_blueprint(taxes)
return app
def create_app(config=None):
"""The kickstarter which creates a Flask application and sets up the
rest of the framework for Sowingo's Microservices Template's application.
This method initializes all the core extensions, services and modules
required to run the Sowingo's Microservices Template Flask Application.
:param:`config` - An optional argument to be used when setting up the
current flask app's config. See `app.config`
:returns:`app` - Returns the current initialized flask application.
"""
logger.info('Init :: Creating Flask Application')
app = flask.Flask(__name__)
migrate = Migrate()
logger.info('Init :: Loading Application Settings')
app.config.from_object('api.settings')
logger.info('Init :: Loading Core Extensions')
for extension in EXTENSIONS:
extension.init_app(app)
migrate.init_app(app, extension)
logger.info('Init :: Initializing Service Registry')
app.services = core.services.ServiceRegistry(app)
logger.info('Init :: Registering Modules')
for module_name in MODULES:
module = importlib.import_module(module_name)
initialize_module(app, module)
logger.debug('Init :: Welcome to Sowingo\'s Microservices Template Application' \
+ ' [app_version: {}]'.format(version))
return app
def init_ext(app):
db.init_app(app=app)
migrate = Migrate(app, db)
migrate.init_app(app=app, db=db)
login_manager.init_app(app=app)
login_manager.login_view = 'login.sign_in'
mail.init_app(app)
def create_app():
app = Flask(__name__)
app.config.from_mapping(config)
from core.cli import CLI
from core.database import db
from apps.user import UserModule
from apps.post import PostModule
from apps.comment import CommentModule
from apps.category import CategoryModule
from apps.file import FileModule
cli = CLI()
cors = CORS()
migrate = Migrate()
user = UserModule()
post = PostModule()
comment = CommentModule()
category = CategoryModule()
file = FileModule()
cors.init_app(app)
cli.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
user.init_app(app)
post.init_app(app)
comment.init_app(app)
category.init_app(app)
file.init_app(app)
return app
def db(app):
"""Create database for the tests."""
_db.app = app
# If the backup db exists, use it
# if not, create it from scratch and save it for other tests
if BACKUP_DB_PATH.is_file():
copy(BACKUP_DB_PATH, TEST_DB_PATH)
else:
with app.app_context():
migrate = Migrate()
migrate.init_app(app, _db)
upgrade()
test_data_records(_db, limit=TEST_RECORDS)
test_data_medals(_db)
DonorsOverview.refresh_overview()
copy(TEST_DB_PATH, BACKUP_DB_PATH)
yield _db
# Explicitly close DB connection
_db.session.close()
def create_app():
"""Construct the core application."""
app = Flask(__name__, template_folder="templates")
app.config.from_pyfile("config.py")
db.init_app(app)
migrate = Migrate(app, db)
# Add and init LoginManager instance
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"
# Add Blueprints
app.register_blueprint(user_blueprint)
app.register_blueprint(stonk_blueprint)
with app.app_context():
from . import routes
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
@login_manager.unauthorized_handler
def unauthorized_callback():
return redirect(url_for('user.login'))
# render_as_batch for renaming columns in SQLite
if db.engine.url.drivername == "sqlite":
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
return app
def setup_db(app, database_path=database_path):
app.config["SQLALCHEMY_DATABASE_URI"] = database_path
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.app = app
migrate = Migrate()
db.init_app(app)
migrate.init_app(app, db)
def create_app():
app = Flask(__name__)
load_dotenv()
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv("DATABASE")
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['DEBUG'] = True
db.init_app(app)
ma.init_app(app)
migrate = Migrate(app, db)
manager = Manager(app)
from .routes.user import user_bp
app.register_blueprint(user_bp)
from .routes.product import product_bp
app.register_blueprint(product_bp)
from .routes.category import category_bp
app.register_blueprint(category_bp)
swagger_bp = get_swaggerui_blueprint(swagger_url,
api_url,
config={'app_name': "Flask-StoreAPI"})
app.register_blueprint(swagger_bp, url_prefix=swagger_url)
migrate.init_app(app, db)
manager.add_command('db', MigrateCommand)
return manager
def create_app(settings_module):
app = Flask(__name__, instance_relative_config=True)
# Load the config file specified by the APP environment variable
app.config.from_object(settings_module)
# Load the configuration from the instance folder
if app.config.get('TESTING', False):
app.config.from_pyfile('config-testing.py', silent=True)
else:
app.config.from_pyfile('config.py', silent=True)
db.init_app(app)
# configurar flask migrate
migrate = Migrate()
migrate.init_app(app, db)
login_manager.init_app(app)
login_manager.login_view = "auth.login"
db.init_app(app)
# Registro de los Blueprints
from .auth import auth_bp
app.register_blueprint(auth_bp)
from .admin import admin_bp
app.register_blueprint(admin_bp)
from .public import public_bp
app.register_blueprint(public_bp)
return app
def create_app(script_info=None):
app = Flask(__name__, instance_relative_config=True)
# carrega a configuracao baseado no variavel de ambiente FLASK_CONFIG
# ou utiliza a configuracao para um ambiente de desenvolvimento
config_name = os.getenv('FLASK_CONFIG', 'development')
# configuracoes padroes baseadas no ambiente
app.config.from_object(CONFIG_NAME_MAPPER[config_name])
with app.app_context():
# registra database
from app.models import db
db.init_app(app)
# inicia extensao de migrate
migrate = Migrate()
migrate.init_app(app=app, db=db)
# registra modulo de autenticacao
from app.auth import jwt
jwt.init_app(app)
# registra modulos de resources
from app import auth
auth.init_app(app)
from app import api
api.init_app(app)
return app
def create_app():
"""Construct the core application."""
app = Flask(__name__,
instance_relative_config=True,
static_folder='./uploads')
CORS(app)
app.config.from_object('config.Config')
app.config['JWT_SECRET_KEY'] = 'jwt-secret-string'
jwt = JWTManager(app)
db.init_app(app)
migrate = Migrate(app, db)
ma.init_app(app)
logging.getLogger('flask_cors').level = logging.DEBUG
with app.app_context():
from application.users.routes import user_profile
from application.items.routes import item_profile
from application.reviews.routes import review_profile
from application.addresses.routes import address_profile
from application.accounts.routes import account_profile
app.register_blueprint(user_profile)
app.register_blueprint(item_profile)
app.register_blueprint(review_profile)
app.register_blueprint(address_profile)
app.register_blueprint(account_profile)
migrate.init_app(app, db)
db.create_all()
return app
def create_app(extra_config_settings={}):
# Instantiate Flask extensions
db = SQLAlchemy()
auth = HTTPBasicAuth()
# mail = Mail()
migrate = Migrate()
"""Create a Flask application.
"""
# Instantiate Flask
app = Flask(__name__)
# Load common settings
app.config.from_object('app.settings')
# Load environment specific settings
app.config.from_object('app.local_settings')
# Load extra settings from extra_config_settings param
app.config.update(extra_config_settings)
# Setup Flask-SQLAlchemy
db.init_app(app)
# Setup Flask-Migrate
migrate.init_app(app, db)
# Setup CORS
CORS(app)
# Register blueprints
from .views import register_blueprints
register_blueprints(app)
return app
def configure(self):
# Create the app
app = Flask(__name__)
# Disable CORS
CORS(app)
# Setup the TMDB API client
tmdb = Tmdb(self.tmdb_key, db)
# Set up the database
database = Database(db)
app.config['SQLALCHEMY_DATABASE_URI'] = self.database_uri
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# Get the executable schema
schema = get_schema(tmdb, database)
# Setup migrations
migrate = Migrate(app, db)
db.init_app(app)
migrate.init_app(app, db)
# Run migrations
with app.app_context():
upgrade(directory=os.path.join(os.path.dirname(__file__), "..",
"migrations"))
# Register the routes
register_routes(app, schema, self.backend_secret)
# Expose the Flask app
self.app = app
def create_app(config_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
db.init_app(app)
migrate = Migrate()
migrate.init_app(app, db)
app.config['SECRET_KEY'] = 'key_secret'
return app
def create_app(config_class=Config):
app.config.from_object(config_class)
from application import routes, forms
from application.models import db
db.init_app(app)
migrate = Migrate()
migrate.init_app(app, db)
return app
def register_extensions(app):
db.init_app(app)
app.app_context().push()
migrate = Migrate()
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
class Database(SQLAlchemy):
def __init__(self):
super().__init__()
self.migrate = Migrate()
def init_app(self, app):
super().init_app(app)
self.migrate.init_app(app, self)
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
migrate = Migrate(app=app, db=db)
migrate.init_app(app)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
restful_api(app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object('config.Config')
app.register_blueprint(routes.routes)
db.init_app(app)
migrate = Migrate(app, db, directory=Config.MIGRATIONS_DIRECTORY)
migrate.init_app(app, db)
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
# Database
db.init_app(app)
migrate = Migrate()
migrate.init_app(app, db)
register_resources(app, '/api')
return app
def init_app(app, db):
migrate = Migrate(app, db)
with app.app_context():
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
return migrate
def register_exts(app):
db.init_app(app)
db.app = app
cache.init_app(app)
migrate = Migrate()
migrate.init_app(app, db)
register_login(app)
if not app.config.get('TESTING'):
register_admins(app)
def register_extensions(app):
"""
Import and register flask extensions and initialize with app object
"""
from app.assets import env
env.init_app(app)
from app.extensions import db
db.init_app(app)
# XXX avoids "RuntimeError: application not registered on db instance and
# no application bound to current context" when accessing db outside of app
# context
db.app = app
from flask_migrate import Migrate
from sqlalchemy.exc import ArgumentError
migrate = Migrate()
# XXX SQLite chokes on constraint changes without this
with app.app_context():
try:
render_as_batch = db.engine.url.drivername == 'sqlite'
# XXX this happens during a test
except ArgumentError:
render_as_batch = True
migrate.init_app(app, db, render_as_batch=bool(render_as_batch))
from flask_humanize import Humanize
Humanize(app)
from flask_security import Security
from app.extensions import user_datastore
from app.main.models import AnonymousUser, Role, User
user_datastore.role_model = Role
user_datastore.user_model = User
Security(app, user_datastore, anonymous_user=AnonymousUser)
from app.extensions import notify
notify.init_app(app)
from app.oidc_client import OIDCClient
OIDCClient(app)
from app.extensions import pay
pay.init_app(app)
def register_extensions(app):
"""
Import and register flask extensions and initialize with app object
"""
from app.assets import env
env.init_app(app)
from app.extensions import db
db.init_app(app)
# XXX avoids "RuntimeError: application not registered on db instance and
# no application bound to current context" when accessing db outside of app
# context
db.app = app
from flask_migrate import Migrate
from sqlalchemy.exc import ArgumentError
migrate = Migrate()
# XXX SQLite chokes on constraint changes without this
with app.app_context():
try:
render_as_batch = db.engine.url.drivername == 'sqlite'
# XXX this happens during a test
except ArgumentError:
render_as_batch = True
migrate.init_app(app, db, render_as_batch=bool(render_as_batch))
from flaskext.markdown import Markdown
Markdown(app, extensions=app.config.get('MARKDOWN_EXTENSIONS', []))
from flask_humanize import Humanize
Humanize(app)
from app.extensions import oidc
oidc.init_app(app)
from flask_security import Security
from app.extensions import user_datastore
from app.blueprints.base.models import Role, User
user_datastore.role_model = Role
user_datastore.user_model = User
Security(app, user_datastore)
def add_sqlalchemy(self):
db.init_app(self)
migrate = Migrate()
migrate.init_app(self, db)
from coverage import coverage
from flask import current_app
from youngs_server.helpers.image_helper import save_json_image, generate_image_url
from youngs_server import app
from flask_migrate import Migrate, MigrateCommand
from flask_script import Shell, Manager, Server
from youngs_server.models.host_models import Member, Question, Review, Lecture
from youngs_server.youngs_app import db, youngs_redis
from youngs_server.common.time_util import today_obj, now_datetime
from youngs_server.youngs_app import log
app.config['RUN'] = False
manager = Manager(app)
migrate = Migrate()
migrate.init_app(app, db, directory="./migrations")
base_dir = os.path.dirname(os.getcwd())
config_dir = os.path.join(base_dir, 'app_server/config')
server = Server(host="0.0.0.0", port=8082)
manager.add_command('db', MigrateCommand)
@manager.command
def initall():
createdb()
initmember()
initlecture()
initquestion()
initreview()
initredis()
return 'success'
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from app import app, db
migrate = Migrate()
DATABASE_URI = getattr(app.config, 'SQLALCHEMY_DATABASE_URI', '')
is_sqlite = DATABASE_URI.startswith('sqlite:')
migrate.init_app(app, db, render_as_batch=is_sqlite)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
def create_app(config=None):
"""Create the Flask app instance that is used throughout the application.
Args:
config: Path to configuration file as a string or an object with config
directives.
Returns:
Application object (instance of flask.Flask).
"""
# Setup the Flask app and load the config.
app = Flask(
__name__, template_folder=u'ui/templates', static_folder=u'ui/static')
if not config:
config = u'/etc/timesketch.conf'
if isinstance(config, unicode):
os.environ[u'TIMESKETCH_SETTINGS'] = config
try:
app.config.from_envvar(u'TIMESKETCH_SETTINGS')
except IOError:
sys.stderr.write(
u'Config file {0} does not exist.\n'.format(config))
sys.exit()
else:
app.config.from_object(config)
# Make sure that SECRET_KEY is configured.
if not app.config[u'SECRET_KEY']:
sys.stderr.write(u'ERROR: Secret key not present. '
u'Please update your configuration.\n'
u'To generate a key you can use openssl:\n\n'
u'$ openssl rand -base64 32\n\n')
sys.exit()
# Setup the database.
configure_engine(app.config[u'SQLALCHEMY_DATABASE_URI'])
db = init_db()
# Alembic migration support:
# http://alembic.zzzcomputing.com/en/latest/
migrate = Migrate()
migrate.init_app(app, db)
# Register blueprints. Blueprints are a way to organize your Flask
# Flask application. See this for more information:
# http://flask.pocoo.org/docs/latest/blueprints/
app.register_blueprint(user_views)
app.register_blueprint(home_views)
app.register_blueprint(sketch_views)
app.register_blueprint(story_views)
# Setup URL routes for the API.
api_v1 = Api(app, prefix=u'/api/v1')
api_v1.add_resource(SketchListResource, u'/sketches/')
api_v1.add_resource(SketchResource, u'/sketches/<int:sketch_id>/')
api_v1.add_resource(
AggregationResource, u'/sketches/<int:sketch_id>/aggregation/')
api_v1.add_resource(ExploreResource, u'/sketches/<int:sketch_id>/explore/')
api_v1.add_resource(EventResource, u'/sketches/<int:sketch_id>/event/')
api_v1.add_resource(
EventAnnotationResource, u'/sketches/<int:sketch_id>/event/annotate/')
api_v1.add_resource(ViewListResource, u'/sketches/<int:sketch_id>/views/')
api_v1.add_resource(
ViewResource, u'/sketches/<int:sketch_id>/views/<int:view_id>/')
api_v1.add_resource(UploadFileResource, u'/upload/')
api_v1.add_resource(TaskResource, u'/tasks/')
api_v1.add_resource(
StoryListResource, u'/sketches/<int:sketch_id>/stories/')
api_v1.add_resource(
StoryResource, u'/sketches/<int:sketch_id>/stories/<int:story_id>/')
# Register error handlers
# pylint: disable=unused-variable
@app.errorhandler(ApiHTTPError)
def handle_api_http_error(error):
"""Error handler for API HTTP errors.
Returns:
HTTP response object (instance of flask.wrappers.Response)
"""
return error.build_response()
# Setup the login manager.
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = u'user_views.login'
# This is used by the flask_login extension.
# pylint: disable=unused-variable
@login_manager.user_loader
def load_user(user_id):
"""Based on a user_id (database primary key for a user) this function
loads a user from the database. It is used by the Flask-Login extension
to setup up the session for the user.
Args:
user_id: Integer primary key for the user.
Returns:
A user object (Instance of timesketch.models.user.User).
"""
return User.query.get(user_id)
# Setup CSRF protection for the whole application
CsrfProtect(app)
return app
from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from pyrwbs.config import Config app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy() db.init_app(app) from pyrwbs.models import TestStep, TestDesStep, TestCase, Run, CaseCollector, Collection migrate = Migrate() migrate.init_app(app, db) from .views import *
from flask_migrate import Migrate, MigrateCommand
from sqlalchemy.orm.exc import NoResultFound
from flask_script import Manager
from flask_mail import Mail
from flask_sqlalchemy import SQLAlchemy
from flask_security import Security, SQLAlchemyUserDatastore, login_required, current_user, user_registered
import datetime
from cloudinary import uploader
app = Flask(__name__)
app.config.from_object('kickstarter.default_settings')
manager = Manager(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
migrate.init_app(app, db, render_as_batch=True)
manager.add_command('db', MigrateCommand)
from kickstarter.models import *
from forms import ExtendedRegisterForm
user_datastore = SQLAlchemyUserDatastore(db, Member, Role)
security = Security(app, user_datastore, register_form=ExtendedRegisterForm)
mail = Mail(app)
import stripe
stripe.api_key = app.config["STRIPE_API_KEY"]
from mixpanel import Mixpanel
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='templates', static_folder='static')
if not config:
config = '/etc/timesketch.conf'
if isinstance(config, six.text_type):
os.environ['TIMESKETCH_SETTINGS'] = config
try:
app.config.from_envvar('TIMESKETCH_SETTINGS')
except IOError:
sys.stderr.write(
'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['SECRET_KEY']:
sys.stderr.write('ERROR: Secret key not present. '
'Please update your configuration.\n'
'To generate a key you can use openssl:\n\n'
'$ openssl rand -base64 32\n\n')
sys.exit()
# Plaso version that we support
if app.config['UPLOAD_ENABLED']:
try:
from plaso import __version__ as plaso_version
except ImportError:
sys.stderr.write('Upload is enabled, but Plaso is not installed.')
sys.exit()
app.config['PLASO_VERSION'] = plaso_version
# Setup the database.
configure_engine(app.config['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(auth_views)
app.register_blueprint(home_views)
app.register_blueprint(sketch_views)
# Setup URL routes for the API.
api_v1 = Api(app, prefix='/api/v1')
for route in V1_API_ROUTES:
api_v1.add_resource(*route)
# 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 = '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
