def createsuperuser():
"""
Create a super user of the system, requiring Email and password.
"""
email = prompt('User E-Mail')
email_confirm = prompt('Confirm E-Mail')
if not email == email_confirm:
sys.exit('\nCould not create user: E-Mail did not match')
if not EMAIL_REGEX.match(email):
sys.exit('\nCould not create user: Invalid E-Mail addresss')
password = prompt_pass('User password')
password_confirm = prompt_pass('Confirmed password')
if not password == password_confirm:
sys.exit('\nCould not create user: Passwords did not match')
datastore = SQLAlchemyUserDatastore(db, User, Role)
datastore.create_user(
email=email,
password=encrypt_password(password),
active=True,
super_user=True)
db.session.commit()
def run(self, user):
from app import db
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
u = User.query.filter_by(email=user).first()
role = user_datastore.find_or_create_role('admin')
user_datastore.add_role_to_user(u, role)
db.session.commit()
def run(self, user):
from app import db
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
u = User.query.filter_by(email=user).first()
role = user_datastore.find_or_create_role('admin')
user_datastore.add_role_to_user(u, role)
db.session.commit()
class UserRepository(object):
def __init__(self):
self.ud = SQLAlchemyUserDatastore(db, User, Role)
def get(self, email):
return self.ud.get_user(email)
def create(self, username, email, pwd):
user = self.ud.create_user(
email=email,
username=username,
password=pwd
)
db.session.commit()
return user
def login(self, email, pwd):
user = self.get(email)
if user:
if user.password == pwd:
return login_user(user)
return False
def register(self, username, email, pwd):
user = self.get(email)
if not user:
user_obj = self.create(username, email, pwd)
return login_user(user_obj)
else:
return False
def setUp(self):
self.user_datastore = SQLAlchemyUserDatastore(tutorial.db, User, Role)
tutorial.db.create_all()
# u = User( nickname='test1', email='*****@*****.**' )
self.remap_from = "University of Oxford"
self.remap_to = "Oxford, United Kingdom"
self.cache_loc = "Oxford, United Kingdom"
self.cache_lat = 51.7519
self.cache_lon = -1.2578
self.user = self.user_datastore.create_user(nickname='test1',
email='*****@*****.**',
password='******')
tutorial.db.session.add(self.user)
tutorial.db.session.commit()
oxford_remap = Gps_remap(from_location=self.remap_from,
to_location=self.remap_to)
tutorial.db.session.add(oxford_remap)
oxford_lookup = Gps_cache(location=self.cache_loc,
latitude=self.cache_lat,
longitude=self.cache_lon)
tutorial.db.session.add(oxford_lookup)
tutorial.db.session.commit()
def data():
return
db.drop_all()
db.create_all()
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
from flask_security.utils import encrypt_password
role = user_datastore.create_role(name="root", description="Site administrator")
db.session.commit()
return "OK"
def setUp(self):
self.user_datastore = SQLAlchemyUserDatastore(tutorial.db, User, Role)
tutorial.db.create_all()
#u = User( nickname='test1', email='*****@*****.**' )
self.user = self.user_datastore.create_user(nickname='test1',
email='*****@*****.**',
password='******')
tutorial.db.session.add(self.user)
tutorial.db.session.commit()
# must commit before ID exists
self.first_id = self.user.id
def run(self):
command.upgrade(alembic_cfg, "head")
roles = ['admin', 'user', 'superuser']
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
for r in roles:
user_datastore.find_or_create_role(r)
try:
db.session.commit()
except IntegrityError:
# Happens if records already exist.
db.session.rollback()
def run(self):
command.upgrade(alembic_cfg, "head")
roles = ['admin', 'user', 'superuser']
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
for r in roles:
user_datastore.find_or_create_role(r)
try:
db.session.commit()
except IntegrityError:
# Happens if records already exist.
db.session.rollback()
def do_setup(app):
"""Create a new settings database from scratch"""
if config.SERVER_MODE is False:
print("NOTE: Configuring authentication for DESKTOP mode.")
email = config.DESKTOP_USER
p1 = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(32)
])
else:
print("NOTE: Configuring authentication for SERVER mode.\n")
# Prompt the user for their default username and password.
print("""
Enter the email address and password to use for the initial pgAdmin user \
account:\n""")
email = ''
while email == '':
email = input("Email address: ")
def pprompt():
return getpass.getpass(), getpass.getpass('Retype password:'******'Passwords do not match. Try again')
p1, p2 = pprompt()
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
with app.app_context():
password = encrypt_password(p1)
db.create_all()
user_datastore.create_role(name='Administrators',
description='pgAdmin Administrators Role')
user_datastore.create_user(email=email, password=password)
db.session.flush()
user_datastore.add_role_to_user(email, 'Administrators')
# Get the user's ID and create the default server group
user = User.query.filter_by(email=email).first()
server_group = ServerGroup(user_id=user.id, name="Servers")
db.session.merge(server_group)
# Set the schema version
version = Version(name='ConfigDB',
value=config.SETTINGS_SCHEMA_VERSION)
db.session.merge(version)
db.session.commit()
# Done!
print("")
print("The configuration database has been created at {0}".format(
config.SQLITE_PATH))
def ext_security(self, app_models=None, **kwargs):
"""
Initialize Security for application.
:param kwargs: parameters that will be passed through to Flask-Security
:type kwargs: dict
:returns: None
A number of common User account operations are provided by `Flask-
Security <http://pythonhosted.org/Flask-Security/>`_. This function is
responsible for associating User models in the database with the
Security object.
In case you need to override a Flask-Security form (as is the case
with implementing CAPTCHA) then you must use super() from within your
application and provide any arguments destined for Flask-Security.
>>> def ext_security(self):
>>> super(MyApp, self).ext_security(confirm_register_form=CaptchaRegisterForm)
"""
if not app_models:
from . import models
else:
models = app_models
user_datastore = SQLAlchemyUserDatastore(db, models.User, models.Role)
security.init_app(self.app, datastore=user_datastore, **kwargs)
security._state = self.app.extensions["security"]
security.datastore = user_datastore
def init_accounts(self, user=None, role=None):
"""
Initialize Security for application.
:param kwargs: parameters that will be passed through to Flask-Security
:type kwargs: dict
:returns: None
A number of common User account operations are provided by `Flask-
Security <http://pythonhosted.org/Flask-Security/>`_. This function is
responsible for associating User models in the database with the
Security object.
In case you need to override a Flask-Security form (as is the case
with implementing CAPTCHA) then you must use super() from within your
application and provide any arguments destined for Flask-Security.
>>> def ext_security(self):
>>> super(MyApp, self).ext_security(confirm_register_form=CaptchaRegisterForm)
"""
# import database
from .. import db
if not user or not role:
raise Exception
# create datastore
user_datastore = SQLAlchemyUserDatastore(db, user, role)
setattr(Security, "user_datastore", user_datastore)
security.init_app(self.app, datastore=user_datastore)
def setUp(self):
self.user_datastore = SQLAlchemyUserDatastore(tutorial.db, User, Role)
tutorial.db.create_all()
# u = User( nickname='test1', email='*****@*****.**' )
self.remap_from = "University of Oxford"
self.remap_to = "Oxford, United Kingdom"
self.cache_loc = "Oxford, United Kingdom"
self.cache_lat = 51.7519
self.cache_lon = -1.2578
self.user = self.user_datastore.create_user(nickname='test1',
email='*****@*****.**',
password='******')
tutorial.db.session.add(self.user)
tutorial.db.session.commit()
oxford_remap = Gps_remap(from_location=self.remap_from,
to_location=self.remap_to)
tutorial.db.session.add(oxford_remap)
oxford_lookup = Gps_cache(location=self.cache_loc,
latitude=self.cache_lat,
longitude=self.cache_lon)
tutorial.db.session.add(oxford_lookup)
tutorial.db.session.commit()
def configure_extensions(app):
# configure extensions
# sqlalchemy
db.init_app(app)
db_ean.init_app(app)
# mail
mail.init_app(app)
# cache
cache.init_app(app)
# babel
babel = Babel(app)
# login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
login_manager.setup_app(app)
# security and Social
app.flask_security = Security(app, SQLAlchemyUserDatastore(db, User, Role))
#app.flask_social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
# admin
admin = Admin(app)
#admin.add_view(ModelView(GenomeRule, db.session))
admin.add_view(GenomeRuleView(db.session, name="Genome Rules"))
admin.add_view(GenomeCategoryView(db.session, name="Genome Categories"))
def init_security(self):
from .. import db
from ..models import Role
from ..models import User
from ..forms import ExtendedLoginForm
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(
self.app,
datastore=user_datastore,
login_form=ExtendedLoginForm,
)
try:
from wtforms.fields import HiddenField
except ImportError:
def is_hidden_field_filter(field):
raise RuntimeError('WTForms is not installed.')
else:
def is_hidden_field_filter(field):
return isinstance(field, HiddenField)
self.app.jinja_env.globals['is_hidden_field'] = is_hidden_field_filter
def create_app(package_name=__name__, package_path=__path__, has_blueprints=True, **config_overrides):
app = Flask(package_name, static_url_path='')
app.config.update(APP)
app.config.update(SECURITY)
# Apply overrides.
app.config.update(config_overrides)
# Initialize the database and declarative Base class.
db.init_app(app)
Migrate(app, db)
# Setup security.
from argos.web import models
user_db = SQLAlchemyUserDatastore(db, models.User, models.Role)
Security(app, user_db)
# Create the database tables.
# Flask-SQLAlchemy needs to know which
# app context to create the tables in.
with app.app_context():
db.create_all()
# Register blueprints.
if has_blueprints:
register_blueprints(app, package_name, package_path)
return app
def create_app(package_name,
package_path,
config_name,
debug_override=None,
register_security_blueprint=True):
"""Returns a :class:`Flask` application instance configured with common
functionality for the Longboxed platform.
:param package_name: application package name
:param package_path: application package path
:param settings_override: a dictionary of settings to override
:param debug_overide: :class:`Bool` value that overrides the debug settings
"""
app = Flask(package_name, instance_relative_config=True)
app.config.from_object(config[config_name])
app.config.from_pyfile('settings.cfg', silent=True)
if debug_override is not None:
app.debug = debug_override
#: Additional Settings setup
config[config_name].init_app(app, store=store)
#: Setup Flask Extensions
cache.init_app(app, config=app.config.get('CACHE_CONFIG'))
db.init_app(app)
mail.init_app(app)
s3_assets.init_app(app)
#: Setup Flask-Security
security.init_app(app,
SQLAlchemyUserDatastore(db, User, Role),
register_blueprint=register_security_blueprint,
confirm_register_form=ExtendedConfirmRegisterForm)
# Register all blueprints
register_blueprints(app, package_name, package_path)
# Register all signal handlers
signals.init_app(app)
app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)
@app.before_request
def start_implicit_store_context():
push_store_context(store)
@app.teardown_request
def stop_implicit_store_context(exception=None):
try:
pop_store_context()
except IndexError:
pass
#: Setup Logging if not debug
setup_logging()
return app
def create_app(package_name,
package_path,
settings_override=None,
security_register_blueprint=False):
"""
Returns a :class:`Flask` application instance configured with common
functionality for the webapp.
:param package_name: application package name
:param package_path: application package path
:param settings_override: a dictionary of settings to override
:param security_register_blueprint: register views for flask-security
"""
# Instance Path
instance_path = os.environ.get(
"{{ cookiecutter.app_name | upper }}_INSTANCE_PATH", None)
app = Flask(package_name,
instance_relative_config=True,
instance_path=instance_path)
# Initialize settings
app.config.from_object("{{ cookiecutter.app_name }}.settings")
app.config.from_pyfile("settings.cfg", silent=True)
app.config.from_object(settings_override)
# Flask-SQLAlchemy
db.init_app(app)
# Flask-Migrate
migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Security
security.init_app(app,
SQLAlchemyUserDatastore(db, User, Role),
register_blueprint=security_register_blueprint)
# Flask-JWT
jwt.init_app(app)
jwt.authentication_handler(authenticate)
jwt.payload_handler(make_payload)
jwt.user_handler(load_user)
# Sentry - only for production
if not app.debug and not app.testing and 'SENTRY_DSN' in app.config:
sentry = Sentry(app)
# Middleware
app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)
_log.info("Flask framework app created.")
return app
def initialise_app(app, configclass):
# Load the default configuration
app.config.from_object(configclass)
# Load the configuration from the instance folder
try:
app.config.from_pyfile('config.py')
except:
print 'No instance config file'
if app.config['USE_PROXY']:
app.wsgi_app = ProxyFix(app.wsgi_app)
toolbar = DebugToolbarExtension(app)
db.init_app(app)
mail.init_app(app)
assets = Environment(app)
assets.register(bundles)
from .models import User, Feed, Entry, Author, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.security = Security(app, user_datastore)
wtf.add_helpers(app)
admin = Admin(app, 'Admin', index_view=SecuredAdminIndexView())
admin.add_view(SecuredModelView(User, db.session))
admin.add_view(SecuredModelView(Feed, db.session))
admin.add_view(SecuredModelView(Entry, db.session))
admin.add_view(SecuredModelView(Author, db.session))
app.register_blueprint(frontend_blueprint)
identity_loaded.connect_via(app)(on_identity_loaded)
add_errorhandlers(app)
Principal(app)
if not app.debug:
import logging
from .utils.loggers import add_logger_filehandler, add_logger_external
add_logger_filehandler(app)
if app.config['LOG_ADDRESS']:
add_logger_external(app)
app.logger.setLevel(logging.INFO)
app.logger.info(u'{0} startup'.format(app.config['PROJECT_NAME']))
return app
def create_app():
app = Flask(__name__)
app.config.from_object('jobs_board.settings')
db.init_app(app)
foundation.init_app(app)
mail.init_app(app)
from .users.models import Role, User
security.init_app(app, SQLAlchemyUserDatastore(db, User, Role))
from .jobs.views import blueprint as jobs
app.register_blueprint(jobs)
return app
def register_extensions(app):
cache.init_app(app)
db.init_app(app)
admin.init_app(app)
register_admin_views(admin)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore, confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
debug_toolbar.init_app(app)
return None
def init(app):
# --> Extension setup
db.init_app(app)
admin.init_app(app)
modules["migrate"] = Migrate(app, db)
modules["user_datastore"] = SQLAlchemyUserDatastore(db, User, Role)
modules["security"] = Security(app,
modules["user_datastore"],
confirm_register_form=MyRegisterForm)
# --> Register blueprints
from modules.play.play import play
app.register_blueprint(play, url_prefix='/play')
from modules.api.core import api_core
app.register_blueprint(api_core, url_prefix='/kcsapi')
# Declare API v1 blueprints.
from modules.api.v1.user import api_user
from modules.api.v1.actions import api_actions
app.register_blueprint(api_user, url_prefix='/kcsapi')
app.register_blueprint(api_actions, url_prefix='/kcsapi')
# Declare API v2 blueprints.
from modules.api.v2.AdmiralAPI import AdmiralAPIv2
from modules.api.v2.DockAPI import DockAPIv2
app.register_blueprint(AdmiralAPIv2, url_prefix='/api/v2/admiral')
app.register_blueprint(DockAPIv2, url_prefix='/api/v2/docks')
from modules.resources import resources
app.register_blueprint(resources, url_prefix='/kcs')
# --> Base application routes
@app.route('/')
def index():
return render_template('index.html')
@app.route('/kcs/<path:path>')
def kcs(path):
return send_from_directory('kcs', path)
# --> Signals
@user_logged_in.connect_via(app)
def u_logged_in(sender, user):
"""
Regenerate the API token every login.
"""
user.api_token = generate_api_token()
def register_extensions(app):
db.init_app(app)
bcrypt.init_app(app)
babel.init_app(app)
login_manager.init_app(app)
login_manager.login_view = '/login'
s3.init_app(app)
mail.init_app(app)
from app.models import AppUser, Role
user_datastore = SQLAlchemyUserDatastore(db, AppUser, Role)
Security(app, user_datastore)
def create_app(config=None, debug=True):
app = create_base_app(config, debug)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask_social_test'
db = SQLAlchemy(app)
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(120))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
connections = db.relationship('Connection',
backref=db.backref('user',
lazy='joined'))
class Connection(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
provider_id = db.Column(db.String(255))
provider_user_id = db.Column(db.String(255))
access_token = db.Column(db.String(255))
secret = db.Column(db.String(255))
display_name = db.Column(db.String(255))
profile_url = db.Column(db.String(512))
image_url = db.Column(db.String(512))
rank = db.Column(db.Integer)
app.security = Security(app, SQLAlchemyUserDatastore(db, User, Role))
app.social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
@app.before_first_request
def before_first_request():
db.drop_all()
db.create_all()
populate_data()
pass
return app
def create_app(config):
app = Flask(
__name__,
template_folder="../dist/",
static_folder="static/",
static_url_path="/static")
app.config.from_object(config)
for key, value in security_messages.items():
app.config['SECURITY_MSG_' + key] = value
# app.config['SESSION_TYPE'] = 'filesystem'
app.config['SECRET_KEY'] = os.urandom(24)
# Session(app)
_log_config(app)
app.db = db
db.init_app(app)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
app.user_datastore = user_datastore
@app.route('/')
def to_app():
return redirect(url_for('ngapp.home'))
@app.route('/_uploads/photos/<path:path>')
def do_not_allow_uploads(path):
return abort(404)
from .response import init as response_init
response_init(app)
import ngapp
app.register_blueprint(ngapp.bp)
@app.before_request
def populate_user():
header_key = app.config.get('SECURITY_TOKEN_AUTHENTICATION_HEADER', 'Authentication-Token')
args_key = app.config.get('SECURITY_TOKEN_AUTHENTICATION_KEY', 'token')
header_token = request.headers.get(header_key, None)
token = request.args.get(args_key, header_token)
if request.get_json(silent=True):
token = request.json.get(args_key, token)
if token:
user = app.extensions['security'].login_manager.token_callback(token)
_request_ctx_stack.top.user = user
return app
def do_setup(app):
"""Create a new settings database from scratch"""
if config.SERVER_MODE is False:
print("NOTE: Configuring authentication for DESKTOP mode.")
email = config.DESKTOP_USER
p1 = "".join([random.choice(string.ascii_letters + string.digits) for n in xrange(32)])
else:
print("NOTE: Configuring authentication for SERVER mode.\n")
# Prompt the user for their default username and password.
print("Enter the email address and password to use for the initial pgAdmin user account:\n")
email = ""
while email == "":
email = raw_input("Email address: ")
pprompt = lambda: (getpass.getpass(), getpass.getpass("Retype password: "******"Passwords do not match. Try again")
p1, p2 = pprompt()
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
with app.app_context():
password = encrypt_password(p1)
db.create_all()
user_datastore.create_role(name="Administrators", description="pgAdmin Administrators Role")
user_datastore.create_user(email=email, password=password)
db.session.flush()
user_datastore.add_role_to_user(email, "Administrators")
# Get the user's ID and create the default server group
user = User.query.filter_by(email=email).first()
server_group = ServerGroup(user_id=user.id, name="Servers")
db.session.merge(server_group)
# Set the schema version
version = Version(name="ConfigDB", value=config.SETTINGS_SCHEMA_VERSION)
db.session.merge(version)
db.session.commit()
# Done!
print("")
print("The configuration database has been created at %s" % config.SQLITE_PATH)
def create_app():
app = Flask(__name__)
app.config.from_object('transcriber.app_config')
app.config['SQLALCHEMY_DATABASE_URI'] = app.config['DB_CONN']
app.register_blueprint(views)
app.register_blueprint(auth)
db.init_app(app)
datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app,
datastore,
login_form=LoginForm,
confirm_register_form=RegisterForm)
mail.init_app(app)
csrf.init_app(app)
flask_bcrypt.init_app(app)
@app.template_filter('format_number')
def format_number(s): # pragma: no cover
if s:
return '{:,}'.format(s)
return s
@app.template_filter('format_date')
def format_date(s, fmt='%H:%M%p %b %d, %Y'): # pragma: no cover
if s:
return s.strftime(fmt)
else:
return '0'
@app.template_filter('format_date_sort')
def format_date_sort(s, fmt='%Y%m%d%H%M'): # pragma: no cover
if s:
return s.strftime(fmt)
else:
return '0'
app.config['sentry'] = None
if sentry:
sentry.init_app(app)
app.config['sentry'] = sentry
return app
def create_user(self):
if self.email is None or self.password is None:
logging.warning('Email and Password cannot be null')
return None
try:
SQLAlchemyUserDatastore(db, UsersModel, RolesModel).create_user(
email=self.email,
password=self.password,
first_name=self.first_name,
last_name=self.last_name,
token=generate_token(),
active=self.active)
db.session.commit()
return self
except Exception as ex:
logging.warning(ex)
def create_app(config, **kwargs):
app = create_base_app(config)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask_security_test'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = SQLAlchemy(app)
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
@app.before_first_request
def before_first_request():
db.drop_all()
db.create_all()
populate_data(app.config.get('USER_COUNT', None))
app.security = Security(app,
datastore=SQLAlchemyUserDatastore(db, User, Role),
**kwargs)
add_context_processors(app.security)
return app
def create_app(settings_override=None):
"""Creates and returns a configured :class:`~flask.Flask` application.
:param package_name: application package name.
:param settings_override: ``dict`` containing settings to override.
"""
if settings_override is None:
settings_override = {}
app = Flask(__name__)
app.config.from_object('ivadb.settings')
app.config.update(settings_override)
api.init_app(app)
db.init_app(app)
security.init_app(app, SQLAlchemyUserDatastore(db, User, Role))
app.register_blueprint(bp)
return app
def create_app(env):
init_config(env)
app = _initialize_flask_app()
app.wsgi_app = RequestLoggerMiddleware(app.wsgi_app)
app = _configure_logging(app)
app.config.from_object(Ivysaur.Config)
app = _register_blueprints(app)
app = _register_version_and_log(app)
db = SQLAlchemy(app, session_options={"autoflush": False})
reg = get_registry()
reg['DB'] = db
mail = Mail(app)
reg['MAIL'] = mail
reg['TOKBOX'] = OpenTok(
Ivysaur.Config.TOKBOX_API_KEY, Ivysaur.Config.TOKBOX_API_SECRET
)
from lib.models.user import User
from lib.models.role import Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
Security(app, user_datastore)
from lib.repo.user_repo import UserRepo
from lib.repo.device_repo import DeviceRepo
from lib.repo.deck_repo import DeckRepo
from lib.repo.notification_repo import NotificationRepo
from lib.repo.ask_repo import AskRepo
# see comment for this method
_initialize_models()
reg['USER_DATASTORE'] = user_datastore
reg['USER_REPO'] = UserRepo()
reg['DEVICE_REPO'] = DeviceRepo()
reg['DECK_REPO'] = DeckRepo()
reg['NOTIFICATION_REPO'] = NotificationRepo()
reg['ASK_REPO'] = AskRepo()
app = _initialize_managers(app)
app.json_encoder = AppJSONEncoder
return app
def init_webapp():
"""Initialize the web application."""
# logging.getLogger('flask_cors').level = logging.DEBUG
# app.wsgi_app = LoggingMiddleware(app.wsgi_app)
# Note, this url namespace also exists for the Flask-Restless
# extension and is where CRUD interfaces live, so be careful not to
# collide with model names here. We could change this, but it's nice
# to have API live in the same url namespace.
app.register_blueprint(api, url_prefix='/api')
# Initialize Flask configuration
app.config['SQLALCHEMY_DATABASE_URI'] = make_conn_str()
app.config['SECRET_KEY'] = 'abc123'
app.config['WTF_CSRF_ENABLED'] = False
app.config['SECURITY_TOKEN_MAX_AGE'] = 60
app.config['SECURITY_TOKEN_AUTHENTICATION_HEADER'] = 'Auth-Token'
# app.config['SECURITY_POST_LOGIN_VIEW'] = 'http://127.0.0.1:4200'
# app.config['CORS_HEADERS'] = 'Content-Type'
# Initialize Flask-CORS
CORS(app, supports_credentials=True)
# CORS(app, supports_credentials=True, resources={r"/*": {"origins": "*"}})
# Initialize Flask-Bootstrap
Bootstrap(app)
# Initialize Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# Initialize Flask-SQLAlchemy
db.app = app
db.init_app(app)
db.create_all()
# Initialize Flask-Restless
manager = APIManager(
app,
flask_sqlalchemy_db=db,
preprocessors=dict(GET_MANY=[restless_api_auth_func]),
)
manager.create_api(Employee, methods=['GET', 'POST', 'OPTIONS'])
return app
def setup_app(app):
from adsws.core import db, User, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.config.setdefault('SECURITY_PASSWORD_HASH', 'pbkdf2_sha512')
app.config.setdefault('SECURITY_PASSWORD_SALT',
app.config.get('SECRET_KEY'))
register_blueprint = app.config.get('SECURITY_REGISTER_BLUEPRINT', True)
# if desired, we'll use ADS Classic as a source for authenticating
# users
if app.config.get('FALL_BACK_ADS_CLASSIC_LOGIN', False):
from .ads_classic_login import AdsClassicFallBackLoginForm
security.init_app(app,
user_datastore,
register_blueprint=register_blueprint,
login_form=AdsClassicFallBackLoginForm)
else:
security.init_app(app,
user_datastore,
register_blueprint=register_blueprint)
# if there is Flask-Email extension, we'll use that one for sending
# emails
if 'email' in app.extensions:
from flask_email import EmailMessage
def send_email(msg):
if not 'email' in app.extensions:
warn(
"Flask-Email extension has disappeared from app.extensions"
)
return
email = EmailMessage(subject=msg.subject,
body=msg.body,
from_email=msg.sender,
to=msg.recipients)
email.send(app.extensions['email'])
app.extensions['security'].send_mail_task(send_email)
return app
def do_setup(app):
"""Create a new settings database from scratch"""
if config.SERVER_MODE is False:
print("NOTE: Configuring authentication for DESKTOP mode.")
email = config.DESKTOP_USER
p1 = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(32)
])
else:
print("NOTE: Configuring authentication for SERVER mode.\n")
# Prompt the user for their default username and password.
print("""
Enter the email address and password to use for the initial pgAdmin user \
account:\n""")
email_filter = re.compile(
"^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9]"
"(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9]"
"(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")
email = ''
input("Email address: ")
while email == '' or not email_filter.match(email):
print('Invalid email address. Please try again.')
email = input("Email address: ")
def pprompt():
return getpass.getpass(), getpass.getpass('Retype password:'******'Passwords do not match. Please try again.')
p1, p2 = pprompt()
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
Security(app, user_datastore)
with app.app_context():
password = encrypt_password(p1)
db.create_all()
user_datastore.create_role(
name='Administrator',
description='pgAdmin Administrator Role'
)
user_datastore.create_role(
name='User',
description='pgAdmin User Role'
)
user_datastore.create_user(email=email, password=password)
db.session.flush()
user_datastore.add_role_to_user(email, 'Administrator')
# Get the user's ID and create the default server group
user = User.query.filter_by(email=email).first()
server_group = ServerGroup(user_id=user.id, name="Servers")
db.session.merge(server_group)
# Set the schema version
version = Version(
name='ConfigDB', value=config.SETTINGS_SCHEMA_VERSION
)
db.session.merge(version)
db.session.commit()
# Done!
print("")
print(
"The configuration database has been created at {0}".format(
config.SQLITE_PATH
)
)
def __init__(self):
self.ud = SQLAlchemyUserDatastore(db, User, Role)
class GPSTest(MarionTest):
"""
Tests both the GPS lookup and some biblio functions that rely on it
"""
def setUp(self):
self.user_datastore = SQLAlchemyUserDatastore(tutorial.db, User, Role)
tutorial.db.create_all()
# u = User( nickname='test1', email='*****@*****.**' )
self.remap_from = "University of Oxford"
self.remap_to = "Oxford, United Kingdom"
self.cache_loc = "Oxford, United Kingdom"
self.cache_lat = 51.7519
self.cache_lon = -1.2578
self.user = self.user_datastore.create_user(nickname='test1',
email='*****@*****.**',
password='******')
tutorial.db.session.add(self.user)
tutorial.db.session.commit()
oxford_remap = Gps_remap(from_location=self.remap_from,
to_location=self.remap_to)
tutorial.db.session.add(oxford_remap)
oxford_lookup = Gps_cache(location=self.cache_loc,
latitude=self.cache_lat,
longitude=self.cache_lon)
tutorial.db.session.add(oxford_lookup)
tutorial.db.session.commit()
def _logout(self):
logout_user()
def tearDown(self):
self._logout()
tutorial.db.session.remove()
tutorial.db.drop_all()
def test_retrieval(self):
remap = Gps_remap.query.get(self.remap_from)
self.assertEqual(remap.from_location, self.remap_from)
cache = Gps_cache.query.get(self.cache_loc)
self.assertAlmostEqual(cache.latitude, self.cache_lat)
self.assertAlmostEqual(cache.longitude, self.cache_lon)
def test_has_keys(self):
self.assertAlmostEqual(remap_has_key(self.remap_from), True)
self.assertAlmostEqual(cache_has_key(self.cache_loc), True)
def test_simplified_guess(self):
self.assertEqual(next_guess("Inst Angew Phys, D-76131 Karlsruhe, Germany"),
"Inst Angew Phys, D-76131 Karlsruhe, Germany")
self.assertEqual(next_guess("Soochow Univ, Sch Phys Sci & Technol, Suzhou 215006, Jiangsu, Peoples R China"),
"Sch Phys Sci & Technol, Suzhou 215006, Jiangsu, Peoples R China")
def test_get_location(self):
self.assertEqual(get_location("blorfing"), None)
self.assertAlmostEqual(get_location(self.cache_loc)['lat'],
self.cache_lat)
self.assertAlmostEqual(get_location("london")['lon'], -0.1277583)
def test_get_locations_and_unknowns(self):
locs, unks = get_locations_and_unknowns(
["University of Oxford", "blorfing"],
False)
self.assertAlmostEqual(locs["University of Oxford"]['lon'],
self.cache_lon)
self.assertEqual(unks[0], "blorfing")
def test_paper_lat_lon_query(self):
"""
"""
with wos_reader.open_wos_h5("test_data/irwin.h5") as w5:
locresults = wos_reader_query.paperLatLonQuery(
w5, get_locations_and_unknowns_nocache)
tmp = self.maxDiff
self.maxDiff = None
irwin_network = {'not_located': ['Kyushu Univ, Dept Phys, Fukuoka 812, Japan', 'Natl Res Inst Astron & Geophys, Dept Astron, Cairo 11421, Egypt; Natl Res Inst Astron & Geophys, Kottamia Ctr Sci Excellence Astron & Space Sci KC, Cairo 11421, Egypt', 'Natl Res Inst Astron & Geophys, Dept Astron, Cairo 11421, Egypt'], 'paper_locations': {'10.1051/mmnp/20138208': {'edges': {0: {'to': 1, 'text': '10.1051/mmnp/20138208', 'from': 0, 'val': 0}, 1: {'to': 2, 'text': '10.1051/mmnp/20138208', 'from': 0, 'val': 0}, 2: {'to': 3, 'text': '10.1051/mmnp/20138208', 'from': 0, 'val': 0}, 3: {'to': 4, 'text': '10.1051/mmnp/20138208', 'from': 0, 'val': 0}, 4: {'to': 2, 'text': '10.1051/mmnp/20138208', 'from': 1, 'val': 0}, 5: {'to': 3, 'text': '10.1051/mmnp/20138208', 'from': 1, 'val': 0}, 6: {'to': 4, 'text': '10.1051/mmnp/20138208', 'from': 1, 'val': 0}, 7: {'to': 3, 'text': '10.1051/mmnp/20138208', 'from': 2, 'val': 0}, 8: {'to': 4, 'text': '10.1051/mmnp/20138208', 'from': 2, 'val': 0}, 9: {'to': 4, 'text': '10.1051/mmnp/20138208', 'from': 3, 'val': 0}}, 'nodes': {0: {'text': '10.1051/mmnp/20138208: Univ Southern Denmark, MEMPHYS Ctr Biomembrane Phys, Dept Phys Chem & Pharm, DK-5230 Odense M, Denmark', 'val': 0, 'lon': 10.4033399, 'lat': 55.37906169999999}, 1: {'text': '10.1051/mmnp/20138208: Univ Potsdam, Inst Phys & Astron, D-14476 Potsdam, Germany; Tech Univ Tampere, Dept Phys, FI-33101 Tampere, Finland', 'val': 0, 'lon': 23.7610254, 'lat': 61.4981508}, 2: {'text': '10.1051/mmnp/20138208: Univ Oxford, Rudolf Peierls Ctr Theoret Phys, Oxford OX1 3NP, England', 'val': 0, 'lon': -1.259116, 'lat': 51.7595933}, 3: {'text': '10.1051/mmnp/20138208: Inst Theoret Phys NSC KIPT, UA-61108 Kharkov, Ukraine; Max Planck Inst Phys Komplexer Syst, D-01187 Dresden, Germany', 'val': 0, 'lon': 13.7090684, 'lat': 51.0266014}, 4: {'text': '10.1051/mmnp/20138208: Humboldt Univ, Inst Phys, D-12489 Berlin, Germany', 'val': 0, 'lon': 13.5470509, 'lat': 52.4370179}}}}, 'failed_papers': ['', '10.1016/j.newast.2014.02.011']}
self.assertEqual(locresults['paper_locations'].keys(),
irwin_network['paper_locations'].keys())
self.assertEqual(set(locresults['failed_papers']),
set(irwin_network['failed_papers']))
self.assertEqual(set(locresults['not_located']),
set(irwin_network['not_located']))
self.maxDiff = tmp
def test_paper_hexbin_query(self):
with wos_reader.open_wos_h5("test_data/irwin.h5") as w5:
locresults = wos_reader_query.paperHexbinQuery(
w5,
get_locations_and_unknowns_nocache)
expected_results = {'not_located': ['Kyushu Univ, Dept Phys, Fukuoka 812, Japan', 'Natl Res Inst Astron & Geophys, Dept Astron, Cairo 11421, Egypt', 'Natl Res Inst Astron & Geophys, Dept Astron, Cairo 11421, Egypt; Natl Res Inst Astron & Geophys, Kottamia Ctr Sci Excellence Astron & Space Sci KC, Cairo 11421, Egypt'], 'paper_locations': {'10.1051/mmnp/20138208': {'nodes': {'3': {'val': 0, 'text': '10.1051/mmnp/20138208: Humboldt Univ, Inst Phys, D-12489 Berlin, Germany', 'lat': 52.4370179, 'lon': 13.5470509}, '2': {'val': 0, 'text': '10.1051/mmnp/20138208: Univ Potsdam, Inst Phys & Astron, D-14476 Potsdam, Germany; Tech Univ Tampere, Dept Phys, FI-33101 Tampere, Finland', 'lat': 61.4981508, 'lon': 23.7610254}, '1': {'val': 0, 'text': '10.1051/mmnp/20138208: Univ Oxford, Rudolf Peierls Ctr Theoret Phys, Oxford OX1 3NP, England', 'lat': 51.7595933, 'lon': -1.259116}, '0': {'val': 0, 'text': '10.1051/mmnp/20138208: Univ Southern Denmark, MEMPHYS Ctr Biomembrane Phys, Dept Phys Chem & Pharm, DK-5230 Odense M, Denmark', 'lat': 55.37906169999999, 'lon': 10.4033399}, '4': {'val': 0, 'text': '10.1051/mmnp/20138208: Inst Theoret Phys NSC KIPT, UA-61108 Kharkov, Ukraine; Max Planck Inst Phys Komplexer Syst, D-01187 Dresden, Germany', 'lat': 51.0266014, 'lon': 13.7090684}}, 'edges': {'3': {'val': 0, 'to': 4, 'from': 0, 'text': '10.1051/mmnp/20138208'}, '2': {'val': 0, 'to': 3, 'from': 0, 'text': '10.1051/mmnp/20138208'}, '1': {'val': 0, 'to': 2, 'from': 0, 'text': '10.1051/mmnp/20138208'}, '0': {'val': 0, 'to': 1, 'from': 0, 'text': '10.1051/mmnp/20138208'}, '7': {'val': 0, 'to': 3, 'from': 2, 'text': '10.1051/mmnp/20138208'}, '6': {'val': 0, 'to': 4, 'from': 1, 'text': '10.1051/mmnp/20138208'}, '5': {'val': 0, 'to': 3, 'from': 1, 'text': '10.1051/mmnp/20138208'}, '4': {'val': 0, 'to': 2, 'from': 1, 'text': '10.1051/mmnp/20138208'}, '9': {'val': 0, 'to': 4, 'from': 3, 'text': '10.1051/mmnp/20138208'}, '8': {'val': 0, 'to': 4, 'from': 2, 'text': '10.1051/mmnp/20138208'}}}}, 'failed_papers': ['', '10.1016/j.newast.2014.02.011'], 'hexbin': {'nodes': [{'text': '10.1051/mmnp/20138208: Univ Southern Denmark, MEMPHYS Ctr Biomembrane Phys, Dept Phys Chem & Pharm, DK-5230 Odense M, Denmark', 'lng': 10.4033399, 'lat': 55.37906169999999, 'pubcount': 1}, {'text': '10.1051/mmnp/20138208: Univ Oxford, Rudolf Peierls Ctr Theoret Phys, Oxford OX1 3NP, England', 'lng': -1.259116, 'lat': 51.7595933, 'pubcount': 1}, {'text': '10.1051/mmnp/20138208: Univ Potsdam, Inst Phys & Astron, D-14476 Potsdam, Germany; Tech Univ Tampere, Dept Phys, FI-33101 Tampere, Finland', 'lng': 23.7610254, 'lat': 61.4981508, 'pubcount': 1}, {'text': '10.1051/mmnp/20138208: Humboldt Univ, Inst Phys, D-12489 Berlin, Germany', 'lng': 13.5470509, 'lat': 52.4370179, 'pubcount': 1}, {'text': '10.1051/mmnp/20138208: Inst Theoret Phys NSC KIPT, UA-61108 Kharkov, Ukraine; Max Planck Inst Phys Komplexer Syst, D-01187 Dresden, Germany', 'lng': 13.7090684, 'lat': 51.0266014, 'pubcount': 1}], 'edges': [{'fromlng': 10.4033399, 'fromlat': 55.37906169999999, 'tolng': -1.259116, 'weight': 1, 'tolat': 51.7595933}, {'fromlng': 10.4033399, 'fromlat': 55.37906169999999, 'tolng': 23.7610254, 'weight': 1, 'tolat': 61.4981508}, {'fromlng': 10.4033399, 'fromlat': 55.37906169999999, 'tolng': 13.5470509, 'weight': 1, 'tolat': 52.4370179}, {'fromlng': 10.4033399, 'fromlat': 55.37906169999999, 'tolng': 13.7090684, 'weight': 1, 'tolat': 51.0266014}, {'fromlng': -1.259116, 'fromlat': 51.7595933, 'tolng': 23.7610254, 'weight': 1, 'tolat': 61.4981508}, {'fromlng': -1.259116, 'fromlat': 51.7595933, 'tolng': 13.5470509, 'weight': 1, 'tolat': 52.4370179}, {'fromlng': -1.259116, 'fromlat': 51.7595933, 'tolng': 13.7090684, 'weight': 1, 'tolat': 51.0266014}, {'fromlng': 23.7610254, 'fromlat': 61.4981508, 'tolng': 13.5470509, 'weight': 1, 'tolat': 52.4370179}, {'fromlng': 23.7610254, 'fromlat': 61.4981508, 'tolng': 13.7090684, 'weight': 1, 'tolat': 51.0266014}, {'fromlng': 13.5470509, 'fromlat': 52.4370179, 'tolng': 13.7090684, 'weight': 1, 'tolat': 51.0266014}]}}
self.assertEqual(len(locresults['hexbin']['nodes']),
len(expected_results['hexbin']['nodes']))
self.assertEqual(len(locresults['hexbin']['edges']),
len(expected_results['hexbin']['edges']))
def create_app(option):
app = FlaskOpinewExt(__name__)
config = config_factory.get(option)
app.config.from_object(config)
from common import create_jinja_filters, random_pwd, verify_initialization
create_jinja_filters(app)
from webapp.client import client
from webapp.media import media
app.register_blueprint(client)
app.register_blueprint(media, url_prefix=Constants.MEDIA_URL_PREFIX)
compress.init_app(app)
gravatar.init_app(app)
resize.init_app(app)
db.init_app(app)
admin.init_app(app)
mail.init_app(app)
migrate.init_app(app, db)
babel.init_app(app)
from models import User, Role
from webapp.forms import ExtendedRegisterForm
assets.init_app(app)
assets.register('js_all', js_assets)
assets.register('css_all', css_assets)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app,
user_datastore,
confirm_register_form=ExtendedRegisterForm)
with app.app_context():
from providers import database, payment
if not app.testing:
verify_initialization()
if app.testing:
from async import tasks
api_manager.init_app(app, flask_sqlalchemy_db=db)
@app.before_request
def before_request():
# hack to allow browsers who don't set 3rd party cookies
x_session = request.headers.get('X-Session')
if x_session:
rc = dict(request.cookies)
rc['session'] = x_session
request.cookies = ImmutableTypeConversionDict(rc)
# refresh session
refreshed_csrf_token = app.session_interface.open_session(
app, request).get('csrf_token')
session['csrf_token'] = refreshed_csrf_token
user_agent = parse(request.user_agent.string)
g.mobile = False
if user_agent.is_mobile or user_agent.is_tablet:
g.mobile = True
g.constants = Constants
g.config = app.config
g.mode = app.config.get('MODE')
g.response_context = []
g.s = strings
g.payment = payment.StripeAPI()
g.db = database.OpinewSQLAlchemyFacade()
@app.after_request
def redirect_if_next(response_class):
if request.endpoint == 'static':
response_class.headers['Access-Control-Allow-Origin'] = '*'
payload = request.args if request.method == 'GET' else request.form
if 'api_next' in payload:
if not response_class.status_code == 200:
flash(response_class.data)
return redirect(request.referrer)
return redirect(payload.get('api_next'))
return response_class
# register here CSRF so that the before_request is executed after the hack above
csrf.init_app(app)
patch_request_class(app, Constants.MAX_FILE_SIZE)
from webapp.common import make_json_error
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
configure_uploads(app, (
user_images,
review_images,
shop_images,
))
admins = [email for name, email in config.ADMINS]
if not (app.debug or app.testing):
mail_handler = SMTPHandler(
app.config.get('MAIL_SERVER'),
'*****@*****.**',
admins,
'Your Application Failed',
credentials=(app.config.get('MAIL_USERNAME'),
app.config.get('MAIL_PASSWORD')),
secure=())
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
Formatter('''
Time : %(asctime)s
Location : %(pathname)s:%(lineno)d
Module : %(module)s
Function : %(funcName)s
%(message)s'''))
app.logger.addHandler(mail_handler)
return app
# -*- coding: utf-8 -*-
from flask.ext.security import SQLAlchemyUserDatastore
from app import create_app
from app.core import db
from app.data.users import User, Role
app = create_app("dev")
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
# security = Security(app, user_datastore)
# Create a user to test with
# db.drop_all()
# db.create_all()
role = user_datastore.create_role(name="root", description="Site administrator")
user_datastore.create_user(email='*****@*****.**', password='******', roles=[role])
user_datastore.create_user(email='*****@*****.**', password='******')
db.session.commit()
class Test(object):
id = 1
en_title = "title"
ru_title = u"тайтл"
comment = db.Column(db.String(1000))
rating = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.now)
def __repr__(self):
return str(self.id)
@property
def admin_url(self):
return "%s/%s/%s" % (app.config['ADMIN_URL'], 'review', self.id)
@property
def url(self):
return "%s/%s/" % ('review', self.id)
users = SQLAlchemyUserDatastore(db, User, Role)
# social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
class ExtendedRegisterForm(RegisterForm):
name = TextField(u'İsim Soyisim', [Required(u'İsmini girmen gerekli')])
why = TextAreaField(
u'Eşya Kütüphanesi\'ne neden geldiğinden kısaca bahsedebilir misin? '
u'Mesela buradan beklentilerin neler? '
u'Bizi nereden duydun?',
[Length(min=0, max=1000, message=u'En fazla 1000 karakter girebilirsin.'),
Required(u'Seni daha yakından tanımayı istiyoruz.')]
)
about = TextAreaField(
u'Hobilerin neler? Bir ejderhan olsa adını ne koyardın? '
u'En sevdiğin yemek ne? Boş zamanlarında ne yapmaktan hoşlanırsın?',
from flask.ext.admin import Admin
from flask_admin.base import MenuLink
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask_wtf.csrf import CsrfProtect
from config import FIRST_USER_PASS, FIRST_USER_NAME
# Initialize the app and database, import the config
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
CsrfProtect(app)
app.killswitch = 0
# setup db, create the db, setup security, and add first user
from app import models
userstore = SQLAlchemyUserDatastore(db, models.User, None)
sec = Security(app, userstore)
db.create_all()
try:
userstore.create_user(email=FIRST_USER_NAME, password=FIRST_USER_PASS)
db.session.commit()
except: db.session.rollback()
#this loads all views
from app.views import main, admin
#admin setup
_admin = Admin(app, 'NYX Admin', template_mode='bootstrap3',
index_view=admin.ProtectedIndexView())
_admin.add_link(MenuLink(name='Back to Site', url='/'))
_admin.add_view(admin.UserModelView(models.User, db.session))
:return: security_monkey.datastore.User object
"""
app.logger.info("Inside load_user!")
user = User.query.filter(User.email == email).first()
if not user:
user = User(email=email)
db.session.add(user)
db.session.commit()
db.session.close()
user = User.query.filter(User.email == email).first()
return user
### Flask-Security ###
from flask.ext.security import Security, SQLAlchemyUserDatastore
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
### Flask Mail ###
from flask_mail import Mail
mail = Mail(app=app)
from security_monkey.common.utils import send_email as common_send_email
@security.send_mail_task
def send_email(msg):
"""
Overrides the Flask-Security/Flask-Mail integration
to send emails out via boto and ses.
"""
common_send_email(subject=msg.subject,
def create_app(config_name):
from models import (
User,
Role,
)
from places.models import (
Category,
Feature,
Place,
)
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app,user_datastore)
principal.init_app(app)
# jwt.init_app(app)
api.init_app(app)
admin.init_app(app)
assets.init_app(app)
assets.register('css_all', css_all)
assets.register('js_vendor', js_vendor)
with app.app_context():
db.init_app(app)
db.create_all()
if not Role.query.first():
admin_role = Role(name='admin',description='Administrator')
db.session.add(admin_role)
db.session.commit()
else:
admin_role = Role.query.filter(Role.name=='admin').first()
if not User.query.first():
user_datastore.create_user(
email='*****@*****.**',
password=encrypt_password('Haukola'),
roles=[admin_role]
)
db.session.commit()
# attach routes and custom error pages here
admin.add_view(UserModelView(User, db.session, category='Auth'))
admin.add_view(AdminModelView(Role, db.session, category='Auth'))
admin.add_view(PlaceAdmin(Place, db.session))
admin.add_view(CategoryAdmin(Category, db.session))
admin.add_view(FeatureAdmin(Feature, db.session))
admin.add_view(LogoutView(name='Logout', endpoint='logout'))
admin.add_view(LoginView(name='Login', endpoint='login'))
sitemap_view = Sitemap.as_view('sitemap')
app.add_url_rule('/sitemap', view_func=sitemap_view)
tapvendors_csv_view = TAPVendorsCSV.as_view('tapvendors_csv')
app.add_url_rule('/csv/tapvendors', view_func=tapvendors_csv_view)
railstations_csv_view = RailStationsCSV.as_view('railstations_csv')
app.add_url_rule('/csv/railstations', view_func=railstations_csv_view)
placemap_view = Placemap.as_view('placemap')
app.add_url_rule('/placemap/',
view_func=placemap_view,
methods=['GET'],
)
placemaptapvendors_view = Placemap.as_view('placemaptapvendors')
app.add_url_rule('/placemap/tapvendors',
view_func=placemaptapvendors_view,
methods=['GET'],
)
placemaprailstations_view = Railmap.as_view('placemaprailstations')
app.add_url_rule('/placemap/railstations',
view_func=placemaprailstations_view,
methods=['GET'],
)
return app
filename="hexbin_query.json", template="hexbin_query.html")
# create tabdata queries
replace_tabdata_query(
db, name="Tabdata_hexbin",
description="Hexbin of geographical data",
parameters='{ "locationColumn" : 0, "valueColumn" : 0, "textColumn" : 0 }',
template="tabdata_hexbin_query.html")
replace_tabdata_query(
db, name="Tabdata_markercluster",
description="Markercluster map of geographical data",
parameters='{ "locationColumn" : 0, "valueColumn" : 0, "textColumn" : 0 }',
template="tabdata_markercluster_query.html")
# create users
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
if user_datastore.find_user(nickname="admin") is None:
admin = user_datastore.create_user(
nickname="admin", email="*****@*****.**", password="******")
db.session.add(admin)
db.session.commit()
create_gps_cache()
if not os.path.exists(SQLALCHEMY_MIGRATE_REPO):
api.create(SQLALCHEMY_MIGRATE_REPO, 'database repository')
api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
else:
api.version_control(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO,
user = User.query.filter_by(
name=self.name.data).first()
if user is None:
self.name.errors.append('Unknown username')
return False
if not user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
self.user = user
return True
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore, login_form=ExtendedLoginForm)
# Create an admin user to test with
def create_user_and_role():
first_user = User.query.filter(User.name == str('admin')).first()
if not first_user:
user_email = '*****@*****.**'
username = '******'
user_pass = app.config['ADMIN_PASS']
the_user = user_datastore.create_user(email=user_email, name=username, password=user_pass, dhbox_duration=1000000000)
the_role = user_datastore.create_role(name='admin', description='The administrator')
user_datastore.add_role_to_user(the_user, the_role)
db.session.commit()
try:
