def setUp(self): super(TestnGetOtherUserApi, self).setUp() self.verified_user = UserModel( name=user1["name"] + " Example", email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.other_user = UserModel( name=user2["name"], email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) self.verified_user.is_email_verified = True self.verified_user.is_available = False self.other_user.is_email_verified = True self.other_user.is_available = False db.session.add(self.verified_user) db.session.add(self.other_user) db.session.commit()
def test_dao_confirm_registration_of_already_verified_user(self): dao = UserDAO() user = UserModel( name=user2["name"], email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) db.session.add(user) db.session.commit() # Verify that user was inserted in database through DAO user = UserModel.query.filter_by(email=user2["email"]).first() self.assertIsNotNone(user) user.is_email_verified = True db.session.add(user) db.session.commit() self.assertTrue(user.is_email_verified) good_token = generate_confirmation_token(user2["email"]) actual_result = dao.confirm_registration(good_token) self.assertTrue(user.is_email_verified) self.assertEqual((messages.ACCOUNT_ALREADY_CONFIRMED, 200), actual_result)
def delete_user(user_id: int): """ Deletes a user. Deletes the specified user and removes them from the directory, with checks to make sure that the user exists and is not the only administrator. Arguments: user_id: The ID of the user to be deleted. Returns: A tuple with two elements. The first element is a dictionary containing a key 'message' containing a string which indicates whether or not the user was created successfully. The second is the HTTP response code. """ user = UserModel.find_by_id(user_id) # check if this user is the only admin if user.is_admin: admins_list_count = len(UserModel.get_all_admins()) if admins_list_count <= UserDAO.MIN_NUMBER_OF_ADMINS: return messages.USER_CANT_DELETE, HTTPStatus.BAD_REQUEST if user: user.delete_from_db() return messages.USER_SUCCESSFULLY_DELETED, HTTPStatus.OK return messages.USER_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND
def setUp(self): super().setUp() self.mentor = UserModel( name="Mentor A", email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) # User A self.mentee = UserModel( name="Mentee B", email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) # User B self.mentor.is_email_verified = True self.mentee.is_email_verified = True self.mentor.available_to_mentor = True self.mentee.need_mentoring = True db.session.add(self.mentor) db.session.add(self.mentee) db.session.commit() self.test_description = "A nice task description"
def send_invite_to_mod(firebase_id: str, email: str): mod_email = email try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 if user.is_donor: mod_exists = UserModel.find_by_email(mod_email) if mod_exists: if mod_exists.is_moderator: return {"message": f"Moderator is already registered. Do you want to proceed?"}, 409 else: role = "donor" if mod_exists.is_donor else "recipient" if mod_exists.is_recipient else "moderator" return {"message": f"User with this email is already signed up as a {role}"}, 400 else: otp = random.randint(111111,999999) invite = InvitesModel(user, email, otp) invite.save_to_db() send_invite_mod_email(user.name, otp, email) return {"message": "Invitation sent"}, 200 else: return {"message": "User cannot invite moderator"}, 401
def setUp(self): super(TestHomeStatisticsApi, self).setUp() self.user1 = UserModel("User1", "user1", "__test__", "*****@*****.**", True) self.user2 = UserModel("User2", "user2", "__test__", "*****@*****.**", True) self.user1.available_to_mentor = True self.user1.is_email_verified = True self.user2.need_mentoring = True self.user2.is_email_verified = True db.session.add(self.user1) db.session.add(self.user2) db.session.commit()
def setUp(self): super(TestMentorshipRelationDeleteDAO, self).setUp() self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.second_user = UserModel( name=user2["name"], email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) # making sure both are available to be mentor or mentee self.first_user.need_mentoring = True self.first_user.available_to_mentor = True self.first_user.is_email_verified = True self.second_user.need_mentoring = True self.second_user.available_to_mentor = True self.second_user.is_email_verified = True self.notes_example = "description of a good mentorship relation" self.now_datetime = datetime.now() self.end_date_example = self.now_datetime + timedelta(weeks=5) db.session.add(self.first_user) db.session.add(self.second_user) db.session.commit() # create new mentorship relation self.mentorship_relation = MentorshipRelationModel( action_user_id=self.first_user.id, mentor_user=self.first_user, mentee_user=self.second_user, creation_date=self.now_datetime.timestamp(), end_date=self.end_date_example.timestamp(), state=MentorshipRelationState.PENDING, notes=self.notes_example, tasks_list=TasksListModel(), ) db.session.add(self.mentorship_relation) db.session.commit()
def update_preferred_location(firebase_id: str, data: Dict[str, str]): state = data['state'] district = data['district'] if "sub_district" in data: sub_district = data["sub_district"] else: sub_district = "" if "area" in data: area = data["area"] else: area = "" try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 if user.is_donor: preferred_location = user.preferred_location if preferred_location: preferred_location.state = state preferred_location.district = district preferred_location.sub_district = sub_district preferred_location.area = area preferred_location.save_to_db() else: updated_location = PreferredLocationModel(user.id, state, district, sub_district, area) updated_location.save_to_db() return {"message": "Preferred location updated successfully"}, 200 else: return {"message": "This user cannot set preferred location"}, 401
def test_update_username_not_taken(self): self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.first_user.is_email_verified = True db.session.add(self.first_user) db.session.commit() user1_new_username = "******" auth_header = get_test_request_header(self.first_user.id) expected_response = messages.USER_SUCCESSFULLY_UPDATED actual_response = self.client.put( "/user", follow_redirects=True, headers=auth_header, data=json.dumps(dict(username=user1_new_username)), content_type="application/json", ) self.assertEqual(200, actual_response.status_code) self.assertDictEqual(expected_response, json.loads(actual_response.data)) self.assertEqual(user1_new_username, self.first_user.username)
def test_update_username_already_taken(self): self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.first_user.is_email_verified = True db.session.add(self.first_user) db.session.commit() auth_header = get_test_request_header(self.first_user.id) expected_response = messages.USER_USES_A_USERNAME_THAT_ALREADY_EXISTS actual_response = self.client.put( "/user", follow_redirects=True, headers=auth_header, data=json.dumps(dict(username=self.admin_user.username)), content_type="application/json", ) self.assertEqual(400, actual_response.status_code) self.assertDictEqual(expected_response, json.loads(actual_response.data))
def create_task(user_id: int, mentorship_relation_id: int, data: Dict[str, str]): """Creates a new task. Creates a new task in a mentorship relation if the specified user is already involved in it. Args: user_id: The id of the user. mentorship_relation_id: The id of the mentorship relation. data: A list containing the description of the task. Returns: A two element list where the first element is a dictionary containing a key 'message' indicating in its value if the task creation was successful or not as a string. The last element is the HTTP response code. """ description = data["description"] user = UserModel.find_by_id(user_id) relation = MentorshipRelationModel.find_by_id(_id=mentorship_relation_id) if relation is None: return messages.MENTORSHIP_RELATION_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND if relation.state != MentorshipRelationState.ACCEPTED: return messages.UNACCEPTED_STATE_RELATION, HTTPStatus.FORBIDDEN if (relation.mentor_id != user_id) and (relation.mentee_id != user_id): return messages.USER_NOT_INVOLVED_IN_THIS_MENTOR_RELATION, 403 now_timestamp = datetime.now().timestamp() relation.tasks_list.add_task(description=description, created_at=now_timestamp) relation.tasks_list.save_to_db() return messages.TASK_WAS_CREATED_SUCCESSFULLY, HTTPStatus.CREATED
def close_application(firebase_id: str, reserved_application_id: int): try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 if not user.is_donor: return {"message": "This user cannot close the application"}, 200 application = ReservedApplicationModel.find_by_id( reserved_application_id) if application and application.donor == user: if application.donation_date == None: original_applcation = ApplicationModel.find_by_id( application.application_id) original_applcation.remaining_amount = original_applcation.remaining_amount + application.amount original_applcation.donor.remove(user) original_applcation.save_to_db() # Not a good practice, if we need to check which donor is culprit and just wasting time of moderator and recipient application.delete_from_db() return {"message": "Application is removed and updated"}, 200 else: application.is_active = False original_applcation = ApplicationModel.find_by_id( application.application_id) original_applcation.donor.remove(user) original_applcation.save_to_db() application.save_to_db() return {"message": "Application is closed"}, 200 else: return { "message": "Cannot find reserved application for this user" }, 404
def test_dao_confirm_registration_bad_token(self): dao = UserDAO() user = UserModel( name=user2["name"], email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) db.session.add(user) db.session.commit() # Verify that user was inserted in database through DAO user = UserModel.query.filter_by(email=user2["email"]).first() self.assertIsNotNone(user) # bad token because it is incomplete bad_token = generate_confirmation_token(user2["email"])[:4] self.assertFalse(user.is_email_verified) actual_result = dao.confirm_registration(bad_token) self.assertFalse(user.is_email_verified) self.assertIsNone(user.email_verification_date) self.assertEqual((messages.EMAIL_EXPIRED_OR_TOKEN_IS_INVALID, 400), actual_result)
def test_update_availability_to_be_mentee_to_false(self): self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.first_user.is_email_verified = True self.first_user.need_mentoring = True db.session.add(self.first_user) db.session.commit() expected_response = messages.USER_SUCCESSFULLY_UPDATED test_need_mentoring = False auth_header = get_test_request_header(self.first_user.id) self.assertEqual(True, self.first_user.need_mentoring) actual_response = self.client.put( "/user", follow_redirects=True, headers=auth_header, data=json.dumps(dict(need_mentoring=test_need_mentoring)), content_type="application/json", ) self.assertEqual(200, actual_response.status_code) self.assertDictEqual(expected_response, json.loads(actual_response.data)) self.assertEqual(test_need_mentoring, self.first_user.need_mentoring)
def delete_request(user_id: int, request_id: int): """Deletes a mentorship request. Deletes a mentorship request if the current user was the one who created it and the request is in the pending state. Args: user_id: ID of the user that is deleting a request. request_id: ID of the request. Returns: message: A message corresponding to the completed action; success if mentorship relation request is deleted, failure if otherwise. """ user = UserModel.find_by_id(user_id) request = MentorshipRelationModel.find_by_id(request_id) # verify if request exists if request is None: return messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND # verify if request is in pending state if request.state != MentorshipRelationState.PENDING: return messages.NOT_PENDING_STATE_RELATION, HTTPStatus.BAD_REQUEST # verify if user created the mentorship request if request.action_user_id != user_id: return messages.CANT_DELETE_UNINVOLVED_REQUEST, HTTPStatus.BAD_REQUEST # All was checked request.delete_from_db() return messages.MENTORSHIP_RELATION_WAS_DELETED_SUCCESSFULLY, HTTPStatus.OK
def confirm_registration(token: str): """ Determines whether a user's email registration has been confirmed. Determines whether a user's email registration was invalid, previously confirmed, or just confirmed. Arguments: token: Serialized and signed email address as a URL safe string. Returns: A message that indicates if the confirmation was invalid, already happened, or just happened, and the HTTP response code. """ email_from_token = confirm_token(token) if not email_from_token or email_from_token is None: return messages.EMAIL_EXPIRED_OR_TOKEN_IS_INVALID, HTTPStatus.BAD_REQUEST user = UserModel.find_by_email(email_from_token) if user.is_email_verified: return messages.ACCOUNT_ALREADY_CONFIRMED, HTTPStatus.OK else: user.is_email_verified = True user.email_verification_date = datetime.now() user.save_to_db() return messages.ACCOUNT_ALREADY_CONFIRMED_AND_THANKS, HTTPStatus.OK
def reject_request(user_id: int, request_id: int): """Rejects a mentorship request. Args: user_id: ID of the user rejecting the request. request_id: ID of the request to be rejected. Returns: message: A message corresponding to the completed action; success if mentorship relation request is rejected, failure if otherwise. """ user = UserModel.find_by_id(user_id) request = MentorshipRelationModel.find_by_id(request_id) # verify if request exists if request is None: return messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND # verify if request is in pending state if request.state != MentorshipRelationState.PENDING: return messages.NOT_PENDING_STATE_RELATION, HTTPStatus.BAD_REQUEST # verify if I'm the receiver of the request if request.action_user_id == user_id: return messages.USER_CANT_REJECT_REQUEST_SENT_BY_USER, HTTPStatus.BAD_REQUEST # verify if I'm involved in this relation if not (request.mentee_id == user_id or request.mentor_id == user_id): return messages.CANT_REJECT_UNINVOLVED_RELATION_REQUEST, HTTPStatus.BAD_REQUEST # All was checked request.state = MentorshipRelationState.REJECTED request.save_to_db() return messages.MENTORSHIP_RELATION_WAS_REJECTED_SUCCESSFULLY, HTTPStatus.OK
def cancel_relation(user_id: int, relation_id: int): """Allows a given user to terminate a particular relationship. Args: user_id: ID of the user terminating the relationship. relation_id: ID of the relationship. Returns: message: A message corresponding to the completed action; success if mentorship relation is terminated, failure if otherwise. """ user = UserModel.find_by_id(user_id) request = MentorshipRelationModel.find_by_id(relation_id) # verify if request exists if request is None: return messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND # verify if request is in pending state if request.state != MentorshipRelationState.ACCEPTED: return messages.UNACCEPTED_STATE_RELATION, HTTPStatus.BAD_REQUEST # verify if I'm involved in this relation if not (request.mentee_id == user_id or request.mentor_id == user_id): return messages.CANT_CANCEL_UNINVOLVED_REQUEST, HTTPStatus.BAD_REQUEST # All was checked request.state = MentorshipRelationState.CANCELLED request.save_to_db() return messages.MENTORSHIP_RELATION_WAS_CANCELLED_SUCCESSFULLY, HTTPStatus.OK
def get_histroy(firebase_id: str): try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 role = 0 if user.is_donor else 1 if user.is_recipient else 2 reserved_applications = list() if user.is_donor: reserved_applications = user.reserved_as_donor elif user.is_moderator: reserved_applications = user.reserved_as_moderator else: applications = user.application for app in applications: reserved_applications = app.reserved application_list = list() for reserved in reserved_applications: if reserved.is_active == False: application = ApplicationModel.find_by_id(reserved.application_id) application_data = application.json() history_application = dict() history_application["recipient_name"] = application_data["applicant_first_name"] + " " + application_data["applicant_last_name"] history_application["moderator_name"] = reserved.moderator.name history_application["donor_name"] = reserved.donor.name history_application["amount"] = reserved.amount history_application["donation_date"] = reserved.donation_date application_list.append(history_application) return {"role": role, "history": application_list }, 200
def accept_request(user_id: int, request_id: int): """Allows a mentorship request. Args: user_id: ID of the user accepting the request. request_id: ID of the request to be accepted. Returns: message: A message corresponding to the completed action; success if mentorship relation request is accepted, failure if otherwise. """ user = UserModel.find_by_id(user_id) request = MentorshipRelationModel.find_by_id(request_id) # verify if request exists if request is None: return messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND # verify if request is in pending state if request.state != MentorshipRelationState.PENDING: return messages.NOT_PENDING_STATE_RELATION, HTTPStatus.BAD_REQUEST # verify if I'm the receiver of the request if request.action_user_id == user_id: return messages.CANT_ACCEPT_MENTOR_REQ_SENT_BY_USER, HTTPStatus.BAD_REQUEST # verify if I'm involved in this relation if not (request.mentee_id == user_id or request.mentor_id == user_id): return messages.CANT_ACCEPT_UNINVOLVED_MENTOR_RELATION, HTTPStatus.BAD_REQUEST my_requests = user.mentee_relations + user.mentor_relations # verify if I'm on a current relation for my_request in my_requests: if my_request.state == MentorshipRelationState.ACCEPTED: return messages.USER_IS_INVOLVED_IN_A_MENTORSHIP_RELATION, HTTPStatus.BAD_REQUEST mentee = request.mentee mentor = request.mentor # If I am mentor : Check if the mentee isn't in any other relation already if user_id == mentor.id: mentee_requests = mentee.mentee_relations + mentee.mentor_relations for mentee_request in mentee_requests: if mentee_request.state == MentorshipRelationState.ACCEPTED: return messages.MENTEE_ALREADY_IN_A_RELATION, HTTPStatus.BAD_REQUEST # If I am mentee : Check if the mentor isn't in any other relation already else: mentor_requests = mentor.mentee_relations + mentor.mentor_relations for mentor_request in mentor_requests: if mentor_request.state == MentorshipRelationState.ACCEPTED: return messages.MENTOR_ALREADY_IN_A_RELATION, HTTPStatus.BAD_REQUEST # All was checked request.state = MentorshipRelationState.ACCEPTED request.save_to_db() return messages.MENTORSHIP_RELATION_WAS_ACCEPTED_SUCCESSFULLY, HTTPStatus.OK
def delete_task(user_id: int, mentorship_relation_id: int, task_id: int): """Deletes a specified task from a mentorship relation. Deletes a task that belongs to a user who is involved in the specified mentorship relation. Args: user_id: The id of the user. mentorship_relation_id: The id of the mentorship relation. task_id: The id of the task. Returns: A two element list where the first element is a dictionary containing a key 'message' indicating in its value if the task was deleted successfully or not as a string. The last element is the HTTP response code. """ user = UserModel.find_by_id(user_id) relation = MentorshipRelationModel.find_by_id(mentorship_relation_id) if relation is None: return messages.MENTORSHIP_RELATION_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND task = relation.tasks_list.find_task_by_id(task_id) if task is None: return messages.TASK_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND if not (user_id == relation.mentee_id or user_id == relation.mentor_id): return messages.USER_NOT_INVOLVED_IN_THIS_MENTOR_RELATION, HTTPStatus.UNAUTHORIZED relation.tasks_list.delete_task(task_id) return messages.TASK_WAS_DELETED_SUCCESSFULLY, HTTPStatus.OK
def list_tasks(user_id: int, mentorship_relation_id: int): """Retrieves all tasks of a user in a mentorship relation. Lists all tasks from a mentorship relation for the specified user if the user is involved in a current mentorship relation. Args: user_id: The id of the user. mentorship_relation_id: The id of the mentorship relation. Returns: A list containing all the tasks one user has in a mentorship relation. otherwise, it returns a two element list where the first element is a dictionary containing a key 'message' indicating in its value if there were any problem finding user's tasks in the specified mentorship relation as a string. The last element is the HTTP response code """ user = UserModel.find_by_id(user_id) relation = MentorshipRelationModel.find_by_id(mentorship_relation_id) if relation is None: return messages.MENTORSHIP_RELATION_DOES_NOT_EXIST, HTTPStatus.NOT_FOUND if not (user_id == relation.mentee_id or user_id == relation.mentor_id): return messages.USER_NOT_INVOLVED_IN_THIS_MENTOR_RELATION, HTTPStatus.UNAUTHORIZED all_tasks = relation.tasks_list.tasks return all_tasks
def test_change_password_to_current_password(self): self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.first_user.is_email_verified = True self.first_user.need_mentoring = True db.session.add(self.first_user) db.session.commit() auth_header = get_test_request_header(self.first_user.id) expected_response = messages.USER_ENTERED_CURRENT_PASSWORD actual_response = self.client.put( "/user/change_password", follow_redirects=True, headers=auth_header, data=json.dumps( dict(current_password=user1["password"], new_password=user1["password"])), content_type="application/json", ) self.assertEqual(400, actual_response.status_code) self.assertDictEqual(expected_response, json.loads(actual_response.data))
def get_user_statistics(user_id: int): """Shows some basic user statistics Gets the following statistics of the user: -> Pending Requests -> Accepted Requests -> Rejected Requests -> Completed Relations -> Cancelled Relations -> Up to 3 recent achievements Args: user_id: The id of the user for whom stats are requested Returns: A dict containing the stats (if the user ID is valid) If user ID is invalid, returns None """ user = UserModel.find_by_id(user_id) if not user: return None all_relations = user.mentor_relations + user.mentee_relations ( pending_requests, accepted_requests, rejected_requests, completed_relations, cancelled_relations, ) = (0, 0, 0, 0, 0) for relation in all_relations: if relation.state == MentorshipRelationState.PENDING: pending_requests += 1 elif relation.state == MentorshipRelationState.ACCEPTED: accepted_requests += 1 elif relation.state == MentorshipRelationState.REJECTED: rejected_requests += 1 elif relation.state == MentorshipRelationState.COMPLETED: completed_relations += 1 elif relation.state == MentorshipRelationState.CANCELLED: cancelled_relations += 1 achievements = UserDAO.get_achievements(user_id) if achievements: # We only need the first three of these achievements achievements = achievements[0:3] sorted(achievements, key=itemgetter("created_at")) response = { "name": user.name, "pending_requests": pending_requests, "accepted_requests": accepted_requests, "rejected_requests": rejected_requests, "completed_relations": completed_relations, "cancelled_relations": cancelled_relations, "achievements": achievements, } return response
def test_get_achievements(self): dao = UserDAO() mentor = UserModel("Test mentor", "test_mentor", "test_password", "*****@*****.**", True) mentee = UserModel("Test mentee", "test_mentee", "test_password", "*****@*****.**", True) mentor.is_email_verified = True mentor.available_to_mentor = True mentee.is_email_verified = True mentee.need_mentoring = True db.session.add(mentor) db.session.add(mentee) db.session.commit() start_date = datetime.datetime.now() end_date = start_date + datetime.timedelta(weeks=4) tasks_list = TasksListModel() tasks_list.add_task( description="Test Task", created_at=start_date.timestamp(), is_done=True, completed_at=end_date.timestamp(), ) tasks_list.add_task( description="Test Task 2", created_at=start_date.timestamp(), is_done=True, completed_at=end_date.timestamp(), ) relation = MentorshipRelationModel( action_user_id=mentee.id, mentor_user=mentor, mentee_user=mentee, creation_date=start_date.timestamp(), end_date=end_date.timestamp(), state=MentorshipRelationState.ACCEPTED, tasks_list=tasks_list, notes="Test Notes", ) db.session.add(tasks_list) db.session.add(relation) db.session.commit() achievements = dao.get_achievements(mentee.id) self.assertEqual(2, len(achievements)) for achievement in achievements: self.assertTrue(achievement.get("is_done"))
def setUp(self): db.create_all() self.first_user = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) self.second_user = UserModel( name=user2["name"], email=user2["email"], username=user2["username"], password=user2["password"], terms_and_conditions_checked=user2["terms_and_conditions_checked"], ) self.notes_example = "description of a good mentorship relation" now_datetime = datetime.now() self.start_date_example = datetime(year=now_datetime.year + 1, month=3, day=1).timestamp() self.end_date_example = datetime(year=now_datetime.year + 1, month=5, day=1).timestamp() self.now_datetime = datetime.now().timestamp() db.session.add(self.first_user) db.session.add(self.second_user) db.session.commit() self.mentorship_relation = MentorshipRelationModel( action_user_id=self.first_user.id, mentor_user=self.first_user, mentee_user=self.second_user, creation_date=self.now_datetime, end_date=self.end_date_example, state=MentorshipRelationState.PENDING, notes=self.notes_example, tasks_list=TasksListModel(), ) db.session.add(self.mentorship_relation) db.session.commit()
def test_dao_assign_admin_role_to_admin_user(self): dao = AdminDAO() user = UserModel( name=user1["name"], username=user1["username"], email=user1["email"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) user.save_to_db() user = UserModel.query.filter_by(id=2).first() self.assertFalse(user.is_admin) user.is_admin = True user.save_to_db() self.assertTrue(user.is_admin) data = dict(user_id=2) dao_result = dao.assign_new_user(1, data) self.assertEqual((messages.USER_IS_ALREADY_AN_ADMIN, 400), dao_result)
def dashboard(firebase_id: str): try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 role = "donor" if user.is_donor else "recipient" if user.is_recipient else "moderator" return {"message": role}, 200
def setUp(self): super(TestListAdminUsersApi, self).setUp() self.admin_user_2 = UserModel( name=test_admin_user_2["name"], email=test_admin_user_2["email"], username=test_admin_user_2["username"], password=test_admin_user_2["password"], terms_and_conditions_checked=test_admin_user_2[ "terms_and_conditions_checked" ], ) self.admin_user_3 = UserModel( name=test_admin_user_3["name"], email=test_admin_user_3["email"], username=test_admin_user_3["username"], password=test_admin_user_3["password"], terms_and_conditions_checked=test_admin_user_3[ "terms_and_conditions_checked" ], ) self.normal_user_1 = UserModel( name=user1["name"], email=user1["email"], username=user1["username"], password=user1["password"], terms_and_conditions_checked=user1["terms_and_conditions_checked"], ) # creating 3 admin users(first admin user created by basetestcase setup) and 1 normal user self.admin_user_2.is_email_verified = True self.admin_user_3.is_email_verified = True self.normal_user_1.is_email_verified = True self.admin_user_2.is_admin = True self.admin_user_3.is_admin = True self.normal_user_1.is_admin = False db.session.add(self.admin_user_2) db.session.add(self.admin_user_3) db.session.add(self.normal_user_1) db.session.commit()
def update_profile_image(firebase_id: str, image_url: str): try: user = UserModel.find_by_firebase_id(firebase_id) except Exception as e: return messages.CANNOT_FIND_USER, 400 user.profile_image = image_url user.save_to_db() return {"message": "Image updated successfully"}, 200