def post(self) -> Response:
"""
POST response method for enrolling in a course.
:return: JSON object
"""
data = request.get_json()
user_id=get_jwt_identity()
if Courses.objects(id=data["courseId"], students=ObjectId(user_id)):
return conflict("You cannot enrol in the same course twice!")
try:
enroll = Courses.objects(id=data["courseId"]).update(push__students=ObjectId(user_id))
if enroll == 0:
return not_found("404 Error: The requested course does not exist")
except InvalidId as e:
print(e.__class__.__name__)
print(dir(e))
return bad_request(str(e))
except ValidationError as e:
return bad_request(e.message)
output = {'id': user_id}
return jsonify(output)
def post(self) -> Response:
"""
POST response method for endorsing a course.
:return: JSON object
"""
data = request.get_json()
user_id=get_jwt_identity()
course_id = data["courseId"]
authorized: bool = Users.objects.get(id=user_id).roles.organization
if authorized:
# don't let an organization endorse the same course twice
if Courses.objects(id=course_id, endorsedBy=ObjectId(user_id)):
return conflict("You already endorsed this course!")
# add the organization the course's endorsedBy list
try:
endorse = Courses.objects(id=course_id).update(push__endorsedBy=ObjectId(user_id))
if endorse == 0:
return not_found("404 Error: The requested course does not exist")
except InvalidId as e:
print(e.__class__.__name__)
print(dir(e))
return bad_request(str(e))
except ValidationError as e:
return bad_request(e.message)
output = {'id': user_id}
return jsonify(output)
else:
return forbidden()
def get(self) -> Response:
"""
GET response method for single documents in course collection.
:return: JSON object
"""
student_id=get_jwt_identity()
output = Courses.objects(students=student_id)
fields = { 'id', 'name' }
converted = convert_query(output, fields)
return jsonify(converted)
def post(self) -> Response:
"""
POST response method for creating a quiz submission.
JSON Web Token is required.
Student must be in the course.
Student may only have one submission per quiz.
"""
user = get_jwt_identity()
data = request.get_json()
quiz_id = data['quiz']
# already a submission from this user
if len(Submissions.objects(quiz=quiz_id, user=user)) != 0:
return forbidden()
# quiz doesn't exist
try:
quiz = Quizzes.objects.get(id=quiz_id)
course = Courses.objects.get(id=quiz.course.id)
except DoesNotExist as e:
return not_found()
# student must be enrolled in the course of the quiz
courses = Courses.objects(students=user)
if course not in courses:
return forbidden()
# student is in course and has not submitted
# generate the answer key
answer_key = {}
for question in quiz.quizQuestions:
answer_key[question.index] = question.answer
# compare answer key to student responses
student_responses = data['answers']
grade = 0
for response in student_responses:
index = response['question']
if index in answer_key and answer_key[index] == response['answer']:
grade += 1
try:
data['user'] = user
data['grade'] = grade
submission = Submissions(**data).save()
except ValidationError as e:
return bad_request(e.to_dict())
output = {'id': str(submission.id)}
return jsonify(output)
def get(self) -> Response:
"""
GET response method for all documents in course collection with published=true.
:return: JSON object
"""
output = Courses.objects(published=True)
fields = {
'id',
'name',
'objective'
}
embedded = {'instructor': {'name': 'instructor'}}
converted = convert_embedded_query(output, fields, embedded)
return jsonify(converted)
def get(self) -> Response:
"""
GET response method for single documents in course collection.
:return: JSON object
"""
query = Courses.objects(instructor=get_jwt_identity())
fields = {
'id',
'name',
'objective',
'learningOutcomes',
'published',
}
values = convert_query(query, fields)
return jsonify(values)
def get(self) -> Response:
"""
GET response method for returning all courses endorsed by an npo
:return: JSON object
"""
user_id = get_jwt_identity()
query = Courses.objects(endorsedBy=user_id)
fields = {
'id',
'name'
}
values = convert_query(query, fields)
return jsonify(values)
def post(self) -> Response:
"""
POST response method for creating a course.
JSON Web Token is required.
Authorization is required: Access(admin=true)
"""
authorized: bool = True #Users.objects.get(id=get_jwt_identity()).access.admin
if authorized:
data = request.get_json()
# get the instructor id based off of jwt token identity
data['instructor'] = get_jwt_identity()
try:
course = Courses(**data).save()
except ValidationError as e:
return bad_request(e.to_dict())
output = {'id': str(course.id)}
return jsonify(output)
else:
return forbidden()
def get(self, course_id: str) -> Response:
"""
GET response method a list of organizations endorsing a course.
:return: JSON object
"""
# get the course
try:
course = Courses.objects().get(id=course_id)
except DoesNotExist:
return not_found("404 Error: The requested course does not exist")
# get the names and pictures of the organizations endorsing the course
orgs = []
for org in course.endorsedBy:
img_b64 = base64.b64encode(org.image.thumbnail.read())
org_json = { 'name': org.name, 'image': img_b64.decode('utf-8') }
orgs.append(org_json)
return jsonify(orgs)
def delete(self, course_id: str) -> Response:
"""
DELETE response method for disenrolling in a course.
:return: JSON object
"""
user_id=get_jwt_identity()
try:
disenroll = Courses.objects(id=course_id).update(pull__students=ObjectId(user_id))
if disenroll == 0:
return not_found("404 Error: The requested course does not exist")
except InvalidId as e:
print(e.__class__.__name__)
print(dir(e))
return bad_request(str(e))
except ValidationError as e:
return bad_request(e.message)
output = {'id': user_id}
return jsonify(output)
def delete(self, course_id: str) -> Response:
"""
DELETE response method for deleting single course.
JSON Web Token is required.
Authorization is required: Access(admin=true)
"""
queryCourse = Courses.objects.get(id=course_id)
user = get_jwt_identity()
# only the course instructor can delete courses
authorized: bool = queryCourse['instructor']['id'] == ObjectId(user)
# or an admin
authorized = authorized or Users.objects.get(id=user).roles.admin
if authorized:
output = Courses.objects(id=course_id).delete()
if output == 0:
return not_found()
else:
return jsonify(output)
else:
return forbidden()
def get(self) -> Response:
"""
GET response method for all documents in course collection.
JSON Web Token is required.
"""
authorized: bool = True #Users.objects.get(id=get_jwt_identity()).access.admin
if authorized:
query = Courses.objects()
fields = {
'id',
'name',
'objective',
'learningOutcomes',
'published',
}
res = convert_query(query, include=fields)
return jsonify(res)
else:
return forbidden()