def setup_method(self, method): db.drop_all() db.create_all() # Create normal user for tests. self.user = Users(id="testuser") self.user.first_name = "Test1" self.user.last_name = "User" self.user.email = "*****@*****.**" self.user.is_admin = False db.session.add(self.user) db.session.commit() self.user_token = self.user.generate_auth() self.user_token = self.user_token.decode('ascii') # Create admin user for tests. self.admin_user = Users(id="adminuser") self.admin_user.first_name = "Admin" self.admin_user.last_name = "User" self.admin_user.email = "*****@*****.**" self.admin_user.is_admin = True db.session.add(self.admin_user) db.session.commit() self.admin_user_token = self.admin_user.generate_auth() self.admin_user_token = self.admin_user_token.decode('ascii')
def setup_method(self, method): db.drop_all() db.create_all() # Create admin user for tests. admin = Users(id = "adminuser") admin.first_name = "Admin" admin.last_name = "User" admin.email = "*****@*****.**" admin.is_admin = True db.session.add(admin) db.session.commit() self.admin_token = admin.generate_auth() self.admin_token = self.admin_token.decode('ascii') # Create normal user for tests. user = Users(id = "testuser") user.first_name = "Test1" user.last_name = "User" user.email = "*****@*****.**" user.is_admin = False db.session.add(user) db.session.commit() self.test_user = user self.user_token = user.generate_auth() self.user_token = self.user_token.decode('ascii') # Create normal user for tests. user2 = Users(id = "testuser2") user2.first_name = "Test" user2.last_name = "User" user2.email = "*****@*****.**" user2.is_admin = False db.session.add(user2) db.session.commit() self.test_user2 = user2 self.user_token2 = user2.generate_auth() self.user_token2 = self.user_token2.decode('ascii') # Create a test committee. committee = Committees(id = "testcommittee") committee.title = "Test Committee" committee.description = "Test Description" committee.location = "Test Location" committee.meeting_time = "1300" committee.meeting_day = 2 committee.head = "testuser" self.committee = committee db.session.add(committee) db.session.commit() committee_note = CommitteeNotes(id = 10) committee_note.author = "testuser" committee_note.description = "Test Note" committee_note.committee = "testcommittee" committee_note.hidden = False self.committee_note = committee_note db.session.add(self.committee_note) db.session.commit()
def setup_method(self, method): db.drop_all() db.create_all() self.user_data = { "user_id": "testuser", "committee_id": "testcommittee" } # Create admin user for tests. admin = Users(id="adminuser") admin.first_name = "Admin" admin.last_name = "User" admin.email = "*****@*****.**" admin.is_admin = True db.session.add(admin) db.session.commit() self.admin_token = admin.generate_auth() self.admin_token = self.admin_token.decode('ascii') # Create normal user for tests. user = Users(id="testuser") user.first_name = "Test1" user.last_name = "User" user.email = "*****@*****.**" user.is_admin = False db.session.add(user) db.session.commit() self.user_token = user.generate_auth() self.user_token = self.user_token.decode('ascii') self.user = user # Create second normal user for tests. user2 = Users(id="testuser2") user2.first_name = "Test2" user2.last_name = "User2" db.session.add(user2) db.session.commit() self.user_token2 = user2.generate_auth() self.user_token2 = self.user_token2.decode('ascii') self.user2 = user2 # Create a test committee. self.committee = Committees(id="testcommittee") self.committee.title = "Test Committee" self.committee.description = "Test Description" self.committee.location = "Test Location" self.committee.meeting_time = "1300" self.committee.meeting_day = 2 self.committee.head = "adminuser" db.session.add(self.committee) db.session.commit() self.invite = Invitations(id=5) self.invite.user_name = "newuser1" self.invite.committee = self.committee self.invite.committee_id = "testcommittee" self.invite.isInvite = False
def setup_method(self, method): db.drop_all() db.create_all() self.test_committee_dict = { "id": "testcommittee", "title": "testcommittee", "description": "Test Description", "location": "Test Location", "meeting_time": "1300", "meeting_day": 2, "head": "testuser", "committee_img": "R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==" } self.test_committee = Committees(id="testcommittee") self.test_committee.title = self.test_committee_dict["title"] self.test_committee.location = self.test_committee_dict["location"] self.test_committee.description = self.test_committee_dict[ "description"] self.test_committee.meeting_time = self.test_committee_dict[ "meeting_time"] self.test_committee.meeting_day = self.test_committee_dict[ "meeting_day"] self.test_committee.head = self.test_committee_dict["head"] com_img = base64.b64decode(self.test_committee_dict["committee_img"]) self.test_committee.com_image = com_img # Create admin user for tests. admin = Users(id="adminuser") admin.first_name = "Admin" admin.last_name = "User" admin.email = "*****@*****.**" admin.is_admin = True db.session.add(admin) db.session.commit() self.admin_token = admin.generate_auth() self.admin_token = self.admin_token.decode('ascii') # Create normal user for tests. user = Users(id="testuser") user.first_name = "Test1" user.last_name = "User" user.email = "*****@*****.**" user.is_admin = False db.session.add(user) db.session.commit() self.test_user = user self.user_token = user.generate_auth() self.user_token = self.user_token.decode('ascii')
def setup(self): db.create_all() db.session.add( Users(id=1, username="******", password="******", email="*****@*****.**")) db.session.add(Role(id=1, name="admin")) db.session.add(UserRoles(id=1, user_id=1, role_id=1)) db.session.add(Profile(id=1, avatar="jeff.jpg", user_id=1)) db.session.add( Users(id=2, username="******", password="******", email="*****@*****.**")) db.session.add(Role(id=2, name="player")) db.session.add(UserRoles(id=2, user_id=2, role_id=2)) db.session.add(Profile(id=2, avatar="finn.jpg", user_id=2)) db.session.commit() db.session.add( AwayTeamBet(id=1, game_key=123, bet_key=123, away_team="BUF", vs="BUF vs @NE", away_ps=1, amount=20, user_id=1)) db.session.add( HomeTeamBet(id=1, game_key=123, bet_key=123, home_team="NE", vs="BUF vs @NE", home_ps=-1, amount=20, user_id=2)) db.session.add( OverUnder(id=1, game_key=123, bet_key=123, over_under="o", total=40, amount=20, vs="BUF vs @NE", user_id=1)) db.session.commit()
def create_object(self, user_data: dict): try: user = Users(**user_data) self.db.session.add(user) except (IntegrityError, FlushError): raise Exception(f'User {user.email} already exists') self.db.session.commit()
def setUp(self): db.create_all() db.session.add( Users(username="******", email="*****@*****.**", password='******')) db.session.commit()
def registeruser(): """ Build the view used to add new accounts """ form = RegisterForm() if form.validate_on_submit(): try: user = Users(username=form.username.data, email=form.email.data, specialties=form.specialties.data.split(','), interests=form.interests.data.split(',')) user.password = form.password.data user.save() token = user.generate_confirmation_token() send_email(user.email, 'Confirmare email', 'users/email/confirm', user=user, token=token) flash( 'Contul a fost adaugat! Va rugam confirmati adresa de email!', category='alert-success') except Exception as err: flash('Contul nu poate fi creat!', category='alert-warning') return redirect(url_for('users.login')) return render_template('users/login.html', pagetitle='Inregistrare', form=form, login=False)
def post(self): raw_dict = request.get_json(force=True) try: schema.validate(raw_dict) request_dict = raw_dict['data']['attributes'] payload = parse_token(request) logged_user = Users.query.get(payload['sub']) createdby = logged_user.name updatedby = logged_user.name password = generate_password_hash(request_dict['password']) user = Users( request_dict['email'], password, request_dict['name'], createdby, updatedby, ) user.add(user) # Should not return password hash query = Users.query.get(user.id) results = schema.dump(query).data return results, 201 except ValidationError as err: resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e)}) resp.status_code = 403 return resp
def login_from_acs(acs): if acs.get('errors'): return jsonify({'errors': acs.get('errors')}) elif not acs.get('logged_in'): return jsonify({"error": "login failed"}) else: attributes = list(acs.get("attributes")) username = attributes[0][1][0] firstname = attributes[1][1][0] lastname = attributes[2][1][0] email = attributes[3][1][0] user = Users.query.filter_by(id = username).first() if user is None: user = Users(id = username) user.first_name = firstname user.last_name = lastname user.email = email db.session.add(user) db.session.commit() login_user(user) return redirect('/')
def post(self): raw_dict = request.get_json(force=True) try: schema.validate(raw_dict) request_dict = raw_dict['data']['attributes'] role = None active = 0 user = Users(request_dict['email'], generate_password_hash(request_dict['password']), request_dict['name'], active, role) user.add(user) # Should not return password hash query = Users.query.get(user.id) results = schema.dump(query).data return results, 201 except ValidationError as err: resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e)}) resp.status_code = 403 return resp
def adduser(): """ Build the view used to add new accounts """ form = RegisterForm() if form.validate_on_submit(): try: user = Users(username=form.username.data, email=form.email.data, specialties=form.specialties.data.split(','), interests=form.interests.data.split(',')) user.password = form.password.data user.save() token = user.generate_confirmation_token() send_email(user.email, 'Confirmare email', 'users/email/confirm', user=user, token=token) flash('Contul a fost adaugat!', category='alert-success') except Exception as err: flash('Utilizatorul are deja cont!', category='alert-warning') return redirect(url_for('users.list')) return render_template('users/add.html', pagetitle='Adauga utilizator', form=form)
def test_add(): crud = CRUD() try: users = Users('test', 'test', 'test') result = crud.add(users, USERS_SCHEMA) except Exception as err: print(err) assert True
def login_ldap(credentials): ldap_server = "ldaps://ldap.rit.edu" if credentials.get("username", "") == "" or credentials.get( "password", "") == "": emit('auth', {'error': "Authentication error."}) return user_dn = "uid=" + credentials.get("username", "") + ",ou=People,dc=rit,dc=edu" search_filter = "uid=" + credentials.get("username", "") connect = ldap.initialize(ldap_server) try: connect.bind_s(user_dn, credentials.get("password", "")) result = connect.search_s(user_dn, ldap.SCOPE_SUBTREE, search_filter) connect.unbind_s() values = result[0][1] username = values["uid"][0].decode('utf-8') firstname = values["givenName"][0].decode('utf-8') lastname = values["sn"][0].decode('utf-8') email = values["mail"][0].decode('utf-8') # Check if a user exists. if Users.query.filter_by(id=username).first() is not None: user = Users.query.filter_by(id=username).first() token = user.generate_auth() admin = user.is_admin emit( 'auth', { 'token': token.decode('ascii'), 'admin': admin, 'super': user.is_super, 'username': username }) else: user = Users(id=username) user.first_name = firstname user.last_name = lastname user.email = email db.session.add(user) db.session.commit() token = user.generate_auth() emit('auth', {'token': token.decode('ascii')}) except ldap.LDAPError: connect.unbind_s() emit('auth', Response.AuthError) return
def create_admins(admin): from app.users.models import Users try: user = Users.objects(email=admin['email']).get() except: user = Users(email=admin['email'],username=admin['username'],permissions='full',status=True) user.password = admin['password'] user.save()
def test_confirm_token_route_expired_token(self): # Ensure user cannot confirm account with expired token. user = Users(username="******", email='*****@*****.**', password='******', confirmed=False) db.session.add(user) db.session.commit() token = generate_confirmation_token('*****@*****.**') self.assertFalse(confirm_token(token, -1))
def signup(): if g.user is not None and g.user.is_authenticated: return redirect(url_for('index')) form = SignupForm() if form.validate_on_submit(): new_user = Users(form.username.data, form.name.data, form.email.data, form.password.data) db.session.add(new_user) db.session.commit() flash('Signup in successfully.', category='success') return redirect(url_for('users.login')) return render_template('signup.html', form=form)
def post(self): raw_dict = request.get_json(force=True) try: schema.validate(raw_dict) request_dict = raw_dict['data']['attributes'] role = None active = 0 classified = 0 in_queue = 0 #Check for existing entry userCheck = Users.query.filter_by( email=request_dict['email']).first() if userCheck is None: user = Users(request_dict['email'], generate_password_hash(request_dict['password']), request_dict['name'], active, role, classified, in_queue) user.add(user) query = Users.query.get(user.id) # Should not return password hash query.password = "******" results = schema.dump(query).data fp = os.getcwd() fp = fp.rsplit('/', 1)[0] # go back one dir direct = fp + "/GT_USERS/USER_" + str(query.id) if not os.path.exists(direct): os.makedirs(direct) os.makedirs(direct + "/cropped") os.makedirs(direct + "/images") os.makedirs(direct + "/json") os.makedirs(direct + "/labelled") os.makedirs(direct + "/packaged") os.makedirs(direct + "/segmented") return results, 201 else: resp = jsonify({"error": "Email already taken"}) resp.status_code = 403 return resp except ValidationError as err: resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e)}) resp.status_code = 403 return resp
def api_create_user(): data = request.args.to_dict(flat=True) hashed_password = generate_password_hash(data['password'], method='sha256') try: new_user = Users(public_id=str(uuid.uuid4()), name=data['name'], password=hashed_password,) new_user.id_role = 3 session.add(new_user) session.commit() return jsonify({'message': None, 'data': None, 'status': 'success'}), 201 except Exception as e: session.rollback() return jsonify({'message': 'Unexpected error', 'data': None, 'status': 'error'}), 400
def user_add(): if request.method == 'POST': #Validate form values by de-serializing the request, http://marshmallow.readthedocs.org/en/latest/quickstart.html#validation form_errors = schema.validate(request.form.to_dict()) if not form_errors: name = request.form['name'] email = request.form['email'] user = Users(email, name) return add(user, success_url='users.user_index', fail_url='users.user_add') else: flash(form_errors) return render_template('/users/add.html')
def register(): """ Registration page """ page = {'page': 'Register', 'error': ''} if request.method != 'POST': return render_template('front/register.html', page=page) form_data = request.form user_data = { 'username': form_data['username'], 'email': form_data['email'], 'password': form_data['password'] } for key, value in user_data.items(): if value == '': page['error'] = 'All fields must be filled' return render_template('front/register.html', page=page) check_username = Users.query.filter_by( username=user_data['username']).count() check_email = Users.query.filter_by(email=user_data['email']).count() if check_email > 0: page['error'] = 'An account with this email already exists' if check_username > 0: page['error'] = 'This username already exists' if not page['error']: user_data['password'] = pbkdf2_sha256.encrypt(user_data['password'], rounds=200000, salt_size=16) user = Users(**user_data) db.session.add(user) db.session.commit() session['user_id'] = user.id flash('Thanks for registering') return redirect(url_for('.index')) print(page) return render_template('front/register.html', page=page)
def user_add(): if request.method == 'POST': #http://marshmallow.readthedocs.org/en/latest/quickstart.html#validation form_errors = schema.validate(request.form.to_dict()) if not form_errors: name=request.form['name'] email=request.form['email'].lower() password=generate_password_hash(request.form['password']) is_enabled=request.form['is_enabled'] user=Users(email, name,password, is_enabled) roles = request.form.getlist('role') for r in roles: role = Roles.query.filter_by(name=r).first() user.roles.append(role) return add(user, success_url = 'users.user_index', fail_url = 'users.user_add') else: flash(form_errors) return render_template('/users/add.html')
def register(): if request.method == 'GET': return render_template('users/register.html') elif request.method == 'POST': name = request.form.get('name', '') username = request.form.get('username', '') email = request.form.get('email', '') password = pbkdf2_sha256.encrypt(request.form.get('password', ''), rounds=8000, salt_size=10) user = Users(name=name, username=username, email=email, password=password) # TODO: Make more flexible based on the UI for this view if request.form.get('role', '') == "2": role = Roles.by_id(2) user.roles.append(role) db.session.add(user) db.session.commit() if not current_user.is_anonymous(): return redirect(url_for('STUFF')) else: return redirect(url_for('handle_splash'))
def post(self): raw_dict = request.get_json(force=True) try: schema.validate(raw_dict) user_dict = raw_dict['data']['attributes'] user = Users(user_dict['firstname'], user_dict['lastname'], user_dict['dob'], user_dict['zipcode']) user.add(user) query = Users.query.get(user.id) results = schema.dump(query).data return results, 201 except ValidationError as err: resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e)}) resp.status_code = 403 return resp
def post(self): raw_dict = request.get_json(force=True) try: schema.validate(raw_dict) request_dict = raw_dict['data']['attributes'] createdby = "Self Signup" updatedby = "Self Signup" password = generate_password_hash(request_dict['password']) user = Users( request_dict['email'], password, request_dict['name'], createdby, updatedby, ) user.add(user) # Should not return password hash query = Users.query.get(user.id) results = schema.dump(query).data return results, 201 except ValidationError as err: print(err.messages) resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e.orig.args)}) print(str(e)) resp.status_code = 403 return resp
def create_user(): try: username = request.form['username'] password = request.form['password'] name = request.form['name'] date_of_birth = request.form['date_of_birth'] email = request.form['email'] photo_link = request.form['photo_link'] print(photo_link) except KeyError as e: return jsonify(success=False, message="%s not sent in the request" % e.args), 400 username = username.replace('<', '<') username = username.replace('>', '>') password = password.replace('<', '<') password = password.replace('>', '>') name = name.replace('<', '<') name = name.replace('>', '>') date_of_birth = date_of_birth.replace('<', '<') date_of_birth = date_of_birth.replace('>', '>') email = email.replace('<', '<') email = email.replace('>', '>') photo_link = photo_link.replace('<', '<') photo_link = photo_link.replace('>', '>') dob = date(int(date_of_birth[0:4]), int(date_of_birth[5:7]), int(date_of_birth[8:10])) u = Users(username, name, email, dob, photo_link, password) try: db.session.add(u) db.session.commit() except IntegrityError as e: return jsonify(success=False, message="This username already exists"), 400 return jsonify(success=True)
def post(self): raw_dict = request.get_json(force=True) user_dict = raw_dict['data']['attributes'] try: schema.validate(user_dict) user = Users(user_dict['name'], user_dict['email'], user_dict['address'], user_dict['website'], user_dict['is_active'], user_dict['mobile'], user_dict['Birthday']) user.add(user) query = Users.query.get(user.id) results = schema.dump(query).data return results, 201 except ValidationError as err: resp = jsonify({"error": err.messages}) resp.status_code = 403 return resp except SQLAlchemyError as e: db.session.rollback() resp = jsonify({"error": str(e)}) resp.status_code = 403 return resp
def setup_method(self, method): db.drop_all() db.create_all() # Create admin user for tests. admin = Users(id="adminuser") admin.first_name = "Admin" admin.last_name = "User" admin.email = "*****@*****.**" admin.is_admin = True db.session.add(admin) db.session.commit() self.admin_token = admin.generate_auth() self.admin_token = self.admin_token.decode('ascii') # Create normal user for tests. user = Users(id="testuser") user.first_name = "Test1" user.last_name = "User" user.email = "*****@*****.**" user.is_admin = False db.session.add(user) db.session.commit() self.test_user = user self.user_token = user.generate_auth() self.user_token = self.user_token.decode('ascii') # Create normal user for tests. user2 = Users(id="testuser2") user2.first_name = "Test" user2.last_name = "User" user2.email = "*****@*****.**" user2.is_admin = False db.session.add(user2) db.session.commit() self.test_user2 = user2 self.user_token2 = user2.generate_auth() self.user_token2 = self.user_token2.decode('ascii') # Create normal user for tests. user3 = Users(id="activemember") user3.first_name = "Active" user3.last_name = "Member" user3.email = "*****@*****.**" user3.is_admin = False db.session.add(user2) db.session.commit() self.test_user3 = user3 self.user_token3 = user3.generate_auth() self.user_token3 = self.user_token3.decode('ascii') # Create a test committee. committee = Committees(id="testcommittee") committee.title = "Test Committee" committee.description = "Test Description" committee.location = "Test Location" committee.meeting_time = "1300" committee.meeting_day = 2 committee.head = "testuser" self.committee = committee # Create a test committee. committee2 = Committees(id="testcommittee2") committee2.title = "Test Committee2" committee2.description = "Test Description" committee2.location = "Test Location" committee2.meeting_time = "1300" committee2.meeting_day = 2 committee2.head = "testuser" self.committee2 = committee2 # Add user3 to committee. role = Members(role=Roles.ActiveMember) role.member = self.test_user3 self.committee.members.append(role) db.session.add(self.committee) db.session.add(self.committee2) db.session.commit() self.charge_dict = { 'id': 10, 'title': 'Test Charge', 'description': 'Test Description', 'committee': 'testcommittee', 'status': 0, 'priority': 0, 'private': True, 'paw_links': "https://testlink.com" } # Create a test charge. charge = Charges(id=10) charge.author = "testuser" charge.title = "Test Charge" charge.description = "Test Description" charge.committee = "testcommittee" charge.paw_links = "https://testlink.com" charge.priority = 0 charge.status = 0 charge.private = True self.charge = charge db.session.add(charge) db.session.commit() self.charge_dict["created_at"] = self.charge.created_at.isoformat()
def setup_method(self, method): db.drop_all() db.create_all() self.socketio = socketio.test_client(app) self.socketio.connect() db.event.remove(Committees, "after_insert", new_committee) db.event.remove(Actions, "after_insert", new_action) # Create admin user for tests. admin = Users(id="adminuser") admin.first_name = "Admin" admin.last_name = "User" admin.email = "*****@*****.**" admin.is_admin = True db.session.add(admin) db.session.commit() self.admin_token = admin.generate_auth() self.admin_token = self.admin_token.decode('ascii') # Create normal user for tests. user = Users(id="testuser") user.first_name = "Test1" user.last_name = "User" user.email = "*****@*****.**" user.is_admin = False db.session.add(user) db.session.commit() self.test_user = user self.user_token = user.generate_auth() self.user_token = self.user_token.decode('ascii') # Create normal user for tests. user_two = Users(id="testuser2") user_two.first_name = "Test2" user_two.last_name = "User" user_two.email = "*****@*****.**" user_two.is_admin = False db.session.add(user_two) db.session.commit() self.test_user_two = user_two self.user_token_two = user_two.generate_auth() self.user_token_two = self.user_token_two.decode('ascii') # Create a test committee. committee = Committees(id="testcommittee") committee.title = "Test Committee" committee.description = "Test Description" committee.location = "Test Location" committee.meeting_time = "1300" committee.meeting_day = 2 committee.head = "testuser" self.committee = committee db.session.add(committee) db.session.commit() # Create a test charge. charge = Charges(id=10) charge.author = "testuser" charge.title = "Test Charge" charge.description = "Test Description" charge.committee = "testcommittee" charge.paw_links = "https://testlink.com" charge.priority = 0 charge.status = 0 self.charge = charge db.session.add(charge) db.session.commit() # Create a test action. action = Actions(id=10) action.author = admin.id action.title = "Test Action" action.description = "Test Description" action.charge = 10 action.status = 0 self.test_action = action db.session.add(self.test_action) db.session.commit() db.event.listen(Committees, "after_insert", new_committee) db.event.listen(Actions, "after_insert", new_action) # Test committee dictionary self.test_committee_dict = { "id": "testcommittee1", "title": "testcommittee1", "description": "Test Description", "location": "Test Location", "meeting_time": "1300", "meeting_day": 2, "head": "testuser", "committee_img": "R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==" } # Test action dict self.test_action_dict = { "token": self.user_token, "charge": 10, "assigned_to": "testuser", "title": "test title", "description": "test description" }
def post(self): args_ = self.parser.parse_args() password = args_['user_password'] hash_pw = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()) user = Users(args_['user_id'], hash_pw, args_['user_email']) return user.add(user, USERS_SCHEMA)