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 })