Exemple #1
0
    def setUp(self):
        from selenium.webdriver.chrome.options import Options
        chrome_options = Options()
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--no-default-browser-check')
        chrome_options.add_argument('--no-first-run')
        chrome_options.add_argument('--disable-default-apps')
        chrome_options.add_argument('--remote-debugging-port=9222')
        chrome_options.add_argument('--headless')
        chrome_options.add_argument('--disable-gpu')

        """Setup the test driver and create test users"""
        self.driver = webdriver.Chrome(chrome_options=chrome_options)
        self.driver.get(self.get_server_url())

        email_admin = test_admin_email

        db.session.commit()
        db.drop_all()
        db.create_all()

        user_datastore.create_user(email=test_admin_email, username=test_admin_username, password=test_admin_password)
        user_datastore.create_user(email=test_user_final_email, username=test_user_final_username, password=test_user_final_password)
        user_datastore.find_or_create_role(name='admin', description='Administrator')
        user_datastore.find_or_create_role(name='end-user', description='End user')
        user_datastore.add_role_to_user(email_admin, 'admin')
        db.session.commit()
Exemple #2
0
def create_admin_user_to_db():
    print(db.session.query(User).count())
    user = User.query.filter(User.email == "admin").first()
    user_role = Role.query.filter(Role.name == "user").first()
    super_user_role = Role.query.filter(Role.name == "superuser").first()

    if not user_role:
        user_role = Role(name="user")
        db.session.add(user_role)
        db.session.commit()

    if not super_user_role:
        super_user_role = Role(name="superuser")
        db.session.add(super_user_role)
        db.session.commit()

    if not user:
        now = datetime.now()

        user_datastore.create_user(email='admin',
                                   password=encrypt_password('8Lapis6Luna'),
                                   connect_date=now,
                                   roles=[user_role, super_user_role])
        db.session.commit()
        print("admin user created")
Exemple #3
0
def register():
    if request.method == 'POST':
        name = request.form['name']
        email = request.form['email']
        phone = request.form['phone']
        username = request.form['username']
        password = utils.encrypt_password(request.form['password'])
        active = True
        user_datastore.create_user(name=name,
                                   email=email,
                                   phone=phone,
                                   username=username,
                                   password=password,
                                   active=active)
        db.session.commit()
        flash('Вітаємо! Ви зареєстровані!')

        return redirect(url_for('security.login'))

    name_form = 'user'
    title = 'Реєстрація користувача'
    form = RegistrationForm()

    return render_template('create_form.html',
                           form=form,
                           form_type=name_form,
                           title=title)
Exemple #4
0
def before_first_request():

    # Create any database tables that don't exist yet.
    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='end-user', description='End user')

    # Create two Users for testing purposes -- unless they already exists.
    # In each case, use Flask-Security utility function to encrypt the password.
    encrypted_password = utils.encrypt_password(app.config['ADMIN_PASS'])
    if not user_datastore.get_user(app.config['ADMIN_EMAIL']):
        user_datastore.create_user(email=app.config['ADMIN_EMAIL'],
                                   password=encrypted_password,
                                   username=app.config['ADMIN_USERNAME'],
                                   name=app.config['ADMIN_NAME'])

    for specie in ALL_SPECIES:
        # Commit any database changes; the User and Roles must exist before
        # we can add a Role to the User
        specie_to_add = Specie(name=specie)

        if not db.session.query(Specie)\
                .filter(Specie.name == specie_to_add.name).count() > 0:
            db.session.add(specie_to_add)

    db.session.commit()
