def create_app(config=Config):
app = Flask(__name__,
template_folder='../templates',
static_folder='../static')
app.config.from_object(config)
config.init_app(app)
mail.init_app(app)
db.init_app(app)
admin.init_app(app)
pagedown.init_app(app)
migrate.init_app(app, db)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
Security(app, datastore=user_datastore, login_form=ExtendedLoginForm)
with app.test_request_context():
db.create_all()
user_datastore.find_or_create_role(name='admin',
description='Administrator')
if not user_datastore.get_user(app.config['ADMIN_EMAIL']):
user_datastore.create_user(email=app.config['ADMIN_EMAIL'],
password=app.config['ADMIN_PASSWORD'])
db.session.commit()
user_datastore.add_role_to_user(app.config['ADMIN_EMAIL'], 'admin')
db.session.commit()
return app
def add_role(ctx, email, role):
ds = SQLAlchemyUserDatastore(ctx.obj, User, Role)
try:
ds.add_role_to_user(email, role)
ds.commit()
except:
log.exception("Couldn't add role")
def create_init_user(user_datastore: SQLAlchemyUserDatastore) -> None:
"""
TODO in doc:
在这里创建初始的角色和管理用户。
"""
user_datastore.find_or_create_role(name='root', description='系统管理员')
user_datastore.find_or_create_role(name='admin', description='管理员')
user_datastore.find_or_create_role(name='user', description='用户')
if not user_datastore.get_user('*****@*****.**'):
user_datastore.create_user(
email='*****@*****.**',
password=security_utils.encrypt_password('default_password'))
# TODO in doc:
# 如果还需要更多的初始用户，在这里创建
db.session.commit() # 在给用户分配角色前，必须commit这个User对象
user_datastore.add_role_to_user('*****@*****.**', 'root')
# TODO in doc:
# 在这里分配其他角色给初始用户
db.session.commit()
def create_admin_user(db, survey, email, password):
user_datastore = SQLAlchemyUserDatastore(db, WebUser, WebUserRole)
admin_role = user_datastore.find_or_create_role(name='admin')
user = user_datastore.create_user(email=email,
password=hash_password(password),
survey_id=survey.id)
user_datastore.add_role_to_user(user, admin_role)
def make_admin(ctx, email):
"""Makes a given user an admin"""
ds = SQLAlchemyUserDatastore(ctx.obj, User, Role)
try:
ds.add_role_to_user(email, 'admin')
ds.commit()
except:
log.exception("Couldn't make admin")
def create_roles_users():
log.info('Insert Role data in database')
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
admin = user_datastore.find_or_create_role(name='Admin',
description='Administrator')
user_datastore.find_or_create_role(name='api', description='API user')
user = user_datastore.create_user(email=app.config['ADMIN_EMAIL'],
password=app.config['ADMIN_PASSWORD'])
user_datastore.add_role_to_user(user, admin)
db.session.commit()
def add_user():
user = User.query.order_by(User.id.desc()).first()
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
if request.method == 'POST':
if 'email' in request.form:
email = request.form.get('email')
if 'password' in request.form:
password = request.form.get('password')
if 'name' in request.form:
name = request.form.get('name')
if 'firstname' in request.form:
firstname = request.form.get('firstname')
if 'phone' in request.form:
phone = request.form.get('phone')
if 'signing' in request.files:
filename = str(user.id + 1) + '.jpg'
signing = request.files.get('signing')
path = f"APPLICATION/{admin.app['MODULES_FOLDER']}/{'admin'}/{'signing'}"
pathlib.Path(path).mkdir(parents=True, exist_ok=True)
try:
signing.save(os.path.join(path, filename))
except PermissionError:
admin.log.error(
"Permission Error to create / save file to uploads folder")
exists = db.session.query(
db.exists().where(User.email == email)).scalar()
if exists:
flash("Utilisateur existe déja", "error")
return redirect(url_for('admin.index'))
encrypted_password = utils.hash_password(password)
if not user_datastore.get_user(email):
user_datastore.create_user(email=email,
password=encrypted_password,
last_name=name,
first_name=firstname,
phone=phone,
signing=filename)
try:
db.session.commit()
except OperationalError:
admin.logger.error("Operational Error permission access database")
user_datastore.add_role_to_user(email,
'user') # set Role to the new User
try:
db.session.commit()
except OperationalError:
admin.logger.error("Operational Error permission access database")
flash("Utilisateur créer", "success")
return redirect(url_for('admin.index'))
def make_admin(manager, email):
"""Make a pre-existing user an admin."""
# Example: python3 -m compath make_admin [email protected]
ds = SQLAlchemyUserDatastore(manager, User, Role)
user = ds.find_user(email=email)
if user is None:
click.echo('User not found')
sys.exit(0)
admin = ds.find_or_create_role('admin')
ds.add_role_to_user(user, admin)
ds.commit()
click.echo('User {} is now admin'.format(email))
def register_users_from_manifest(user_datastore: SQLAlchemyUserDatastore, manifest: Dict) -> None:
"""Register the users and roles in a manifest.
:param user_datastore: A user data store
:param dict manifest: A manifest dictionary, which contains two keys: ``roles`` and ``users``. The ``roles``
key corresponds to a list of dictionaries containing ``name`` and ``description`` entries. The ``users`` key
corresponds to a list of dictionaries containing ``email``, ``password``, and ``name`` entries
as well as a optional ``roles`` entry with a corresponding list relational to the names in the ``roles``
entry in the manifest.
"""
for role in manifest['roles']:
user_datastore.find_or_create_role(**role)
for user_manifest in manifest['users']:
email = user_manifest['email']
user = user_datastore.find_user(email=email)
if user is None:
logger.info(f'creating user: {email}')
user = user_datastore.create_user(
confirmed_at=datetime.datetime.now(),
email=email,
password=user_manifest['password'],
name=user_manifest['name'],
)
for role_name in user_manifest.get('roles', []):
if user_datastore.add_role_to_user(user, role_name):
logger.info(f'registered {user} as {role_name}')
user_datastore.commit()
def create_user():
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
# db.drop_all()
# db.create_all()
# user_datastore.create_user(username='******', password='******')
# db.session.commit()
# print user_datastore.find_user(username='******')
for permissions, (name, desc) in Permission.PERMISSION_MAP.items():
user_datastore.find_or_create_role(name=name,
description=desc,
permissions=permissions)
for username, passwd, permissions in (('xjd', '123', (Permission.LOGIN,
Permission.EDITOR)),
('xilixjd', '123',
(Permission.ADMINISTER, ))):
user = user_datastore.create_user(username=username, password=passwd)
db.session.commit()
for permission in permissions:
user_datastore.add_role_to_user(
user,
user_datastore.find_role(
role=Permission.PERMISSION_MAP[permission][0]))
db.session.commit()
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 add_or_update_user(username, password, is_admin=False, active=True):
"""
:param username: username or email --> unique identification
:param password: the password may be passed in cleartext (yeah I just \
wrote that) as it is encrypted internally.
:param is_admin: determines whether the account receives the 'admin' role
:param active: determines whether users will be able to login in with the\
account
"""
user_datastore = SQLAlchemyUserDatastore(DB, User, Role)
existing_user = user_datastore.find_user(email=username)
if existing_user:
user = User.query.filter_by(email=username).first()
user.email = username
user.password = encrypt_password(password)
user.active = active
else:
user = user_datastore.create_user(email=username,
password=encrypt_password(password),
active=active)
if is_admin:
user_datastore.add_role_to_user(user, 'admin')
DB.session.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()
def create_app(config_object=ProductionConfig):
app = Flask(__name__)
# Sentry(app, dsn='https://*****:*****@sentry.io/300199') # noqa
# CORS(app)
app.config.from_object(config_object)
db.init_app(app)
migrate.init_app(app, db)
csrf.init_app(app)
from Mandark.project import models
userstore = SQLAlchemyUserDatastore(db, models.User, models.Role)
Security(app, userstore)
@app.before_request
def before_request():
g.user = current_user
@app.errorhandler(404)
def not_found_error(e):
print(e)
return render_template('404.html', title='FourOhFour')
@app.errorhandler(500)
def internal_error():
return render_template('500.html', title='A server oops happened')
try:
with app.app_context():
userstore.find_or_create_role(name='admin',
description='Administrator')
userstore.find_or_create_role(name='moderator',
description='Moderator')
userstore.find_or_create_role(name='projectmgr',
description='Project Manager')
userstore.find_or_create_role(name='user',
description='General User')
userstore.create_user(email='*****@*****.**',
password=hash_password('admin'))
userstore.create_user(email='*****@*****.**',
password=hash_password('user'))
userstore.create_user(email='*****@*****.**',
password=hash_password('Allanice-001'))
userstore.add_role_to_user('*****@*****.**', 'admin')
userstore.add_role_to_user('*****@*****.**', 'user')
userstore.add_role_to_user('*****@*****.**', 'admin')
db.session.commit()
print('IGETHEE')
except OperationalError:
if app.debug:
print(OperationalError)
else:
pass
except Exception as e:
with app.app_context():
print(e)
db.session.rollback()
from Mandark.project.views import main, admin
app.register_blueprint(main.main)
app_admin = Admin(app,
'Administration Section',
template_mode='bootstrap3',
index_view=admin.MyAdminIndexView())
app_admin.add_view(admin.UserModelView(models.User, db.session))
app_admin.add_view(admin.RoleModelView(models.Role, db.session))
app_admin.add_view(admin.ProjectModelView(models.Project, db.session))
app_admin.add_view(admin.ProjectMgrModelView(models.Projectmgr,
db.session))
app_admin.add_view(
admin.OrganisationModelView(models.Organisation, db.session))
app_admin.add_view(
admin.ChangeRequestTypeView(models.ChangeRequestType, db.session))
app_admin.add_view(
admin.ChangeRequestSubmitterView(models.ChangeRequestSubmitter,
db.session))
app_admin.add_link(MenuLink(name='Back to Site', url='/'))
return app
def init_db(app):
"""
# import all modules here that might define models so that
# they will be registered properly on the metadata. Otherwise
# you will have to import them first before calling init_db()
Initializes database and creates the tables
"""
from app.models import db, Role, AdminLogin, Project
from flask_security import Security, SQLAlchemyUserDatastore
from flask_migrate import Migrate
db.init_app(app)
app.app_context().push()
# Initialize the SQLAlchemy data store and Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, AdminLogin, Role)
security_bp = Security(app, user_datastore)
# Initialize Flask-Migrate
migrate = Migrate(app, db)
# db.drop_all() # drops tables, won't drop functions or anything else
# db.create_all()
"""
only run configure_mappers() and create_all() once, because
create_all() will throw an error that the tsvector functions
already exist. With tables, create_all() can recognize they already
exist and then not create them again, but with functions it struggles
and will try to create the functions that already exist in the database.
"""
# db.configure_mappers() # need this to enable TsVector triggers
# db.create_all()
# # insert dummy data
# from app.dummy_data import insert_dummy_data
# insert_dummy_data(db)
# Create a default superuser that has all permissions
user_datastore.find_or_create_role(name="superuser_admins",
table_name='admins',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_roles",
table_name='roles',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_advisorapplicants",
table_name='advisorapplicants',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_advisors",
table_name='advisors',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_projects",
table_name='projects',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_specialties",
table_name='specialties',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_subspecialties",
table_name='subspecialties',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_bigfirms",
table_name='bigfirms',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_occupations",
table_name='occupations',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="superuser_occupationtypes",
table_name='occupationtypes',
can_read=True,
can_edit=True,
can_create=True,
can_delete=True)
user_datastore.find_or_create_role(name="can_edit_advisorapplicants")
user_datastore.find_or_create_role(name="can_create_advisors", )
if not user_datastore.get_user(app.config['SUPERUSER_ADMIN_EMAIL']):
user_datastore.create_user(email=app.config['SUPERUSER_ADMIN_EMAIL'],
password=app.config['SUPERUSER_ADMIN_PASSWORD'],
active=True,
analytics_access=True,
database_access=True)
db.session.commit()
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_admins")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_roles")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_advisorapplicants")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_advisors")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_projects")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_specialties")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_subspecialties")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_bigfirms")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_occupations")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "superuser_occupationtypes")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "can_edit_advisorapplicants")
user_datastore.add_role_to_user(app.config['SUPERUSER_ADMIN_EMAIL'], "can_create_advisors")
db.session.commit()
db.session.close()
return security_bp
# set up the database model if not already set up
from app import models
db.create_all()
db.session.commit()
# setup the User/Role tables with flask-security, create base users/groups if neccessary
userstore = SQLAlchemyUserDatastore(db, models.User, models.Role)
sec = Security(app, userstore)
try:
with app.app_context():
userstore.find_or_create_role(name='admin', description='Administrator')
userstore.find_or_create_role(name='user', description='General user')
userstore.create_user(email=FIRST_USER_NAME,
password=utils.encrypt_password(FIRST_USER_PASS))
userstore.add_role_to_user(FIRST_USER_NAME, 'admin')
db.session.commit()
except: db.session.rollback()
# get the view controllers for the app
from app.views import main, admin, common
# set up main as a blueprint, add as many blueprints as necessary
app.register_blueprint(main.main)
# configure the admin interface, populate it with pages and links
app_admin = Admin(app, 'Flask Skeleton Admin', template_mode='bootstrap3', index_view=admin.AdminIndexView())
app_admin.add_view(admin.UserModelView(models.User, db.session))
app_admin.add_view(admin.RoleModelView(models.Role, db.session))
app_admin.add_link(MenuLink(name='Back to Site', url='/'))
def add_student():
form = AddStudentForm()
name = current_user.first_name
# for select2 fields
colleges = College.query.all()
buildings = Building.query.all()
# query all rooms in database for selectfield
form.room_id.choices = [(str(room.id), repr(room))
for room in Room.query.all()]
if form.validate_on_submit():
first_name = form.first_name.data
last_name = form.last_name.data
email = form.email.data
password = form.password.data
student = form.student.data
parent = form.parent.data
dean = form.dean.data
confirmed_at = datetime.utcnow()
user = User(first_name=first_name,
last_name=last_name,
email=email,
password=password,
student=student,
parent=parent,
dean=dean,
confirmed_at=confirmed_at)
db.session.add(user)
db.session.commit()
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
if user.student == True:
user_datastore.add_role_to_user(user.email, 'student')
elif user.parent == True:
user_datastore.add_role_to_user(user.email, 'parent')
elif user.dean == True:
user_datastore.add_role_to_user(user.email, 'dean')
else:
flash("You must select a role", 'success')
return redirect(url_for('main.dean_panel'))
db.session.commit()
relationship = ResidentOf()
relationship.user_id = user.id
if form.room_id.data != "Room":
relationship.room_id = form.room_id.data
else:
relationship.room_id = None
db.session.add(relationship)
db.session.commit()
flash("Added " + form.first_name.data + " " + form.last_name.data,
'success')
return redirect(url_for('main.dean_panel'))
return render_template('stem/add_student.html',
form=form,
colleges=colleges,
buildings=buildings,
name=name,
action="new")
# set up the database model if not already set up
from app import models
db.create_all()
db.session.commit()
# setup the User/Role tables with flask-security, create base users/groups if neccessary
userstore = SQLAlchemyUserDatastore(db, models.User, models.Role)
sec = Security(app, userstore)
try:
with app.app_context():
userstore.find_or_create_role(name='admin', description='Administrator')
userstore.find_or_create_role(name='user', description='General user')
userstore.create_user(email=FIRST_USER_NAME,
password=utils.encrypt_password(FIRST_USER_PASS))
userstore.add_role_to_user('admin', 'admin')
db.session.commit()
except: db.session.rollback()
# get the view controllers for the app
from app.views import main, admin, common
# set up main as a blueprint, add as many blueprints as necessary
app.register_blueprint(main.main)
# configure the admin interface, populate it with pages and links
app_admin = Admin(app, 'Flask Skeleton Admin', template_mode='bootstrap3', index_view=admin.AdminIndexView())
app_admin.add_view(admin.UserModelView(models.User, db.session))
app_admin.add_view(admin.LinkModelView(models.Link, db.session))
app_admin.add_link(MenuLink(name='Back to Site', url='/'))
def create_app():
myapp = Flask(__name__)
myapp.config['DEBUG'] = True
myapp.config['SECRET_KEY'] = 'super-secret'
myapp.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
# As of Flask-SQLAlchemy 2.4.0 it is easy to pass in options directly to the
# underlying engine. This option makes sure that DB connections from the
# pool are still valid. Important for entire application since
# many DBaaS options automatically close idle connections.
myapp.config["SQLALCHEMY_ENGINE_OPTIONS"] = {
"pool_pre_ping": True,
}
myapp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
myapp.config['SECURITY_PASSWORD_SALT'] = 'onetwothreefourfive'
myapp.config['SECURITY_REGISTERABLE'] = True
myapp.config['SECURITY_CONFIRMABLE'] = False
myapp.config['SECURITY_RECOVERABLE'] = True
myapp.config['SECURITY_TRACKABLE'] = True
myapp.config['SECURITY_CHANGEABLE'] = True
myapp.config['MAIL_SERVER']='localhost'
myapp.config['MAIL_PORT']=8025
db.init_app(myapp)
mail.init_app(myapp)
db_admin.init_app(myapp)
from app.models import User, Role
from app.forms import ExtendedRegisterForm
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(myapp, datastore=user_datastore,
register_form=ExtendedRegisterForm, confirm_register_form=ExtendedRegisterForm)
from app.main import bp as main_bp
myapp.register_blueprint(main_bp)
from app.db_admin import bp as db_admin_bp
myapp.register_blueprint(db_admin_bp)
# This is junk. This should be in the security blueprint, but the "myapp" variable is not
# available there, so I had to register it here.
# I thought I could put connect_via(bp), but that didn't work
# Here are some hints for fixing this
# https://stackoverflow.com/questions/16163139/catch-signals-in-flask-blueprint
# https://stackoverflow.com/questions/57866541/how-to-get-user-registered-signal-in-flask-user
# https://stackoverflow.com/questions/17146724/setting-a-default-role-in-flask-security?rq=1
@user_registered.connect_via(myapp)
def user_registered_sighandler(app, user, confirm_token):
default_role = user_datastore.find_role("user")
user_datastore.add_role_to_user(user, default_role)
db.session.commit()
# debug only for testing.
app_context = myapp.app_context()
app_context.push()
db.create_all()
# Create the Roles "admin" and "end-user" -- unless they already exist
user_datastore.find_or_create_role(name='admin', description='Administrator')
user_datastore.find_or_create_role(name='user', description='End user')
user_datastore.create_user(email='*****@*****.**', password='******')
user_datastore.create_user(email='*****@*****.**', password='******')
db.session.commit()
# Give one User has the "end-user" role, while the other has the "admin" role. (This will have no effect if the
# Users already have these Roles.) Again, commit any database changes.
user_datastore.add_role_to_user('*****@*****.**', 'user')
user_datastore.add_role_to_user('*****@*****.**', 'admin')
db.session.commit()
return myapp
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))
class HomeAdminView(AdminIndexView):
def is_accessible(self):
return current_user.has_role('admin')
from app import models
db.create_all()
db.session.commit()
# setup the User/Role tables with flask-security, create base users/groups if neccessary
userstore = SQLAlchemyUserDatastore(db, models.User, models.Role)
sec = Security(app, userstore)
try:
with app.app_context():
userstore.find_or_create_role(name='admin',
description='Administrator')
userstore.find_or_create_role(name='user', description='General user')
userstore.create_user(email=FIRST_USER_NAME,
password=utils.encrypt_password(FIRST_USER_PASS))
userstore.add_role_to_user(FIRST_USER_NAME, 'admin')
db.session.commit()
except:
db.session.rollback()
# get the view controllers for the app
from app.views import main, admin, common
# set up main as a blueprint, add as many blueprints as necessary
app.register_blueprint(main.main)
# configure the admin interface, populate it with pages and links
app_admin = Admin(app,
'Flask Skeleton Admin',
template_mode='bootstrap3',
index_view=admin.AdminIndexView())
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))
