def get_courses(self, instance):
""" Return the courses in the product """
from courses.serializers import CourseSerializer
model_class = instance.product.content_type.model_class()
if model_class is CourseRun:
# filter_products=True because the course run must have an associated product.
return [
CourseSerializer(
instance.product.content_object.course,
context={
**self.context, "filter_products": True
},
).data
]
elif model_class is Program:
courses = Course.objects.filter(
program=instance.product.content_object).order_by(
"position_in_program")
# filter_products=False because we want to show course runs even if they don't have
# products, since the product is for the program.
return CourseSerializer(courses,
many=True,
context={
**self.context, "filter_products":
False
}).data
else:
raise ValueError(f"Unexpected product for {model_class}")
def put(self, request, pk):
item = get_object_or_404(Course, pk=pk)
serializer = CourseSerializer(item, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
course = self.get_object(pk)
serializer = CourseSerializer(course, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def course_detail(request, cID):
#Retrieve, update or delete a code snippet.
try:
course = Course.objects.using('course').get(courseID=cID)
except Course.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = CourseSerializer(course)
return JSONResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = CourseSerializer(course, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
delete_enroll(cID=cID)
print "test"
course.delete(using='course')
return HttpResponse(status=204)
def handle(self, *args, **options):
succ = 0
fail = 0
file_name = options.get('file_name')
if not options.get('file_name'):
print "No Filename Specified (--file_name <FILE_NAME>)"
return
with open(COURSE_DATA_DIR + file_name[0], 'r') as f:
course_data = [parse_course_data(data) for data in f.readlines()]
print "Ingesting {0} courses".format(len(course_data))
for record_data in course_data:
serializer = CourseSerializer(data=record_data)
if serializer.is_valid():
# print serializer.validated_data
course = serializer.save()
succ += 1
print "course created: {0}".format(course.name)
else:
fail += 1
print "Course data invalid: {0}".format(serializer.errors)
print "Ingestion complete"
print "{0} courses processed".format(str(succ))
if fail:
print "Failed to ingest {0} courses".format(str(fail))
def post(self, req):
course = CourseSerializer(data=req.data)
if course.is_valid():
course.save()
return Response(status=status.HTTP_201_CREATED)
else:
return Response(status=status.HTTP_400, data=course.errors)
def put(self, req, pk):
course_obj = get_object_or_404(Course, id=pk)
serialized = CourseSerializer(instance=course_obj, data=req.data, partial=True)
if serialized.is_valid():
serialized.save()
return Response(status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_400_BAD_REQUEST, data=serialized.errors)
def put(self, request, course_id=None):
if not course_id:
return Response('no course_id supplied', status=400)
course = self.queryset.get(course_id=course_id)
serializer = CourseSerializer(data=request.data.copy(), instance=course)
serializer.is_valid(raise_exception=True)
course = serializer.save()
return Response(serializer.data)
def get(self, request, course_id=None):
if course_id:
print course_id
course = self.queryset.get(course_id=course_id)
serializer = CourseSerializer(course)
else:
course = self.queryset.all()
serializer = CourseSerializer(course, many=True)
return Response(serializer.data)
def post(self, request):
course_data = request.data.copy()
print course_data
if not course_data.get('course_id'):
course_data['course_id'] = randint(10000, 99999)
serializer = CourseSerializer(data=course_data)
serializer.is_valid(raise_exception=True)
course = serializer.save()
return Response(serializer.data)
def get(self, request, *args, **kwargs):
user = self.request.user
return Response({
'user':
UserSerializer(user, context=self.get_serializer_context()).data,
'instructor_courses':
CourseSerializer(user.instructor_courses.all(), many=True).data,
'ta_courses':
CourseSerializer(user.ta_courses.all(), many=True).data,
'student_courses':
CourseStudentSerializer(user.student_courses.all(), many=True).data
})
def get_student_dict(school, student, semester):
""" Return serialized representation of a student. """
user_dict = {
'timeAcceptedTos': None,
'isLoggedIn': False,
'timetables': [],
'courses': []
}
if student is not None:
user_dict = dict(user_dict, **StudentSerializer(student).data)
user_dict['isLoggedIn'] = True
timetables = student.personaltimetable_set.filter(
school=school, semester=semester).order_by('-last_updated')
courses = {
course
for timetable in timetables for course in timetable.courses.all()
}
context = {'semester': semester, 'school': school, 'student': student}
user_dict['timetables'] = DisplayTimetableSerializer.from_model(
timetables, many=True).data
user_dict['courses'] = CourseSerializer(courses,
context=context,
many=True).data
return user_dict
def course_page(request, code):
"""
Generates a static course page for the provided course code and
school (via subdomain). Completely outside of the React framework
purely via Django templates.
"""
school = request.subdomain
school_name = SCHOOLS_MAP[school].name
course = Course.objects.get(code__iexact=code)
semester, _ = Semester.objects.get_or_create(name="Fall", year=datetime.now().year)
course_dict = CourseSerializer(
course, context={"semester": semester, "school": school}
).data
sections = course_dict["sections"]
lectures = [s for s in sections if s["section_type"] == "L"]
tutorials = [s for s in sections if s["section_type"] == "T"]
practicals = [s for s in sections if s["section_type"] == "P"]
avg = round(course.get_avg_rating(), 2)
clean_evals = get_clean_evals(course_dict)
course_url = f"/course/{course_dict['code']}/{semester.name}/{semester.year}"
context = {
"school": school,
"school_name": school_name,
"course": course_dict,
"lectures": lectures,
"tutorials": tutorials,
"practicals": practicals,
"url": course_url,
"evals": clean_evals,
"avg": avg,
}
return render(request, "course_page.html", context)
class SalesInfoDetailSerializer(serializers.ModelSerializer):
course = CourseSerializer(many=False)
student = UserEnrollSerializer(many=False)
class Meta:
model = SalesInfo
fields = "__all__"
def get(self, request, sem_name, year):
"""Returns student's personal timetables"""
sem, _ = Semester.objects.get_or_create(name=sem_name, year=year)
student = Student.objects.get(user=request.user)
timetables = student.personaltimetable_set.filter(
school=request.subdomain, semester=sem).order_by("-last_updated")
courses = {
course
for timetable in timetables for course in timetable.courses.all()
}
context = {
"semester": sem,
"school": request.subdomain,
"student": student
}
return Response(
{
"timetables":
DisplayTimetableSerializer.from_model(timetables,
many=True).data,
"courses":
CourseSerializer(courses, context=context, many=True).data,
},
status=status.HTTP_200_OK,
)
def get(self, request, query, sem_name, year):
""" Return vectorized search results. """
school = request.subdomain
sem = Semester.objects.get_or_create(name=sem_name, year=year)[0]
# TODO: use vectorized search after completion.
# Use vectorized_search if and only if a valid Searcher object is created, otherwise use baseline_search
# if apps.get_app_config('searches').searcher:
# course_match_objs = apps.get_app_config('searches').searcher.vectorized_search(request.subdomain, query, sem)[:4]
# else:
# course_match_objs = baseline_search(request.subdomain, query, sem)[:4]
# sorts queries by course number through a comparator
def course_comparator(course1, course2):
#isolate course number from XX0000
c1=int(str(course1)[2:6])
c2=int(str(course2)[2:6])
if c1 < c2:
return -1
elif c1 > c2:
return 1
else:
return 0
course_match_objs = baseline_search(request.subdomain, query, sem).distinct()
#only sort if results is less than 100 for efficiency sake
if len(course_match_objs) < 100:
course_match_objs = sorted(course_match_objs, key=cmp_to_key(course_comparator))
#display only 12 courses to avoid displaying too many.
course_match_objs = course_match_objs[:12]
save_analytics_course_search(query[:200], course_match_objs[:2], sem, request.subdomain,
get_student(request))
course_matches = [CourseSerializer(course, context={'semester': sem, 'school': school}).data
for course in course_match_objs]
return Response(course_matches, status=status.HTTP_200_OK)
class MembershipSerializer(serializers.ModelSerializer):
courses = CourseSerializer(many=True)
class Meta:
model = Membership
fields = ['price', 'membership_type', 'courses']
def custom_data(self):
ordering = self.request.query_params.get('ordering', "id")
try:
queryset = self.model_class.objects.all().order_by(ordering)
filter_queryset = self.filter_queryset(queryset)
if self.model_class == Student and (ordering == "courses"
or ordering == "-courses"):
filter_queryset = Student.objects.raw(
"SELECT * FROM (SELECT DISTINCT ON(courses_student.id) courses_course.name cc_name, * "
"FROM courses_student "
"LEFT JOIN courses_student_courses ON courses_student.id = courses_student_courses.student_id "
"LEFT JOIN courses_course ON courses_student_courses.course_id = courses_course.id) t "
"ORDER BY t.cc_name {}".format("DESC" if ordering ==
"-courses" else "ASC"))
paginate_queryset = self.paginate_queryset(filter_queryset)
except FieldError:
raise ParseError
total_items = len(list(filter_queryset))
serializer = self.serializer_class(paginate_queryset, many=True)
related = []
if self.model_class == Student:
related = CourseSerializer(Course.objects.all(), many=True).data
data = {
"total": total_items,
"related": related,
"result": serializer.data
}
return data
def get_feature_flow(self, request, slug):
"""
Overrides :obj:`FeatureFlowView` *get_feature_flow* method. Takes the slug,
decrypts the hashed database id, and either retrieves the corresponding
timetable or hits a 404.
"""
timetable_id = hashids.decrypt(slug)[0]
shared_timetable = get_object_or_404(SharedTimetable,
id=timetable_id,
school=request.subdomain)
context = {
"semester": shared_timetable.semester,
"school": request.subdomain,
"student": get_student(request),
}
return {
"semester":
shared_timetable.semester,
"courses":
CourseSerializer(shared_timetable.courses,
context=context,
many=True).data,
"sharedTimetable":
DisplayTimetableSerializer.from_model(shared_timetable).data,
}
def test_courses_not_live_in_courses_api(client, live):
"""Courses should be filtered out of the courses API if not live"""
course = CourseFactory.create(live=live)
resp = client.get(reverse("courses_api-list"))
assert resp.status_code == status.HTTP_200_OK
assert_drf_json_equal(resp.json(),
[CourseSerializer(course).data] if live else [])
def test_serialize_basket_product_version_program(mock_context):
"""Test ProductVersion serialization for a Program"""
program = ProgramFactory.create()
courses = CourseFactory.create_batch(3, program=program)
product_version = ProductVersionFactory.create(
product=ProductFactory(content_object=program)
)
data = FullProductVersionSerializer(
instance=product_version, context=mock_context
).data
assert data == {
"id": product_version.id,
"description": product_version.description,
"content_title": product_version.product.content_object.title,
"price": str(round_half_up(product_version.price)),
"type": product_version.product.content_type.model,
"courses": [
CourseSerializer(instance=course, context=mock_context).data
for course in courses
],
"thumbnail_url": program.catalog_image_url,
"object_id": product_version.product.object_id,
"product_id": product_version.product.id,
"readable_id": get_readable_id(product_version.product.content_object),
"run_tag": None,
"created_on": product_version.created_on.strftime(datetime_millis_format),
"start_date": product_version.product.content_object.next_run_date.isoformat()
if product_version.product.content_object.next_run_date
else None,
}
def courses(self, request, pk=None):
student = self.get_object()
courses = []
for enr in student.enrollment_set.all():
courses.append(enr.course)
courses = CourseSerializer(courses, many=True).data
return Response(courses)
def create_response(self, courses, locked_sections, timetables, context):
return {
"timetables": DisplayTimetableSerializer(timetables,
many=True).data,
"new_c_to_s": locked_sections,
"courses": CourseSerializer(courses, context=context,
many=True).data,
}
class StudentSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
name = serializers.CharField(required=True, max_length=50)
courses = CourseSerializer(many=True, read_only=True)
class Meta:
model = Student
fields = '__all__'
def course_list(request):
#List all code courses, or create a new course.
if request.method == 'GET':
courses = Course.objects.using('course').all()
serializer = CourseSerializer(courses, many=True)
print serializer.data
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = CourseSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def test_course_details_GET_invalid(self):
response = self.client.get(
reverse('courseDetail', kwargs={'pk':
Course.objects.get(id=1).pk}))
serializer = CourseSerializer(Course.objects.get(id=2))
self.assertFalse(response.data == serializer.data)
self.assertEqual(response.status_code, 200)
def test_list_view(self):
admin = User.objects.get(username='******')
client.force_login(user=admin)
response = client.get(reverse('courses-list'))
courses = Course.objects.all()
serializer = CourseSerializer(courses, many=True)
self.assertEqual(response.data, serializer.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def list(self, request, region_pk=None):
# If the request contains a region ID, then filter the
# queryset to return only courses from that region.
queryset = Course.objects.all()
if region_pk is not None:
queryset = queryset.filter(region=region_pk)
serializer = CourseSerializer(queryset, many=True)
return Response(serializer.data)
def get_courses(self, programpage):
"""Get only core courses for a program."""
elective_course_ids = programpage.program.electives_set.filter(electivecourse__isnull=False).values_list(
'electivecourse__course__id')
# Return only core courses in program serializer. All elective courses would be part of electives_sets
# If there is no elective set associated with program, All the associated courses with program will be treated
# as core courses
return CourseSerializer(programpage.program.course_set.exclude(id__in=elective_course_ids), many=True).data
def course_detail(request, pk):
# find course by pk (id)
try:
course = Course.objects.get(pk=pk)
except Course.DoesNotExist:
return JsonResponse({'message': 'The course does not exist'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
course_serializer = CourseSerializer(course)
return JsonResponse(course_serializer.data)
elif request.method == 'PUT':
course_data = JSONParser().parse(request)
course_serializer = CourseSerializer(course, data=course_data)
if course_serializer.is_valid():
course_serializer.save()
return JsonResponse(course_serializer.data)
return JsonResponse(course_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
course.delete()
return JsonResponse({'message': 'Course was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def test_course_with_run(self):
"""
Make sure the course URL serializes properly
"""
course_run = CourseRunFactory.create()
course = course_run.course
data = CourseSerializer(course).data
assert data['url'] == course_run.enrollment_url
assert data['enrollment_text'] == course.enrollment_text
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data
_, token = AuthToken.objects.create(user) # _ is instance
return Response({
'user':
UserSerializer(user, context=self.get_serializer_context()).data,
'token':
token,
'instructor_courses':
CourseSerializer(user.instructor_courses.all(), many=True).data,
'ta_courses':
CourseSerializer(user.ta_courses.all(), many=True).data,
'student_courses':
CourseStudentSerializer(user.student_courses.all(), many=True).data
})