Exemple #5
0
    def run(self):
        email = input("Email: ")
        name = input("Name: ")
        password = get_pw()

        roles = Role.query.all()
        selected_roles = []
        if len(roles) > 0:
            role_select = None
            while role_select not in [r.id for r in roles]:
                print(role_select, [r.id for r in roles])
                print("Select a role")
                role_select = int(
                    input("".join([
                        "[{}] - {} : {}\n".format(role.id, role.name,
                                                  role.description)
                        for role in roles
                    ])))
            selected_roles.append(Role.query.get(role_select).name)
        with app.app_context():
            try:
                user_datastore.create_user(email=email,
                                           password=hash_password(password),
                                           name=name,
                                           roles=selected_roles)
                db.session.commit()
                print("User with email {} has been created".format(email))
            except IntegrityError as e:
                print(e)
Exemple #6
0
def before_first_request():
    """
    runs before the first request, adds an user account and sets it as 'admin' role.
    """

    # create admin and normal user roles
    user_datastore.find_or_create_role(name='admin', description='Administrator')
    user_datastore.find_or_create_role(name='user', description='End user')

    # create an admin user and add to database
    encrypted_password = hash_password('password')
    if not user_datastore.get_user('*****@*****.**'):
        user_datastore.create_user(email='*****@*****.**', password=encrypted_password)

    try:
        db_init.session.commit()
    except SQLAlchemyError:
        raise InvalidUsage(status_code=500)

    # make [email protected] the admin user
    user_datastore.add_role_to_user('*****@*****.**', 'admin')
    try:
        db_init.session.commit()
    except SQLAlchemyError:
        raise InvalidUsage(status_code=500)
    def setUp(self):
        from selenium.webdriver.chrome.options import Options
        chrome_options = Options()
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-setuid-sandbox")
        """Setup the test driver and create test users"""
        self.driver = webdriver.Chrome(chrome_options=chrome_options)
        self.driver.get(self.get_server_url())

        email_admin = test_admin_email

        db.session.commit()
        db.drop_all()
        db.create_all()

        user_datastore.create_user(email=test_admin_email,
                                   username=test_admin_username,
                                   password=test_admin_password)
        user_datastore.create_user(email=test_user_final_email,
                                   username=test_user_final_username,
                                   password=test_user_final_password)
        user_datastore.find_or_create_role(name='admin',
                                           description='Administrator')
        user_datastore.find_or_create_role(name='end-user',
                                           description='End user')
        user_datastore.add_role_to_user(email_admin, 'admin')
        db.session.commit()
Exemple #8
0
def createadmin():
    username = prompt(Fore.BLUE + "Username")
    query_username = db.session.query(FinalUser).filter_by(
        username=username).first()
    email = prompt(Fore.BLUE + "Write Email")
    if re.match(
            '^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$',
            email) == None:
        print(Fore.RED + "Invalid email format")
        return
    query_email = db.session.query(FinalUser).filter_by(email=email).first()
    if query_username is None and query_email is None:
        password = prompt(Fore.BLUE + "Write password")
        repeat_password = prompt(Fore.BLUE + "Repeat password")
        if password == repeat_password:
            encrypted_password = utils.encrypt_password(password)
            user_datastore.create_user(username=username,
                                       password=encrypted_password,
                                       email=email)
            db.session.commit()
            user_datastore.add_role_to_user(email, 'admin')
            db.session.commit()
            print(Fore.GREEN + "Admin created")
        else:
            print(Fore.RED + "The password does not match")
            return
    else:
        print(Fore.RED + "The username or email are in use")
        return
    def setUp(self):
        super().setUp()

        # Create user
        user_datastore.create_user(email='*****@*****.**', password='******', name='Foo Bar')
        # Log in with the user we just created
        self.client.post(url_for('security.login'), data={
            'email': '*****@*****.**',
            'password': '******'
        }, follow_redirects=True)
Exemple #10
0
def register():
  form = forms.RegistrationForm()
  if form.validate_on_submit():
    user_datastore.create_user(email=form.email.data, password=form.password.data)
    db.session.commit()
    return '', 200
  for field, errors in form.errors.items():
    for error in errors:
      print(error)
  return '', 403
