def create_admin_entries(): b1 = business.Business(name='VEPL-III') db.session.add(b1) db.session.commit() u1 = user.User(username='******', password='******', contact_email='*****@*****.**', role='production', responsibility='Both', phoneNo=00000000000, businessId=1) u2 = user.User(username='******', password='******', contact_email='*****@*****.**', role='me', responsibility='Electrical', phoneNo=9673001769, businessId=1) db.session.add(u1) db.session.add(u2) db.session.commit() return jsonify({'result': 'success'})
def test_save_duplicate_users(self): new_user = user.User(username="******", email="manu@someone", password="******") new_user.save() new_user = user.User(username="******", email="manu@someone", password="******") self.assertFalse(new_user.save())
def usercase_1(): usercase_0() vk = user.User(nome_usuario='vk') leandro = user.User(nome_usuario='leandro') assert vk.get_relacionamento(leandro) == user.Relacionamento.SEGUINDO ps = vk.get_postagens() assert len(ps) == 3 ps[2].excluir() assert ps[1].texto() == "WIIILSOOOON!!!" assert "terminar" in ps[0].texto() c = ps[0].get_comentarios() assert len(c) == 1 assert "vou" in c[0].texto() assert 1 == sum(1 if i.lida() else 0 for i in notification.get_notificacoes_usuario(vk))
def test_authenticate_password_works(self): new_user = user.User(username="******", email="manu@someone", password="******") new_user.save() self.assertTrue(new_user.authenticate_password("uniquekey")) self.assertFalse(new_user.authenticate_password("wrongpassword"))
def test_hashed_password_not_same_to_password(self): new_user = user.User(username="******", email="manu@someone", password="******") save = new_user.save() self.assertTrue(save) self.assertTrue(new_user.password != "uniquek")
def create_biness_user(businessId): biness = business.Business.query.get(businessId) if not biness: abort(404) entity = user.User(username=request.json['username'], password=request.json['password'], contact_email=request.json['contact_email'], role=request.json['role']) if not request.json['role'] == 'Admin': if request.json['role'] == 'Manager': binessMgrUsers = user.User.query.filter\ ((user.User.businessId==businessId) & (user.User.role=='Manager')).all() if (len(binessMgrUsers) < biness.allowedMgrUsers): biness.users.append(entity) db.session.add(biness) db.session.commit() else: raise BadRequestError( 'Allowed Manager accounts limit reached.') else: binessUsrUsers = user.User.query.filter\ ((user.User.businessId==businessId) & (user.User.role=='User')).all() if (len(binessUsrUsers) < biness.allowedUsrUsers): biness.users.append(entity) db.session.add(biness) db.session.commit() else: raise BadRequestError('Allowed User accounts limit reached.') else: abort(404) return jsonify(entity.to_dict()), 201
def user_info(variables={}, request={}): result = {} try: user_id = Token.Token().query('USERID').where( 'TOKEN', '=', request.params['token']).get()[0]['USERID'] user_query = User.User()\ .query('USERS.ID', 'USERS.USERNAME', 'USERS.FIRSTNAME', 'USERS.LASTNAME', 'USERS.EMAIL')\ .where('USERS.ID', '=', user_id).get()[0] locations = Location.Location()\ .query('LOCATIONS.COUNTRY', 'LOCATIONS.CITY', 'LOCATIONS.STREET')\ .where('USERID', '=', user_id).get() if locations: locations = locations[0] else: locations = dict() prefs = Preference.Preference().query('*').where( 'USERID', '=', user_id).get() if prefs: prefs = prefs[0] else: prefs = dict() result['firstname'] = user_query['USERS.FIRSTNAME'] result['lastname'] = user_query['USERS.LASTNAME'] result['email'] = user_query['USERS.EMAIL'] result['country'] = locations.get('LOCATIONS.COUNTRY', '') result['city'] = locations.get('LOCATIONS.CITY', '') result['street'] = locations.get('LOCATIONS.STREET', '') result['title_preferences'] = prefs.get('PREFERENCE', '') except UserWarning, e: logging.exception('User warning') return Controller.response_json({'status': 'error', 'message': str(e)})
def get_book_by_id(id): books_query = Book.Book()\ .query('BOOKS.ID', 'BOOKS.GOODREADSID', 'BOOKS.ISBN', 'BOOKS.TITLE', 'BOOKS.GENRE', 'BOOKS.EXPIRES', 'BOOKS.AUTHORID', 'BOOKS.COVER', 'BOOKS.DELETED', 'AUTHORS.NAME', 'USERBOOKS.USERID')\ .join('AUTHORS', 'AUTHORID', 'ID')\ .join('USERBOOKS', 'ID', 'BOOKID')\ .where('BOOKS.ID', '=', id).get() if books_query: books_query = books_query[0] else: return {} user = User.User().query('*').where( 'ID', '=', books_query['USERBOOKS.USERID']).get()[0] book = {} book['user_id'] = user['ID'] book['username'] = user['USERNAME'] book['title'] = books_query['BOOKS.TITLE'].decode('cp1252') book['goodreads_id'] = books_query['BOOKS.GOODREADSID'] book['id'] = books_query['BOOKS.ID'] book['isbn'] = books_query['BOOKS.ISBN'].decode('cp1252') book['genre'] = books_query['BOOKS.GENRE'].decode('cp1252') book['expires'] = books_query['BOOKS.EXPIRES'].strftime('%d-%m-%Y') book['author'] = books_query['AUTHORS.NAME'].decode('cp1252') if books_query['BOOKS.COVER']: book['cover'] = books_query['BOOKS.COVER'].decode('cp1252') else: book['cover'] = '' return book
def create_user(db: Session, user: schemas.UserCreate): fake_hashed_password = user.password + "notreallyhashed" db_user = models.User(email=user.email, hashed_password=fake_hashed_password) db.add(db_user) db.commit() db.refresh(db_user) return db_user
def init_class_blog(app): global settingsClass global postClass global userClass # print (app.config) settingsClass = settings.Settings(app.config) postClass = post.Post(app.config) userClass = user.User(app.config)
def load_logged_in_user(): """If a user id is stored in the session, load the user object from the database into ``g.user``.""" user_id = session.get("user_id") if user_id is None: g.user = None else: g.user = users.User(user_id)
def create_user(): entity = user.User( username = request.json['username'] , firstname = request.json['firstname'] , lastname = request.json['lastname'] ) db.session.add(entity) db.session.commit() return jsonify(entity.to_dict()), 201
def user_info(variables={}, request={}): id = request.params['id'] ok, error_message = Validator.validate([(id, r'^[0-9]|[1-9][0-9]+$', 'id value is invalid')]) user = {} try: if not ok: raise UserWaning(error_message) found_user = User.User().query('*').where('ID', '=', id).get() if not found_user: raise UserWarning('no such user') found_user = found_user[0] book_count = UserBook.UserBook().count().where( 'USERID', '=', found_user['ID']).get()[0] books_query = Book.Book()\ .query('BOOKS.ID')\ .join('USERBOOKS', 'ID', 'BOOKID')\ .where('USERBOOKS.USERID', '=', found_user['ID']).get() books = [] for book_result in books_query: book = BookController.get_book_by_id(book_result['BOOKS.ID']) books.append(book) location = Location.Location().query('*').where( 'USERID', '=', found_user['ID']).get() if location: location = location[0] else: location = dict() prefs = Preference.Preference().query('*').where( 'USERID', '=', found_user['ID']).get() if prefs: prefs = prefs[0] else: prefs = dict() user = { 'id': found_user['ID'], 'username': found_user['USERNAME'], 'first_name': found_user['FIRSTNAME'], 'last_name': found_user['LASTNAME'], 'country': location.get('COUNTRY', ''), 'city': location.get('CITY', ''), 'street': location.get('STREET', ''), 'email': found_user['EMAIL'], 'book_count': book_count['count'], 'books': books, 'title_preference': prefs.get('PREFERENCE', '') } except UserWarning, e: logging.exception('User warning') return Controller.response_json({'status': 'error', 'message': str(e)})
def aceitar(nome_usuario, id_usuario=None): if not nome_usuario is None: u = user.get_user(nome_usuario) elif not id_usuario is None: u = user.User(id_usuario) else: u = None if u is None or not u.e_valido(): return abort(404) user.aceitar_solicitacao(u, g.user) return redirect(url_for('usuario', nome_usuario=nome_usuario))
def update_user(id): entity = user.User.query.get(id) if not entity: abort(404) entity = user.User( username = request.json['username'], firstname = request.json['firstname'], lastname = request.json['lastname'], id = id ) db.session.merge(entity) db.session.commit() return jsonify(entity.to_dict()), 200
def test_edit_user(self): new_user = user.User("test_user", "user_password", "*****@*****.**") new_user.save() user_to_update = user.User.get_user(name="test_user") user_to_update.username = "******" user_to_update.email = "*****@*****.**" user_to_update.user_password = "******" user_to_update.save() deleted_user = user.User.get_user(name="test_user") self.assertEqual(deleted_user, None) updated_user = user.User.get_user(email="*****@*****.**") self.assertTrue(updated_user.username == "update_username") self.assertFalse(updated_user.authenticate_password("user_password")) self.assertTrue(updated_user.authenticate_password("new_password"))
def foto_perfil(nome_usuario, id_usuario=None): if not nome_usuario is None: u = user.get_user(nome_usuario) elif not id_usuario is None: u = user.User(id_usuario) else: u = None from os import path basedir = app.config['IMAGES_USERS_ABS'] if not u is None and u.e_valido() and u.foto() and path.exists( path.join(basedir, u.foto())): return send_from_directory(basedir, u.foto()) return send_from_directory(app.static_folder, 'images_app/default-user.png')
def general_info(variables={}, request={}): users = 0 connections = 0 locations = 0 books = 0 authors = 0 genres = 0 try: users = User.User().count().get()[0]['count'] connections = Exchange.Exchange().count().get()[0]['count'] locations = Location.Location().count().get()[0]['count'] books = Book.Book().count().get()[0]['count'] authors = Author.Author().count().get()[0]['count'] genres = len(BookController.genres) except Exception, e: print str(e) pass
def de_seguir(nome_usuario, id_usuario=None): if not nome_usuario is None: u = user.get_user(nome_usuario) elif not id_usuario is None: u = user.User(id_usuario) else: u = None if u is None or not u.e_valido(): return abort(404) rel = g.user.get_relacionamento(u) if rel is user.Relacionamento.NONE: u.solicitar_seguir(g.user) elif rel is user.Relacionamento.SEGUINDO or rel is user.Relacionamento.SOLICITOU: u._set_relacionamento(g.user, user.Relacionamento.NONE) return redirect(url_for('usuario', nome_usuario=nome_usuario))
def register(variables={}, request={}): status = 'success' message = '' username = request.params['username'] password = request.params['password'] user = User.User() response_dict_user = user.query("ID").where("USERNAME", "=", username).condition( "OR", "EMAIL", "=", username).get() if not response_dict_user: message = 'incorrect username or password' status = 'error' else: response_dict_pass = user.query("PASSWORD", "SALT").where( "USERNAME", "=", username).condition("OR", "EMAIL", "=", username).get() input_pass_hash = bcrypt.hashpw(password.encode('utf8'), response_dict_pass[0]["SALT"]) if input_pass_hash != response_dict_pass[0]["PASSWORD"]: message = 'incorrect username or password' status = 'error' else: token = Token.Token() response_dict_token = token.query("TOKEN").where( "USERID", "=", response_dict_user[0]["ID"]).condition("AND", "TOKENTYPE", "=", "booxtoken").get() message = 'log in successful' status = 'success' if status == 'success': response = { 'token': response_dict_token[0]['TOKEN'], 'id': response_dict_user[0]['ID'] } result = {'status': status, 'message': message, 'response': response} else: result = {'status': status, 'message': message} return Controller.response_json(result)
def de_bloquear(nome_usuario, id_usuario=None): if not nome_usuario is None: u = user.get_user(nome_usuario) elif not id_usuario is None: u = user.User(id_usuario) else: u = None if u is None or not u.e_valido(): return abort(404) rel = g.user.get_relacionamento(u) if rel is user.Relacionamento.BLOQUEOU: u.desbloquear(g.user) return redirect(url_for('usuario', nome_usuario=nome_usuario)) else: u.bloquear(g.user) return redirect(url_for('index'))
def test_create_user(self): new_user = user.User("new_name", "user_password", "*****@*****.**") save = new_user.save() self.assertTrue(save) user_created = user.User.get_users() self.assertTrue(len(user_created) > 0) self.assertTrue(new_user in user_created) # create user using json_schema dict_data = { 'username': '******', 'password': '******', 'email': '*****@*****.**' } schema = user.UserSchema() new_user, error = schema.load(dict_data) self.assertFalse(error) new_user.save() self.assertTrue(new_user in user.User.get_users())
def test_password_hash_is_unique_for_password(self): new_user = user.User(username="******", email="manu@someone", password="******") new_user.save() self.assertFalse(new_user.password == self.new_user.password)
def user_edit(variables={}, request={}): status = 'success' message = '' fname = request.params.get('fname', '') lname = request.params.get('lname', '') email = request.params.get('email', '') password = request.params.get('password', None) new_password = request.params.get('npassword', None) confirm_new_password = request.params.get('cnpassword', None) country = request.params.get('country', '') city = request.params.get('city', '') street = request.params.get('street', '') title_prefs = request.params.get('title_preferences', '') result = None try: if not fname or not lname or not email: raise UserWarning( 'firstname, lastname and email are mandatory fields') user_id = Token.Token().query('USERID').where( 'TOKEN', '=', request.params['token']).get()[0]['USERID'] User.User().update({ 'FIRSTNAME': fname, 'LASTNAME': lname, 'EMAIL': email }).where('ID', '=', user_id).execute() user = User.User().query('*').where('ID', '=', user_id).get()[0] Preference.Preference().update_or_create( { 'USERID': user_id, 'PREFERENCETYPE': 'bookname' }, { 'USERID': user_id, 'PREFERENCETYPE': 'bookname', 'PREFERENCE': title_prefs }) if country or city or street: Location.Location().update_or_create({'USERID': user_id}, { 'USERID': user_id, 'COUNTRY': country, 'CITY': city, 'STREET': street }) if password: old_password_hash = bcrypt.hashpw(password.encode('utf8'), user['SALT']) if old_password_hash != user['PASSWORD']: raise UserWarning('password incorrect') if new_password != confirm_new_password: raise UserWarning( 'new password and confirm password don\'t match') else: new_password_hash = bcrypt.hashpw(new_password.encode('utf8'), user['SALT']) User.User().update({ 'PASSWORD': new_password_hash }).where('ID', '=', user_id).execute() except UserWarning, e: logging.exception('User warning') return Controller.response_json({'status': 'error', 'message': str(e)})
def test_user_exists(self): user.User(registration_id='1234', is_registered=True).put() self.assertEqual(user.register('1234', 'fake password'), None)
def test_is_authenticated(self): self.assertTrue(user.User().is_authenticated())
def test_is_anonymous(self): self.assertFalse(user.User().is_anonymous())
def test_is_active(self): self.assertTrue(user.User().is_active())
def test_id(self): new_user = user.User() new_user_key = new_user.put() self.assertEqual(new_user_key, new_user.key())
def test_delete_non_existing_user(self): new_user = user.User(username="******", email="manu@someone", password="******") self.assertFalse(new_user.delete())