def create_app(app_name, config_obj):
    app = Flask(app_name)
    app.config.from_object(config_obj)
    app.db = SQLAlchemy(app)

    app.api = Api(app, prefix='/api/v1')
    app.api_registry = []
    app.migrate = Migrate(app, app.db)
    app.bcrypt = Bcrypt(app)
    app.manager = Manager(app)

    if not app.debug:
        import logging
        from logging.handlers import RotatingFileHandler
        file_handler = RotatingFileHandler(
            "/var/log/monitor/%s.log" %
            app.config.get("LOGFILE_NAME", app_name),
            maxBytes=500 * 1024)
        file_handler.setLevel(logging.ERROR)
        from logging import Formatter
        file_handler.setFormatter(
            Formatter('%(asctime)s %(levelname)s: %(message)s '
                      '[in %(pathname)s:%(lineno)d]'))
        app.logger.addHandler(file_handler)

    return app
Beispiel #2
0
def initialize_extensions(app: Flask):
    """
    initialize flask app extensions
    :param app:
    :return:
    """
    # import login manager
    from flask_login import LoginManager

    # Import Migrate
    from flask_migrate import Migrate

    # import sqlalchemy
    from flask_sqlalchemy import SQLAlchemy

    # Import bcrypt
    from flask_bcrypt import Bcrypt

    # import flask marshmallow
    from flask_marshmallow import Marshmallow

    # import database
    from .database import db

    # Define database object
    db.init_app(app)
    app.db = db

    # initialize migrate to manage db migrations
    Migrate(app, db)

    # add a rotating file handler
    handler = RotatingFileHandler('feature_requests.log',
                                  maxBytes=15000,
                                  backupCount=2)
    app.logger.addHandler(handler)

    # remove default logging handler
    app.logger.removeHandler(flask_logging.default_handler)

    # initialize flask login
    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = "core.login"
    app.login_manager = login_manager

    # setup bcrypt for encrypting password
    bcrypt = Bcrypt(app)
    app.bcrypt = bcrypt

    # initialize marshmallow for serialization
    marshmallow = Marshmallow(app)
    app.marshmallow = marshmallow

    return app
Beispiel #3
0
def create_app(app_name, config):
	
	app = Flask(app_name)
	app.config.from_object(config)

	app.db = SQLAlchemy(app)

	app.migrate = Migrate(app,app.db)

	app.bcrypt = Bcrypt(app)

	app.api = Api(app, prefix='/api/v1')

	app.api_registry = []

	return app
Beispiel #4
0
def create_app(app_name, config_obj, api_prefix='/api/v1'):
    """ Generates and configures the main application."""

    # Launching application
    app = Flask(app_name)  # So the engine would recognize the root package

    with app.app_context():
        # Load Configuration
        app.config.from_object(config_obj)

        # Loading assets
        assets = Environment(app)
        assets.from_yaml('assets.yaml')
        app.assets = assets

        # Initializing bcrypt password encryption
        bcrypt = Bcrypt(app)
        app.bcrypt = bcrypt

        # Initializing Database
        db = SQLAlchemy(app)
        app.db = db

        # Initializing login manager
        login_manager = LoginManager()
        login_manager.login_view = app.config.get('LOGIN_VIEW', '.login')

        login_manager.session_protection = 'strong'
        login_manager.init_app(app)
        app.login_manager = login_manager

        # Initializing principal manager
        app.principal = Principal(app)

        # Initializing Alembic
        alembic = Alembic()
        alembic.init_app(app)
        app.alembic = alembic

        api = Api(app, prefix=api_prefix)
        app.api = api

        # include an api_registry to the application
        app.api_registry = [
        ]  # a simple list holding the values to be registered

    return app
Beispiel #5
0
def create_app(config_name=None):
    # Setup Flask app
    assert env in (
        "development",
        "test",
        "production",
    ), f"{env} it not a valid environment."
    app = Flask(__name__)
    CORS(app)
    if config_name is None:
        app.config.from_object(app_config[APP_SETTINGS])
    else:
        app.config.from_object(app_config[config_name])
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['JWT_SECRET_KEY'] = 'admin'
    app.config['PROPAGATE_EXCEPTIONS'] = True
    db.init_app(app)
    jwt = JWTManager(app)
    jwt._set_error_handler_callbacks(api_blueprint)
    app.url_map.strict_slashes = app.config.get("STRICT_SLASHES", False)

    # Register blueprints
    blueprints = _load_object(Blueprint)
    for blueprint in blueprints:
        app.register_blueprint(blueprint)

    authenticators = []
    for auth_backend in app.config.get("AUTH_BACKENDS", []):
        module_name, class_name = auth_backend.rsplit(".", 1)
        module_name = 'project.' + module_name
        auth_initialized = getattr(importlib.import_module(module_name),
                                   class_name)(app)
        authenticators.append(auth_initialized)

    app.authenticators = authenticators

    app.bcrypt = Bcrypt(app)

    user_model = app.config.get("USER_MODEL")
    if user_model:
        module_name, class_name = user_model.rsplit(".", 1)
        module_name = 'project.' + module_name
        app.user_model = getattr(importlib.import_module(module_name),
                                 class_name)("", "")

    return app
Beispiel #6
0
def create_app():

    app = Flask(__name__)
    cors = CORS(app, resources={r"/api/*": {"origins": "*"}})

    try:
        app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('POSTGRES_CONNECTION') + os.environ.get('SQLALCHEMY_DATABASE_URI')
    except TypeError:
        app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/test'

    print 'app.config[SQLALCHEMY_DATABASE_URI] =', app.config['SQLALCHEMY_DATABASE_URI']

    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['SALT'] = '3W8y%,pP@)'
    app.app_context().push()
    init_views(app)
    app.bcrypt = Bcrypt(app)
    return app