Exemple #11
0
 def test_add_user(self):
     """
     Create a user and find it (test_user_model.UserModel)
     """
     user_datastore.create_user(email='*****@*****.**',
                                password='******',
                                username='******',
                                active=True)
     self.assertTrue(True)
     user = user_datastore.get_user('*****@*****.**')
     self.assertIn('Test', str(user))
Exemple #12
0
 def test_add_user(self):
     """
     Create a user and find it (test_user_model.UserModel)
     """
     user_datastore.create_user(email='*****@*****.**',
                                password='******',
                                username='******',
                                active=True)
     self.assertTrue(True)
     user = user_datastore.get_user('*****@*****.**')
     self.assertIn('Test', str(user))
Exemple #13
0
    def setUp(self):
        print("Setting up test environment")

        configuration = config.TestConfig()
        app.config.from_object(configuration)

        self.app = app.test_client()

        db.create_all()
        user_datastore.create_user(email='*****@*****.**', password='******')
        db.session.commit()
Exemple #14
0
 def test_register_fail(self):
     user_datastore.create_user(email='*****@*****.**', name='test', password='******')
     db.session.commit()
     response = self.client.post(
         '/api/users',
         headers={'Content-Type': 'application/json'},
         data=json.dumps({
                 'email': '*****@*****.**',
                 'name': 'test',
                 'password': '******'
             }))
     self.assertEqual(response.status_code, 409)
Exemple #15
0
def init():
    db.drop_all()
    db.create_all()

    # Create roles
    user_datastore.create_role(name='admin', description='System administrator')
    user_datastore.create_role(name='user', description='Conference user')
    admin = user_datastore.create_user(username='******',
                               password=utils.encrypt_password('admin'))
    user = user_datastore.create_user(username='******',
                               password=utils.encrypt_password('user'))
    user_datastore.add_role_to_user(admin, 'admin')
    user_datastore.add_role_to_user(user, 'user')

    contacts = [
        ('1010', gettext('John Smith')),
        ('1020', gettext('Sam Brown')),
    ]
    for c in contacts:
        rec = Contact(phone=c[0], name=c[1], user=admin)
        db.session.add(rec)

    guest_user_profile = ParticipantProfile(name=gettext('Guest'), startmuted=True)
    db.session.add(guest_user_profile)
    marked_user_profile = ParticipantProfile(name=gettext('Marker'),marked=True)
    db.session.add(marked_user_profile)
    admin_user_profile = ParticipantProfile(name=gettext('Administrator'), admin=True)
    db.session.add(admin_user_profile)

    conf_profile = ConferenceProfile(name=gettext('Default'))
    db.session.add(conf_profile)

    conf = Conference(number=100,
                      name=gettext('Test Conference'),
                      conference_profile=conf_profile,
                      public_participant_profile=guest_user_profile,
                      is_public=True,
                      user=admin,
                      )
    db.session.add(conf)

    p1 = Participant(conference=conf, profile=admin_user_profile, phone='1001',
                     user=admin)
    p2 = Participant(conference=conf, profile=guest_user_profile, phone='1002',
                     user=admin)
    p3 = Participant(conference=conf, profile=marked_user_profile, phone='1003',
                     user=admin)
    db.session.add(p1)
    db.session.add(p2)
    db.session.add(p3)

    db.session.commit()
Exemple #16
0
 def test_login_success(self):
     user_datastore.create_user(email='*****@*****.**', name='test', password=hash_password('123456'))
     db.session.commit()
     response = self.client.post(
         '/api/sessions',
         headers={'Content-Type': 'application/json'},
         data=json.dumps({
                 'email': '*****@*****.**',
                 'password': '******',
             }))
     self.assertEqual(response.status_code, 200)
     json_response = json.loads(response.get_data(as_text=True))
     self.assertEqual(json_response['name'], 'test')
