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
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
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
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
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
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
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
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
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
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
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
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__
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)
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
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
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
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
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
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