def get_reqeusts(valid_data: Dict, user: User) -> Result[List[Dict], HttpError]:
if not valid_data:
return Ok([request_converter.to_dict(r) for r in Request.objects.filter(customer=user)])
radius = valid_data.get('radius')
lat = valid_data.get('lat')
long = valid_data.get('long')
finished = valid_data.get('finished')
assigned = valid_data.get('assigned')
starts_after = valid_data.get('starts_after')
if starts_after is not None:
starts_after = datetime.fromtimestamp(starts_after)
filters = dict_filter({
'finished': finished,
'start_time__gte': starts_after,
})
if assigned is not None:
filters['assigned_to__isnull'] = not assigned
request_query = Request.objects.filter(**filters)
if radius is None or lat is None or long is None:
return Ok([request_converter.to_dict(r) for r in request_query])
return Ok([
request_converter.to_dict(r) for r in request_query if
haversine((lat, long), (r.latitude, r.longitude)) <= radius
])
def find_job(valid_data: Dict, user: User):
data = {key + 'itude' if key in ('lat', 'long') else key: val for key, val in
valid_data.items()}
job = Request.objects.find_job(user, **data)
if job:
return Ok(request_converter.to_dict(job.value))
return Ok(None)
def delete_note(self, note_id: uuid.UUID) -> Result[uuid.UUID, str]:
if not self.get_note(note_id):
return Err(f"Note {note_id} does not exist")
c = self.connection.cursor()
c.execute("DELETE FROM notes WHERE note_id=%s", (str(note_id),))
self.connection.commit()
return Ok(note_id)
def delete_course(self, course_code: str) -> Result[str, str]:
if not self.get_course(course_code):
return Err(f"Course {course_code} does not exist")
c = self.connection.cursor()
c.execute("DELETE FROM courses WHERE course_code=%s", (course_code,))
self.connection.commit()
return Ok(course_code)
def delete_comment(self, comment_id: uuid.UUID) -> Result[uuid.UUID, str]:
if not self.get_comment(comment_id):
return Err(f"Comment {comment_id} does not exist")
c = self.connection.cursor()
c.execute("DELETE FROM comments WHERE comment_id=%s", (str(comment_id),))
self.connection.commit()
return Ok(comment_id)
def test_delete_note(schema, success):
context = MagicMock()
note_id = uuid4()
error = Err(fake.pystr())
context.user = fake_instructor()
context.api.meeting_api.delete_note.return_value = Ok(
note_id) if success else error
query = """
mutation deleteNote($noteId: UUID!) {
deleteNote(noteId: $noteId) {
noteId
}
}
"""
result = schema.execute(query,
context=context,
variables={"noteId": str(note_id)})
if success:
assert not result.errors
assert result.data["deleteNote"] == {"noteId": str(note_id)}
else:
assert error.unwrap_err() in str(result.errors)
context.api.meeting_api.delete_note.assert_called_once_with(
note_id, context.user)
def test_create_note(schema, success):
note = next(fake_note())
error = Err(fake.pystr())
context = MagicMock()
context.api.meeting_api.create_note.return_value = Ok(
note) if success else error
query = """
mutation createNote($meetingId: UUID!, $contentText: String!) {
createNote(meetingId: $meetingId, contentText: $contentText) {
noteId
meetingId
timeStamp
contentText
}
}
"""
variables = {
"meetingId": str(note.meeting_id),
"contentText": note.content_text
}
result = schema.execute(query, context=context, variables=variables)
if success:
assert not result.errors
for attr, val in result.data["createNote"].items():
expected = getattr(note, to_snake_case(attr))
if isinstance(expected, UUID):
expected = str(expected)
assert expected == val
else:
assert error.unwrap_err() in str(result.errors)
context.api.meeting_api.create_note.assert_called_once_with(
note.meeting_id, context.user, note.content_text)
def create_comment(self, comment: Comment) -> Result[Comment, str]:
if self.get_comment(comment.comment_id):
return Err(f"Comment {comment} already exists")
elif not self.get_meeting(comment.meeting_id):
return Err(f"Meeting {comment.meeting_id} does not exist")
else:
c = self.connection.cursor()
if isinstance(comment.author, Instructor):
term = (
str(comment.comment_id),
str(comment.meeting_id),
comment.author.user_name,
None,
comment.time_stamp,
comment.content_text,
)
else:
term = (
str(comment.comment_id),
str(comment.meeting_id),
None,
comment.author.student_number,
comment.time_stamp,
comment.content_text,
)
c.execute(
"INSERT INTO comments(comment_id, meeting_id, author_if_instructor,"
" author_if_student, time_stamp, content_text) "
"VALUES (%s, %s, %s, %s, %s, %s)",
term,
)
self.connection.commit()
return Ok(comment)
def test(host="1.1.1.1", port=53, timeout=3) -> Result[None, str]:
try:
socket.setdefaulttimeout(timeout)
socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
return Ok(None)
except OSError err:
return Err(f'No internet connection availiable. {err.strerror} ({err.errno})')
def create_request(valid_data: Dict, user: User):
try:
request = Request.objects.create_request(user, **valid_data)
except ValidationError as e:
return Err(HttpError(400, '\n'.join(e.messages)))
else:
return Ok(request)
def assign_worker(valid_data: Dict, user: User):
worker_id = valid_data.get('worker_id')
if worker_id is not None:
try:
worker = User.objects.get(id=worker_id)
except (OverflowError, User.DoesNotExist):
return Err(HttpError(404, f'Worker with ID {worker_id} does not exist'))
else:
worker = user
request_id = valid_data['request_id']
try:
request = Request.objects.get(id=request_id)
except (OverflowError, Request.DoesNotExist):
return Err(HttpError(404, f'Request with ID {request_id} does not exist'))
if request.finished:
return Err(HttpError(400, f'Request with ID {request_id} is already finished'))
if request.assigned_to is not None:
return Err(HttpError(400, f'Request with ID {request_id} is already assigned'))
if worker == request.customer:
return Err(HttpError(400, 'Cannot assign yourself to your own request'))
if user != worker and request.customer != user:
return Err(HttpError(403, "Cannot assign a worker to someone else's request"))
request.assigned_to = worker
request.save()
return Ok(request)
def find_worker(request_id, user: User):
parsed_id = validate_int(request_id)
if not parsed_id:
return Err(HttpError(400, f'{request_id} is not a valid request ID'))
request_id = parsed_id.value
try:
request = Request.objects.get(id=request_id)
except (OverflowError, Request.DoesNotExist):
return Err(HttpError(404, f'Request with {request_id} does not exist'))
if request.customer != user:
return Err(HttpError(403, 'You cannot find a worker for another customer\'s request'))
worker = Request.objects.find_worker(request)
if worker:
return Ok(user_converter.to_dict(worker.value))
return Ok(None)
def test_success(self, mock_course_presistence):
course_api = CourseApi(mock_course_presistence)
course = fake_course()
mock_course_presistence.create_course = MagicMock(
return_value=Ok(course))
assert course_api.create_course(course.course_code).unwrap() == course
mock_course_presistence.create_course.assert_called_once_with(course)
def delete_meeting(self, meeting_id: uuid.UUID) -> Result[uuid.UUID, str]:
if not self.get_meeting(meeting_id):
return Err(f"Meeting {meeting_id} does not exist")
c = self.connection.cursor()
c.execute("DELETE FROM meetings WHERE meeting_id=%s", (str(meeting_id),))
self.connection.commit()
return Ok(meeting_id)
def create_course(self, course: Course) -> Result[Course, str]:
if self.get_course(course.course_code):
return Err(f"Course {course} already exists")
c = self.connection.cursor()
term = (course.course_code,)
c.execute("INSERT INTO courses VALUES (%s)", term)
self.connection.commit()
return Ok(course)
def delete_student(self, student: Student) -> Result[Student, str]:
if not self.get_student(student.student_number):
return Err(f"Student {student} does not exist")
c = self.connection.cursor()
term = (student.student_number, )
c.execute("DELETE FROM students WHERE student_number=%s", term)
self.connection.commit()
return Ok(student)
def test_delete_meeting(meeting_api, success, user_type):
meeting = next(fake_meeting())
error = Err(fake.pystr())
meeting_api.meeting_persistence.delete_meeting.return_value = (Ok(
meeting.meeting_id) if success else error)
meeting_api._check_meeting_user = MagicMock(return_value=Ok(None))
user = meeting.instructor if user_type == "instructor" else meeting.student
result = meeting_api.delete_meeting(meeting.meeting_id, user)
if success:
assert result.unwrap() == meeting.meeting_id
else:
assert result == error
meeting_api._check_meeting_user.assert_called_once_with(
meeting.meeting_id, user,
"Cannot delete meeting that you are not a part of")
meeting_api.meeting_persistence.delete_meeting.assert_called_once_with(
meeting.meeting_id)
def test_verify_token(instructor_api, instructor_found):
token = fake.sha256()
instructor = fake_instructor()
instructor_api.jwt_authenticator.verify_token.return_value = Ok(
{"id": instructor.user_name})
if instructor_found:
instructor_api.get_instructor = MagicMock(
return_value=Some(instructor))
assert instructor_api.verify_instructor_by_token(token) == Ok(
instructor)
else:
instructor_api.get_instructor = MagicMock(return_value=NONE)
assert instructor_api.verify_instructor_by_token(token) == Err(
"UNAUTHORIZED - Could not get instructor")
instructor_api.jwt_authenticator.verify_token.assert_called_once_with(
token)
instructor_api.get_instructor.assert_called_once_with(instructor.user_name)
def validate_json(json_data: Json, schema: Dict, *args,
**kwargs) -> Result[Json, str]:
"""Validate a JSON value"""
try:
validate(json_data, schema, *args, **kwargs)
except ValidationError as e:
return Err(e.message)
return Ok(json_data)
class FakeApp(App):
def create_user(self, post_json: dict) -> Result[str, str]:
pass
def get_token(self, user_identity, password) -> Result[str, str]:
pass
authenticate_user_by_token = MagicMock(return_value=Ok(None))
def update_password_hash(self, user_identity: str,
new_hash: str) -> Result[None, str]:
c = self.connection.cursor()
term = (new_hash, user_identity)
c.execute("UPDATE instructors SET password_hash=%s WHERE user_name=%s",
term)
self.connection.commit()
return Ok(None)
def delete_instructor(self,
instructor: Instructor) -> Result[Instructor, str]:
if not self.get_instructor(instructor.user_name):
return Err(f"Instructor {instructor} does not exist")
c = self.connection.cursor()
term = (instructor.user_name, )
c.execute("DELETE FROM instructors WHERE user_name=%s", term)
self.connection.commit()
return Ok(instructor)
def delete_officehour(self, office_hour_id: UUID,
mp: MeetingPersistence) -> Result[UUID, str]:
if not self.get_officehour(office_hour_id, mp):
return Err(f"OfficeHour {office_hour_id} does not exist")
c = self.connection.cursor()
c.execute("DELETE FROM officehours WHERE office_hour_id=%s",
(office_hour_id, ))
self.connection.commit()
return Ok(office_hour_id)
def enroll_student(self, section: Section,
student_number: str) -> Result[str, str]:
c = self.connection.cursor()
term = (student_number, section.identity().to_string())
c.execute(
"INSERT INTO enrollment(student_number, section_id) VALUES (%s, %s)",
term)
self.connection.commit()
return Ok(student_number)
def _check_meeting_user(self, meeting_id: UUID, user: User,
error_msg: str) -> Result[None, str]:
meeting_result = self.meeting_persistence.get_meeting(meeting_id)
if not meeting_result:
return Err(f"Meeting with ID: '{meeting_id}' does not exist")
meeting = meeting_result.unwrap()
if user not in (meeting.instructor, meeting.student):
return Err(error_msg)
return Ok(None)
def test_verify_password_success_with_update(password_authenticator):
user_id, password = fake.pystr(), fake.pystr()
expected_hash = fake.sha256()
new_hash = fake.sha256()
password_authenticator.authentication_persistence.get_password_hash = MagicMock(
return_value=Ok(expected_hash))
password_authenticator.authentication_persistence.update_password_hash = MagicMock(
return_value=Ok(None))
password_authenticator.crypto_context.verify_and_update = MagicMock(
return_value=(True, new_hash))
assert password_authenticator.verify_password(user_id,
password).unwrap() is None
password_authenticator.authentication_persistence.get_password_hash.assert_called_once_with(
user_id)
password_authenticator.authentication_persistence.update_password_hash.assert_called_once_with(
user_id, new_hash)
password_authenticator.crypto_context.verify_and_update.assert_called_once_with(
password, expected_hash)
def get_password_hash(self, user_identity: str) -> Result[str, str]:
c = self.connection.cursor()
term = (user_identity, )
c.execute("SELECT * FROM instructors WHERE user_name=%s", term)
res = c.fetchone()
if res:
pass_hash = res[2]
return Ok(pass_hash)
else:
return Err(f"Instructor {user_identity} does not exist")
def test_get_token(instructor_api, success):
error = Err(fake.pystr())
password = fake.pystr()
token = fake.sha256()
user_name = fake.pystr()
instructor_api.password_authenticator.verify_password.return_value = (
Ok(None) if success else error)
instructor_api.jwt_authenticator.generate_token.return_value = token
result = instructor_api.get_token(user_name, password)
if success:
assert result == Ok(token)
instructor_api.jwt_authenticator.generate_token.assert_called_once_with(
user_name)
else:
assert result == error
instructor_api.jwt_authenticator.generate_token.assert_not_called()
instructor_api.password_authenticator.verify_password.assert_called_once_with(
user_name, password)
def get_password_hash(self, user_identity: str) -> Result[str, str]:
c = self.connection.cursor()
term = (user_identity, )
c.execute("SELECT * FROM students WHERE student_number=%s", term)
pass_hash = None
res = c.fetchone()
if res:
pass_hash = res[2]
else:
return Err(f"Student {user_identity} does not exist")
return Ok(pass_hash)
def test_create_course(schema, mock_context, create_course_query):
context, course_api, instructor_api = mock_context
course = fake_course()
course_api.create_course = MagicMock(return_value=Ok(course))
result = schema.execute(
create_course_query,
variables={"courseCode": course.course_code},
context=context,
)
assert not result.errors
assert result.data == {"createCourse": {"courseCode": course.course_code}}
course_api.create_course.assert_called_once_with(course.course_code)