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
