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