Exemple #17
0
def registration():
    if request.method == 'POST':
        if not User.query.filter(
                User.email == request.form.get('email')).first():
            user_datastore.create_user(email=request.form.get('email'),
                                       password=hash_password(
                                           request.form.get('password')))
            db.session.commit()
            user = User.query.filter(
                User.email == request.form.get('email')).first()
            login_user(user)
            return redirect('/')
    return render_template('registration.html')
Exemple #18
0
def create_user():
    db.create_all()
    with app.app_context():
        password = encrypt_password('admin')
        user_datastore.create_role(name='admin', description='Administrator')
        user_datastore.create_role(name='user', description='Simple user')
        user_datastore.create_user(email='*****@*****.**', password=password)

        user = User.query.first()
        role = Role.query.first()
        user_datastore.add_role_to_user(user, role)

        db.session.commit()
Exemple #19
0
def create_user():
    print("Let's create a new user ... ")
    email = get_and_validate('email')
    password = get_and_validate('password')
    active = get_and_validate('active (True/False)', is_bool=True)
    admin = get_and_validate('admin (True/False)', is_bool=True)
    if not user_datastore.get_user(email):
        user_datastore.create_user(email=email,
                                   password=password,
                                   active=active)
    else:
        print('User by email {} already exists.'.format(email))
    if admin:
        user_datastore.add_role_to_user(email, 'admin')
    db.session.commit()
Exemple #20
0
def create_admin_admin():
    user_datastore.create_role(name='admin', description='System administrator')
    user_datastore.create_role(name='user', description='Conference user')
    admin = user_datastore.create_user(username='******',
                               password=utils.encrypt_password('admin'))
    user_datastore.add_role_to_user(admin, 'admin')
    db.session.commit()
Exemple #21
0
def create_admin_admin():
    user_datastore.create_role(name='admin',
                               description='System administrator')
    user_datastore.create_role(name='user', description='Conference user')
    admin = user_datastore.create_user(
        username='******', password=utils.encrypt_password('admin'))
    user_datastore.add_role_to_user(admin, 'admin')
    db.session.commit()
Exemple #22
0
 def setUp(self):
     database.clean()
     self.client = application.test_client()
     self.user1 = user_datastore.create_user(email="*****@*****.**",
         password="******")
     self.user2 = user_datastore.create_user(email="*****@*****.**",
         password="******")
     db.session.commit()
     with self.client.session_transaction() as sess:
         sess["user_id"] = self.user1.get_id()
         sess["_fresh"] = True
     self.project1 = Project(name="Foos project")
     self.project2 = Project(name="Bars project")
     self.user1.add_project(self.project1, ProjectsUsers.ROLE_ADMIN)
     self.user2.add_project(self.project2, ProjectsUsers.ROLE_ADMIN)
     self.project1.save()
     self.project2.save()
Exemple #23
0
 def setUp(self):
     database.clean()
     self.client = application.test_client()
     self.user1 = user_datastore.create_user(email="*****@*****.**",
                                             password="******")
     self.user2 = user_datastore.create_user(email="*****@*****.**",
                                             password="******")
     db.session.commit()
     with self.client.session_transaction() as sess:
         sess["user_id"] = self.user1.get_id()
         sess["_fresh"] = True
     self.project1 = Project(name="Foos project")
     self.project2 = Project(name="Bars project")
     self.user1.add_project(self.project1, ProjectsUsers.ROLE_ADMIN)
     self.user2.add_project(self.project2, ProjectsUsers.ROLE_ADMIN)
     self.project1.save()
     self.project2.save()
Exemple #24
0
 def post(self):
     parser = request.get_json()
     email = parser.get('email')
     password = parser.get('password')
     if email is None or password is None:
         abort(400)  # missing arguments
     user = user_datastore.create_user(email=email,password=utils.encrypt_password(password))
     login_user(user, remember = True)
     return 201
Exemple #25
0
    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)
