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()