def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get('q') partner = self.request.site.partner edit_mode = get_query_param(self.request, 'editable') or self.request.method not in SAFE_METHODS if edit_mode and q: raise EditableAndQUnsupported() if edit_mode and (not self.request.user.is_staff and not is_publisher_user(self.request.user)): raise PermissionDenied if edit_mode: queryset = CourseRun.objects.filter_drafts() queryset = CourseEditor.editable_course_runs(self.request.user, queryset) else: queryset = self.queryset if q: qs = SearchQuerySetWrapper(CourseRun.search(q).filter(partner=partner.short_code)) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs queryset = queryset.filter(course__partner=partner) return self.get_serializer_class().prefetch_queryset(queryset=queryset)
def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get('q') partner = self.request.site.partner if q: qs = SearchQuerySetWrapper( CourseRun.search(q).filter(partner=partner.short_code)) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs else: queryset = super( CourseRunViewSet, self).get_queryset().filter(course__partner=partner) return self.get_serializer_class().prefetch_queryset( queryset=queryset)
def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get('q') include_all_partners = get_query_param(self.request, 'include_all_partners') partners = Partner.objects.all( ) if include_all_partners else Partner.objects.filter( site=self.request.site) edx_org_short_name = self.request.query_params.get('org') if q: qs = SearchQuerySetWrapper( CourseRun.search(q).filter( partner__in=partners.values_list('short_code', flat=True))) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs else: queryset = super( CourseRunViewSet, self).get_queryset().filter(course__partner__in=partners) return self.get_serializer_class().prefetch_queryset( queryset=queryset, edx_org_short_name=edx_org_short_name)
def contains_course_runs(self, course_run_ids): """ Determines if the given course runs are contained in this catalog. Arguments: course_run_ids (str[]): List of course run IDs Returns: dict: Mapping of course IDs to booleans indicating if course run is contained in this catalog. """ contains = {course_run_id: False for course_run_id in course_run_ids} course_runs = CourseRun.search(self.query).filter( 'terms', **{ 'key.raw': course_run_ids }).source(['key']) try: course_runs_keys = [i.key for i in course_runs] except RequestError: course_runs_keys = [] contains.update({ course_run_id: course_run_id in course_runs_keys for course_run_id in course_run_ids }) return contains
def contains(self, request): """ Determine if course runs are found in the query results. A dictionary mapping course run keys to booleans, indicating course run presence, will be returned. --- serializer: serializers.ContainedCourseRunsSerializer parameters: - name: query description: Elasticsearch querystring query required: true type: string paramType: query multiple: false - name: course_run_ids description: Comma-separated list of course run IDs required: true type: string paramType: query multiple: true """ query = request.GET.get('query') course_run_ids = request.GET.get('course_run_ids') if query and course_run_ids: course_run_ids = course_run_ids.split(',') course_runs = CourseRun.search(query).filter(key__in=course_run_ids).values_list('key', flat=True) contains = {course_run_id: course_run_id in course_runs for course_run_id in course_run_ids} instance = {'course_runs': contains} serializer = serializers.ContainedCourseRunsSerializer(instance) return Response(serializer.data) return Response(status=status.HTTP_400_BAD_REQUEST)
def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get('q', None) partner = self.get_partner() if q: qs = SearchQuerySetWrapper( CourseRun.search(q).filter(partner=partner.short_code)) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs else: queryset = super( CourseRunViewSet, self).get_queryset().filter(course__partner=partner) queryset = queryset.select_related( *serializers.SELECT_RELATED_FIELDS['course_run']) queryset = queryset.prefetch_related( *serializers.PREFETCH_FIELDS['course_run']) return queryset
def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get('q') partner = self.request.site.partner edit_mode = get_query_param(self.request, 'editable') or self.request.method not in SAFE_METHODS if edit_mode and q: raise EditableAndQUnsupported() if edit_mode: queryset = CourseRun.objects.filter_drafts() queryset = CourseEditor.editable_course_runs(self.request.user, queryset) else: queryset = self.queryset if q: queryset = CourseRun.search(q, queryset=queryset) queryset = queryset.filter(course__partner=partner) return self.get_serializer_class().prefetch_queryset(queryset=queryset)
def test_search(self): """ Verify the method returns a filtered queryset of course runs. """ title = 'Some random title' course_runs = factories.CourseRunFactory.create_batch(3, title=title) query = 'title:' + title actual_sorted = sorted(SearchQuerySetWrapper(CourseRun.search(query)), key=lambda course_run: course_run.key) expected_sorted = sorted(course_runs, key=lambda course_run: course_run.key) self.assertEqual(actual_sorted, expected_sorted)
def get_queryset(self): q = self.request.query_params.get('q', None) if q: qs = SearchQuerySetWrapper(CourseRun.search(q)) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs else: return super(CourseRunViewSet, self).get_queryset()
def contains_course_runs(self, course_run_ids): # pylint: disable=unused-argument """ Determines if the given course runs are contained in this catalog. Arguments: course_run_ids (str[]): List of course run IDs Returns: dict: Mapping of course IDs to booleans indicating if course run is contained in this catalog. """ contains = {course_run_id: False for course_run_id in course_run_ids} course_runs = CourseRun.search(self.query).filter(key__in=course_run_ids).values_list('key', flat=True) contains.update({course_run_id: course_run_id in course_runs for course_run_id in course_run_ids}) return contains
def contains(self, request): """ Determine if course runs are found in the query results. A dictionary mapping course run keys to booleans, indicating course run presence, will be returned. --- serializer: serializers.ContainedCourseRunsSerializer parameters: - name: query description: Elasticsearch querystring query required: true type: string paramType: query multiple: false - name: course_run_ids description: Comma-separated list of course run IDs required: true type: string paramType: query multiple: true - name: partner description: Filter by partner required: false type: string paramType: query multiple: false """ query = request.GET.get('query') course_run_ids = request.GET.get('course_run_ids') partner = self.request.site.partner if query and course_run_ids: course_run_ids = course_run_ids.split(',') course_runs = (CourseRun.search(query).filter( ESDSLQ('term', partner=partner.short_code) & ESDSLQ('terms', **{'key.raw': course_run_ids})).source( ['key'])) course_runs_keys = [i.key for i in course_runs] contains = { course_run_id: course_run_id in course_runs_keys for course_run_id in course_run_ids } instance = {'course_runs': contains} serializer = serializers.ContainedCourseRunsSerializer(instance) return Response(serializer.data) return Response(status=status.HTTP_400_BAD_REQUEST)
def contains(self, request): """ Determine if course runs are found in the query results. A dictionary mapping course run keys to booleans, indicating course run presence, will be returned. --- serializer: serializers.ContainedCourseRunsSerializer parameters: - name: query description: Elasticsearch querystring query required: true type: string paramType: query multiple: false - name: course_run_ids description: Comma-separated list of course run IDs required: true type: string paramType: query multiple: true - name: partner description: Filter by partner required: false type: string paramType: query multiple: false """ query = request.GET.get('query') course_run_ids = request.GET.get('course_run_ids') partner = self.get_partner() if query and course_run_ids: course_run_ids = course_run_ids.split(',') course_runs = CourseRun.search(query).filter(partner=partner.short_code).filter(key__in=course_run_ids). \ values_list('key', flat=True) contains = { course_run_id: course_run_id in course_runs for course_run_id in course_run_ids } instance = {'course_runs': contains} serializer = serializers.ContainedCourseRunsSerializer(instance) return Response(serializer.data) return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request): """ Determine if a set of courses and/or course runs is found in the query results. Returns dict: mapping of course and run indentifiers included in the request to boolean values indicating whether or not the associated course or run is contained in the queryset described by the query found in the request. """ query = request.GET.get('query') course_run_ids = request.GET.get('course_run_ids', None) course_uuids = request.GET.get('course_uuids', None) partner = self.request.site.partner if query and (course_run_ids or course_uuids): identified_course_ids = set() specified_course_ids = [] if course_run_ids: course_run_ids = course_run_ids.split(',') specified_course_ids = course_run_ids identified_course_ids.update( i.key for i in CourseRun.search(query).filter( ESDSLQ('term', partner=partner.short_code) | ESDSLQ('terms', **{'key.raw': course_run_ids})). source(['key'])) if course_uuids: course_uuids = [ UUID(course_uuid) for course_uuid in course_uuids.split(',') ] specified_course_ids += course_uuids identified_course_ids.update( Course.search(query).filter( partner=partner, uuid__in=course_uuids).values_list('uuid', flat=True)) contains = { str(identifier): identifier in identified_course_ids for identifier in specified_course_ids } return Response(contains) return Response( 'CatalogQueryContains endpoint requires query and identifiers list(s)', status=status.HTTP_400_BAD_REQUEST)
def get_queryset(self): """ List one course run --- parameters: - name: include_deleted_programs description: Will include deleted programs in the associated programs array required: false type: integer paramType: query multiple: false """ q = self.request.query_params.get("q", None) partner = self.get_partner() if q: qs = SearchQuerySetWrapper(CourseRun.search(q).filter(partner=partner.short_code)) # This is necessary to avoid issues with the filter backend. qs.model = self.queryset.model return qs else: queryset = super(CourseRunViewSet, self).get_queryset().filter(course__partner=partner) queryset = queryset.select_related(*serializers.SELECT_RELATED_FIELDS["course_run"]) queryset = queryset.prefetch_related(*serializers.PREFETCH_FIELDS["course_run"]) return queryset
def contains(self, request): """ Determine if course runs are found in the query results. A dictionary mapping course run keys to booleans, indicating course run presence, will be returned. --- serializer: serializers.ContainedCourseRunsSerializer parameters: - name: query description: Elasticsearch querystring query required: true type: string paramType: query multiple: false - name: course_run_ids description: Comma-separated list of course run IDs required: true type: string paramType: query multiple: true - name: partner description: Filter by partner required: false type: string paramType: query multiple: false - name: org description: Filter results on edx organization's short name. required: false type: string paramType: query multiple: false - name: include_all_partners description: Include courses for all partners. required: false type: integer paramType: query multiple: false """ query = request.GET.get('query') course_run_ids = request.GET.get('course_run_ids') include_all_partners = get_query_param(self.request, 'include_all_partners') partners = Partner.objects.all( ) if include_all_partners else Partner.objects.filter( site=self.request.site) edx_org_short_name = request.GET.get('org') if query and course_run_ids: course_run_ids = course_run_ids.split(',') course_runs = CourseRun.search(query).filter( partner__in=partners.values_list( 'short_code', flat=True)).filter(key__in=course_run_ids) # update "course_runs" with edx organization filter course_runs = course_runs.filter( course__authoring_organizations__key=edx_org_short_name ).values_list('key', flat=True) contains = { course_run_id: course_run_id in course_runs for course_run_id in course_run_ids } instance = {'course_runs': contains} serializer = serializers.ContainedCourseRunsSerializer(instance) return Response(serializer.data) return Response(status=status.HTTP_400_BAD_REQUEST)