def test_dao_create_mentorship_relation_with_mentor_already_in_relation(self):
self.mentorship_relation = MentorshipRelationModel(
action_user_id=self.admin_user.id,
mentor_user=self.admin_user,
mentee_user=self.second_user,
creation_date=self.now_datetime.timestamp(),
end_date=self.end_date_example.timestamp(),
state=MentorshipRelationState.ACCEPTED,
notes=self.notes_example,
tasks_list=TasksListModel(),
)
db.session.add(self.mentorship_relation)
db.session.commit()
dao = MentorshipRelationDAO()
data = dict(
mentor_id=self.second_user.id,
mentee_id=self.first_user.id,
end_date=self.end_date_example.timestamp(),
notes=self.notes_example,
tasks_list=TasksListModel(),
)
# Use DAO to create a mentorship relation
result = dao.create_mentorship_relation(self.second_user.id, data)
self.assertEqual((messages.MENTOR_ALREADY_IN_A_RELATION, 400), result)
query_mentorship_relations = MentorshipRelationModel.query.all()
self.assertTrue(1, len(query_mentorship_relations))
def test_dao_list_mentorship_relation_state_none(self):
DAO = MentorshipRelationDAO()
result = DAO.list_mentorship_relations(user_id=self.first_user.id,
state=None)
expected_response = [self.mentorship_relation], 200
self.assertEqual(expected_response, result)
def test_dao_sender_does_not_exist_mentorship_request(self):
DAO = MentorshipRelationDAO()
result = DAO.accept_request(123, self.mentorship_relation.id)
self.assertEqual((messages.USER_DOES_NOT_EXIST, 404), result)
self.assertEqual(MentorshipRelationState.PENDING,
self.mentorship_relation.state)
def test_dao_list_mentorship_relation_state_invalid(self):
DAO = MentorshipRelationDAO()
result = DAO.list_mentorship_relations(user_id=self.first_user.id,
state="anything")
expected_response = [], 400
self.assertEqual(expected_response, result)
def test_dao_accept_non_existing_mentorship_request(self):
DAO = MentorshipRelationDAO()
result = DAO.accept_request(self.first_user.id, 123)
self.assertEqual(
(messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, 404), result)
self.assertEqual(MentorshipRelationState.PENDING,
self.mentorship_relation.state)
def test_dao_requester_tries_to_accept_mentorship_request(self):
DAO = MentorshipRelationDAO()
result = DAO.accept_request(self.first_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.CANT_ACCEPT_MENTOR_REQ_SENT_BY_USER, 400),
result)
self.assertEqual(MentorshipRelationState.PENDING,
self.mentorship_relation.state)
def test_dao_requester_tries_to_reject_mentorship_request(self):
DAO = MentorshipRelationDAO()
result = DAO.reject_request(self.first_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.USER_CANT_REJECT_REQUEST_SENT_BY_USER, 403),
result)
self.assertEqual(MentorshipRelationState.PENDING,
self.mentorship_relation.state)
def test_dao_receiver_accepts_mentorship_request(self):
DAO = MentorshipRelationDAO()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual(
(messages.MENTORSHIP_RELATION_WAS_ACCEPTED_SUCCESSFULLY, 200),
result)
self.assertEqual(MentorshipRelationState.ACCEPTED,
self.mentorship_relation.state)
def test_dao_list_mentorship_relation_all(self):
DAO = MentorshipRelationDAO()
self.mentorship_relation.state = MentorshipRelationState.PENDING
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.list_mentorship_relations(user_id=self.first_user.id)
expected_response = [self.mentorship_relation], 200
self.assertEqual(expected_response, result)
self.assertIsNotNone(result)
def test_dao_list_mentorship_relation_completed(self):
DAO = MentorshipRelationDAO()
self.mentorship_relation.state = MentorshipRelationState.COMPLETED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.list_mentorship_relations(
user_id=self.first_user.id,
state=self.mentorship_relation.state.name)
expected_response = [self.mentorship_relation], 200
self.assertEqual(expected_response, result)
def test_dao_sender_cancel_mentorship_request(self):
self.mentorship_relation.state = MentorshipRelationState.ACCEPTED
db.session.add(self.mentorship_relation)
db.session.commit()
DAO = MentorshipRelationDAO()
result = DAO.cancel_relation(self.first_user.id, self.mentorship_relation.id)
self.assertEqual(
(messages.MENTORSHIP_RELATION_WAS_CANCELLED_SUCCESSFULLY, 200), result
)
self.assertEqual(
MentorshipRelationState.CANCELLED, self.mentorship_relation.state
)
def test_dao_create_mentorship_relation_with_good_args_mentor_is_receiver(self):
dao = MentorshipRelationDAO()
data = dict(
mentor_id=self.first_user.id,
mentee_id=self.second_user.id,
end_date=self.end_date_example.timestamp(),
notes=self.notes_example,
tasks_list=TasksListModel(),
)
# Use DAO to create a mentorship relation
result = dao.create_mentorship_relation(self.second_user.id, data)
self.assertEqual(messages.MENTORSHIP_RELATION_WAS_SENT_SUCCESSFULLY, result[0])
query_mentorship_relation = MentorshipRelationModel.query.first()
self.assertTrue(query_mentorship_relation is not None)
self.assertEqual(1, query_mentorship_relation.id)
# asserting relation extra fields
self.assertEqual(self.second_user.id, query_mentorship_relation.action_user_id)
self.assertEqual(self.notes_example, query_mentorship_relation.notes)
# asserting dates
# asserting dates
self.assertIsNone(query_mentorship_relation.start_date)
self.assertEqual(
self.end_date_example.timestamp(), query_mentorship_relation.end_date
)
# asserting mentor and mentees setup
self.assertEqual(self.first_user.id, query_mentorship_relation.mentor_id)
self.assertEqual(self.second_user.id, query_mentorship_relation.mentee_id)
# assert mentors' mentor_relations and mentee_relations
self.assertEqual(1, len(self.first_user.mentor_relations))
self.assertEqual(query_mentorship_relation, self.first_user.mentor_relations[0])
self.assertEqual([], self.first_user.mentee_relations)
# assert mentees' mentor_relations and mentee_relations
self.assertEqual(1, len(self.second_user.mentee_relations))
self.assertEqual(
query_mentorship_relation, self.second_user.mentee_relations[0]
)
self.assertEqual([], self.second_user.mentor_relations)
def test_dao_list_current_mentorship_relation(self):
result = MentorshipRelationDAO.list_current_mentorship_relation(
user_id=self.first_user.id)
expected_response = self.future_accepted_mentorship_relation
self.assertEqual(expected_response, result)
def test_dao_create_mentorship_relation_with_good_args_but_invalid_timestamp(self):
dao = MentorshipRelationDAO()
data = dict(
mentor_id=self.first_user.id,
mentee_id=self.second_user.id,
end_date=1580338800000000,
notes=self.notes_example,
tasks_list=TasksListModel(),
)
# Use DAO to create a mentorship relation
result = dao.create_mentorship_relation(self.first_user.id, data)
self.assertEqual(messages.INVALID_END_DATE, result[0])
self.assertEqual(400, result[1])
def test_dao_list_pending_mentorship_relation(self):
result = MentorshipRelationDAO.list_pending_mentorship_relations(
user_id=self.first_user.id)
expected_response = [self.future_pending_mentorship_relation]
self.assertEqual(expected_response, result[0])
self.assertEqual(200, result[1])
def test_dao_list_past_mentorship_relations(self):
result = MentorshipRelationDAO.list_past_mentorship_relations(
user_id=self.first_user.id)
expected_response = [self.past_mentorship_relation]
self.assertIsNotNone(result[0])
self.assertEqual(expected_response, result[0])
def test_dao_sender_does_not_exist(self):
result = MentorshipRelationDAO.delete_request(
123, self.mentorship_relation.id)
self.assertEqual((messages.USER_DOES_NOT_EXIST, 404), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(
id=self.mentorship_relation.id).first())
def test_dao_mentee_user_already_in_relationship(self):
DAO = MentorshipRelationDAO()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual(
(messages.MENTORSHIP_RELATION_WAS_ACCEPTED_SUCCESSFULLY, 200),
result)
self.assertEqual(MentorshipRelationState.ACCEPTED,
self.mentorship_relation.state)
result3 = DAO.accept_request(self.third_user.id,
self.mentorship_relation3.id)
self.assertEqual((messages.MENTEE_ALREADY_IN_A_RELATION, 400), result3)
self.assertEqual(MentorshipRelationState.PENDING,
self.mentorship_relation3.state)
def test_dao_delete_non_existing_mentorship_request(self):
result = MentorshipRelationDAO.delete_request(self.first_user.id, 123)
self.assertEqual(
(messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, 404), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(
id=self.mentorship_relation.id).first())
def test_dao_receiver_tries_to_delete_mentorship_request(self):
result = MentorshipRelationDAO.delete_request(
self.second_user.id, self.mentorship_relation.id)
self.assertEqual((messages.CANT_DELETE_UNINVOLVED_REQUEST, 400),
result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(
id=self.mentorship_relation.id).first())
def test_dao_create_mentorship_relation_with_non_existent_mentee(self):
dao = MentorshipRelationDAO()
data = dict(
mentor_id=self.first_user.id,
mentee_id=1234,
end_date=self.end_date_example.timestamp(),
notes=self.notes_example,
tasks_list=TasksListModel(),
)
# Use DAO to create a mentorship relation
result = dao.create_mentorship_relation(self.first_user.id, data)
self.assertDictEqual(messages.MENTEE_DOES_NOT_EXIST, result[0])
query_mentorship_relation = MentorshipRelationModel.query.first()
self.assertIsNone(query_mentorship_relation)
def test_dao_mentorship_delete_request_not_in_pending_state(self):
relation_id = self.mentorship_relation.id
self.mentorship_relation.state = MentorshipRelationState.ACCEPTED
db.session.add(self.mentorship_relation)
db.session.commit()
result = MentorshipRelationDAO.delete_request(
self.first_user.id, self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
self.mentorship_relation.state = MentorshipRelationState.COMPLETED
db.session.add(self.mentorship_relation)
db.session.commit()
result = MentorshipRelationDAO.delete_request(
self.first_user.id, self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
self.mentorship_relation.state = MentorshipRelationState.CANCELLED
db.session.add(self.mentorship_relation)
db.session.commit()
result = MentorshipRelationDAO.delete_request(
self.first_user.id, self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
self.mentorship_relation.state = MentorshipRelationState.REJECTED
db.session.add(self.mentorship_relation)
db.session.commit()
result = MentorshipRelationDAO.delete_request(
self.first_user.id, self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
def test_dao_mentorship_request_is_not_in_pending_state(self):
DAO = MentorshipRelationDAO()
self.mentorship_relation.state = MentorshipRelationState.ACCEPTED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.COMPLETED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.CANCELLED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.REJECTED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.accept_request(self.second_user.id,
self.mentorship_relation.id)
self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
def test_dao_mentorship_cancel_relation_not_in_accepted_state(self):
DAO = MentorshipRelationDAO()
self.mentorship_relation.state = MentorshipRelationState.PENDING
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id)
self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.COMPLETED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id)
self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.CANCELLED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id)
self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result)
self.mentorship_relation.state = MentorshipRelationState.REJECTED
db.session.add(self.mentorship_relation)
db.session.commit()
result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id)
self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result)
def test_dao_sender_delete_mentorship_request(self):
relation_id = self.mentorship_relation.id
self.assertIsNotNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
result = MentorshipRelationDAO.delete_request(self.first_user.id,
relation_id)
self.assertEqual(
(messages.MENTORSHIP_RELATION_WAS_DELETED_SUCCESSFULLY, 200),
result)
self.assertIsNone(
MentorshipRelationModel.query.filter_by(id=relation_id).first())
def list_users(user_id: int,
search_query: str = "",
page: int = DEFAULT_PAGE,
per_page: int = DEFAULT_USERS_PER_PAGE,
is_verified=None):
""" Retrieves a list of verified users with the specified ID.
Arguments:
user_id: The ID of the user to be listed.
search_query: The search query for name of the users to be found.
is_verified: Status of the user's verification; None when provided as an argument.
page: The page of users to be returned
per_page: The number of users to return per page
Returns:
A list of users matching conditions and the HTTP response code.
"""
users_list = UserModel.query.filter(
UserModel.id != user_id, not is_verified
or UserModel.is_email_verified,
func.lower(UserModel.name).contains(
search_query.lower())).order_by(UserModel.id).paginate(
page=page,
per_page=per_page,
error_out=False,
max_per_page=UserDAO.MAX_USERS_PER_PAGE).items
list_of_users = [user.json() for user in users_list]
for user in list_of_users:
relation = MentorshipRelationDAO.list_current_mentorship_relation(
user["id"])
if isinstance(relation, MentorshipRelationModel):
user["is_available"] = False
else:
# we don't need if statement for this case
# is_available is true
# when either need_mentoring or available_to_mentor is true
user["is_available"] = (user["need_mentoring"]
or user["available_to_mentor"])
return list_of_users, HTTPStatus.OK
def test_dao_list_non_existing_current_mentorship_relation(self):
result = MentorshipRelationDAO.list_current_mentorship_relation(
user_id=self.admin_user.id)
expected_response = (messages.NOT_IN_MENTORED_RELATION_CURRENTLY, 200)
self.assertEqual(expected_response, result)
def get_user_dashboard(user_id):
"""
returns user dashboard: relations received. sent as mentor or mentee for all states.
Also returns all done, to be done tasks if in a relation
Args:
user_id: id of the user whose dashboard is to be returned
"""
user = UserModel.find_by_id(user_id)
if not user:
return None
response = {}
all_user_relations = user.mentee_relations + user.mentor_relations
relations_in_response_form = [
DashboardRelationResponseModel(relation)
for relation in all_user_relations
]
mentor_sent_relations = [
relation for relation in relations_in_response_form
if relation.action_user_id == user_id
and relation.mentor_id == user_id
]
mentor_received_relations = [
relation for relation in relations_in_response_form
if relation.action_user_id != user_id
and relation.mentor_id == user_id
]
mentee_sent_relations = [
relation for relation in relations_in_response_form
if relation.action_user_id == user_id
and relation.mentee_id == user_id
]
mentee_received_relations = [
relation for relation in relations_in_response_form
if relation.action_user_id != user_id
and relation.mentee_id == user_id
]
as_mentee = {
"sent": {
"accepted": [],
"rejected": [],
"completed": [],
"cancelled": [],
"pending": [],
},
"received": {
"accepted": [],
"rejected": [],
"completed": [],
"cancelled": [],
"pending": [],
},
}
as_mentor = {
"sent": {
"accepted": [],
"rejected": [],
"completed": [],
"cancelled": [],
"pending": [],
},
"received": {
"accepted": [],
"rejected": [],
"completed": [],
"cancelled": [],
"pending": [],
},
}
as_mentee["received"]["accepted"] = [
relation.response for relation in mentee_received_relations
if relation.state == MentorshipRelationState.ACCEPTED
]
as_mentee["received"]["rejected"] = [
relation.response for relation in mentee_received_relations
if relation.state == MentorshipRelationState.REJECTED
]
as_mentee["received"]["completed"] = [
relation.response for relation in mentee_received_relations
if relation.state == MentorshipRelationState.COMPLETED
]
as_mentee["received"]["cancelled"] = [
relation.response for relation in mentee_received_relations
if relation.state == MentorshipRelationState.CANCELLED
]
as_mentee["received"]["pending"] = [
relation.response for relation in mentee_received_relations
if relation.state == MentorshipRelationState.PENDING
]
as_mentor["received"]["accepted"] = [
relation.response for relation in mentor_received_relations
if relation.state == MentorshipRelationState.ACCEPTED
]
as_mentor["received"]["rejected"] = [
relation.response for relation in mentor_received_relations
if relation.state == MentorshipRelationState.REJECTED
]
as_mentor["received"]["completed"] = [
relation.response for relation in mentor_received_relations
if relation.state == MentorshipRelationState.COMPLETED
]
as_mentor["received"]["cancelled"] = [
relation.response for relation in mentor_received_relations
if relation.state == MentorshipRelationState.CANCELLED
]
as_mentor["received"]["pending"] = [
relation.response for relation in mentor_received_relations
if relation.state == MentorshipRelationState.PENDING
]
as_mentee["sent"]["accepted"] = [
relation.response for relation in mentee_sent_relations
if relation.state == MentorshipRelationState.ACCEPTED
]
as_mentee["sent"]["rejected"] = [
relation.response for relation in mentee_sent_relations
if relation.state == MentorshipRelationState.REJECTED
]
as_mentee["sent"]["completed"] = [
relation.response for relation in mentee_sent_relations
if relation.state == MentorshipRelationState.COMPLETED
]
as_mentee["sent"]["cancelled"] = [
relation.response for relation in mentee_sent_relations
if relation.state == MentorshipRelationState.CANCELLED
]
as_mentee["sent"]["pending"] = [
relation.response for relation in mentee_sent_relations
if relation.state == MentorshipRelationState.PENDING
]
as_mentor["sent"]["accepted"] = [
relation.response for relation in mentor_sent_relations
if relation.state == MentorshipRelationState.ACCEPTED
]
as_mentor["sent"]["rejected"] = [
relation.response for relation in mentor_sent_relations
if relation.state == MentorshipRelationState.REJECTED
]
as_mentor["sent"]["completed"] = [
relation.response for relation in mentor_sent_relations
if relation.state == MentorshipRelationState.COMPLETED
]
as_mentor["sent"]["cancelled"] = [
relation.response for relation in mentor_sent_relations
if relation.state == MentorshipRelationState.CANCELLED
]
as_mentor["sent"]["pending"] = [
relation.response for relation in mentor_sent_relations
if relation.state == MentorshipRelationState.PENDING
]
response["as_mentor"] = as_mentor
response["as_mentee"] = as_mentee
current_relation = MentorshipRelationDAO.list_current_mentorship_relation(
user_id=user_id)
if current_relation != (messages.NOT_IN_MENTORED_RELATION_CURRENTLY,
HTTPStatus.OK):
response["tasks_todo"] = marshal(
[
task for task in current_relation.tasks_list.tasks
if not task["is_done"]
],
list_tasks_response_body,
)
response["tasks_done"] = marshal(
[
task for task in current_relation.tasks_list.tasks
if task["is_done"]
],
list_tasks_response_body,
)
return response
COMMENT_MAX_LENGTH,
)
from app.utils.validation_utils import get_length_validation_error_message
from app.database.models.mentorship_relation import MentorshipRelationModel
from app.api.email_utils import send_email_mentorship_relation_accepted
from app.api.email_utils import send_email_new_request
mentorship_relation_ns = Namespace(
"Mentorship Relation",
description="Operations related to "
"mentorship relations "
"between users",
)
add_models_to_namespace(mentorship_relation_ns)
DAO = MentorshipRelationDAO()
userDAO = UserDAO()
@mentorship_relation_ns.route("mentorship_relation/send_request")
class SendRequest(Resource):
@classmethod
@jwt_required
@mentorship_relation_ns.doc("send_request")
@mentorship_relation_ns.expect(auth_header_parser,
send_mentorship_request_body)
@mentorship_relation_ns.response(
HTTPStatus.CREATED,
"%s" % messages.MENTORSHIP_RELATION_WAS_SENT_SUCCESSFULLY)
@mentorship_relation_ns.response(
HTTPStatus.BAD_REQUEST,