Exemple #26
0
def build():
  db.create_all()
  user_role = user_datastore.create_role(name="user")
  admin_role = user_datastore.create_role(name="admin")

  admin_user = user_datastore.create_user(email="*****@*****.**", password="******")
  user_datastore.add_role_to_user(admin_user, admin_role)

  test_user1 = user_datastore.create_user(email="*****@*****.**", password="******")
  test_user2 = user_datastore.create_user(email="*****@*****.**", password="******")

  user_datastore.add_role_to_user(test_user1, user_role)
  user_datastore.add_role_to_user(test_user2, user_role)

  db.session.add(admin_user)
  db.session.add(test_user1)
  db.session.add(test_user2)

  db.session.commit()
Exemple #27
0
def createadmin():
    email = prompt(Fore.BLUE + "Email")
    query_email = db.session.query(FinalUser).filter_by(email=email).first()
    if query_email is None:
        password = prompt(Fore.BLUE + "Write password")
        repeat_password = prompt(Fore.BLUE + "Repeat password")
        if password == repeat_password:
            encrypted_password = utils.encrypt_password(password)
            user_datastore.create_user(email=email,
                                       password=encrypted_password)
            db.session.commit()
            user_datastore.add_role_to_user(email, 'admin')
            db.session.commit()
            print(Fore.GREEN + "Admin created")
        else:
            print(Fore.RED + "The password does not match")
            return
    else:
        print(Fore.RED + "The username or email are in use")
        return
Exemple #28
0
    def setUp(self):
        """Clear the database for the next unit test.
        """
        self.client = application.test_client()
        database.clean()
        self.user = user_datastore.create_user(email="*****@*****.**",
            password="******")
        db.session.commit()

        with self.client.session_transaction() as sess:
            sess["user_id"] = self.user.id
            sess["_fresh"] = True
Exemple #29
0
def add_admin(email):
    """ Creates an admin user and adds it to the database """
    pwd = getpass.getpass("Password for " + email + ": ")
    verify = getpass.getpass("Verify password for " + email + ": ")
    if pwd != verify:
        print("Passwords don't match")
        return
    salt = binascii.hexlify(os.urandom(32))
    encrypted_pwd = flask_security.utils.encrypt_password(password=pwd)

    admin = user_datastore.create_user(email=email, password=encrypted_pwd)
    user_datastore.add_role_to_user(admin, 'Admin')
    user_datastore.commit()
Exemple #30
0
def build_sample_db():
    """
    Populate a small db with some example entries.
    """

    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='admin',
            password=encrypt_password('admin'),
            roles=[user_role, super_user_role])

        first_names = ['Harry', 'Amelia', 'Oliver']
        last_names = ['Brown', 'Smith', 'Patel']

        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=encrypt_password(tmp_pass),
                                       roles=[
                                           user_role,
                                       ])
        db.session.commit()
    return
Exemple #31
0
def registration():
    if request.method == 'POST':
        try:
            user = user_datastore.create_user(
                email=request.form['email'], password=request.form['password'])
            role = Role.query[1]
            user_datastore.add_role_to_user(user, role)
            db.session.commit()
        except:
            print('Please try again.')
        return redirect(url_for('security.login'))
    form = Registration()
    return render_template('security/register.html', form=form)
Exemple #32
0
    def setUp(self):
        database.clean()
        self.client = application.test_client()
        self.user1 = user_datastore.create_user(email="*****@*****.**",
            password="******")
        self.user2 = user_datastore.create_user(email="*****@*****.**",
            password="******")
        db.session.commit()
        with self.client.session_transaction() as sess:
            sess["user_id"] = self.user1.get_id()
            sess["_fresh"] = True

        self.project = Project(name="Bars project", user=self.user2)
        self.project.save()

        file_handle, file_path = tempfile.mkstemp()
        file_handle = os.fdopen(file_handle, "r+")
        file_handle.write("foobar")

        self.file_path = os.path.join(file_path)
        self.document_file = DocumentFile(projects=[self.project],
                path=self.file_path)
        self.document_file.save()