Beispiel #7
0
def create_app():
    global app
    global l

    mode = os.environ.get("APP_MODE")

    assert mode is not None, "APP_MODE environment variable must be set"

    app = Flask(__name__)
    app.config.from_object("config.config_flask_{}".format(mode))

    setup_logging(app.config["LOGGING_LEVEL"])
    # logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
    # logging.getLogger('sqlalchemy.dialects').setLevel(logging.INFO)
    # logging.getLogger('sqlalchemy.pool').setLevel(logging.INFO)
    # logging.getLogger('sqlalchemy.orm').setLevel(logging.INFO)
    
    l = logging.getLogger(__name__)
    l.info("starting in mode {}".format(mode))

    app.jinja_env.globals.update(current_year=current_year)

    # Have to do this so that redirects work in proxy mode behind NGINX.
    if mode == "production":
        app.wsgi_app = ProxyFix(app.wsgi_app)

    app.db = SQLAlchemy(app)

    app.bcrypt = Bcrypt(app)
    app.assets = Environment(app)

    login_manager = LoginManager()
    login_manager.login_view = "signin"
    login_manager.login_message_category = "alert"  # Need newer release of Flask-Login for this to work.
    login_manager.init_app(app)

    from app import views
    from app import models

    app.backend = Backend()
    app.backend.start()
    
    return app
Beispiel #8
0
def create_app():
    application = Flask(__name__)
    with application.app_context():
        application.config.from_object(os.environ['APP_SETTINGS'])

        # initialising database
        application.db = db
        application.db.init_app(application)
        application.db.create_all()

        application.bcrypt = Bcrypt(application)
        application.jwt = jwt.init_app(application)

        # registering blueprints
        application.register_blueprint(auth_blueprint)
        application.register_blueprint(general_blueprint)
        application.register_blueprint(data_sources_blueprint)

        application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
        application.debug = application.config['DEBUG']
        CORS(application, resources={r"/*": {"origins": "*"}})
    return application
Beispiel #9
0
def create_app():
    app = Flask(__name__, instance_relative_config=True)

    # Config
    app.config.from_object('config')
    app.config.from_pyfile('application.cfg', silent=True)

    # Extension setup
    app.bcrypt = Bcrypt(app)  # -*- coding: utf-8 -*-
    app.login_manager = LoginManager(app)
    app.login_manager.user_loader(
        lambda user_id: User(user_id, is_authenticated=True))
    app.login_manager.login_view = 'pages.login'
    app.login_manager.needs_refresh_message = 'Please log in again to continue.'
    app.mongo = PyMongo(app)
    app.sg = sendgrid.SendGridAPIClient(apikey=app.config['SENDGRID_API_KEY'])
    app.ts = URLSafeTimedSerializer(app.config['SECRET_KEY'])
    # Blueprints
    app.register_blueprint(pages)

    # with app.app_context():
    #     setup_db()

    return app
Beispiel #10
0
def create_app():
    app = Flask(__name__)
    DATABASE_URI = 'postgresql://' + os.environ['DATABASE_LOGIN'] + ':'\
        + os.environ['DATABASE_PASSWORD'] + '@'\
        + os.environ['DATABASE_HOST'] + '/'\
        + os.environ['DATABASE_NAME']
    app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URI
    print(DATABASE_URI)
    # Avoid SQLAlchemy to track when objects changes.
    # Will be disabled by default in the future
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

    app.config[
        'UPLOADED_PHOTOS_DEST'] = os.environ['APP_DIRECTORY'] + 'static/img/'
    photos = UploadSet('photos', IMAGES)
    configure_uploads(app, (photos, ))

    from model import db
    db.init_app(app)
    app.db = db
    app.photos = photos

    app.algoClient = algoliasearch.Client("ADD_CLIENT_ID", 'ADD_KEY_ID')
    app.indexMedia = app.algoClient.init_index('media')
    app.indexNews = app.algoClient.init_index('news')
    app.indexArtist = app.algoClient.init_index('artist')

    with app.app_context():
        from auth import auth
        from crud import crud
    app.register_blueprint(auth)
    app.register_blueprint(crud)

    app.bcrypt = Bcrypt(app)

    return app
Beispiel #11
0
from app.api_1_0 import blueprint as api

# configure according which machine we're running
module = __import__('config')
configuration = getattr(module, os.getenv('LOCAL_ENV', 'ProductionEnvironment'))

# Basic App initialization     ===============================================

app = Flask(__name__)
app.config.from_object(configuration)

app.appBucket = Bucket('couchbase://' + app.config['CB_HOST'] + '/' + app.config['CB_APP_BUCKET'])
app.userBucket = Bucket('couchbase://' + app.config['CB_HOST'] + '/' + app.config['CB_USERS_BUCKET'])

jwt = JWT(app)
app.bcrypt = Bcrypt(app)

# initialize JWT authentication  ======================================
@jwt.authentication_handler
def authenticate(username, password):
    bucket = app.userBucket
    print '@authentication handler'
    user = []
    try:
        q = N1QLQuery('SELECT * FROM ' + app.config['CB_USERS_BUCKET'] + ' WHERE username = $user', user=username)
        results = bucket.n1ql_query(q)

        print vars(results)

        resultsCount = 0
Beispiel #12
0
import os
import binascii
from functools import wraps
import markdown

from flask import Flask, request, abort, Markup
from flask_bcrypt import Bcrypt
from flask_login import LoginManager, current_user
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_wtf.csrf import CSRFProtect

# Flask convention is to use `app`
app = Flask(__name__)  # pylint: disable=invalid-name
Bootstrap(app)
app.bcrypt = Bcrypt()
app.db = SQLAlchemy()

