def create_user():
Base.metadata.create_all(bind=engine)
# Create roles
admin_role = user_datastore.find_or_create_role(
name="admin", description="Administrator")
user_role = user_datastore.find_or_create_role(name="user",
description="End user")
db_session.commit()
# Create users
admin_user = user_datastore.find_user(email="*****@*****.**")
if not admin_user:
admin_user = user_datastore.create_user(
email="*****@*****.**",
password=hash_password("Passw0rd1"))
db_session.commit()
user_user = user_datastore.find_user(email="*****@*****.**")
if not user_user:
user_user = user_datastore.create_user(
email="*****@*****.**",
password=hash_password("Passw0rd1"))
db_session.commit()
# Assign roles
user_datastore.add_role_to_user(user_user, user_role)
user_datastore.add_role_to_user(admin_user, admin_role)
db_session.commit()
# Create database structure
get_topic_store().create_database()
def create_users():
if current_app.testing:
return
db.create_all()
user_datastore.create_role(
name="admin",
permissions={"admin-read", "admin-write", "user-read", "user-write"},
)
user_datastore.create_role(name="monitor",
permissions={"admin-read", "user-read"})
user_datastore.create_role(name="user",
permissions={"user-read", "user-write"})
user_datastore.create_role(name="reader", permissions={"user-read"})
user_datastore.create_user(email="*****@*****.**",
password=hash_password("password"),
roles=["admin"])
user_datastore.create_user(email="*****@*****.**",
password=hash_password("password"),
roles=["monitor"])
real_user = user_datastore.create_user(email="*****@*****.**",
password=hash_password("password"),
roles=["user"])
user_datastore.create_user(email="*****@*****.**",
password=hash_password("password"),
roles=["reader"])
# create initial blog
blog = app.blog_cls(text="my first blog", user=real_user)
db.session.add(blog)
db.session.commit()
print("First blog id {}".format(blog.id))
def build_sample_db():
"""
Populate a small db with some example entries.
"""
import string
import random
db.drop_all()
db.create_all()
with app.app_context():
user_role = Role(name='user')
super_user_role = Role(name='superuser')
db.session.add(user_role)
db.session.add(super_user_role)
db.session.commit()
test_user = user_datastore.create_user(
first_name='Admin',
email='*****@*****.**',
password=hash_password('admin'),
roles=[user_role, super_user_role])
first_names = [
'Harry', 'Amelia', 'Oliver', 'Jack', 'Isabella', 'Charlie',
'Sophie', 'Mia', 'Jacob', 'Thomas', 'Emily', 'Lily', 'Ava', 'Isla',
'Alfie', 'Olivia', 'Jessica', 'Riley', 'William', 'James',
'Geoffrey', 'Lisa', 'Benjamin', 'Stacey', 'Lucy'
]
last_names = [
'Brown', 'Smith', 'Patel', 'Jones', 'Williams', 'Johnson',
'Taylor', 'Thomas', 'Roberts', 'Khan', 'Lewis', 'Jackson',
'Clarke', 'James', 'Phillips', 'Wilson', 'Ali', 'Mason',
'Mitchell', 'Rose', 'Davis', 'Davies', 'Rodriguez', 'Cox',
'Alexander'
]
for i in range(len(first_names)):
tmp_email = first_names[i].lower() + "." + last_names[i].lower(
) + "@example.com"
tmp_pass = ''.join(
random.choice(string.ascii_lowercase + string.digits)
for i in range(10))
user_datastore.create_user(first_name=first_names[i],
last_name=last_names[i],
email=tmp_email,
password=hash_password(tmp_pass),
roles=[
user_role,
])
db.session.commit()
return
def index(self):
form = CreateNewUserForm()
from src.db_models import Role
from src import user_datastore, db
from flask_security import hash_password
db_roles = Role.query.order_by(Role.name).all()
roles = [(r.name, r.name) for r in db_roles]
form.roles.choices = roles
if form.validate_on_submit():
try:
user_datastore.create_user(email=form.email.data,
password=hash_password(
form.password.data))
db.session.commit()
for r in form.roles.data:
user_datastore.add_role_to_user(form.email.data, r)
db.session.commit()
flash(f"User {form.email.data} created", "info")
except Exception as ex:
flash(f"Creating user failed: {ex}", "error")
return self.render("admin/create_new_user.html",
form=form,
with_categories=True)
def addCairisUser(userName, passWd, fullName):
rp = ''.join(
choice(string.ascii_letters + string.digits) for i in range(255))
if (existingAccount(userName)):
raise Exception(userName + ' already exists')
dbAccount = canonicalDbUser(userName)
b = Borg()
createDatabaseAccount(b.rPasswd, b.dbHost, b.dbPort, dbAccount, rp)
createDatabaseAndPrivileges(b.rPasswd, b.dbHost, b.dbPort, dbAccount, rp,
canonicalDbUser(userName) + '_default')
createDatabaseSchema(b.cairisRoot, b.dbHost, b.dbPort, userName, rp,
dbAccount + '_default')
db.create_all()
user_datastore.create_user(email=userName,
account=dbAccount,
password=hash_password(passWd),
dbtoken=rp,
name=fullName)
db.session.commit()
createDefaults(b.cairisRoot, b.dbHost, b.dbPort, userName, rp,
dbAccount + '_default')
def create_user():
admin = user_datastore.find_or_create_role('admin',
description='admin role')
user_datastore.find_or_create_role('enzyme_types_admin',
description='enzyme_types_admin')
user_datastore.find_or_create_role('contributor',
description='contributor')
user_datastore.find_or_create_role('super_contributor',
description='contributor')
user_datastore.find_or_create_role('rxn_rules_admin',
description='rxn_rules_admin')
user_datastore.find_or_create_role('paper_adder',
description='paper_finder')
user_datastore.find_or_create_role('experimental',
description='experimental')
user_datastore.find_or_create_role('enzyme_champion',
description='enzyme_champion')
user_datastore.find_or_create_role('enzyme_teams',
description='enzyme_teams')
if not user_datastore.get_user(app.config['ADMIN_EMAIL']):
user = user_datastore.create_user(
email=app.config['ADMIN_EMAIL'],
password=hash_password(app.config['ADMIN_PASSWORD']),
first_name='Admin',
last_name='',
affiliation='RetroBioCat',
confirmed_at=datetime.datetime.now())
user_datastore.add_role_to_user(user, admin)
print("done")
def gerom(app, manager, user_ds, db):
"""
Create a test user.
Gerom has a confirmed account, but is not logged in.
"""
gerom = user_ds.create_user(
email="*****@*****.**",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
)
schedule = md.Schedule(
schd.Schedule(manager.get_default_project_id(),
label="GEROM'S SCHEDULE"),
user=gerom,
)
db.session.add(schedule)
db.session.commit()
yield gerom
db.session.delete(schedule)
db.session.delete(gerom)
db.session.commit()
def create_superuser(login: str, password: str):
admin_role = user_datastore.find_or_create_role('admin')
user = user_datastore.create_user(
login=login, password=hash_password(password), active=True, roles=[admin_role]
)
db.session.add(user)
db.session.commit()
click.echo("Superuser {} successfully created.".format(login))
def test__register_post(flask_app, load_admin_data, database):
user_data = {
"username":load_admin_data['email'],
"password":hash_password(load_admin_data['password'])
}
flask_app.test_client_class = FlaskClient
# flask_app.db = database
with flask_app.test_request_context():
with flask_app.test_client() as client:
print(f"user.register: {url_for('security.register')}")
print(f"user.login: {url_for('security.login')}")
print(f"admin: {url_for('admin.index')}")
register_response = client.post('/user/register', data=user_data, follow_redirects=True)
print(f"register_response: {register_response}")
print(f"base request: {request}")
print(f"base request form: {request.form}")
print(f"base request cookies: {request.cookies}")
print(f"base session: {session}")
print(f"base g: {g.__dict__}")
print(f"check db for users")
print(f"<Users: {[x for x in User.objects()]}")
login_response = client.post('/user/sign-in', data=user_data, follow_redirects=True)
print(f"login_response: {login_response}")
print(f"2 request: {request}")
print(f"2 request form: {request.form}")
# print(f"2 request headers: {request.headers}")
print(f"2 request cookies: {request.cookies}")
print(f"2 session: {session}")
# print(f"2 g: {g.__dict__}")
admin_response = client.get('/admin/', follow_redirects=True)
print(f"admin_response: {admin_response}")
print(f"3 request: {request}")
print(f"3 request data: {request.data}")
# print(f"3 request headers: {request.headers}")
print(f"3 request cookies: {request.cookies}")
print(f"3 session: {session}")
# print(f"3 g: {g.__dict__}")
print(f"app.db: {flask_app.db}")
print(f"database: {database}")
assert admin_response.status_code == 200
def create(email, password, do_hash=True, **kwargs):
from app import user_datastore
if do_hash:
password = hash_password(password)
return user_datastore.create_user(email=email,
password=password,
**kwargs)
def create_user():
print("=========="*3)
print(f"prerun function")
if not user_datastore.find_user(email="*****@*****.**"):
user_datastore.create_user(email="*****@*****.**", password=hash_password("password"))
user = user_datastore.find_user(email="*****@*****.**")
print(user)
print("=========="*3)
def create_user():
user_store.init_db()
# Create roles
user_datastore.find_or_create_role(name="admin", description="Administrator")
user_datastore.find_or_create_role(name="user", description="End user")
# Create users
if not user_datastore.get_user("*****@*****.**"):
user_datastore.create_user(email="*****@*****.**", password=hash_password("Passw0rd1"))
if not user_datastore.get_user("*****@*****.**"):
user_datastore.create_user(email="*****@*****.**", password=hash_password("Passw0rd1"))
user_store.db_session.commit()
# Assign roles
user_datastore.add_role_to_user("*****@*****.**", "user")
user_datastore.add_role_to_user("*****@*****.**", "admin")
user_store.db_session.commit()
def quick_setup(dbHost,
dbPort,
dbRootPassword,
tmpDir,
rootDir,
configFile,
webPort,
logLevel,
staticDir,
assetDir,
userName,
passWd,
mailServer='',
mailPort='',
mailUser='',
mailPasswd=''):
if (len(userName) > 255):
raise ARMException("Username cannot be longer than 255 characters")
if (userName == "root"):
raise ARMException("Username cannot be root")
createCairisCnf(configFile, dbRootPassword, dbHost, dbPort, tmpDir,
rootDir, webPort, logLevel, staticDir, assetDir,
mailServer, mailPort, mailUser, mailPasswd)
os.environ["CAIRIS_CFG"] = configFile
createDbOwnerDatabase(dbRootPassword, dbHost, dbPort)
createUserDatabase(dbHost, dbPort, dbRootPassword, rootDir)
pathName = os.path.split(
os.path.split(os.path.realpath(os.path.dirname(__file__)))[0])[0]
sys.path.insert(0, pathName)
fileName = os.environ.get("HOME") + "/.bashrc"
f = open(fileName, 'a')
f.write("export CAIRIS_SRC=" + rootDir + "\n")
f.write("export CAIRIS_CFG_DIR=${CAIRIS_SRC}/config\n")
f.write("export CAIRIS_CFG=" + configFile + "\n")
f.write("export PYTHONPATH=${PYTHONPATH}:" + pathName + "\n")
f.close()
from cairis.bin.add_cairis_user import user_datastore, db
db.create_all()
if (userName != ''):
rp = ''.join(choice(ascii_letters + digits) for i in range(255))
dbAccount = canonicalDbUser(userName)
user_datastore.create_user(email=userName,
account=dbAccount,
password=hash_password(passWd),
dbtoken=rp,
name='Default user')
db.session.commit()
createDatabaseAccount(dbRootPassword, dbHost, dbPort, dbAccount, rp)
createDatabaseAndPrivileges(dbRootPassword, dbHost, dbPort, userName,
rp, dbAccount + '_default')
createDatabaseSchema(rootDir, dbHost, dbPort, userName, rp,
dbAccount + '_default')
createDefaults(rootDir, dbHost, dbPort, userName, rp,
dbAccount + '_default')
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('email')
parser.add_argument('password')
args = parser.parse_args()
return user_datastore.create_user(email=args["email"],
password=hash_password(args["password"]))
def test_replace_send_code(app, get_message):
# replace tf_send_code - and have it return an error to check that.
from flask_sqlalchemy import SQLAlchemy
from flask_security.models import fsqla_v2 as fsqla
from flask_security import Security, hash_password
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
db = SQLAlchemy(app)
fsqla.FsModels.set_db_info(db)
class Role(db.Model, fsqla.FsRoleMixin):
pass
class User(db.Model, fsqla.FsUserMixin):
rv = [None, "That didnt work out as we planned", "Failed Again"]
def tf_send_security_token(self, method, **kwargs):
return User.rv.pop(0)
with app.app_context():
db.create_all()
ds = SQLAlchemyUserDatastore(db, User, Role)
app.security = Security(app, datastore=ds)
with app.app_context():
client = app.test_client()
ds.create_user(
email="*****@*****.**",
password=hash_password("password"),
tf_primary_method="sms",
tf_totp_secret=app.security._totp_factory.generate_totp_secret(),
)
ds.commit()
data = dict(email="*****@*****.**", password="******")
response = client.post("/login", data=data, follow_redirects=True)
assert b"Please enter your authentication code" in response.data
rescue_data = dict(help_setup="lost_device")
response = client.post("/tf-rescue",
data=rescue_data,
follow_redirects=True)
assert b"That didnt work out as we planned" in response.data
# Test JSON
headers = {
"Accept": "application/json",
"Content-Type": "application/json"
}
response = client.post("/tf-rescue", json=rescue_data, headers=headers)
assert response.status_code == 500
assert response.json["response"]["errors"]["help_setup"][
0] == "Failed Again"
def create_admin_user():
database.models.user_datastore.create_user(
email=app.config['ADMIN_EMAIL'],
password=hash_password(app.config['ADMIN_PASSWORD']),
)
admin_role = database.models.user_datastore.find_or_create_role(
name='admin')
database.models.user_datastore.add_role_to_user(
user=app.config['ADMIN_EMAIL'], role=admin_role)
def fix_null_passwords():
users = db.session.query(User).all()
from flask_security import hash_password
from app.manage_users.actions import _randompassword
for user in users:
if user.password is None:
user.password = hash_password(_randompassword())
db.session.commit()
def init_db():
# Init db
db.drop_all()
db.create_all()
click.echo("db reinitialised")
# Roles
roles = [("admin", {"rw_admin", "rw_user"}), ("user", {"rw_user"})]
for name, permissions in roles:
user_datastore.create_role(name=name, permissions=permissions)
print(len(roles), "roles créés")
# Users
users = [("raphael", hash_password("azerty"), ["admin"]),
("test", hash_password("azerty"), ["user"])]
for username, pwd, roles in users:
user_datastore.create_user(username=username,
password=pwd,
roles=roles)
print(len(users), "utilisateurs créés")
def create_manager():
CSManager_role = USER_DATASTORE.find_or_create_role("CSManager")
USER_DATASTORE.create_user(name='管理員',
password=hash_password('beautifulgirl'),
phone='0912345678',
user_id='handsomeboy',
email='*****@*****.**',
role='CSManager',
major=None,
course_list=None,
personal_plan=None,
roles=[CSManager_role])
def setup_inactive_user(db, setup_accounts, setup_roles_users):
"""
Set up one inactive user.
"""
from flexmeasures.data.models.user import User, Role
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
account_id=setup_accounts["Prosumer"].id,
active=False,
)
def user(app, client):
"""
Fixture for an active logged-in user
"""
with app.app_context():
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
user = user_datastore.create_user(
email="*****@*****.**", password=hash_password("testpassword"))
user_datastore.activate_user(user)
client.post("/web-ui/login",
data={
"email": "*****@*****.**",
"password": "******"
},
follow_redirects=True)
yield user
def create_user(self):
user_list = self._get_user_list()
user = self.session.prompt(
'username: '******'user must not exist and not be empty'),
completer=None)
while True:
password = getpass.getpass('password: '******'Password is not legal. Please choose another password.')
continue
break
with self.app.app_context():
self.store.create_user(email=user,
password=hash_password(password),
roles=['guest'])
self.db.session.commit()
def jyl(app, manager, user_ds, db):
"""
Create a test user.
JYL has a confirmed account and is logged in.
"""
jyl = user_ds.create_user(
email="*****@*****.**",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
)
data = schd.Schedule(manager.get_default_project_id(),
label="JYL'S SCHEDULE")
data.add_course("LEPL1104")
active_schedule = md.Schedule(data, user=jyl)
db.session.add(active_schedule)
old_schedule = md.Schedule(schd.Schedule(manager.get_default_project_id(),
label="OLD SCHEDULE"),
user=jyl)
db.session.add(old_schedule)
db.session.commit()
# Login user
@app.login_manager.request_loader
def load_user_from_request(request):
utl.init_session()
session["current_schedule"] = copy.copy(jyl.get_schedules()[0].data)
return jyl
yield jyl
# Logout & delete user
@app.login_manager.request_loader
def load_user_from_request(request):
return None
db.session.delete(active_schedule)
db.session.delete(old_schedule)
db.session.delete(jyl)
db.session.commit()
def create_user(input_name, input_password, input_phone, input_user_id,
input_email, input_role, input_major, input_course_list,
input_personal_plan):
student_role = USER_DATASTORE.find_or_create_role("student")
teacher_role = USER_DATASTORE.find_or_create_role("teacher")
if input_role == "teacher":
my_role = teacher_role
else:
my_role = student_role
if USER_DATASTORE.get_user("Liao") is None:
USER_DATASTORE.create_user(name=input_name,
password=hash_password(input_password),
phone=input_phone,
user_id=input_user_id,
email=input_email,
role=input_role,
major=input_major,
course_list=input_course_list,
personal_plan=input_personal_plan,
roles=[my_role])
def post(self):
"""
Creates a new user
---
tags:
- users
description: Given user's email and password creates a new instance in the database.
parameters:
- in: body
name: email
required: true
type: string
description: User's email.
example: [email protected]
- in: body
name: password
required: true
type: string
description: User's password.
example: some_strong_password
responses:
201:
description: User created
400:
description: Invalid input data
"""
data = request.get_json()
user_schema = UserSchema()
user = user_schema.load(data)
if not (user.get('email') and user.get('password')):
return make_response('', 400)
if user_datastore.find_user(email=user.get('email')):
return make_response('', 400)
user_datastore.create_user(email=user.get('email'),
password=hash_password(
user.get('password')))
db.session.commit()
return make_response('User created', 201)
def init_database():
"""Initiate database and create admin user"""
db.create_all()
for role_definition in app.role_definitions:
name = role_definition['name']
description = role_definition['description']
permissions = role_definition['permissions']
level = role_definition['level']
user_datastore.find_or_create_role(
name=name,
description=description,
level=level,
permissions=permissions
)
if not user_datastore.find_user(username=app.admin['username']):
user_datastore.create_user(
username=app.admin['username'],
email=app.admin['email'],
password=hash_password(app.admin['password']),
roles=['owner', 'admin', 'member']
)
db.session.commit()
def ensure_password(plain_text: str) -> str:
return hash_password(plain_text) if plain_text else None
def create_user():
if not user_exists('*****@*****.**'):
user_datastore.create_user(email='*****@*****.**',
password=hash_password("test1234"))
def init_db(defineowner=True):
#--------------------------------------------------------------------------
# must wait until user_datastore is initialized before import
from loutilities.user import user_datastore
from flask_security import hash_password
# special processing for user roles because need to remember the roles when defining the owner
# define user roles here
interests = [
{'interest':'fsrc', 'description':'Frederick Steeplechasers Running Club', 'public':True}
]
# initialize applications, remembering what applications we have
allapps = []
appname2db = {}
for app in APP_ALL:
thisapp = Application(application=app)
db.session.add(thisapp)
db.session.flush()
allapps.append(thisapp)
appname2db[app] = thisapp
# initialize roles, remembering what roles we have
combinedroles = {}
local_all_roles = deepcopy(all_roles)
for approles in local_all_roles:
for approle in approles:
apps = approle.pop('apps')
rolename = approle['name']
thisrole = Role.query.filter_by(name=rolename).one_or_none() or user_datastore.create_role(**approle)
for thisapp in apps:
thisrole.applications.append(appname2db[thisapp])
combinedroles[rolename] = thisrole
allinterests = []
# initialize interests, remembering what interests we have
# common interests are associated with all applications
for interest in interests:
thisinterest = Interest(**interest)
for thisapp in allapps:
thisinterest.applications.append(thisapp)
db.session.flush()
allinterests.append(thisinterest)
# define owner if desired
if defineowner:
from flask import current_app
rootuser = current_app.config['APP_OWNER']
rootpw = current_app.config['APP_OWNER_PW']
name = current_app.config['APP_OWNER_NAME']
given_name = current_app.config['APP_OWNER_GIVEN_NAME']
owner = User.query.filter_by(email=rootuser).first()
if not owner:
owner = user_datastore.create_user(email=rootuser, password=hash_password(rootpw), name=name, given_name=given_name)
for rolename in combinedroles:
user_datastore.add_role_to_user(owner, combinedroles[rolename])
db.session.flush()
owner = User.query.filter_by(email=rootuser).one()
if not owner.interests:
for thisinterest in allinterests:
owner.interests.append(thisinterest)
# and we're done, let's accept what we did
db.session.commit()
def init_db(defineowner=True):
#--------------------------------------------------------------------------
# init the modelitems from dbinit_contracts
# must wait until user_datastore is initialized before import
from runningroutes import user_datastore
from flask_security import hash_password
# special processing for user roles because need to remember the roles when defining the owner
# define user roles here
userroles = [
{
'name': 'super-admin',
'description': 'everything'
},
{
'name': 'interest-admin',
'description': 'interest administrator'
},
]
# initialize roles, remembering what roles we have
allroles = {}
for userrole in userroles:
rolename = userrole['name']
allroles[rolename] = Role.query.filter_by(
name=rolename).first() or user_datastore.create_role(**userrole)
# initialize interests
interests = [
{
'interest': 'fsrc',
'description': 'Frederick Steeplechasers Running Club',
'public': True
},
{
'interest': 'l-and-h',
'description': 'Lou and Harriet',
'public': False
},
]
allinterests = []
for interest in interests:
thisinterest = Interest(**interest)
db.session.add(thisinterest)
db.session.flush()
allinterests.append(thisinterest)
# define owner if desired
if defineowner:
from flask import current_app
rootuser = current_app.config['APP_OWNER']
rootpw = current_app.config['APP_OWNER_PW']
name = current_app.config['APP_OWNER_NAME']
given_name = current_app.config['APP_OWNER_GIVEN_NAME']
owner = User.query.filter_by(email=rootuser).first()
if not owner:
owner = user_datastore.create_user(email=rootuser,
password=hash_password(rootpw),
name=name,
given_name=given_name)
for rolename in allroles:
user_datastore.add_role_to_user(owner, allroles[rolename])
db.session.flush()
owner = User.query.filter_by(email=rootuser).one()
for thisinterest in allinterests:
owner.interests.append(thisinterest)
# and we're done, let's accept what we did
db.session.commit()