Exemple #33
0
    def setUp(self):
        """Clear the database for the next unit test.
        """
        self.client = application.test_client()
        database.clean()
        self.user = user_datastore.create_user(email="*****@*****.**",
                                               password="******")
        db.session.add(self.user)
        db.session.commit()

        with self.client.session_transaction() as sess:
            db.session.add(self.user)
            sess["user_id"] = self.user.id
            sess["_fresh"] = True
Exemple #34
0
    def setUp(self):
        database.clean()
        self.client = application.test_client()
        self.user1 = user_datastore.create_user(email="*****@*****.**",
                                                password="******")
        self.user2 = user_datastore.create_user(email="*****@*****.**",
                                                password="******")
        db.session.commit()
        with self.client.session_transaction() as sess:
            sess["user_id"] = self.user1.get_id()
            sess["_fresh"] = True

        self.project = Project(name="Bars project")
        self.user2.add_project(self.project, role=ProjectsUsers.ROLE_ADMIN)

        file_handle, file_path = tempfile.mkstemp()
        file_handle = os.fdopen(file_handle, "r+")
        file_handle.write("foobar")

        self.file_path = os.path.join(file_path)
        self.document_file = DocumentFile(projects=[self.project],
                                          path=self.file_path)
        self.document_file.save()
Exemple #35
0
 def login_as_admin(self):
     user = user_datastore.create_user(email='*****@*****.**', name='test', password=hash_password('123456'))
     role = user_datastore.create_role(name='admin')
     user_datastore.add_role_to_user(user, role)
     db.session.commit()
     response = self.client.post(
         '/api/sessions',
         headers={'Content-Type': 'application/json'},
         data=json.dumps({
                 'email': '*****@*****.**',
                 'password': '******',
             }))
     json_response = json.loads(response.get_data(as_text=True))
     return json_response
Exemple #36
0
 def post(self):
     """
     register
     """
     args = user_args.parse_args()
     password_hash = hash_password(args['password'])
     try:
         user = user_datastore.create_user(name=args['name'],
                                           email=args['email'],
                                           password=password_hash)
         db.session.commit()
         return user
     except Exception as e:
         db.session.rollback()
         raise Conflict
Exemple #37
0
def db_create():
    with app.app_context():
        db.create_all()
        db.session.commit()

        admin_role = user_datastore.find_or_create_role(name="admin", description="Administrator")
        user_role = user_datastore.find_or_create_role(name="user", description="User")

        admin = user_datastore.create_user(email="*****@*****.**", password=encrypt_password("password"),
                                           cc_login="******")
        user_datastore.add_role_to_user(admin, admin_role)
        user_datastore.add_role_to_user(admin, user_role)

        admin = user_datastore.create_user(email="*****@*****.**", password=encrypt_password("password"),
                                           cc_login="******")
        user_datastore.add_role_to_user(admin, admin_role)
        user_datastore.add_role_to_user(admin, user_role)
        
        admin = user_datastore.create_user(email="*****@*****.**", password=encrypt_password("password"),
                                           cc_login="******")
        user_datastore.add_role_to_user(admin, admin_role)
        user_datastore.add_role_to_user(admin, user_role)

        db.session.commit()
Exemple #38
0
def create_superuser():
    if Role.query.filter_by(name='admin').first():
        return
    password_raw = os.getenv("FLASK_USER_PASSWORD") or '123456'
    password_hash = hash_password(password_raw)
    try:
        role = user_datastore.create_role(name='admin')
        user = user_datastore.create_user(name=os.getenv("FLASK_USER")
                                          or "admin",
                                          email=os.getenv("FLASK_USER_EMAIL")
                                          or "*****@*****.**",
                                          password=password_hash)
        user_datastore.add_role_to_user(user, role)
        db.session.commit()
    except Exception as e:
        print(e)
        pass