app.login_manager = LoginManager()
app.login_manager.login_view = 'login_page'


def init_app():
    app.bcrypt.init_app(app)
    app.db.init_app(app)
    app.login_manager.init_app(app)
    CSRFProtect(app)


try:
    from collegejump._version import __version__
Beispiel #13
0
class MongoEngineJSONEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, BaseDocument):
            return json_util._json_convert(obj.to_mongo())
        elif isinstance(obj, BaseQuerySet):
            return json_util._json_convert(obj.as_pymongo())
        return JSONEncoder.default(self, obj)


api_bp = Blueprint('api', __name__)
api = Api(api_bp)
# Twitter
api.add_resource(TwitterCrawler, '/requesters/crawlTwitter/')
# Flickr
api.add_resource(FlickrCrawler, '/requesters/crawlFlickr/')
# Imgur
api.add_resource(ImgurCrawler, '/requesters/crawlImgur/')

app = Flask(__name__)
app.json_encoder = MongoEngineJSONEncoder
app.register_blueprint(api_bp)
app.bcrypt = Bcrypt(app)


@app.route('/')
def index():
    return jsonify({'status': 200, 'success': True})


app.run(host='localhost', port=9000)
Beispiel #14
0
def create_app(config='config/genocrowd.ini',
               app_name='genocrowd',
               blueprints=None):
    """Create the Genocrowd app

    Parameters
    ----------
    config : str, optional
        Path to the config file
    app_name : str, optional
        Application name
    blueprints : None, optional
        Flask blueprints

    Returns
    -------
    Flask
        Genocrowd Flask application
    """
    conf = configparser.ConfigParser()
    conf.read(config)
    sentry_dsn = None
    try:
        sentry_dsn = conf['sentry']['server_dsn']
    except Exception:
        pass
    if sentry_dsn:
        version = get_distribution('genocrowd').version
        name = get_distribution('genocrowd').project_name
        sentry_sdk.init(dsn=sentry_dsn,
                        release="{}@{}".format(name, version),
                        integrations=[FlaskIntegration(),
                                      CeleryIntegration()])
    app = Flask(app_name, static_folder='static', template_folder='templates')
    app.iniconfig = FlaskIni()
    with app.app_context():
        app.iniconfig.read(config)
        proxy_path = None
        try:
            proxy_path = app.iniconfig.get('genocrowd', 'reverse_proxy_path')
            app.config['REVERSE_PROXY_PATH'] = proxy_path
        except Exception:
            pass
        mongo_dbname = app.iniconfig.get('flask', 'mongo_dbname')
        app.config['MONGO_DBNAME'] = mongo_dbname
        mongo_uri = app.iniconfig.get('flask', 'mongo_uri')
        app.config['MONGO_URI'] = mongo_uri
        if not mongo_uri:
            raise Exception("Missing mongo_uri in config file")
        if not mongo_dbname:
            raise Exception("Missing mongo_dbname in config file")
        app.mongo = PyMongo(app)
        app.bcrypt = Bcrypt(app)
        users = app.mongo.db.users
        app.mongo.db.genes
        app.mongo.db.answers
        groups = app.mongo.db.groups

        app.genocrowd_admin_email = app.iniconfig.get('genocrowd',
                                                      'genocrowd_admin_email')
        app.genocrowd_admin_password = app.iniconfig.get(
            'genocrowd', 'genocrowd_admin_password')

        app.apollo_admin_email = app.iniconfig.get('genocrowd',
                                                   'apollo_admin_email')
        app.apollo_admin_password = app.iniconfig.get('genocrowd',
                                                      'apollo_admin_password')
        app.apollo_dataset_path = app.iniconfig.get('genocrowd',
                                                    'apollo_dataset_path')
        app.apollo_org_id = app.iniconfig.get('genocrowd', 'apollo_org_id')
        app.apollo_url = app.iniconfig.get('genocrowd', 'apollo_url')
        # We don't want ending slash
        if app.apollo_url.endswith("/"):
            app.apollo_url = app.apollo_url[:-1]

        app.apollo_url_ext = app.iniconfig.get('genocrowd', 'apollo_url_ext')
        # We don't want ending slash
        if app.apollo_url_ext.endswith("/"):
            app.apollo_url_ext = app.apollo_url_ext[:-1]

        configure_logging(app)

        if users.find_one() is None:
            # Create default admin user
            local_auth = LocalAuth(app, None)
            local_auth.add_user_to_database('admin', app.genocrowd_admin_email,
                                            app.genocrowd_admin_password,
                                            'admin', 'admin')

        if blueprints is None:
            blueprints = BLUEPRINTS

        for blueprint in blueprints:
            app.register_blueprint(blueprint)

        if groups.find_one() is None:
            # Initiate the groups database
            data = Data(app, None)
            data.initiate_groups()

    if proxy_path:
        ReverseProxyPrefixFix(app)
    return app
