def _attach_run_mode_certificate_url(self, run_mode):
certificate_data = certificate_api.certificate_downloadable_status(self.user, self.course_key)
certificate_uuid = certificate_data.get('uuid')
run_mode['certificate_url'] = certificate_api.get_certificate_url(
course_id=self.course_key,
uuid=certificate_uuid,
) if certificate_uuid else None
def test_without_cert(self):
assert certificate_downloadable_status(self.student_no_cert, self.course.id) ==\
{'is_downloadable': False,
'is_generating': False,
'is_unverified': False,
'download_url': None,
'uuid': None}
def test_with_downloadable_web_cert(self):
CourseEnrollment.enroll(self.student, self.course.id, mode='honor')
self._setup_course_certificate()
with mock_passing_grade():
certs_api.generate_user_certificates(self.student, self.course.id)
cert_status = certificate_status_for_student(self.student,
self.course.id)
self.assertEqual(
certs_api.certificate_downloadable_status(self.student,
self.course.id),
{
'is_downloadable':
True,
'is_generating':
False,
'is_unverified':
False,
'download_url':
'/certificates/user/{user_id}/course/{course_id}'.format(
user_id=self.student.id,
course_id=self.course.id,
),
'uuid':
cert_status['uuid']
})
def _attach_run_mode_certificate_url(self, run_mode):
certificate_data = certificate_api.certificate_downloadable_status(self.user, self.course_key)
certificate_uuid = certificate_data.get('uuid')
run_mode['certificate_url'] = certificate_api.get_certificate_url(
course_id=self.course_key,
uuid=certificate_uuid,
) if certificate_uuid else None
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for organization in program_data['organizations']:
# TODO cache the results of the get_organization_by_short_name call
# so we don't have to hit database that frequently
org_obj = get_organization_by_short_name(organization['key'])
if org_obj and org_obj.get('logo'):
organization['img'] = org_obj['logo'].url
for course_code in program_data['course_codes']:
for run_mode in course_code['run_modes']:
course_key = CourseKey.from_string(run_mode['course_key'])
course_overview = CourseOverview.get_from_id(course_key)
run_mode['course_url'] = reverse('course_root', args=[course_key])
run_mode['course_image_url'] = course_overview.course_image_url
run_mode['start_date'] = course_overview.start_datetime_text()
run_mode['end_date'] = course_overview.end_datetime_text()
end_date = course_overview.end or datetime.datetime.max.replace(
tzinfo=pytz.UTC)
run_mode['is_course_ended'] = end_date < timezone.now()
run_mode['is_enrolled'] = CourseEnrollment.is_enrolled(
user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(
tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(
tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now(
) < enrollment_end
run_mode['is_enrollment_open'] = is_enrollment_open
if not is_enrollment_open:
# Only render this enrollment open date if the enrollment open is in the future
run_mode['enrollment_open_date'] = strftime_localized(
enrollment_start, 'SHORT_DATE')
# TODO: Currently unavailable on LMS.
run_mode['marketing_url'] = ''
certificate_data = certificate_api.certificate_downloadable_status(
user, course_key)
certificate_uuid = certificate_data.get('uuid')
if certificate_uuid:
run_mode[
'certificate_url'] = certificate_api.get_certificate_url(
course_id=course_key,
uuid=certificate_uuid,
)
return program_data
def test_with_downloadable_web_cert(self):
cert_status = certificate_status_for_student(self.student, self.course.id)
assert certificate_downloadable_status(self.student, self.course.id) ==\
{'is_downloadable': True,
'is_generating': False,
'is_unverified': False,
'download_url': f'/certificates/{cert_status["uuid"]}',
'is_pdf_certificate': False,
'uuid': cert_status['uuid']}
def _attach_course_run_certificate_url(self, run_mode):
certificate_data = certificate_api.certificate_downloadable_status(self.user, self.course_run_key)
certificate_uuid = certificate_data.get('uuid')
run_mode['certificate_url'] = certificate_api.get_certificate_url(
user_id=self.user.id, # Providing user_id allows us to fall back to PDF certificates
# if web certificates are not configured for a given course.
course_id=self.course_run_key,
uuid=certificate_uuid,
) if certificate_uuid else None
def _attach_course_run_certificate_url(self, run_mode):
certificate_data = certificate_api.certificate_downloadable_status(self.user, self.course_run_key)
certificate_uuid = certificate_data.get('uuid')
run_mode['certificate_url'] = certificate_api.get_certificate_url(
user_id=self.user.id, # Providing user_id allows us to fall back to PDF certificates
# if web certificates are not configured for a given course.
course_id=self.course_run_key,
uuid=certificate_uuid,
) if certificate_uuid else None
def get_certificate(self, model):
"""Returns the information about the user's certificate in the course."""
certificate_info = certificate_downloadable_status(model.user, model.course_id)
if certificate_info['is_downloadable']:
return {
'url': self.context['request'].build_absolute_uri(
certificate_info['download_url']
),
}
else:
return {}
def test_without_cert(self):
self.assertEqual(
certs_api.certificate_downloadable_status(self.student_no_cert, self.course.id),
{
'is_downloadable': False,
'is_generating': False,
'is_unverified': False,
'download_url': None,
'uuid': None,
}
)
def test_without_cert(self):
self.assertEqual(
certs_api.certificate_downloadable_status(self.student_no_cert, self.course.id),
{
'is_downloadable': False,
'is_generating': False,
'is_unverified': False,
'download_url': None,
'uuid': None,
}
)
def get_certificate(self, model):
"""Returns the information about the user's certificate in the course."""
certificate_info = certificate_downloadable_status(model.user, model.course_id)
if certificate_info['is_downloadable']:
return {
'url': self.context['request'].build_absolute_uri(
certificate_info['download_url']
),
}
else:
return {}
def test_cert_status_with_error(self):
GeneratedCertificateFactory.create(user=self.student,
course_id=self.course.id,
status=CertificateStatuses.error,
mode='verified')
assert certificate_downloadable_status(self.student, self.course.id) ==\
{'is_downloadable': False,
'is_generating': True,
'is_unverified': False,
'download_url': None,
'uuid': None}
def test_cert_status_with_generating(self):
cert_user = UserFactory()
GeneratedCertificateFactory.create(
user=cert_user,
course_id=self.course.id,
status=CertificateStatuses.generating,
mode='verified')
assert certificate_downloadable_status(cert_user, self.course.id) ==\
{'is_downloadable': False,
'is_generating': True,
'is_unverified': False,
'download_url': None,
'uuid': None}
def test_cert_api_return_v1(self, self_paced, cert_avail_delta, cert_downloadable_status, earned_but_not_available):
"""
Test 'downloadable status'
"""
cert_avail_date = datetime.now(pytz.UTC) + cert_avail_delta
self.course.self_paced = self_paced
self.course.certificate_available_date = cert_avail_date
self.course.save()
self._setup_course_certificate()
downloadable_status = certificate_downloadable_status(self.student, self.course.id)
assert downloadable_status['is_downloadable'] == cert_downloadable_status
assert downloadable_status.get('earned_but_not_available') == earned_but_not_available
def test_with_downloadable_web_cert(self):
CourseEnrollment.enroll(self.student, self.course.id, mode='honor')
self._setup_course_certificate()
with mock_passing_grade():
generate_user_certificates(self.student, self.course.id)
cert_status = certificate_status_for_student(self.student, self.course.id)
assert certificate_downloadable_status(self.student, self.course.id) ==\
{'is_downloadable': True,
'is_generating': False,
'is_unverified': False,
'download_url': f'/certificates/{cert_status["uuid"]}',
'is_pdf_certificate': False,
'uuid': cert_status['uuid']}
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for organization in program_data['organizations']:
# TODO cache the results of the get_organization_by_short_name call
# so we don't have to hit database that frequently
org_obj = get_organization_by_short_name(organization['key'])
if org_obj and org_obj.get('logo'):
organization['img'] = org_obj['logo'].url
for course_code in program_data['course_codes']:
for run_mode in course_code['run_modes']:
course_key = CourseKey.from_string(run_mode['course_key'])
course_overview = CourseOverview.get_from_id(course_key)
run_mode['course_url'] = reverse('course_root', args=[course_key])
run_mode['course_image_url'] = course_overview.course_image_url
run_mode['start_date'] = course_overview.start_datetime_text()
run_mode['end_date'] = course_overview.end_datetime_text()
end_date = course_overview.end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
run_mode['is_course_ended'] = end_date < timezone.now()
run_mode['is_enrolled'] = CourseEnrollment.is_enrolled(user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now() < enrollment_end
run_mode['is_enrollment_open'] = is_enrollment_open
if not is_enrollment_open:
# Only render this enrollment open date if the enrollment open is in the future
run_mode['enrollment_open_date'] = strftime_localized(enrollment_start, 'SHORT_DATE')
# TODO: Currently unavailable on LMS.
run_mode['marketing_url'] = ''
certificate_data = certificate_api.certificate_downloadable_status(user, course_key)
certificate_uuid = certificate_data.get('uuid')
if certificate_uuid:
run_mode['certificate_url'] = certificate_api.get_certificate_url(
course_id=course_key,
uuid=certificate_uuid,
)
return program_data
def test_cert_status_with_generating(self):
GeneratedCertificateFactory.create(
user=self.student,
course_id=self.course.id,
status=CertificateStatuses.generating,
mode='verified')
self.assertEqual(
certs_api.certificate_downloadable_status(self.student,
self.course.id),
{
'is_downloadable': False,
'is_generating': True,
'is_unverified': False,
'download_url': None,
'uuid': None,
})
def test_cert_api_return(self, self_paced, cert_avail_delta, cert_downloadable_status, earned_but_not_available):
"""
Test 'downloadable status'
"""
cert_avail_date = datetime.now(pytz.UTC) + cert_avail_delta
self.course.self_paced = self_paced
self.course.certificate_available_date = cert_avail_date
self.course.save()
CourseEnrollment.enroll(self.student, self.course.id, mode='honor')
self._setup_course_certificate()
with mock_passing_grade():
certs_api.generate_user_certificates(self.student, self.course.id)
downloadable_status = certs_api.certificate_downloadable_status(self.student, self.course.id)
self.assertEqual(downloadable_status['is_downloadable'], cert_downloadable_status)
self.assertEqual(downloadable_status.get('earned_but_not_available'), earned_but_not_available)
def test_cert_status_with_generating(self):
GeneratedCertificateFactory.create(
user=self.student,
course_id=self.course.id,
status=CertificateStatuses.generating,
mode='verified'
)
self.assertEqual(
certs_api.certificate_downloadable_status(self.student, self.course.id),
{
'is_downloadable': False,
'is_generating': True,
'is_unverified': False,
'download_url': None,
'uuid': None,
}
)
def test_cert_api_return(self, self_paced, cert_avail_delta, cert_downloadable_status):
"""
Test 'downloadable status'
"""
cert_avail_date = datetime.now(pytz.UTC) + cert_avail_delta
self.course.self_paced = self_paced
self.course.certificate_available_date = cert_avail_date
self.course.save()
CourseEnrollment.enroll(self.student, self.course.id, mode='honor')
self._setup_course_certificate()
with mock_passing_grade():
certs_api.generate_user_certificates(self.student, self.course.id)
self.assertEqual(
certs_api.certificate_downloadable_status(self.student, self.course.id)['is_downloadable'],
cert_downloadable_status
)
def verify_downloadable_pdf_cert(self):
"""
Verifies certificate_downloadable_status returns the
correct response for PDF certificates.
"""
cert = GeneratedCertificateFactory.create(
user=self.student,
course_id=self.course.id,
status=CertificateStatuses.downloadable,
mode='verified',
download_url='www.google.com',
)
assert certificate_downloadable_status(self.student, self.course.id) ==\
{'is_downloadable': True,
'is_generating': False,
'is_unverified': False,
'download_url': 'www.google.com',
'is_pdf_certificate': True,
'uuid': cert.verify_uuid}
def test_with_downloadable_web_cert(self):
CourseEnrollment.enroll(self.student, self.course.id, mode='honor')
self._setup_course_certificate()
with mock_passing_grade():
certs_api.generate_user_certificates(self.student, self.course.id)
cert_status = certificate_status_for_student(self.student, self.course.id)
self.assertEqual(
certs_api.certificate_downloadable_status(self.student, self.course.id),
{
'is_downloadable': True,
'is_generating': False,
'is_unverified': False,
'download_url': '/certificates/user/{user_id}/course/{course_id}'.format(
user_id=self.student.id,
course_id=self.course.id,
),
'uuid': cert_status['uuid']
}
)
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for course_code in program_data['course_codes']:
for run_mode in course_code['run_modes']:
course_key = CourseKey.from_string(run_mode['course_key'])
course_overview = CourseOverview.get_from_id(course_key)
run_mode['course_url'] = reverse('course_root', args=[course_key])
run_mode['course_image_url'] = course_overview.course_image_url
human_friendly_format = '%x'
start_date = course_overview.start or DEFAULT_START_DATE
end_date = course_overview.end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
run_mode['start_date'] = start_date.strftime(human_friendly_format)
run_mode['end_date'] = end_date.strftime(human_friendly_format)
run_mode['is_enrolled'] = CourseEnrollment.is_enrolled(user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now() < enrollment_end
run_mode['is_enrollment_open'] = is_enrollment_open
# TODO: Currently unavailable on LMS.
run_mode['marketing_url'] = ''
certificate_data = certificate_api.certificate_downloadable_status(user, course_key)
certificate_uuid = certificate_data.get('uuid')
if certificate_uuid:
run_mode['certificate_url'] = certificate_api.get_certificate_url(
course_id=course_key,
uuid=certificate_uuid,
)
return program_data
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for course_code in program_data["course_codes"]:
for run_mode in course_code["run_modes"]:
course_key = CourseKey.from_string(run_mode["course_key"])
course_overview = CourseOverview.get_from_id(course_key)
run_mode["course_url"] = reverse("course_root", args=[course_key])
run_mode["course_image_url"] = course_overview.course_image_url
human_friendly_format = "%x"
start_date = course_overview.start or DEFAULT_START_DATE
end_date = course_overview.end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
run_mode["start_date"] = start_date.strftime(human_friendly_format)
run_mode["end_date"] = end_date.strftime(human_friendly_format)
run_mode["is_enrolled"] = CourseEnrollment.is_enrolled(user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now() < enrollment_end
run_mode["is_enrollment_open"] = is_enrollment_open
# TODO: Currently unavailable on LMS.
run_mode["marketing_url"] = ""
certificate_data = certificate_api.certificate_downloadable_status(user, course_key)
certificate_uuid = certificate_data.get("uuid")
if certificate_uuid:
run_mode["certificate_url"] = certificate_api.get_certificate_url(
course_id=course_key, uuid=certificate_uuid
)
return program_data
def verify_downloadable_pdf_cert(self):
"""
Verifies certificate_downloadable_status returns the
correct response for PDF certificates.
"""
cert = GeneratedCertificateFactory.create(
user=self.student,
course_id=self.course.id,
status=CertificateStatuses.downloadable,
mode='verified',
download_url='www.google.com',
)
self.assertEqual(
certs_api.certificate_downloadable_status(self.student, self.course.id),
{
'is_downloadable': True,
'is_generating': False,
'is_unverified': False,
'download_url': 'www.google.com',
'uuid': cert.verify_uuid
}
)
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for organization in program_data['organizations']:
# TODO: Cache the results of the get_organization_by_short_name call so
# the database is hit less frequently.
org_obj = get_organization_by_short_name(organization['key'])
if org_obj and org_obj.get('logo'):
organization['img'] = org_obj['logo'].url
for course_code in program_data['course_codes']:
for run_mode in course_code['run_modes']:
course_key = CourseKey.from_string(run_mode['course_key'])
course_overview = CourseOverview.get_from_id(course_key)
course_url = reverse('course_root', args=[course_key])
course_image_url = course_overview.course_image_url
start_date_string = course_overview.start_datetime_text()
end_date_string = course_overview.end_datetime_text()
end_date = course_overview.end or datetime.datetime.max.replace(
tzinfo=pytz.UTC)
is_course_ended = end_date < timezone.now()
is_enrolled = CourseEnrollment.is_enrolled(user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(
tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(
tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now(
) < enrollment_end
enrollment_open_date = None if is_enrollment_open else strftime_localized(
enrollment_start, 'SHORT_DATE')
certificate_data = certificate_api.certificate_downloadable_status(
user, course_key)
certificate_uuid = certificate_data.get('uuid')
certificate_url = certificate_api.get_certificate_url(
course_id=course_key,
uuid=certificate_uuid,
) if certificate_uuid else None
required_mode_slug = run_mode['mode_slug']
enrolled_mode_slug, _ = CourseEnrollment.enrollment_mode_for_user(
user, course_key)
is_mode_mismatch = required_mode_slug != enrolled_mode_slug
is_upgrade_required = is_enrolled and is_mode_mismatch
# Requires that the ecommerce service be in use.
required_mode = CourseMode.mode_for_course(course_key,
required_mode_slug)
ecommerce = EcommerceService()
sku = getattr(required_mode, 'sku', None)
if ecommerce.is_enabled(user) and sku:
upgrade_url = ecommerce.checkout_page_url(
required_mode.sku) if is_upgrade_required else None
else:
upgrade_url = None
run_mode.update({
'certificate_url': certificate_url,
'course_image_url': course_image_url,
'course_url': course_url,
'end_date': end_date_string,
'enrollment_open_date': enrollment_open_date,
'is_course_ended': is_course_ended,
'is_enrolled': is_enrolled,
'is_enrollment_open': is_enrollment_open,
# TODO: Not currently available on LMS.
'marketing_url': None,
'start_date': start_date_string,
'upgrade_url': upgrade_url,
})
return program_data
def get(self, request, **kwargs):
"""
Implements the GET method as described in the class docstring.
"""
from rest_framework.reverse import reverse
params = request.GET
search_key = request.GET.get('search_key')
course_category = request.GET.get('subjects')
org = request.GET.get('org')
user_id = request.GET.get('user_id')
size = 2000
search_url = request.build_absolute_uri(reverse('course_discovery'))
if course_category or org:
def _process_field_values(request):
""" Create separate dictionary of supported filter values provided """
return {
field_key: request.GET[field_key]
for field_key in request.GET
if field_key in course_discovery_filter_fields()
}
field_dictionary = _process_field_values(request)
results = course_discovery_search(
search_term=search_key,
size=size,
from_=0,
field_dictionary=field_dictionary,
)
else:
def _process_field_values(request):
""" Create separate dictionary of supported filter values provided """
return {
field_key: request.POST[field_key]
for field_key in request.POST
if field_key in course_discovery_filter_fields()
}
field_dictionary = _process_field_values(request)
results = course_discovery_search(
search_term=search_key,
size=size,
from_=0,
field_dictionary=field_dictionary,
)
if results.get('total'):
result = []
course_search_enroll = []
for course in results.get('results'):
search_course = {}
course_id = course.get('_id')
course_key = CourseKey.from_string(course_id)
course_enroll = CourseEnrollment.objects.filter(
course_id=course_key, user_id=user_id, is_active=True)
course_overview = CourseOverview.objects.get(id=course_key)
if course_enroll.exists():
course_enroll = course_enroll[0]
try:
user = User.objects.get(id=user_id)
except:
message = {
"error":
_('Does not match user for "{user_id}"').format(
user_id=user_id)
}
response = JsonResponse(
{
'status': 'false',
'message': message
},
status=400)
return response
search_course['mode'] = course_enroll.mode
search_course['is_active'] = course_enroll.is_active
created = course_enroll.created
created = created.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
search_course['created'] = created
certificate_info = certificate_downloadable_status(
user, course_key)
if certificate_info['is_downloadable']:
certificates = {
'url':
request.build_absolute_uri(
certificate_info['download_url']),
}
else:
certificates = {}
search_course['certificate'] = certificates
start_date = course_overview.start
start = start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = course_overview.end
if end_date:
end_date = end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
search_course['course'] = {
'id':
course_id,
'number':
course_overview.display_number_with_default,
'name':
course_overview.display_name,
'org':
course_overview.display_org_with_default,
# dates
'start':
start,
'start_display':
course_overview.start_display,
'start_type':
course_overview.start_type,
'end':
end_date,
# notification info
'subscription_id':
course_overview.clean_id(padding_char='_'),
# access info
'courseware_access':
has_access(user, 'load_mobile',
course_overview).to_json(),
# various URLs
# course_image is sent in both new and old formats
# (within media to be compatible with the new Course API)
'media': {
'course_image': {
'uri': course_overview.course_image_url,
'name': 'Course Image',
}
},
'course_image':
course_overview.course_image_url,
'course_about':
get_link_for_about_page(course_overview),
'course_sharing_utm_parameters':
get_encoded_course_sharing_utm_params(),
'course_updates':
reverse(
'course-updates-list',
kwargs={'course_id': course_id},
request=request,
),
'course_handouts':
reverse(
'course-handouts-list',
kwargs={'course_id': course_id},
request=request,
),
'discussion_url':
reverse(
'discussion_course',
kwargs={'course_id': course_id},
request=request,
) if course_overview.is_discussion_tab_enabled() else
None,
'video_outline':
reverse(
'video-summary-list',
kwargs={'course_id': course_id},
request=request,
)
}
course_search_enroll.append(search_course)
if not course_search_enroll:
course_search_enroll = []
return JsonResponse(course_search_enroll,
status=200,
safe=False)
return JsonResponse(course_search_enroll, status=200, safe=False)
else:
course_search_enroll = []
return JsonResponse(course_search_enroll, status=200, safe=False)
def get(self, request, **kwargs):
"""
Implements the GET method as described in the class docstring.
"""
from rest_framework.reverse import reverse
params = request.GET
search_key = request.GET.get("search_key")
course_category = request.GET.get("subjects")
org = request.GET.get("org")
user_id = request.GET.get("user_id")
size = 2000
if "org" in request.GET:
if not request.GET.get("org"):
request.GET = request.GET.copy()
request.GET.pop("org")
if "subjects" in request.GET:
if not request.GET.get("subjects"):
request.GET = request.GET.copy()
request.GET.pop("subjects")
search_url = request.build_absolute_uri(reverse("course_discovery"))
if course_category or org:
def _process_field_values(request):
""" Create separate dictionary of supported filter values provided """
return {
field_key: request.GET[field_key]
for field_key in request.GET
if field_key in course_discovery_filter_fields()
}
field_dictionary = _process_field_values(request)
results = course_discovery_search(
search_term=search_key,
size=size,
from_=0,
field_dictionary=field_dictionary,
)
else:
def _process_field_values(request):
""" Create separate dictionary of supported filter values provided """
return {
field_key: request.POST[field_key]
for field_key in request.POST
if field_key in course_discovery_filter_fields()
}
field_dictionary = _process_field_values(request)
if search_key:
results = course_discovery_search(
search_term=search_key,
size=size,
from_=0,
field_dictionary=field_dictionary,
)
else:
results = course_discovery_search(
size=size,
from_=0,
field_dictionary=field_dictionary,
)
if results.get("total"):
# logging.info("for search api have results")
result = []
course_ids = []
for course in results.get("results"):
course_id = course.get("_id")
course_key = CourseKey.from_string(course_id)
course_ids.append(course_key)
course_overviews = CourseOverview.objects.filter(
id__in=course_ids
).order_by("-start")
# logging.info("courses list [%s]", course_overviews)
course_search_enroll = []
for course_overview in course_overviews:
search_course = {}
course_id = str(course_overview.id)
course_key = CourseKey.from_string(course_id)
course_enroll = CourseEnrollment.objects.filter(
course_id=course_key, user_id=user_id, is_active=True
)
if course_enroll.exists():
course_enroll = course_enroll[0]
try:
user = User.objects.get(id=user_id)
except:
message = {
"error": _('Does not match user for "{user_id}"').format(
user_id=user_id
)
}
response = JsonResponse(
{"status": "false", "message": message}, status=400
)
return response
search_course["mode"] = course_enroll.mode
search_course["is_active"] = course_enroll.is_active
created = course_enroll.created
created = created.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
search_course["created"] = created
certificate_info = certificate_downloadable_status(user, course_key)
if certificate_info["is_downloadable"]:
certificates = {
"url": request.build_absolute_uri(
certificate_info["download_url"]
),
}
else:
certificates = {}
search_course["certificate"] = certificates
block_id = modulestore().get_items(
course_key, qualifiers={"category": "video"}
)
if block_id:
data = block_id[0].__dict__
if "scope_ids" in data:
seq_block_id = data.get(
"scope_ids"
).def_id.to_deprecated_string()
else:
seq_block_id = ""
else:
seq_block_id = ""
course_extra_info = course_extrainfo.objects.get(
course_id=course_key
)
if course_extra_info.course_type == "2":
video_blocks_in_course = modulestore().get_items(
course_key, qualifiers={"category": "video"}
)
if video_blocks_in_course:
if video_blocks_in_course[0].html5_sources:
video_url = (
video_blocks_in_course[0].html5_sources[0]
if video_blocks_in_course[0].html5_sources
else video_blocks_in_course[0].html5_sources
)
else:
video_id = (
video_blocks_in_course[0].youtube_id_1_25
or video_blocks_in_course[0].youtube_id_0_75
or video_blocks_in_course[0].youtube_id_1_0
)
if video_id:
video_url = (
"https://www.youtube.com/watch?v=" + video_id
)
else:
video_url = ""
else:
video_url = ""
is_lecture = "true"
else:
video_url = ""
is_lecture = "false"
start_date = course_overview.start
start = start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = course_overview.end
if end_date:
end_date = end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
search_course["course"] = {
"id": course_id,
"is_lecture": is_lecture,
"video_url": video_url,
"seq_block_id": seq_block_id,
"number": course_overview.display_number_with_default,
"name": course_overview.display_name,
"org": course_overview.display_org_with_default,
# dates
"start": start,
"start_display": course_overview.start_display,
"start_type": course_overview.start_type,
"end": end_date,
# notification info
"subscription_id": course_overview.clean_id(padding_char="_"),
# access info
"courseware_access": has_access(
user, "load_mobile", course_overview
).to_json(),
# various URLs
# course_image is sent in both new and old formats
# (within media to be compatible with the new Course API)
"media": {
"course_image": {
"uri": course_overview.course_image_url,
"name": "Course Image",
}
},
"course_image": course_overview.course_image_url,
"course_about": get_link_for_about_page(course_overview),
"course_sharing_utm_parameters": get_encoded_course_sharing_utm_params(),
"course_updates": reverse(
"course-updates-list",
kwargs={"course_id": course_id},
request=request,
),
"course_handouts": reverse(
"course-handouts-list",
kwargs={"course_id": course_id},
request=request,
),
"discussion_url": reverse(
"discussion_course",
kwargs={"course_id": course_id},
request=request,
)
if course_overview.is_discussion_tab_enabled()
else None,
"video_outline": reverse(
"video-summary-list",
kwargs={"course_id": course_id},
request=request,
),
}
course_search_enroll.append(search_course)
if not course_search_enroll:
course_search_enroll = []
return JsonResponse(course_search_enroll, status=200, safe=False)
return JsonResponse(course_search_enroll, status=200, safe=False)
else:
course_search_enroll = []
return JsonResponse(course_search_enroll, status=200, safe=False)
def supplement_program_data(program_data, user):
"""Supplement program course codes with CourseOverview and CourseEnrollment data.
Arguments:
program_data (dict): Representation of a program.
user (User): The user whose enrollments to inspect.
"""
for organization in program_data['organizations']:
# TODO: Cache the results of the get_organization_by_short_name call so
# the database is hit less frequently.
org_obj = get_organization_by_short_name(organization['key'])
if org_obj and org_obj.get('logo'):
organization['img'] = org_obj['logo'].url
for course_code in program_data['course_codes']:
for run_mode in course_code['run_modes']:
course_key = CourseKey.from_string(run_mode['course_key'])
course_overview = CourseOverview.get_from_id(course_key)
course_url = reverse('course_root', args=[course_key])
course_image_url = course_overview.course_image_url
start_date_string = course_overview.start_datetime_text()
end_date_string = course_overview.end_datetime_text()
end_date = course_overview.end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
is_course_ended = end_date < timezone.now()
is_enrolled = CourseEnrollment.is_enrolled(user, course_key)
enrollment_start = course_overview.enrollment_start or datetime.datetime.min.replace(tzinfo=pytz.UTC)
enrollment_end = course_overview.enrollment_end or datetime.datetime.max.replace(tzinfo=pytz.UTC)
is_enrollment_open = enrollment_start <= timezone.now() < enrollment_end
enrollment_open_date = None if is_enrollment_open else strftime_localized(enrollment_start, 'SHORT_DATE')
certificate_data = certificate_api.certificate_downloadable_status(user, course_key)
certificate_uuid = certificate_data.get('uuid')
certificate_url = certificate_api.get_certificate_url(
course_id=course_key,
uuid=certificate_uuid,
) if certificate_uuid else None
required_mode_slug = run_mode['mode_slug']
enrolled_mode_slug, _ = CourseEnrollment.enrollment_mode_for_user(user, course_key)
is_mode_mismatch = required_mode_slug != enrolled_mode_slug
is_upgrade_required = is_enrolled and is_mode_mismatch
# Requires that the ecommerce service be in use.
required_mode = CourseMode.mode_for_course(course_key, required_mode_slug)
ecommerce = EcommerceService()
sku = getattr(required_mode, 'sku', None)
if ecommerce.is_enabled(user) and sku:
upgrade_url = ecommerce.checkout_page_url(required_mode.sku) if is_upgrade_required else None
else:
upgrade_url = None
run_mode.update({
'certificate_url': certificate_url,
'course_image_url': course_image_url,
'course_url': course_url,
'end_date': end_date_string,
'enrollment_open_date': enrollment_open_date,
'is_course_ended': is_course_ended,
'is_enrolled': is_enrolled,
'is_enrollment_open': is_enrollment_open,
'marketing_url': get_run_marketing_url(course_key, user),
'start_date': start_date_string,
'upgrade_url': upgrade_url,
})
return program_data
