def setup(email, username, password):
""" Setup UserDatastore and Roles. Add -a <email> to create default admin user with email and password=password
"""
from datetime import datetime
from app import models, db
from flask_security import SQLAlchemyUserDatastore
# create roles
with app.app_context():
db.create_all()
store = SQLAlchemyUserDatastore(db, models.User, models.Role)
# Add roles
for name, description in [
("Admin", "Administration"),
]:
try:
store.create_role(name=name, description=description)
db.session.commit()
except Exception as e:
db.session.rollback()
print(e)
# optional: add admin user
if email or username or password:
store.create_user(username=username,
email=email,
password=password,
roles=["Admin"])
models.User.get_user("admin").confirmed_at = datetime.now()
db.session.commit()
def _init_users():
"""Initialize Afterglow user datastore if AUTH_ENABLED = True"""
# noinspection PyUnresolvedReferences
from .. import oauth2 # register oauth token-related models
# All imports put here to avoid unnecessary loading of packages on startup
# if user auth is disabled
from alembic import (config as alembic_config, context as alembic_context)
from alembic.script import ScriptDirectory
from alembic.runtime.environment import EnvironmentContext
global user_datastore, security
user_datastore = SQLAlchemyUserDatastore(db, DbUser, DbRole)
security = Security(app, user_datastore, register_blueprint=False)
# Make sure that the database directory exists
try:
os.makedirs(os.path.abspath(app.config['DATA_ROOT']))
except OSError as e:
if e.errno != errno.EEXIST:
raise
# Create/upgrade tables via Alembic
cfg = alembic_config.Config()
cfg.set_main_option(
'script_location',
os.path.abspath(
os.path.join(__file__, '../..', 'db_migration', 'users')))
script = ScriptDirectory.from_config(cfg)
# noinspection PyProtectedMember
with EnvironmentContext(
cfg,
script,
fn=lambda rev, _: script._upgrade_revs('head', rev),
as_sql=False,
starting_rev=None,
destination_rev='head',
tag=None,
), db.engine.connect() as connection:
alembic_context.configure(connection=connection)
with alembic_context.begin_transaction():
alembic_context.run_migrations()
# Initialize user roles if missing
try:
roles_created = False
for name, descr in [('admin', 'Afterglow Administrator'),
('user', 'Afterglow User')]:
if not user_datastore.find_role(name):
user_datastore.create_role(name=name, description=descr)
roles_created = True
if roles_created:
user_datastore.commit()
except Exception:
db.session.rollback()
raise
def add(ctx, name, description):
"""Creates a new role"""
ds = SQLAlchemyUserDatastore(ctx.obj, User, Role)
try:
ds.create_role(name=name, description=description)
ds.commit()
except:
log.exception("Couldn't create role")
def load(ctx, file):
"""Dump stuff for loading later (in lieu of having proper migrations)"""
ds = SQLAlchemyUserDatastore(ctx.obj, User, Role)
for line in file:
email, first, last, roles, password = line.strip().split('\t')
u = ds.find_user(email=email)
if not u:
u = ds.create_user(email=email,
first_name=first,
last_name=last,
password=password)
log.info('added %s', u)
ds.commit()
for role_name in roles.strip().split(','):
r = ds.find_role(role_name)
if not r:
r = ds.create_role(name=role_name)
ds.commit()
if not u.has_role(r):
ds.add_role_to_user(u, r)
ds.commit()
def load_all_fixtures(db, app):
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
# Load default fixtures
role = user_datastore.create_role(name=app.config['VOXO_ROLE_USER'],
description='User role')
admin_role = user_datastore.create_role(name=app.config['VOXO_ROLE_ADMIN'],
description='Admin role')
server_role = user_datastore.create_role(
name=app.config['VOXO_ROLE_SERVER'], description='Server role')
user_vjousse = registerable.register_user(email='*****@*****.**',
password='******')
user_datastore.add_role_to_user(user_vjousse, role)
print("{user} with token {token} created.".format(
user=user_vjousse.email, token=user_vjousse.get_auth_token()))
user = registerable.register_user(email='*****@*****.**',
password='******')
user_datastore.add_role_to_user(user, admin_role)
user_datastore.add_role_to_user(user, role)
print("{user} with token {token} created.".format(
user=user.email, token=user.get_auth_token()))
server = registerable.register_user(email='*****@*****.**',
password='******')
user_datastore.add_role_to_user(server, server_role)
print("{user} with token {token} created.".format(
user=server.email, token=server.get_auth_token()))
asr_model_french = AsrModel(name="french.studio.fr_FR",
description="General purpose french model")
asr_model_french.users.append(user_vjousse)
db.session.add(asr_model_french)
db.session.flush()
asr_model_english = AsrModel(name="english.studio",
description="General purpose english model")
asr_model_english.users.append(user_vjousse)
db.session.add(asr_model_english)
db.session.flush()
media_file = MediaFile(filename='fixture_file.wav',
status=FileStatus.Success,
user_id=user_vjousse.id,
size=2500,
generated_filename='fixture_file_UUID.wav',
duration=70)
db.session.add(media_file)
db.session.flush()
process = Process(
file_id=media_file.id,
status=DecodeStatus.Queued,
)
db.session.add(process)
db.session.flush()
transcription = Transcription(
auto_filename='transcription.xml',
ref_filename='transcription.txt',
user_id=user_vjousse.id,
)
db.session.add(transcription)
db.session.flush()
process = Process(file_id=media_file.id,
status=DecodeStatus.Queued,
type=ProcessType.TranscriptionAlignment,
transcription_id=transcription.id)
db.session.add(process)
db.session.flush()
db.session.commit()
from app import app,db from app.models.Roles import Role,User from flask_security import SQLAlchemyUserDatastore,Security user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore) # db.create_all() admin = user_datastore.create_user(username='******', password='******',active=True) user_datastore.create_role(name='User', description='Generic user role') admin_role = user_datastore.create_role(name='Admin', description='Admin user role') user_datastore.add_role_to_user(admin, admin_role) db.session.commit()
Anna = user_datastore.create_user(username="******",
password="******",
name="Anna",
surname="Trishyna",
email="*****@*****.**",
birthday="17.12.1998",
group="KM-63",
hobby="travel",
grades="C",
proglanguage="Python, Javascript",
specialization="113",
subject="Математика")
Admin = user_datastore.create_role(name="Admin")
User = user_datastore.create_role(name="User")
Dima.roles.append(User)
Vlad.roles.append(User)
Anna.roles.append(Admin)
Oleg = user_datastore.create_user(teacher_id = '0000000300871028',
teacher_username = '******',
teacher_name = 'Олег',
teacher_lastname = 'Чертов',
teacher_birthday = '00.00.0000',
teacher_position = 'Завідувач кафедри',
teacher_subject = 'Математика',
def do_setup(app):
"""Create a new settings database from scratch"""
if config.SERVER_MODE is False:
print(u"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(u"NOTE: Configuring authentication for SERVER mode.\n")
if all(value in os.environ
for value in ['PGADMIN_SETUP_EMAIL', 'PGADMIN_SETUP_PASSWORD']):
email = ''
p1 = ''
if os.environ['PGADMIN_SETUP_EMAIL'] and os.environ[
'PGADMIN_SETUP_PASSWORD']:
email = os.environ['PGADMIN_SETUP_EMAIL']
p1 = os.environ['PGADMIN_SETUP_PASSWORD']
else:
# Prompt the user for their default username and password.
print(
u"Enter the email address and password to use for the initial "
u"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(u'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.')
else:
print(
u'Password must be at least 6 characters. 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()
# Create the keys
key = Keys(name='CSRF_SESSION_KEY', value=config.CSRF_SESSION_KEY)
db.session.merge(key)
key = Keys(name='SECRET_KEY', value=config.SECRET_KEY)
db.session.merge(key)
key = Keys(name='SECURITY_PASSWORD_SALT',
value=config.SECURITY_PASSWORD_SALT)
db.session.merge(key)
db.session.commit()
# Done!
print(u"")
print(u"The configuration database has been created at {0}".format(
config.SQLITE_PATH))
createDate = db.Column(db.DateTime)
seasonId = db.Column(db.Integer, db.ForeignKey('season.id'))
season = db.relationship('Season', backref=db.backref('user_payment_season', order_by=id))
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
User = db.relationship('User', backref=db.backref('user_payment_user', order_by=id))
# Setup Flask-Security
userDatastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, userDatastore)
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = "login.html"
# Set up the DB
db.create_all()
teamMemberRole = userDatastore.create_role()
adminRole = userDatastore.create_role()
teamManagerRole = userDatastore.create_role()
@login_manager.user_loader
def load_user(userid):
return User.query.filter_by(id=userid).first()
#Routes
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
email = method.form['email']
password = method.form['password']
app = create_app()
app.app_context().push()
db.create_all()
# flask-security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# admin user
user_datastore.create_user(email='*****@*****.**', password='******')
user = User.query.first()
user_datastore.create_role(name='admin', description='administrator')
role = Role.query.first()
user_datastore.add_role_to_user(user, role)
# ADMIN
class AdminView(ModelView):
def is_accessible(self):
return current_user.has_role('admin')
def inaccessible_callback(self, name, **kwargs):
return redirect(url_for('security.login', next=request.url))
def create_app(config_name):
"""An application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
@param config_name: The configuration object to use.
"""
app = Flask(__name__)
app.config.from_object(config[config_name]
or config[os.getenv('BG_CONFIG')])
app.config.from_envvar('BG_SETTINGS', silent=True)
config[config_name].init_app(app)
db.init_app(app)
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
from app.users.forms import ExtendedRegisterForm
security.init_app(app, user_datastore, register_form=ExtendedRegisterForm)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
migrate.init_app(app, db)
md = Markdown(app,
output_format='html5',
extensions=['fenced_code', 'tables', 'abbr', 'footnotes'])
pages.init_app(app)
csrf.init_app(app)
register_adminviews(app)
app.jinja_env.filters['alert_class'] = alert_class_filter
# WTForms helpers
from .utils import add_helpers
add_helpers(app)
if not app.debug:
import logging
from logging.handlers import SMTPHandler
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['ADMINS_FROM_EMAIL'],
toaddrs=app.config['ADMINS_EMAIL'],
subject='Application Error Occurred')
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
register_blueprints(app)
register_commands(app)
# Create the bg_interface directory if it does not exist
directory = os.path.join(os.path.dirname(BASE_DIR), 'bg_interface')
if not os.path.exists(directory):
os.makedirs(directory)
with app.app_context():
db.create_all()
if not User.query.first():
# Create a default admin user if there is no user in the database
user_datastore.create_role(name='admin')
user_datastore.create_user(name='Administration Account',
email='*****@*****.**',
password=encrypt_password('password'),
roles=['admin'])
db.session.commit()
app.logger.info('Created admin user [email protected]')
return app