Beispiel #15
0
def create_app(app_name, config_obj, with_api=True):
    """ Generates and configures the main shop application. All additional """
    # Launching application
    app = Flask(app_name)  # So the engine would recognize the root package

    # Load Configuration
    app.config.from_object(config_obj)

    # Initializing Database
    db = SQLAlchemy(app)
    app.db = db

    # migrate = Migrate(app, db)
    alembic = Alembic()
    alembic.init_app(app)
    app.alembic = alembic

    # Loading assets
    assets = Environment(app)
    assets.from_yaml('assets.yaml')
    app.assets = assets

    # Initialize Mail
    app.mail = Mail(app)

    # Initializing login manager
    login_manager = LoginManager()
    login_manager.login_view = app.config.get('LOGIN_VIEW', '.login')
    # login_manager.login_message = 'You need to be logged in to access this page'
    login_manager.session_protection = 'strong'
    login_manager.setup_app(app)
    app.login_manager = login_manager

    # Initializing principal manager
    app.principal = Principal(app)

    # Initializing bcrypt password encryption
    bcrypt = Bcrypt(app)
    app.bcrypt = bcrypt

    app.cloudinary = cloudinary
    app.cloudinary_upload = cloudinary_upload

    photos = UploadSet('photos', IMAGES)
    archives = UploadSet('archives', ARCHIVES)

    configure_uploads(app, (photos, archives))

    patch_request_class(app,
                        16 * 1024 * 1024)  # Patches to 16MB file uploads max.

    app.photos = photos
    app.archives = archives

    moment = Moment(app)
    app.moment = moment

    # Redis store for session management
    # The process running Flask needs write access to this directory:
    # store = RedisStore(redis.StrictRedis())

    # # this will replace the app'cs session handling
    # KVSessionExtension(store, app)

    # # configure sentry
    # if not app.config.get("DEBUG", False):
    # 	sentry = Sentry(app)

    # 	app.sentry = sentry

    # Integrate Elasticsearch

    # es_config = app.config.get("ES_CONFIG", [])

    # app.es = Elasticsearch(es_config)

    # Caching
    app.cache = Cache(app)

    # Initializing the restful API
    if with_api:
        api = Api(app, prefix='/v1')
        app.api = api

    # Initialize Logging
    if not app.debug:
        import logging
        from logging.handlers import RotatingFileHandler
        file_handler = RotatingFileHandler(
            "/var/log/kx/%s.log" % app.config.get("LOGFILE_NAME", app_name),
            maxBytes=500 * 1024)
        file_handler.setLevel(logging.INFO)
        from logging import Formatter
        file_handler.setFormatter(
            Formatter('%(asctime)s %(levelname)s: %(message)s '
                      '[in %(pathname)s:%(lineno)d]'))
        app.logger.addHandler(file_handler)

    # include an api_registry to the application
    app.api_registry = []  # a simple list holding the values to be registered

    return app
Beispiel #16
0
def create_app(app_name, config_obj, with_api=True):
	""" Generates and configures the main shop application. All additional """
	# Launching application
	app = Flask(app_name) # So the engine would recognize the root package

	# Load Configuration
	app.config.from_object(config_obj)

	# Loading assets
	assets = Environment(app)
	assets.from_yaml('assets.yaml')
	app.assets = assets

	# Initialize Mail
	app.mail = Mail(app)

	# Initializing login manager
	login_manager = LoginManager()
	login_manager.login_view = app.config.get('LOGIN_VIEW', 'main.index')
	# login_manager.login_message = 'You need to be logged in to access this page'
	login_manager.session_protection = 'strong'
	login_manager.setup_app(app)
	app.login_manager = login_manager

	# Initializing principal manager
	app.principal = Principal(app)

	# Initializing bcrypt password encryption
	bcrypt = Bcrypt(app)
	app.bcrypt = bcrypt

	# Initializing Database
	db = SQLAlchemy(app)
	app.db = db

	# Initializing Migrate
	migrate = Migrate(app, db, "from fitted.models import *")
	app.migrate = migrate

	photos = UploadSet('photos', IMAGES)
	archives = UploadSet('archives', ARCHIVES)

	configure_uploads(app, (photos, archives))

	patch_request_class(app, 2 * 1024 * 1024) # Patches to 2MB file uploads max.

	app.photos = photos
	app.archives = archives

	# Integrate Elasticsearch

	es_config = app.config.get("ES_CONFIG", [])

	app.es = Elasticsearch(es_config)

	# Integrate sms with Twilio
	app.sms = TwilioRestClient(app.config.get("TWILIO_API_SID"), app.config.get("TWILIO_API_TOKEN"))


	# Redis store for session management
	# The process running Flask needs write access to this directory:
	# store = RedisStore(redis.StrictRedis())

	# # this will replace the app's session handling
	# KVSessionExtension(store, app)

	# configure sentry
	# if not app.config.get("DEBUG", False):
	# 	sentry = Sentry(app)

	# 	app.sentry = sentry

	# inject celery into the app
	app.celery = make_celery(app)

	# injecting mongodb support
	# app.mongo = PyMongo(app)

	# flask s3 integration
	app.s3 = FlaskS3(app)


	# Facebook & Twitter Integration
	app.facebook = oauth.remote_app('facebook',
		app_key='FACEBOOK'
	)


	oauth.init_app(app)



	# Initializing the restful API
	if with_api:
		api = restful.Api(app, prefix='/api/v1')
		app.api = api

	# Initialize Logging
	if not app.debug:
		import logging
		from logging.handlers import RotatingFileHandler
		file_handler = RotatingFileHandler("/var/log/fitted/%s.log" % app.config.get("LOGFILE_NAME", app_name), maxBytes=500*1024)
		file_handler.setLevel(logging.WARNING)
		from logging import Formatter
		file_handler.setFormatter(Formatter(
		    '%(asctime)s %(levelname)s: %(message)s '
		    '[in %(pathname)s:%(lineno)d]'
		))
		app.logger.addHandler(file_handler)

	#include an api_registry to the application
	app.api_registry = [] #a simple list holding the values to be registered

	return app
Beispiel #17
0
def generate_app(db_uri=None,
                 db_options=None,
                 upload_folder=None,
                 secret_key=None,
                 allowed_extensions=None,
                 ll=None, vl=None, pl=None, flask_configs=None,
                 disable_admin_check=False):
    app = Flask(__name__)
    app.config['UPLOAD_FOLDER'] = upload_folder
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    if flask_configs:
        for k, v in flask_configs.items():
            app.config[k] = v
    app.secret_key = secret_key
    # ALLOWED_EXTENSIONS = set(ext for ext in re.split('[\s,]+',
    #                                                  allowed_extensions)
    #                          if ext is not None and ext != '')

    login_manager = LoginManager()
    login_manager.init_app(app)
    app.login_manager = login_manager
    login_manager.login_view = 'login'

    bcrypt = Bcrypt(app)
    app.bcrypt = bcrypt

    if pl is None:
        app.config['SQLALCHEMY_DATABASE_URI'] = db_uri

        opts = split_db_options(db_options)
        app.config['SQLALCHEMY_ENGINE_OPTIONS'] = opts

        db = SQLAlchemy(app)
        pl = SqlAlchemyPersistenceLayer(db)
    app.pl = pl

    class Options(object):
        @staticmethod
        def get(key, default_value=None):
            option = pl.get_option(key)
            if option is None:
                return default_value
            return option.value

        @staticmethod
        def get_title():
            return Options.get('title', 'Tudor')

        @staticmethod
        def get_revision():
            return __revision__

        @staticmethod
        def get_version():
            return __version__

        @staticmethod
        def get_author():
            return Options.get('author', 'the author')

        @staticmethod
        def get_user():
            if current_user is None:
                return pl.get_guest_user()

            try:
                user_id = current_user.id
                return pl.get_user(user_id)
            except AttributeError:
                return pl.get_guest_user()

    app.Options = Options

    if ll is None:
        ll = LogicLayer(upload_folder, allowed_extensions, pl)
    app.ll = ll

    if vl is None:
        vl = ViewLayer(ll, app.bcrypt)
    app.vl = vl

    # Flask setup functions

    @login_manager.user_loader
    def load_user(userid):
        return pl.get_user_by_email(userid)

    @login_manager.request_loader
    def load_user_with_basic_auth(request):
        api_key = request.headers.get('Authorization')
        if api_key:
            api_key = api_key.replace('Basic ', '', 1)
            api_key = base64.b64decode(api_key).decode('utf-8')
            email, password = api_key.split(':', 1)
            user = pl.get_user_by_email(email)

            if user is None:
                return None
            if user.hashed_password is None or user.hashed_password == '':
                return None
            if not bcrypt.check_password_hash(user.hashed_password, password):
                return None

            return user

    def admin_required(func):
        @wraps(func)
        def decorated_view(*args, **kwargs):
            if not disable_admin_check and not current_user.is_admin:
                return ('You are not authorized to view this page', 403)
            return func(*args, **kwargs)

        return decorated_view

    @app.context_processor
    def setup_options():
        return {'opts': Options}

    # View Functions

    @app.route('/')
    @login_required
    def index():
        return vl.index(request, Options.get_user())

    @app.route('/hierarchy')
    @login_required
    def hierarchy():
        return vl.hierarchy(request, Options.get_user())

    @app.route('/deadlines')
    @login_required
    def deadlines():
        return vl.deadlines(request, Options.get_user())

    @app.route('/task/new', methods=['GET'])
    @login_required
    def get_new_task():
        return vl.task_new_get(request, Options.get_user())

    @app.route('/task/new', methods=['POST'])
    @login_required
    def new_task():
        return vl.task_new_post(request, Options.get_user())

    @app.route('/task/<int:id>/mark_done')
    @login_required
    def task_done(id):
        return vl.task_mark_done(request, Options.get_user(), id)

    @app.route('/task/<int:id>/mark_undone')
    @login_required
    def task_undo(id):
        return vl.task_mark_undone(request, Options.get_user(), id)

    @app.route('/task/<int:id>/delete')
    @login_required
    def delete_task(id):
        return vl.task_delete(request, Options.get_user(), id)

    @app.route('/task/<int:id>/undelete')
    @login_required
    def undelete_task(id):
        return vl.task_undelete(request, Options.get_user(), id)

    @app.route('/task/<int:id>/purge')
    @login_required
    @admin_required
    def purge_task(id):
        return vl.task_purge(request, Options.get_user(), id)

    @app.route('/purge_all')
    @login_required
    @admin_required
    def purge_deleted_tasks():
        return vl.purge_all(request, Options.get_user())

    @app.route('/task/<int:id>')
    def view_task(id):
        return vl.task(request, Options.get_user(), id)

    @app.route('/task/<int:id>/hierarchy')
    def view_task_hierarchy(id):
        return vl.task_hierarchy(request, Options.get_user(), id)

    @app.route('/note/new', methods=['POST'])
    @login_required
    def new_note():
        return vl.note_new_post(request, Options.get_user())

    @app.route('/task/<int:id>/edit', methods=['GET', 'POST'])
    @login_required
    def edit_task(id):
        return vl.task_edit(request, Options.get_user(), id)

    @app.route('/attachment/new', methods=['POST'])
    @login_required
    def new_attachment():
        return vl.attachment_new(request, Options.get_user(),
                                 timestamp=datetime.utcnow())

    @app.route('/attachment/<int:aid>', defaults={'x': 'x'})
    @app.route('/attachment/<int:aid>/', defaults={'x': 'x'})
    @app.route('/attachment/<int:aid>/<path:x>')
    @login_required
    def get_attachment(aid, x):
        return vl.attachment(request, Options.get_user(), aid, x)

    @app.route('/task/<int:id>/up')
    @login_required
    def move_task_up(id):
        return vl.task_up(request, Options.get_user(), id)

    @app.route('/task/<int:id>/top')
    @login_required
    def move_task_to_top(id):
        return vl.task_top(request, Options.get_user(), id)

    @app.route('/task/<int:id>/down')
    @login_required
    def move_task_down(id):
        return vl.task_down(request, Options.get_user(), id)

    @app.route('/task/<int:id>/bottom')
    @login_required
    def move_task_to_bottom(id):
        return vl.task_bottom(request, Options.get_user(), id)

    @app.route('/long_order_change', methods=['POST'])
    @login_required
    def long_order_change():
        return vl.long_order_change(request, Options.get_user())

    @app.route('/task/<int:id>/add_tag', methods=['GET', 'POST'])
    @login_required
    def add_tag_to_task(id):
        return vl.task_add_tag(request, Options.get_user(), id)

    @app.route('/task/<int:id>/delete_tag', methods=['GET', 'POST'],
               defaults={'tag_id': None})
    @app.route('/task/<int:id>/delete_tag/', methods=['GET', 'POST'],
               defaults={'tag_id': None})
    @app.route('/task/<int:id>/delete_tag/<tag_id>', methods=['GET', 'POST'])
    @login_required
    def delete_tag_from_task(id, tag_id):
        return vl.task_delete_tag(request, Options.get_user(), id, tag_id)

    @app.route('/task/<int:task_id>/authorize_user', methods=['GET', 'POST'])
    @login_required
    def authorize_user_for_task(task_id):
        return vl.task_authorize_user(request, Options.get_user(), task_id)

    @app.route('/task/<int:task_id>/pick_user')
    @login_required
    def pick_user_to_authorize(task_id):
        return vl.task_pick_user(request, Options.get_user(), task_id)

    @app.route('/task/<int:task_id>/authorize_user/<int:user_id>',
               methods=['GET', 'POST'])
    @login_required
    def authorize_picked_user_for_task(task_id, user_id):
        return vl.task_authorize_user_user(request, Options.get_user(),
                                           task_id, user_id)

    @app.route('/task/<int:task_id>/deauthorize_user', methods=['GET', 'POST'],
               defaults={'user_id': None})
    @app.route('/task/<int:task_id>/deauthorize_user/',
               methods=['GET', 'POST'], defaults={'user_id': None})
    @app.route('/task/<int:task_id>/deauthorize_user/<int:user_id>',
               methods=['GET', 'POST'])
    @login_required
    def deauthorize_user_for_task(task_id, user_id):
        return vl.task_deauthorize_user(request, Options.get_user(), task_id,
                                        user_id)

    @app.route('/login', methods=['GET', 'POST'])
    def login():
        return vl.login(request, Options.get_user())

    @app.route('/logout')
    def logout():
        return vl.logout(request, Options.get_user())

    @app.route('/users', methods=['GET', 'POST'])
    @login_required
    @admin_required
    def list_users():
        return vl.users(request, Options.get_user())

    @app.route('/users/<int:user_id>', methods=['GET'])
    @login_required
    def view_user(user_id):
        return vl.users_user_get(request, Options.get_user(), user_id)

    @app.route('/show_hide_deleted')
    @login_required
    def show_hide_deleted():
        return vl.show_hide_deleted(request, Options.get_user())

    @app.route('/show_hide_done')
    @login_required
    def show_hide_done():
        return vl.show_hide_done(request, Options.get_user())

    @app.route('/options', methods=['GET', 'POST'])
    @login_required
    @admin_required
    def view_options():
        return vl.options(request, Options.get_user())

    @app.route('/option/<path:key>/delete')
    @login_required
    @admin_required
    def delete_option(key):
        return vl.option_delete(request, Options.get_user(), key)

    @app.route('/reset_order_nums')
    @login_required
    def reset_order_nums():
        return vl.reset_order_nums(request, Options.get_user())

    @app.route('/export', methods=['GET', 'POST'])
    @login_required
    @admin_required
    def export_data():
        return vl.export(request, Options.get_user())

    @app.route('/import', methods=['GET', 'POST'])
    @login_required
    @admin_required
    def import_data():
        return vl.import_(request, Options.get_user())

    @app.route('/task_crud', methods=['GET', 'POST'])
    @login_required
    @admin_required
    def task_crud():
        return vl.task_crud(request, Options.get_user())

    @app.route('/tags')
    @app.route('/tags/')
    @login_required
    def list_tags():
        return vl.tags(request, Options.get_user())

    @app.route('/tags/<int:id>')
    @login_required
    def view_tag(id):
        return vl.tags_id_get(request, Options.get_user(), id)

    @app.route('/tags/<int:id>/edit', methods=['GET', 'POST'])
    @login_required
    def edit_tag(id):
        return vl.tags_id_edit(request, Options.get_user(), id)

    @app.route('/task/<int:id>/convert_to_tag')
    @login_required
    def convert_task_to_tag(id):
        return vl.task_id_convert_to_tag(request, Options.get_user(), id)

    @app.route('/search', methods=['GET', 'POST'],
               defaults={'search_query': None})
    @app.route('/search/', methods=['GET', 'POST'],
               defaults={'search_query': None})
    @app.route('/search/<search_query>', methods=['GET'])
    @login_required
    def search(search_query):
        return vl.search(request, Options.get_user(), search_query)

    @app.route('/task/<int:task_id>/add_dependee', methods=['GET', 'POST'],
               defaults={'dependee_id': None})
    @app.route('/task/<int:task_id>/add_dependee/', methods=['GET', 'POST'],
               defaults={'dependee_id': None})
    @app.route('/task/<int:task_id>/add_dependee/<int:dependee_id>',
               methods=['GET', 'POST'])
    @login_required
    def add_dependee_to_task(task_id, dependee_id):
        return vl.task_id_add_dependee(request, Options.get_user(), task_id,
                                       dependee_id)

    @app.route('/task/<int:task_id>/remove_dependee',
               methods=['GET', 'POST'], defaults={'dependee_id': None})
    @app.route('/task/<int:task_id>/remove_dependee/',
               methods=['GET', 'POST'], defaults={'dependee_id': None})
    @app.route('/task/<int:task_id>/remove_dependee/<int:dependee_id>',
               methods=['GET', 'POST'])
    @login_required
    def remove_dependee_from_task(task_id, dependee_id):
        return vl.task_id_remove_dependee(request, Options.get_user(), task_id,
                                          dependee_id)

    @app.route('/task/<int:task_id>/add_dependant', methods=['GET', 'POST'],
               defaults={'dependant_id': None})
    @app.route('/task/<int:task_id>/add_dependant/', methods=['GET', 'POST'],
               defaults={'dependant_id': None})
    @app.route('/task/<int:task_id>/add_dependant/<int:dependant_id>',
               methods=['GET', 'POST'])
    @login_required
    def add_dependant_to_task(task_id, dependant_id):
        return vl.task_id_add_dependant(request, Options.get_user(), task_id,
                                        dependant_id)

    @app.route('/task/<int:task_id>/remove_dependant',
               methods=['GET', 'POST'], defaults={'dependant_id': None})
    @app.route('/task/<int:task_id>/remove_dependant/',
               methods=['GET', 'POST'], defaults={'dependant_id': None})
    @app.route('/task/<int:task_id>/remove_dependant/<int:dependant_id>',
               methods=['GET', 'POST'])
    @login_required
    def remove_dependant_from_task(task_id, dependant_id):
        return vl.task_id_remove_dependant(request, Options.get_user(),
                                           task_id, dependant_id)

    @app.route('/task/<int:task_id>/add_prioritize_before',
               methods=['GET', 'POST'],
               defaults={'prioritize_before_id': None})
    @app.route('/task/<int:task_id>/add_prioritize_before/',
               methods=['GET', 'POST'],
               defaults={'prioritize_before_id': None})
    @app.route(
        '/task/<int:task_id>/add_prioritize_before/<int:prioritize_before_id>',
        methods=['GET', 'POST'])
    @login_required
    def add_prioritize_before_to_task(task_id, prioritize_before_id):
        return vl.task_id_add_prioritize_before(request, Options.get_user(),
                                                task_id, prioritize_before_id)

    @app.route('/task/<int:task_id>/remove_prioritize_before',
               methods=['GET', 'POST'],
               defaults={'prioritize_before_id': None})
    @app.route('/task/<int:task_id>/remove_prioritize_before/',
               methods=['GET', 'POST'],
               defaults={'prioritize_before_id': None})
    @app.route(
        '/task/<int:task_id>/remove_prioritize_before/'
        '<int:prioritize_before_id>',
        methods=['GET', 'POST'])
    @login_required
    def remove_prioritize_before_from_task(task_id, prioritize_before_id):
        return vl.task_id_remove_prioritize_before(request, Options.get_user(),
                                                   task_id,
                                                   prioritize_before_id)

    @app.route('/task/<int:task_id>/add_prioritize_after',
               methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
    @app.route('/task/<int:task_id>/add_prioritize_after/',
               methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
    @app.route(
        '/task/<int:task_id>/add_prioritize_after/<int:prioritize_after_id>',
        methods=['GET', 'POST'])
    @login_required
    def add_prioritize_after_to_task(task_id, prioritize_after_id):
        return vl.task_id_add_prioritize_after(request, Options.get_user(),
                                               task_id, prioritize_after_id)

    @app.route('/task/<int:task_id>/remove_prioritize_after',
               methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
    @app.route('/task/<int:task_id>/remove_prioritize_after/',
               methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
    @app.route(
        '/task/<int:task_id>/remove_prioritize_after/'
        '<int:prioritize_after_id>',
        methods=['GET', 'POST'])
    @login_required
    def remove_prioritize_after_from_task(task_id, prioritize_after_id):
        return vl.task_id_remove_prioritize_after(request, Options.get_user(),
                                                  task_id, prioritize_after_id)

    @app.template_filter(name='gfm')
    def render_gfm(s):
        output = markdown.markdown(s, extensions=['gfm'])
        moutput = Markup(output)
        return moutput

    return app
Beispiel #18
0
def create_app(app_name, config_obj, with_api=True):
    """ Generates and configures the main shop application. All additional """
    # Launching application
    app = Flask(app_name)  # So the engine would recognize the root package

    # Load Configuration
    app.config.from_object(config_obj)

    # Loading assets
    assets = Environment(app)
    assets.from_yaml('assets.yaml')
    app.assets = assets

    # Initialize Mail
    app.mail = Mail(app)

    # Initializing login manager
    login_manager = LoginManager()
    login_manager.login_view = app.config.get('LOGIN_VIEW', 'main.index')
    # login_manager.login_message = 'You need to be logged in to access this page'
    login_manager.session_protection = 'strong'
    login_manager.setup_app(app)
    app.login_manager = login_manager

    # Initializing principal manager
    app.principal = Principal(app)

    # Initializing bcrypt password encryption
    bcrypt = Bcrypt(app)
    app.bcrypt = bcrypt

    # Initializing Database
    db = SQLAlchemy(app)
    app.db = db

    # Initializing Migrate
    migrate = Migrate(app, db, "from fitted.models import *")
    app.migrate = migrate

    photos = UploadSet('photos', IMAGES)
    archives = UploadSet('archives', ARCHIVES)

    configure_uploads(app, (photos, archives))

    patch_request_class(app,
                        2 * 1024 * 1024)  # Patches to 2MB file uploads max.

    app.photos = photos
    app.archives = archives

    # Integrate Elasticsearch

    es_config = app.config.get("ES_CONFIG", [])

    app.es = Elasticsearch(es_config)

    # Integrate sms with Twilio
    app.sms = TwilioRestClient(app.config.get("TWILIO_API_SID"),
                               app.config.get("TWILIO_API_TOKEN"))

    # Redis store for session management
    # The process running Flask needs write access to this directory:
    # store = RedisStore(redis.StrictRedis())

    # # this will replace the app's session handling
    # KVSessionExtension(store, app)

    # configure sentry
    # if not app.config.get("DEBUG", False):
    # 	sentry = Sentry(app)

    # 	app.sentry = sentry

    # inject celery into the app
    app.celery = make_celery(app)

    # injecting mongodb support
    # app.mongo = PyMongo(app)

    # flask s3 integration
    app.s3 = FlaskS3(app)

    # Facebook & Twitter Integration
    app.facebook = oauth.remote_app('facebook', app_key='FACEBOOK')

    oauth.init_app(app)

    # Initializing the restful API
    if with_api:
        api = restful.Api(app, prefix='/api/v1')
        app.api = api

    # Initialize Logging
    if not app.debug:
        import logging
        from logging.handlers import RotatingFileHandler
        file_handler = RotatingFileHandler(
            "/var/log/fitted/%s.log" %
            app.config.get("LOGFILE_NAME", app_name),
            maxBytes=500 * 1024)
        file_handler.setLevel(logging.WARNING)
        from logging import Formatter
        file_handler.setFormatter(
            Formatter('%(asctime)s %(levelname)s: %(message)s '
                      '[in %(pathname)s:%(lineno)d]'))
        app.logger.addHandler(file_handler)

    #include an api_registry to the application
    app.api_registry = []  #a simple list holding the values to be registered

    return app
Beispiel #19
0
def generate_app(db_uri=DEFAULT_SAWMILL_DB_URI,
                 secret_key=DEFAULT_SAWMILL_SECRET_KEY):

    app = Flask(__name__)
    app.secret_key = secret_key

    login_manager = LoginManager()
    login_manager.init_app(app)
    app.login_manager = login_manager
    login_manager.login_view = 'login'

    app.bcrypt = Bcrypt(app)

    app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
    db.init_app(app)
    app.db = db
    app.app_context().push()

    class Options(object):
        @staticmethod
        def get(key, default_value=None):
            option = Option.query.get(key)
            if option is None:
                return default_value
            return option.value

        @staticmethod
        def get_title():
            return Options.get('title', 'Sawmill')

        @staticmethod
        def get_revision():
            return __revision__

    @app.context_processor
    def setup_options():
        return {'opts': Options}

    @app.route('/')
    @login_required
    def index():
        server = get_form_or_arg('server')
        filter_servers = session.get('filter_servers', [])
        filter_log_names = session.get('filter_log_names', [])
        query = LogEntry.query
        if filter_servers:
            query = query.filter(LogEntry.server.in_(filter_servers))
        if filter_log_names:
            query = query.filter(LogEntry.log_name.in_(filter_log_names))
        query = query.order_by(LogEntry.id)
        pager = query.paginate()
        all_servers = (s[0] for s in db.session.query(LogEntry.server).distinct()
            .order_by(LogEntry.server).all())
        all_log_names = (l[0] for l in db.session.query(LogEntry.log_name)
            .distinct().order_by(LogEntry.log_name).all())
        return render_template('index.t.html', pager=pager,
                               all_servers=all_servers, server=server,
                               filter_servers=filter_servers,
                               all_log_names=all_log_names,
                               izipl=itertools.izip_longest,
                               filter_log_names=filter_log_names)

    @app.route('/apply_filters', methods=["GET", "POST"])
    @login_required
    def apply_filters():
        if request.method == 'GET':
            return redirect(url_for('index'))
        filter_servers = []
        filter_log_names = []
        for k in request.form:
            if k.startswith('server_') and request.form[k]:
                s = k[7:]
                filter_servers.append(s)
            if k.startswith('log_name_') and request.form[k]:
                s = k[9:]
                filter_log_names.append(s)
        session['filter_servers'] = filter_servers
        session['filter_log_names'] = filter_log_names
        return redirect(url_for('index', filter_servers=filter_servers))

    @login_manager.user_loader
    def load_user(userid):
        return User.query.filter_by(email=userid).first()

    @login_manager.request_loader
    def load_user_with_basic_auth(request):
        api_key = request.headers.get('Authorization')
        if api_key:
            api_key = api_key.replace('Basic ', '', 1)
            api_key = base64.b64decode(api_key)
            email, password = api_key.split(':', 1)
            user = User.query.filter_by(email=email).first()

            if (user is None or
                    not app.bcrypt.check_password_hash(
                        user.hashed_password, password)):
                return None

            return user

    @app.route('/login', methods=['GET', 'POST'])
    def login():
        if request.method == 'GET':
            login_failed = request.args.get('login_failed')
            return render_template('login.t.html', login_failed=login_failed)
        email = request.form['email']
        password = request.form['password']
        user = User.query.filter_by(email=email).first()

        next_url = (request.args.get('next') or request.args.get('next_url') or
                    url_for('index'))

        if (user is None or
                not app.bcrypt.check_password_hash(user.hashed_password,
                                                   password)):
            flash('Username or Password is invalid', 'error')
            return redirect(url_for('login', login_failed=1,
                                    next_url=next_url))

        login_user(user)
        flash('Logged in successfully')
        return redirect(next_url)

    @app.route('/logout')
    def logout():
        logout_user()
        return redirect(url_for('index'))

    @app.route('/intake', methods=['POST'])
    @login_required
    def intake():
        json = request.get_json()
        timestamp = json['@timestamp']
        server = json['host']
        log_name = json['source']
        message = json['message']
        le = LogEntry(timestamp, server, log_name, message)
        db.session.add(le)
        db.session.commit()
        return ('', 204)

    return app