def test_retrieve_hit():
user_one = UserModel('0',
'chengyun yu',
'yuche',
'male',
'*****@*****.**',
'0,0',
'sports, dining',
'i am a sports guy who likes to eat. '
)
user_two = UserModel('0',
'chengyun yu',
'yuche',
'male',
'*****@*****.**',
'0,0',
'sports, dining',
'this is my new description. '
)
user_three = UserModel('0',
'non existent',
'noext',
'male',
'*****@*****.**',
'0.0',
'sports, dining',
'i am a sports guy who does not exist. '
)
print("Insert New: " + UserController.add_user(user_one))
print("Insert Conflict: " + UserController.add_user(user_two))
print("Update: " + UserController.edit_user(user_two))
print("Retrieve Hit: " + UserController.retrieve_user(UserFields.email.name, user_two.email))
print("Retrieve Miss: " + UserController.retrieve_user(UserFields.email.name, user_three.email))
return 'Tests Finished'
def create_tables():
db.create_all()
# creation of the first admin
user1 = UserModel('dhar', 'KalaChashma')
user1.isAdmin = True
user1.save_to_db()
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(data['username'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def get(self):
claims = get_jwt_claims()
if not claims["is_admin"]:
return {"message": "Un-authorized"}, 401
user_model = UserModel()
user_details = user_model.get_all()
if user_details:
return {"message": user_details}
else:
return {"message": "No Record Found"}
def PlatformUserRemove(self, session, username):
"""
Remove a platform user.
:param session: session id
:param username: user's name to be removed
"""
return True, UserModel.Delete(username)
def PlatformUserGet(self, session, username):
"""
Get a platform user.
:param session: session id
:param username: user's name to be retrieve
"""
return True, UserModel.Retrieve(username)
def update_profile(data):
user = UserModel(0, data['name'], data['nickname'],
data['gender'], data['email'], data['location'],
stringToEnum(data['tags']), data['description'], [], [],
data['image'], data['google_id'])
result = UserController.edit_user(user)
if result == Errors.MISSING.name:
return result, None
elif result == Errors.FAILURE.name:
return result, None
else:
user = UserController.retrieve_user(UserFields.googleid.name,
data['google_id'])
data = {
'id': user.uid,
'name': user.name,
'nickname': user.nickname,
'email': user.email,
'location': user.location,
'description': user.description,
'gender': user.gender,
'image': user.image,
'tags': user.tags,
'google_id': user.google_id
}
return 'OK', data
def put(self, user_id):
user_detail = UserModel.get_by_id(user_id)
if user_detail:
user_data = validate_user_data()
user_detail.name = user_data["name"]
user_detail.email = user_data["email"]
return user_detail.save_user()
else:
return {"message": "No Record Found"}
def loginUser(self, username, password):
self.cur.execute(
"SELECT * from users WHERE username=? AND password=?;",
(username, password))
res = self.cur.fetchall()
if len(res) == 1:
UserModel().setUser(
User(res[0][0], res[0][1], res[0][2], res[0][3], res[0][4]))
return len(res) > 0
def PlatformUserUpdate(self, session, username, new_encrypted_password,
new_level):
"""
Update a platform user.
:param session: session id
:param username: user's name to be updated
:param new_encrypted_password: user's new password with encryption
:param new_level: new level flag of user
"""
return True, UserModel.Update(username, new_encrypted_password,
new_level)
def PlatformUserAdd(self, session, username, encrypted_password, level):
"""
Add a platform user.
:param session: session id
:param username: new user's name
:param encrypted_password: new user's password with encryption
:param level: new user level flag
"""
try:
UserModel.Add(username, encrypted_password, level)
return True, True
except:
return True, False
def read_user():
uid = 0
real_name = str(realname_input.get())
nickname = str(nickname_input.get())
gender = str(gender_input.get())
email = str(email_input.get())
location = str(user_location_input.get())
tags = stringToEnum(str(user_tags_input.get()))
description = user_description_input.get()
host_events = []
join_events = []
new_event = UserModel(uid, real_name, nickname, gender, email, location,
tags, description, host_events, join_events)
return new_event
def __init__(self):
super().__init__()
self._ui = Ui_Navigation()
self._ui.setupUi(self)
self._userModel = UserModel()
self._usersController = UsersController(self._userModel)
self._usersView = UsersView(self._userModel, self._usersController)
self._ui.stackedWidget.addWidget(self._usersView)
self._returnedModel = ReturnedModel()
self._returned_controller = ReturnController(self._returnedModel)
self._returnedBooksView = ReturnedBooksView(self._returned_controller)
self._ui.stackedWidget.addWidget(self._returnedBooksView)
self._issuanceModel = IssuanceModel()
self._issuanceController = IssuanceController(self._issuanceModel)
self._issuanceView = IssuedBooksStudentView(self._issuanceController,
self._returned_controller)
self._ui.stackedWidget.addWidget(self._issuanceView)
self._bookModel = BookModel()
self._bookController = BookController(self._bookModel)
self._addBookView = AddBookView(self._bookModel, self._bookController)
self._ui.stackedWidget.addWidget(self._addBookView)
self._libraryController = LibraryController()
self._libraryView = LibraryStudentView(self._libraryController,
self._issuanceController,
self._bookController)
self._ui.stackedWidget.addWidget(self._libraryView)
self._ui.stackedWidget.setCurrentWidget(self._libraryView)
self._libraryView.InitializeLibrary()
## TOGGLE/BURGUER MENU
self._ui.Btn_Toggle.clicked.connect(lambda: self.toggleMenu(70, True))
## PAGES
self._ui.library_page.clicked.connect(
lambda: self._ui.stackedWidget.setCurrentWidget(self._libraryView))
self._ui.library_page.clicked.connect(
self._libraryView.InitializeLibrary)
self._ui.issued_books_page.clicked.connect(
lambda: self._ui.stackedWidget.setCurrentWidget(self._issuanceView
))
self._ui.issued_books_page.clicked.connect(
self._issuanceView.InitializeIssuedBooks)
def decode_string(user_info: str):
user_info = user_info[1: -1]
field_list = user_info.split(',')
field_list[0] = field_list[0][1: -1]
field_list[1] = field_list[1][2: -1]
field_list[2] = field_list[2][2: -1]
field_list[3] = field_list[3][2: -1]
field_list[4] = field_list[4][2: -1]
field_list[5] = field_list[5][2: -1]
field_list[6] = field_list[6][2: -1]
field_list[7] = field_list[7][1:]
decoded_user = UserModel(field_list[7], field_list[0], field_list[1], field_list[2], field_list[4], field_list[3],
field_list[5], field_list[6], [], [])
return decoded_user
def Connect(username, encrypted_password):
"""
Connect to the engine.
:param username: username to connect
:param encrypted_password: password string with specific encryption
"""
try:
success_flag = UserModel.Verify(username, encrypted_password)
if success_flag is False:
return True, None
session_id = SessionManager.Login(username, encrypted_password)
return True, session_id
except Exception as e:
print "Exception in COrgan: %s" % str(e)
return False, e
class Test(unittest.TestCase):
date = '2018-10-31'
event_1 = EventModel(1, 'event_title_1', 'tags_1', 'description_1', 'image_1', [], [], date, 'location_1', '5')
user_1 = UserModel(1, 'real_name_1', 'nickname_1', 'gender_1', 'email_1', 'location_1', 'tags_1', 'description_1', [], [])
# test event model
def test_post_event(self):
event_id_1 = EventController.post_event(self.user_1, self.event_1)
self.assertIsNotNone(event_id_1)
def test_edit_event(self):
# def test_expire:
# def test_remove_user:
# def test_join_event:
# def test_host_event:
# def test_hosted_event:
# def test_get_hosted_event:
# test user model
def test_add_user(self):
UserController.delete_user('nickname_1', 'email_1')
self.assertEqual(UserController.add_user(self.user_1), 'SUCCESS')
self.assertEqual(UserController.add_user(self.user_1), 'DUPLICATE')
UserController.delete_user('nickname_1', 'email_1')
def test_delete_user(self):
self.assertEqual(UserController.delete_user('nickname_1', 'email_1'), 'SUCCESS')
self.assertEqual(UserController.delete_user('fake_nickname_1', 'fake_email_1'), 'SUCCESS')
# def test_edit_user:
# def test_retrieve_user:
if __name__ == '__main__':
# log_file = 'unittest_log.txt'
# f = open(log_file, 'a')
# runner = unittest.TextTestRunner(f)
# unittest.main(testRunner=runner)
# f.close()
unittest.main()
def decode_string(user_info: str):
user_info = user_info[1: -1]
user_info = '[' + user_info + ']'
user_info = ast.literal_eval(user_info)
name = user_info[0]
nickname = user_info[1]
gender = user_info[2]
location = user_info[3]
email = user_info[4]
tags = user_info[5]
description = user_info[6]
uid = user_info[7]
image = user_info[8]
google_id = user_info[9]
decoded_user = UserModel(uid, name, nickname, gender, email, location, tags, description, [], [], image, google_id)
return decoded_user
def Login(username, password_encrypted):
"""
Log in a session.
:param username: user name string
:param password_encrypted: password string with specific encryption
:return session id
"""
session_id = str(uuid.uuid1())
while SessionManager.ActiveSessionDict.get(session_id, None) is not None:
session_id = str(uuid.uuid1())
session_id = "%s_%s" % (session_id, username)
cur_session = CSession(session_id, username, password_encrypted, time.time())
from Model.UserModel import UserModel
uObj = UserModel.Retrieve(username)
assert uObj is not None
cur_session.Level = uObj["level"]
SessionManager.ActiveSessionDict[session_id] = cur_session
return session_id
def post(self):
data = EventResource.parser.parse_args()
user = UserModel.find_by_username(data['username'])
session = EventModel.find_session(user, data['createdOn'])
if (session):
session.event = data['event']
session.save_to_db()
return {"message": user.json(), "payload": session.json()}, 200
else:
session = EventModel(data['event'], data['createdOn'])
session.user = user
session.save_to_db()
return {"message": user.json(), "payload": session.json()}, 200
class Test(unittest.TestCase):
date = '2018-10-31'
event_1 = EventModel(1, 'event_title_1', 'tags_1', 'description_1',
'image_1', [], [], date, 'location_1', '5')
user_1 = UserModel(1, 'real_name_1', 'nickname_1', 'gender_1', 'email_1',
'location_1', 'tags_1', 'description_1', [], [])
# test event model
def test_post_event(self):
event_id_1 = EventController.add_event(self.user_1, self.event_1)
self.assertIsNotNone(event_id_1)
# def test_edit_event(self):
# def test_expire:
# def test_remove_user:
# def test_join_event:
# def test_host_event:
# def test_hosted_event:
# def test_get_hosted_event:
# test user model
def test_add_user(self):
UserController.delete_user('nickname_1', 'email_1')
self.assertEqual(UserController.add_user(self.user_1), 'SUCCESS')
self.assertEqual(UserController.add_user(self.user_1), 'DUPLICATE')
UserController.delete_user('nickname_1', 'email_1')
def test_delete_user(self):
UserController.add_user(self.user_1)
self.assertEqual(UserController.delete_user('nickname_1', 'email_1'),
'SUCCESS')
self.assertEqual(
UserController.delete_user('fake_nickname_1', 'fake_email_1'),
'SUCCESS')
def __init__(self, bookModel, book_controller, issuance_model, issuance_controller):
super().__init__()
self._book_model = bookModel
self._issuance_model = issuance_model
self._book_controller = book_controller
self._issuance_controller = issuance_controller
self._ui = Ui_Book()
self._ui.setupUi(self)
self._ui.BookId.setText(self._book_model.book_id)
self._ui.BookId.hide()
self._ui.BookTitle.setText(self._book_model.title)
self._ui.BookAuthor.setText(self._book_model.author)
self._ui.BookPublisher.setText(self._book_model.publisher)
self._ui.BookEdition.setText(self._book_model.edition)
self._ui.BookCategory.setText(self._book_model.category)
self._ui.BookPublisherDate.setText(self._book_model.published_date)
self._ui.BookQuantity.setText(self._book_model.quantity)
self._userModel = UserModel()
self._usersController = UsersController(self._userModel)
def post(self):
user_data = validate_login_detail()
user_credential = UserModel.get_by_email(user_data["email"])
if user_credential:
if user_credential.password == user_data["password"]:
access_token = create_access_token(identity={
"id": user_credential.id,
"role": user_credential.role
},
fresh=True)
refresh_token = create_refresh_token(
identity={
"id": user_credential.id,
"role": user_credential.role
})
return {
"access_token": access_token,
"refresh_token": refresh_token
}
else:
return {"message": "Invalid Credential"}
def get_user_relevant_post(self):
rs = self.tender_db.allPosts(UserModel().user.username)
posts = []
for record in rs:
p_id = record[0]
p_seller = record[1]
p_model = record[2]
p_year = record[3]
p_color = record[4]
p_distance_driven = record[5]
p_image = record[6]
p_price = record[7]
p_description = record[8]
im = CoreImage(io.BytesIO(p_image), ext="jpg")
p = Post(p_id, p_seller, p_model, p_year, p_color,
p_distance_driven, im, p_price, p_description)
posts.append(p)
return posts
def __init__(self, issuance_controller, returned_controller):
super().__init__()
self._ui = Ui_IssuedBooks()
self._ui.setupUi(self)
self._issuance_controller = issuance_controller
self._returned_controller = returned_controller
self._ui.lineEdit.hide()
#self._ui.tableWidget.itemSelectionChanged.connect(self.GetSelectedIssuanceID)
columns = [
'Issuance ID', 'Borrowed by', 'Student ID', 'Book Title',
'Book Id', 'Release Date', 'Due Date', 'Librarian', 'Fine'
]
self._ui.tableWidget.setHorizontalHeaderLabels(columns)
self._ui.tableWidget.resizeColumnsToContents()
self._userModel = UserModel()
self._usersController = UsersController(self._userModel)
self._bookModel = BookModel()
self._bookController = BookController(self._bookModel)
def autenticaUser(self, email, senha):
try:
url = "https://dg-2ts-server.herokuapp.com/"
response = requests.get(url + "user_autenticate/email=" + email +
"&password="******"response"] == None:
messageError('Nenhum Usuário Encontrado !!')
else:
messageError('Nenhum Usuário Encontrado !!')
#print(data["response"])
except Exception as e:
print("aqui 1")
user = UserModel(**data)
root.destroy()
windows = boasVindas(user.token, user.name)
windows.mainloop()
except Exception as e:
messageError('Erro no servidor, contate o analista reponsável !')
print(e.with_traceback())
def autenticaUser(self, email, senha):
try:
url = "https://dg-2ts-server.herokuapp.com/"
response = requests.get(url + "user_autenticate/email=" + email +
"&password="******"AAAAAAAAA")
if data["response"] == 'Nenhum usuario encontrado':
messageError('Nenhum Usuário Encontrado !!')
elif data["response"] == 'ERRO':
messageError('Erro no servidor !!')
except Exception as e:
user = UserModel(**data)
root1.destroy()
windows = Window(user.token, user.name)
windows.mainloop()
except Exception as e:
messageError('Erro no servidor. Contate o analista responsável !!')
def viewLiked(self):
self.cur.execute(
"SELECT * FROM Posts INNER JOIN Preferences on Posts.POSTID = Preferences.POSTID WHERE Preference = ? AND username = ?;",
(1, UserModel().user.username))
return self.cur.fetchall()
def identity(payload):
user_id = payload['identity']
return UserModel.find_by_id(user_id)
def dislikePost(self, postid):
self.cur.execute("INSERT into Preferences VALUES (?,?,?);",
(postid, UserModel().user.username, 0))
self.conn.commit()
def authenticate(username, password):
user = UserModel.find_by_username(username)
if user and safe_str_cmp(user.password, password):
return user