Exemple #39
0
def add_to_db(pk, db_type):
    if db_type == 'Unf Questions':
        unf_obj = UnfQuestions.query.filter(UnfQuestions.id == int(pk)).first()
        total = len(Users.query.all()) + 1
        # psy_id=int(random.randrange(start=1,stop=total))

        #getting the latest entry in database
        prev_psy_id = get_last_record_psy_id()

        #finding the next valid psy_id for this question
        pre_psy_id = (prev_psy_id + 1) % total
        '''here we will assume that first 3 ids are admins in user table
        (another perfect work around is to check each time whether that psy_id is psycologist or not)'''
        if pre_psy_id >= 0 and pre_psy_id <= 3:
            pre_psy_id = 4

        f_obj = FilQuestions(q_title=unf_obj.q_title,
                             q_desc=unf_obj.q_desc,
                             psy_id=pre_psy_id,
                             no_upvotes=0)
        db.session.add(f_obj)
        db.session.commit()
        db.session.delete(unf_obj)
        db.session.commit()
    else:
        psy = Psycologists.query.filter(Psycologists.id == pk).first()
        user = user_datastore.create_user(email=psy.email,
                                          password=psy.password)
        db.session.add(user)
        db.session.commit()
        role = Roles.query.filter(Roles.id == 2).first()
        re = user_datastore.add_role_to_user(user, role)
        db.session.commit()
        #setting up their profile also ----------------some bug about unique constraint
        psy_id = Users.query.filter(Users.email == psy.email).first().id
        pr = Profile(psy_id=psy_id, id=psy_id)
        db.session.add(pr)
        db.session.commit()
        if re:
            db.session.delete(psy)
            db.session.commit()
            return 'Data has been moved'
        else:
            return 'unsuccessful'

    return redirect(url_for('conf'))
def add_user(credentials):
    """ Adds user to the database """
    if check_email(credentials["email"]) == None:
        last_id = db.session.query(func.max(User.id)).first()
        id = 1
        if not (last_id[0] == None):
            id = last_id[0] + 1
        encrypted_pass = encrypt_password(credentials["password"])
        user = user_datastore.create_user(id=id,
                                          email=credentials["email"],
                                          password=encrypted_pass,
                                          name=credentials["name"],
                                          surname=credentials["surname"],
                                          lastName=credentials["lastName"]),
        student_role = user_datastore.find_role("Student")
        user_datastore.add_role_to_user(user[0], student_role)
        db.session.commit()
        return (True, "OK")
    else:
        return (False, "User already exists")
Exemple #41
0
def build_sample_db():
    """
    Populate a small db with some example entries.
    """
    db.drop_all()
    db.create_all()

    with app.app_context():
        super_user_role = Role(name='superuser')
        db.session.add(super_user_role)
        db.session.commit()

        test_user = user_datastore.create_user(
            name='superuser',
            email='*****@*****.**',
            password=encrypt_password('123456'),
            roles=[super_user_role])

        db.session.commit()
    return
Exemple #42
0
def run():
    init_db()
    user_datastore.create_user(email='*****@*****.**', password='******')
    db.session.commit()
# coding=utf-8
from app import db, Role, User, roles_users, app, user_datastore
from datetime import date, datetime
from flask_security.utils import encrypt_password

import string
import random
print "Enter password:"******"Admin",
		email="admin",
		password=encrypt_password(admin_pw),
		roles=[user_role, super_user_role]
	)
	db.session.commit()
Exemple #44
0
from app import db
db.create_all()

from app import user_datastore
from config import ADMIN_PASSWORD

try:
    user_datastore.create_role(name="admin", description="Site Administrators.")
    user_datastore.create_user(email="*****@*****.**",
                               password=ADMIN_PASSWORD)

    user_datastore.add_role_to_user("*****@*****.**", "admin")

    db.session.commit()
except Exception:
    pass

# Import your application as:
# from app import application
# Example:

from app import app

# Import CherryPy
import cherrypy

if __name__ == '__main__':
    # Mount the application
    cherrypy.tree.graft(app, "/")

    # Unsubscribe the default server