def create_app(): # Create a Flask application. # Instantiate Flask app = Flask(__name__) # Load App Config settings app.config['SECRET_KEY'] = 'mysecretkey' basedir = os.path.abspath(os.path.dirname(__file__)) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join( basedir, 'data.db') app.config['DEBUG'] = True app.config.from_object('app.settings') # Setup Flask-SQLAlchemy db.init_app(app) # Setup Flask-Migrate migrate.init_app(app, db, render_as_batch=True) # Setup Flask-Admin admin.init_app(app) # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter UserManager(db_adapter, app) # Init Flask-User and bind to app from app.main.views import main_blueprint app.register_blueprint(main_blueprint, url_prefix='/') from app.error_pages.handlers import error_pages app.register_blueprint(error_pages) return app
def init_app(app, db, extra_config_settings={}): # Initialize app config settings app.config.from_object( 'webrob.config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy from webrob.models import users from webrob.models import tutorials # Load all views.py files to register @app.routes() with Flask from webrob.pages import views from webrob.pages import editor from webrob.pages import log from webrob.pages import login init_db(app, db) return app
def create_app(extra_config_settings={}): """Create a Flask applicaction. """ # Instantiate Flask app = Flask(__name__) # Load App Config settings # Load common settings from 'app/settings.py' file app.config.from_object('app.settings') # Load local settings from 'app/local_settings.py' app.config.from_object('app.local_settings') # Load extra config settings from 'extra_config_settings' param app.config.update(extra_config_settings) # Setup Flask-Extensions -- do this _after_ app config has been loaded # Setup Flask-SQLAlchemy db.init_app(app) # Setup Flask-Migrate migrate.init_app(app, db) # Setup Flask-Mail mail.init_app(app) # Setup WTForms CSRFProtect csrf_protect.init_app(app) # Register blueprints from app.views.misc_views import main_blueprint app.register_blueprint(main_blueprint) from app.api import api_blueprint app.register_blueprint(api_blueprint) # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html from wtforms.fields import HiddenField def is_hidden_field_filter(field): return isinstance(field, HiddenField) app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup an error-logger to send emails to app.config.ADMINS init_email_error_handler(app) # Setup Flask-User to handle user account related forms from .models.user_models import User, MyRegisterForm from .views.misc_views import user_profile_page db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to app register_form= MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, ) return app
def create_app(): # Create a Flask application. # Instantiate Flask app = Flask(__name__) # Load App Config settings app.config['SECRET_KEY'] = 'mysecretkey' basedir = os.path.abspath(os.path.dirname(__file__)) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join( basedir, 'data.db') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['USER_ENABLE_EMAIL'] = False # Setup Flask-SQLAlchemy db.init_app(app) # Setup Flask-Migrate migrate.init_app(app, db, render_as_batch=True) # Setup Flask-Admin admin.init_app(app) # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter UserManager(db_adapter, app) # Init Flask-User and bind to app return app
def create_app(extra_config_settings={}): """ Initialize Flask applicaton """ # ***** Initialize app config settings ***** # Read common settings from 'app/startup/common_settings.py' file print "hello" app.config.from_object('app.startup.common_settings') # Read environment-specific settings from file defined by OS environment variable 'ENV_SETTINGS_FILE' env_settings_file = os.environ.get('ENV_SETTINGS_FILE', 'env_settings_example.py') app.config.from_pyfile(env_settings_file) # Read extra config settings from function parameter 'extra_config_settings' app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Migrate migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) # Setup Flask-Mail #mail = Mail(app) # Setup WTForms CsrfProtect CsrfProtect(app) # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html from wtforms.fields import HiddenField def is_hidden_field_filter(field): return isinstance(field, HiddenField) app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup an error-logger to send emails to app.config.ADMINS #init_email_error_handler(app) # Setup Flask-User to handle user account related forms from app.core.models import User, MyRegisterForm from app.core.views import user_profile_page db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to app register_form= MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, ) # Load all blueprints with their manager commands, models and views from app import core return app
def create_app(config: object) -> Flask: """Create the flask app. Can be called from testing contexts""" app = Flask(__name__) app.config.from_envvar("IIS_FLASK_SETTINGS") app.config.from_object(config) # Register blueprints from iis.jobs import jobs app.register_blueprint(jobs, url_prefix="/jobs") # Init db from .extensions import db db.init_app(app) from .models import User db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # noqa: F841 Migrate(app, db) from .extensions import csrf csrf.init_app(app) # Call app.logger to prevent it from clobbering configuration app.logger logging.config.dictConfig(app.config["LOGGING"]) app.logger.info("App configured.") return (app, user_manager)
def create_app(extra_config_settings={}): app = Flask(__name__) app.config.from_object('app.settings') db.init_app(app) # Setup Flask-SQLAlchemy csrf_protect.init_app(app) # Setup WTForms CSRFProtect # Register blueprints from app.views.misc_views import main_blueprint app.register_blueprint(main_blueprint) #Setup login-pass validator from wtforms.validators import ValidationError def my_password_validator(form, field): password = field.data if len(password) < 3: raise ValidationError(_('Password must have at least 3 characters')) def my_username_validator(form, field): username = field.data if len(username) < 3: raise ValidationError(_('Username must be at least 3 characters long')) if not username.isalnum(): raise ValidationError(_('Username may only contain letters and numbers')) # Setup Flask-User to handle user account related forms from .models.user_models import User, MyRegisterForm from .views.misc_views import user_profile_page db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager(db_adapter, app, # Init Flask-User and bind to app register_form=MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, password_validator=my_password_validator, username_validator=my_username_validator ) return app
def create_app(extra_config_settings={}): """Create a Flask applicaction. """ # Instantiate Flask app = Flask(__name__) # Load App Config settings app.config['JSON_AS_ASCII'] = False # Load common settings from 'app/settings.py' file app.config.from_object('app.settings') # Load local settings from 'app/local_settings.py' app.config.from_object('app.local_settings') # Load extra config settings from 'extra_config_settings' param app.config.update(extra_config_settings) oauth.init_app(app) # Setup Flask-SQLAlchemy db.init_app(app) # Setup WTForms CSRFProtect csrf.init_app(app) global CLIENT_ID global CLIENT_SECRET CLIENT_ID = app.config.setdefault('CLIENT_ID', '') CLIENT_SECRET = app.config.setdefault('CLIENT_SECRET', '') # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html from wtforms.fields import HiddenField def is_hidden_field_filter(field): return isinstance(field, HiddenField) app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup Flask-User to handle user account related forms from .models.user_models import User db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app app.app_context().push() # Applications global uandus_client uandus_client = UandusClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) # Register blueprints from app.views.main_views import main_blueprint from app.views.oauth_views import oauth_blueprint app.register_blueprint(main_blueprint) app.register_blueprint(oauth_blueprint) return app
def create_app(extra_config_settings={}): """ Initialize Flask applicaton """ import application.views app.config.from_object('config') # Read extra config settings from function parameter 'extra_config_settings' app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter app.config['LANGUAGE'] = 'pt_BR' if app.testing or app.config['TESTING']: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing app.config['LANGUAGE'] = 'en_US' app.config['BOOKCLOUD_URL_PREFIX'] = '' app.register_blueprint(application.views.bookcloud, url_prefix=app.config['BOOKCLOUD_URL_PREFIX']) # Setup Flask-Mail mail = Mail(app) # Create all database tables db.create_all() # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Register the User model user_manager = UserManager(db_adapter, app) # Initialize Flask-User return app
def populate_tables(): user_manager = UserManager( SQLAlchemyAdapter(db, UserModel, UserAuthClass=UserAuthModel), app) admin_defaults = daconfig.get('default admin account', dict()) if 'email' not in admin_defaults: admin_defaults['email'] = '*****@*****.**' if 'nickname' not in admin_defaults: admin_defaults['nickname'] = 'admin' if 'first_name' not in admin_defaults: admin_defaults['first_name'] = word('System') if 'last_name' not in admin_defaults: admin_defaults['last_name'] = word('Administrator') cron_defaults = daconfig.get( 'default cron account', { 'nickname': 'cron', 'email': '*****@*****.**', 'first_name': 'Cron', 'last_name': 'User' }) cron_defaults['active'] = False user_role = get_role(db, 'user') admin_role = get_role(db, 'admin') cron_role = get_role(db, 'cron') customer_role = get_role(db, 'customer') developer_role = get_role(db, 'developer') advocate_role = get_role(db, 'advocate') trainer_role = get_role(db, 'trainer') admin = get_user(db, admin_role, admin_defaults) cron = get_user(db, cron_role, cron_defaults) if admin.confirmed_at is None: admin.confirmed_at = datetime.datetime.now() if cron.confirmed_at is None: cron.confirmed_at = datetime.datetime.now() db.session.commit() add_dependencies(admin.id) git_packages = Package.query.filter_by(type='git') for package in git_packages: if package.name in [ 'docassemble', 'docassemble.base', 'docassemble.webapp', 'docassemble.demo' ]: package.giturl = None package.gitsubdir = None package.type = 'pip' db.session.commit() # docassemble_git_url = daconfig.get('docassemble git url', 'https://github.com/jhpyle/docassemble') # installed_packages = get_installed_distributions() # existing_packages = [package.name for package in Package.query.all()] # for package in installed_packages: # if package.key in existing_packages: # continue # package_auth = PackageAuth(user_id=admin.id) # if package.key in ['docassemble', 'docassemble.base', 'docassemble.webapp', 'docassemble.demo']: # package_entry = Package(name=package.key, package_auth=package_auth, giturl=docassemble_git_url, packageversion=package.version, gitsubdir=re.sub(r'\.', '_', package.key), type='git', core=True) # else: # package_entry = Package(name=package.key, package_auth=package_auth, packageversion=package.version, type='pip', core=True) # db.session.add(package_auth) # db.session.add(package_entry) return
def init_app(app, extra_config_settings={}): # Read common settings from 'app/settings.py' app.config.from_object('app.settings') # Read environment-specific settings from 'app/local_settings.py' try: app.config.from_object('app.local_settings') except ImportError: print( "The configuration file 'app/local_settings.py' does not exist.\n" + "Please copy app/local_settings_example.py to app/local_settings.py\n" + "and customize its settings before you continue.") exit() # Add/overwrite extra settings from parameter 'extra_config_settings' app.config.update(extra_config_settings) if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Initialize Flask-SQLAlchemy and Flask-Script _after_ app.config has been read db.init_app(app) # Setup Flask-Migrate migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) # Setup Flask-Mail mail = Mail(app) # Setup WTForms CsrfProtect CsrfProtect(app) # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html from wtforms.fields import HiddenField def is_hidden_field_filter(field): return isinstance(field, HiddenField) app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup an error-logger to send emails to app.config.ADMINS init_email_error_handler(app) # Setup Flask-User to handle user account related forms from app.models import User, MyRegisterForm from app.views import user_profile_page db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to app register_form= MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, ) import app.manage_commands
def populate_tables(): start_time = time.time() sys.stderr.write("populate_tables: starting\n") user_manager = UserManager( SQLAlchemyAdapter(db, UserModel, UserAuthClass=UserAuthModel), app) admin_defaults = daconfig.get('default admin account', dict()) if 'email' not in admin_defaults: admin_defaults['email'] = os.getenv('DA_ADMIN_EMAIL', '*****@*****.**') if 'nickname' not in admin_defaults: admin_defaults['nickname'] = 'admin' if 'first_name' not in admin_defaults: admin_defaults['first_name'] = word('System') if 'last_name' not in admin_defaults: admin_defaults['last_name'] = word('Administrator') if 'password' not in admin_defaults: admin_defaults['password'] = os.getenv('DA_ADMIN_PASSWORD', 'password') cron_defaults = daconfig.get( 'default cron account', { 'nickname': 'cron', 'email': '*****@*****.**', 'first_name': 'Cron', 'last_name': 'User' }) cron_defaults['active'] = False user_role = get_role(db, 'user') admin_role = get_role(db, 'admin') cron_role = get_role(db, 'cron') customer_role = get_role(db, 'customer') developer_role = get_role(db, 'developer') advocate_role = get_role(db, 'advocate') trainer_role = get_role(db, 'trainer') for user in UserModel.query.all(): if len(user.roles) == 0: user.roles.append(user_role) db.session.commit() admin = get_user(db, admin_role, admin_defaults) cron = get_user(db, cron_role, cron_defaults) if admin.confirmed_at is None: admin.confirmed_at = datetime.datetime.now() if cron.confirmed_at is None: cron.confirmed_at = datetime.datetime.now() db.session.commit() add_dependencies(admin.id) git_packages = Package.query.filter_by(type='git') for package in git_packages: if package.name in [ 'docassemble', 'docassemble.base', 'docassemble.webapp', 'docassemble.demo' ]: package.giturl = None package.gitsubdir = None package.type = 'pip' if daconfig.get('stable version', False): package.limitation = '<1.1.0' db.session.commit() sys.stderr.write("populate_tables: ending after " + str(time.time() - start_time) + "\n") return
def setup_auth(app, db): # Register the user manager with the app. # Each form that is customised needs to be added here. db_adapter = SQLAlchemyAdapter(db, User) _ = UserManager( db_adapter=db_adapter, # noqa app=app, register_form=CoLabRegisterForm)
def init_db(app): db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy # Define Role model class Role(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(50), unique=True) # Define the User data model. Make sure to add flask.ext.user UserMixin !!! class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) # User authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') # User email information email = db.Column(db.String(255), nullable=True, unique=True) confirmed_at = db.Column(db.DateTime()) # User information active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') roles = db.relationship('Role', secondary='user_roles') # FIXME: really not good performance wise def is_admin(self): for r in self.roles: if r.name == "hacker": return True return False # Define UserRoles model class UserRoles(db.Model): id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE')) role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE')) # Create all database tables db.create_all() user_db_adapter = SQLAlchemyAdapter(db, User) # Register the User model return db, user_db_adapter, User, Role
def init_app(extra_config_settings={}): # Initialize app config settings app.config.from_object( 'config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing if os.environ['EASE_DEBUG'] == 'true': app.config['DEBUG'] = True app.config['SECRET_KEY'] = app.config['DEV_SECRET_KEY'] else: try: app.config['SECRET_KEY'] = open('/etc/ease_secret/secret', 'rb').read() except IOError: app.config['SECRET_KEY'] = random_string(64) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from postgres.users import User db_adapter = SQLAlchemyAdapter(db, User) # Init Flask-User and bind to app app.user_manager = UserManager(db_adapter, app, password_validator=oe_password_validator) # Load all models.py files to register db.Models with SQLAlchemy from postgres import users from postgres import settings # Automatically create all registered DB tables db.create_all() db.session.commit() for role in USER_ROLES: create_role(role) # Load all views.py files to register @app.routes() with Flask from pages import main from pages import api from pages import neem_discovery from pages import editor from pages import tutorials from pages import oauth add_user(user_manager=app.user_manager, name='admin', mail=os.environ.get('OPENEASE_MAIL_USERNAME', '*****@*****.**'), pw=ADMIN_USER_DEFAULT_PW, roles=['admin']) app.logger.info("Webapp started.") return app
def create_app(): create_db() Babel(app) Mail(app) db_adapter = SQLAlchemyAdapter(db, models.User) UserManager(db_adapter, app) searcher = Searcher() init_routes(app, db.session, searcher) return app
def create_app(): """ Flask application factory """ # Setup Flask app and app.config app = Flask(__name__) app.config.from_object(__name__ + '.ConfigClass') # Initialize Flask extensions db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy mail = Mail(app) # Initialize Flask-Mail # Define the User data model. Make sure to add flask.ext.user UserMixin !!! class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) # User authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') # User email information email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) # User information active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') # Create all database tables db.create_all() # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Register the User model user_manager = UserManager(db_adapter, app) # Initialize Flask-User # The Home page is accessible to anyone @app.route('/') def home_page(): return render_template("home.html", story_list=[1, 2, 3, 4]) # The Members page is only accessible to authenticated users @app.route('/members') @login_required # Use of @login_required decorator def members_page(): return render_template("members.html") return app
def init_app(app, db, extra_config_settings={}): # Initialize app config settings app.config.from_object('webrob.config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config['WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing if os.environ['EASE_DEBUG'] == 'true': app.config['DEBUG'] = True app.config['SECRET_KEY'] = app.config['DEV_SECRET_KEY'] else: try: app.config['SECRET_KEY'] = open('/etc/ease_secret/secret', 'rb').read() except IOError: app.config['SECRET_KEY'] = random_string(64) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy from webrob.models import users from webrob.models import tutorials # Load all views.py files to register @app.routes() with Flask register_routes() init_db(app, db) if str(app.name) == 'login': # Initialize DB content init_user_roles(user_manager) init_admin_user(app, user_manager) db_adapter.commit() app.logger.info("Webapp started.") return app
def create_app(): """ Flask application factory """ # Setup Flask app and app.config app = Flask(__name__) app.config.from_object(__name__ + '.ConfigClass') # Initialize Flask extensions db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy mail = Mail(app) # Initialize Flask-Mail # Define the User data model. Make sure to add flask.ext.user UserMixin !!! class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) # User authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') # User email information email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) # User information active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') year = db.Column(db.Enum('Freshman', 'Sophomore', 'Junior', 'Senior', 'Masters', 'PhD'), nullable=True, server_default=None) major = db.Column(db.String(100), nullable=True, server_default=None) gpa = db.Column(db.Float(precision=2)) # Create all database tables db.create_all() # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Register the User model user_manager = UserManager(db_adapter, app) # Initialize Flask-User return app
def init_app(app, db_instance, extra_config_settings={}): # Initialize app config settings app.config.from_object('webrob.config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config['WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing if os.environ['EASE_DEBUG'] == 'true': app.config['DEBUG'] = True app.config['SECRET_KEY'] = app.config['DEV_SECRET_KEY'] else: try: app.config['SECRET_KEY'] = open('/etc/ease_secret/secret', 'rb').read() except IOError: app.config['SECRET_KEY'] = random_string(64) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db_instance, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy from webrob.models import users from webrob.models import tutorials from webrob.models import experiments # Load all views.py files to register @app.routes() with Flask from webrob.pages import api from webrob.pages import db from webrob.pages import editor from webrob.pages import experiments from webrob.pages import knowrob from webrob.pages import login from webrob.pages import meshes from webrob.pages import mongo from webrob.pages import tutorials init_db(app, db_instance) init_webapp(app, db_instance) add_user(app,db_instance,user_manager,'admin', os.environ.get('OPENEASE_MAIL_USERNAME', '*****@*****.**'), os.environ.get('OPENEASE_ADMIN_PASSWORD'), ['admin']) app.logger.info("Webapp started.") return app
def init_app(app, db, extra_config_settings={}): """ Initialize Flask applicaton """ # Initialize app config settings # - settings.py is checked into Git. # - local_settings.py is different for each deployment # - extra_config_settings{} is specified by the automated test suite app.config.from_object( 'app.config.settings') # Read config from 'app/settings.py' file app.config.from_object('app.config.local_settings' ) # Overwrite with 'app/local_settings.py' file app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Mail mail = Mail(app) # Setup an error-logger to send emails to app.config.ADMINS init_error_logger_with_email_handler(app) # Setup Flask-User to handle user account related forms from app.users.models import User, UserProfile from app.users.forms import MyRegisterForm db_adapter = SQLAlchemyAdapter( db, User, # Select database adapter UserProfileClass=UserProfile) # with a custom UserProfile model user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to app register_form=MyRegisterForm ) # using a custom register form with UserProfile fields # Load all models.py files to register db.Models with SQLAlchemy from app.users import models # Load all views.py files to register @app.routes() with Flask from app.pages import views from app.users import views # Automatically create all DB tables in app/app.sqlite file db.create_all() return app
def init_app(app, db_instance, extra_config_settings={}): _init_app_config_settings(app, extra_config_settings) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db_instance, User) app.user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy # Needs to remain in code, even if IDEs might show it's unused, Flask will use them during runtime from webrob.models import users from webrob.models import tutorials from webrob.models import teaching from webrob.models import experiments # Load all views.py files to register @app.routes() with Flask # Needs to remain in code, even if IDEs might show it's unused, Flask will use them during runtime from webrob.pages import api from webrob.pages import db from webrob.pages import editor from webrob.pages import experiments from webrob.pages import knowrob from webrob.pages import login from webrob.pages import meshes from webrob.pages import mongo from webrob.pages import tutorials from webrob.pages import oauth init_db(app, db_instance) init_webapp(app, db_instance) add_user(app=app, db=db_instance, user_manager=app.user_manager, name='admin', mail=evg.get_variable_with_default('OPENEASE_MAIL_USERNAME', '*****@*****.**'), pw=evg.get_required_variable('OPENEASE_ADMIN_PASSWORD'), roles=['admin']) _log_webapp_started(app) return app
def init_app_admin(): app = get_base_app() app.logger.debug("Run ices modules") run_ices_modules(app.config['SQLALCHEMY_DATABASE_URI']) app.before_request(get_current_user) app.logger.debug("Register blueprints") register_blueprints_admin(app) login_manager = LoginManager(app) login_manager.login_view = 'auth.login' login_manager.user_loader(load_user) user_db = SQLAlchemy(app) db_adapter = SQLAlchemyAdapter(user_db, type('UserModel', (user_db.Model, User), {})) user_manager = UserManager(db_adapter, app) admin = Admin(name="Mistofm", template_mode="bootstrap3", index_view=IndexView(url=config.ADMIN_URL_PREFIX)) admin.init_app(app) db_session, connection, engine = get_db_session(app.config.get('SQLALCHEMY_DATABASE_URI')) # remove db session each time when close connection in # order to refresh data and get new session @app.teardown_request def teardown(err): db_session.remove() connection.close() engine.dispose() db = getattr(g, 'db', None) sql_connection = getattr(g, 'db_connection', None) g_engine = getattr(g, 'engine', None) if db is not None: if err: db.rollback() db.remove() if sql_connection: sql_connection.close() if g_engine: g_engine.dispose() return err admin.add_view(StationView(Station, db_session)) admin.add_view(ImageView(Image, db_session)) admin.add_view(MusicView(Music, db_session)) admin.add_view(PlaylistView(Playlist, db_session)) admin.add_view(StationIcesView(StationIces, db_session)) admin.add_view(PlaylistMusicView(PlaylistMusic, db_session)) admin.add_view(AdminView(HtmlHeader, db_session)) admin.add_view(GeneralView(General, db_session)) admin.add_link(MenuLink(name='Logout', category='', url="/logout")) return app
def init_app(app, db, extra_config_settings={}): """ Initialize Flask applicaton """ # Initialize app config settings app.config.from_object('app.startup.settings' ) # Read config from 'app/startup/settings.py' file app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Mail mail = Mail(app) # Setup an error-logger to send emails to app.config.ADMINS init_error_logger_with_email_handler(app) # Setup Flask-User to handle user account related forms from app.users.models import UserAuth, User from app.users.forms import MyRegisterForm from app.users.views import user_profile_page db_adapter = SQLAlchemyAdapter( db, User, # Setup the SQLAlchemy DB Adapter UserAuthClass=UserAuth) # using separated UserAuth/User data models user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to app register_form= MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, ) # Load all models.py files to register db.Models with SQLAlchemy from app.users import models # Load all views.py files to register @app.routes() with Flask from app.pages import views from app.users import views from app.startup.reset_db import reset_db reset_db(app, db) return app
def configure_extensions(app, db): """configure app extensions""" # Setup Flask-Mail mail = Mail(app) # Setup Cache app.cache = Cache(app) # i18n babel = Babel(app) # Setup DebugToolbarExtension toolbar = DebugToolbarExtension(app) # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html # from wtforms.fields import HiddenField # # def is_hidden_field_filter(field): # return isinstance(field, HiddenField) # # app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup Flask-User to handle user account related forms from wuaiwow.models.users import User, UserInvitation from wuaiwow.forms import MyRegisterForm, MyLoginForm, MyChangePasswordForm # Setup the SQLAlchemy DB Adapter db_adapter = SQLAlchemyAdapter(db, User, UserEmailClass=None, UserInvitationClass=UserInvitation) # using a custom register form with UserProfile fields from wuaiwow.controllers.users import register, change_password, reset_password # user_profile from wuaiwow.controllers.player import user_account user_manager = UserManager(db_adapter, app, register_form=MyRegisterForm, register_view_function=register, login_form=MyLoginForm, change_password_form=MyChangePasswordForm, change_password_view_function=change_password, reset_password_view_function=reset_password, user_profile_view_function=user_account) return app
def initialize_user_manager(app, db): db_adapter = SQLAlchemyAdapter(db, UserClass=User) # Initialize Flask-User. UserManager( db_adapter, app, password_validator=validate_password, username_validator=validate_email, login_view_function=login, register_form=ExpandedRegisterForm, register_view_function=register, forgot_password_form=ZenForgotPasswordForm, forgot_password_view_function=forgot_password, unauthenticated_view_function=unauthenticated, unauthorized_view_function=app.page_router.unauthorized, )
def create_app(extra_config_settings={}): """ Initialize Flask applicaton """ # Initialize app config settings app.config.from_object('app.startup.settings') # Read config from 'app/startup/settings.py' file app.config.update(extra_config_settings) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config['WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Migrate migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) # Setup Flask-Mail mail = Mail(app) # Setup WTForms CsrfProtect CsrfProtect(app) # Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html from wtforms.fields import HiddenField def is_hidden_field_filter(field): return isinstance(field, HiddenField) app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter # Setup an error-logger to send emails to app.config.ADMINS init_email_error_handler(app) # Setup Flask-User to handle user account related forms from app.models import User, MyRegisterForm from app.views.user_views import user_profile_page db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter user_manager = UserManager(db_adapter, app, # Init Flask-User and bind to app register_form=MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function = user_profile_page, ) # Load all models.py files to register db.Models with SQLAlchemy from app import models # Load all views.py files to register @app.routes() with Flask from app.views import page_views, user_views return app
def register_user_manager(): """ Creates app.user_manager and database. Call it after loading config which contains 'SECRET_KEY'. """ from models import User from forms import LoginForm, RegisterForm db_adapter = SQLAlchemyAdapter(db, User) try: app.user_manager except AttributeError: UserManager(db_adapter, app=app, login_form=LoginForm, register_form=RegisterForm) db.create_all() return db_adapter
def create_app(): #APP init app = Flask(__name__) app.config.from_object('config.DevelopmentConfig') #THEMES init Themes(app, app_identifier='app') #MAIL init from flask_mail import Mail mail = Mail(app) #DATABASE init from models import db db.init_app(app) #MIGRATIONS init migrate = Migrate(app, db) with app.app_context(): #User init from flask_user import SQLAlchemyAdapter, UserManager from users import User db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) #db finalization db.create_all() #API - is for IOT, or mobile from models import DummyObject, DummyFile manager = flask_restless.APIManager(app, flask_sqlalchemy_db=db) manager.create_api(DummyObject) manager.create_api(DummyFile) #ADMIN - is for basic crud for trained users from admin import admin admin.init_app(app) #MEMBER VIEWS from member import MemberView MemberView.register(app) #upload example from flask_admin.contrib.fileadmin import FileAdmin path = os.path.join(os.path.dirname(__file__), app.config['UPLOAD_FOLDER']) admin.add_view(FileAdmin(path, '/uploads/', name='Uploads')) #sqlmodel example from flask_admin.contrib.sqla import ModelView admin.add_view(ModelView(DummyObject, db.session)) #DASHBOARD - is for customer login pages #I'll have to make that custom return app, migrate
def init_app(app, db, extra_config_settings={}): """ Initialize Flask applicaton """ # Initialize ibwt config settings if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing # Setup Flask-Mail mail = Mail(app) # Setup an error-logger to send emails to ibwt.config.ADMINS init_error_logger_with_email_handler(app) # Setup Flask-User to handle user account related forms from ibwt.users.models import UserAuth, User from ibwt.users.forms import MyRegisterForm from ibwt.users.views import user_profile_page db_adapter = SQLAlchemyAdapter( db, User, # Setup the SQLAlchemy DB Adapter UserAuthClass=UserAuth) # using separated UserAuth/User data models user_manager = UserManager( db_adapter, app, # Init Flask-User and bind to ibwt # register_form=MyRegisterForm, # using a custom register form with UserProfile fields user_profile_view_function=user_profile_page, ) # Load all models.py files to register db.Models with SQLAlchemy from ibwt.users import models # Load all views.py files to register @ibwt.routes() with Flask from ibwt.pages import views from ibwt.users import views from ibwt.orders import views from ibwt.chat import views return app
def route(app, db): # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) # Register the User model user_manager = UserManager(db_adapter, app) # Initialize Flask-User @app.route('/') def hello_world(): return render_template('top.html') @app.route('/index') def index(): return render_template('index.html') @app.route('/base') def home_page(): # return render_template_string(""" # {% extends "base.html" %} # {% block content %} # <h2>Basic Home page</h2> # <p>This page can be accessed by anyone.</p><br/> # <p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p> # <p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p> # {% endblock %} # """) return render_template('base.html') # The Members page is only accessible to authenticated users @app.route('/members') @login_required # Use of @login_required decorator def members_page(): return render_template_string(""" {% extends "base.html" %} {% block content %} <h2>Members page</h2> <p>This page can only be accessed by authenticated users.</p><br/> <p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p> <p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p> {% endblock %} """) return app