Example #1
0
 def test_no_certificates_for_user(self):
     """
     Test the case when there are no certificates for a user.
     """
     self.assertEqual(
         certs_api.get_certificates_for_user(self.student_no_cert.username),
         [])
Example #2
0
    def _get_certificates_for_user(self, username):
        """
        Returns a user's viewable certificates sorted by course name.
        """
        course_certificates = get_certificates_for_user(username)
        passing_certificates = {}
        for course_certificate in course_certificates:
            if course_certificate.get('is_passing', False):
                course_key = course_certificate['course_key']
                passing_certificates[course_key] = course_certificate

        viewable_certificates = []
        for course_key, course_overview in CourseOverview.get_from_ids_if_exists(
                passing_certificates.keys()).items():
            if certificates_viewable_for_course(course_overview):
                course_certificate = passing_certificates[course_key]
                course_certificate[
                    'course_display_name'] = course_overview.display_name_with_default
                course_certificate[
                    'course_organization'] = course_overview.display_org_with_default
                viewable_certificates.append(course_certificate)

        viewable_certificates.sort(
            key=lambda certificate: certificate['created'])
        return viewable_certificates
Example #3
0
    def course_runs_with_state(self):
        """
        Determine which course runs have been completed and failed by the user.

        A course run is considered completed for a user if they have a certificate in the correct state and
        the certificate is available.

        Returns:
            dict with a list of completed and failed runs
        """
        course_run_certificates = certificate_api.get_certificates_for_user(
            self.user.username)

        completed_runs, failed_runs = [], []
        for certificate in course_run_certificates:
            course_key = certificate['course_key']
            course_data = {
                'course_run_id': str(course_key),
                'type':
                self._certificate_mode_translation(certificate['type']),
            }

            try:
                may_certify = CourseOverview.get_from_id(
                    course_key).may_certify()
            except CourseOverview.DoesNotExist:
                may_certify = True
            if (CertificateStatuses.is_passing_status(certificate['status'])
                    and may_certify):
                completed_runs.append(course_data)
            else:
                failed_runs.append(course_data)

        return {'completed': completed_runs, 'failed': failed_runs}
Example #4
0
    def course_runs_with_state(self):
        """
        Determine which course runs have been completed and failed by the user.

        Returns:
            dict with a list of completed and failed runs
        """
        course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)

        completed_runs, failed_runs = [], []
        for certificate in course_run_certificates:
            certificate_type = certificate['type']

            # Treat "no-id-professional" certificates as "professional" certificates
            if certificate_type == CourseMode.NO_ID_PROFESSIONAL_MODE:
                certificate_type = CourseMode.PROFESSIONAL

            course_data = {
                'course_run_id': unicode(certificate['course_key']),
                'type': certificate_type,
            }

            if certificate_api.is_passing_status(certificate['status']):
                completed_runs.append(course_data)
            else:
                failed_runs.append(course_data)

        return {'completed': completed_runs, 'failed': failed_runs}
Example #5
0
 def _get_ordered_certificates_for_user(self, request, username):
     """
     Returns a user's certificates sorted by course name.
     """
     course_certificates = certificate_api.get_certificates_for_user(
         username)
     passing_certificates = []
     for course_certificate in course_certificates:
         if course_certificate.get('is_passing', False):
             course_key = course_certificate['course_key']
             try:
                 course_overview = CourseOverview.get_from_id(course_key)
                 course_certificate['course'] = course_overview
                 if certificates_viewable_for_course(course_overview):
                     # add certificate into passing certificate list only if it's a PDF certificate
                     # or there is an active certificate configuration.
                     if course_certificate[
                             'is_pdf_certificate'] or course_overview.has_any_active_web_certificate:
                         passing_certificates.append(course_certificate)
             except CourseOverview.DoesNotExist:
                 # This is unlikely to fail as the course should exist.
                 # Ideally the cert should have all the information that
                 # it needs. This might be solved by the Credentials API.
                 pass
     passing_certificates.sort(key=lambda certificate: certificate['course']
                               .display_name_with_default)
     return passing_certificates
Example #6
0
def _does_name_change_require_verification(user_profile, old_name, new_name):
    """
    If name change requires ID verification, do not update it through this API.
    """
    profile_meta = user_profile.get_meta()
    old_names_list = profile_meta[
        'old_names'] if 'old_names' in profile_meta else []

    user = user_profile.user

    # We only want to validate on a list of passing certificates for the learner. A learner may have
    # a certificate in a non-passing status, and we do not have to require ID verification based on certificates
    # that are not passing.
    passing_certs = filter(
        lambda cert: CertificateStatuses.is_passing_status(cert["status"]),
        get_certificates_for_user(user.username))
    num_passing_certs = len(list(passing_certs))

    # We check whether the learner has active verified enrollments because we do not want to
    # require the learner to perform ID verification if the learner is not enrolled in a verified mode
    # in any courses. The learner will not be able to complete ID verification without being enrolled in
    # at least one seat.
    has_verified_enrollments = len(get_verified_enrollments(user.username)) > 0

    validator = NameChangeValidator(old_names_list, num_passing_certs,
                                    old_name, new_name)

    return not validator.validate() and has_verified_enrollments
Example #7
0
    def _get_certificates_for_user(self, username):
        """
        Returns a user's viewable certificates sorted by course name.
        """
        course_certificates = get_certificates_for_user(username)
        passing_certificates = {}
        for course_certificate in course_certificates:
            if course_certificate.get('is_passing', False):
                course_key = course_certificate['course_key']
                passing_certificates[course_key] = course_certificate

        viewable_certificates = []
        for course_key, course_overview in CourseOverview.get_from_ids(
                list(passing_certificates.keys())).items():
            if not course_overview:
                # For deleted XML courses in which learners have a valid certificate.
                # i.e. MITx/7.00x/2013_Spring
                course_overview = self._get_pseudo_course_overview(course_key)
            if certificates_viewable_for_course(course_overview):
                course_certificate = passing_certificates[course_key]
                # add certificate into viewable certificate list only if it's a PDF certificate
                # or there is an active certificate configuration.
                if course_certificate[
                        'is_pdf_certificate'] or course_overview.has_any_active_web_certificate:
                    course_certificate[
                        'course_display_name'] = course_overview.display_name_with_default
                    course_certificate[
                        'course_organization'] = course_overview.display_org_with_default
                    viewable_certificates.append(course_certificate)

        viewable_certificates.sort(
            key=lambda certificate: certificate['created'])
        return viewable_certificates
Example #8
0
    def course_runs_with_state(self):
        """
        Determine which course runs have been completed and failed by the user.

        Returns:
            dict with a list of completed and failed runs
        """
        course_run_certificates = certificate_api.get_certificates_for_user(
            self.user.username)

        completed_runs, failed_runs = [], []
        for certificate in course_run_certificates:
            certificate_type = certificate['type']

            # Treat "no-id-professional" certificates as "professional" certificates
            if certificate_type == CourseMode.NO_ID_PROFESSIONAL_MODE:
                certificate_type = CourseMode.PROFESSIONAL

            course_data = {
                'course_run_id': unicode(certificate['course_key']),
                'type': certificate_type,
            }

            if certificate_api.is_passing_status(certificate['status']):
                completed_runs.append(course_data)
            else:
                failed_runs.append(course_data)

        return {'completed': completed_runs, 'failed': failed_runs}
Example #9
0
 def test_no_certificates_for_user(self):
     """
     Test the case when there are no certificates for a user.
     """
     self.assertEqual(
         certs_api.get_certificates_for_user(self.student_no_cert.username),
         []
     )
Example #10
0
    def completed_course_runs(self):
        """
        Determine which course runs have been completed by the user.

        Returns:
            list of dicts, each representing a course run certificate
        """
        course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
        return [
            {'course_run_id': unicode(certificate['course_key']), 'type': certificate['type']}
            for certificate in course_run_certificates
            if certificate_api.is_passing_status(certificate['status'])
        ]
Example #11
0
    def completed_course_runs(self):
        """
        Determine which course runs have been completed by the user.

        Returns:
            list of dicts, each representing a course run certificate
        """
        course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
        return [
            {'course_run_id': unicode(certificate['course_key']), 'type': certificate['type']}
            for certificate in course_run_certificates
            if certificate_api.is_passing_status(certificate['status'])
        ]
 def _get_ordered_certificates_for_user(self, request, username):
     """
     Returns a user's certificates sorted by course name.
     """
     course_certificates = certificate_api.get_certificates_for_user(
         username)
     for course_certificate in course_certificates:
         course_key = course_certificate['course_key']
         course_overview = get_course_overview_with_access(
             request.user, 'load', course_key)
         course_certificate['course'] = course_overview
     course_certificates.sort(key=lambda certificate: certificate['course'].
                              display_name_with_default)
     return course_certificates
Example #13
0
def _does_name_change_require_verification(user_profile, old_name, new_name):
    """
    If name change requires verification, do not update it through this API.
    """

    profile_meta = user_profile.get_meta()
    old_names_list = profile_meta[
        'old_names'] if 'old_names' in profile_meta else []

    user = user_profile.user
    num_certs = len(get_certificates_for_user(user.username))

    validator = NameChangeValidator(old_names_list, num_certs, old_name,
                                    new_name)

    return (is_verified_name_enabled() and not validator.validate())
Example #14
0
def get_completed_courses(student):
    """
    Determine which courses have been completed by the user.

    Args:
        student:
            User object representing the student

    Returns:
        iterable of dicts with structure {'course_id': course_key, 'mode': cert_type}

    """
    all_certs = get_certificates_for_user(student.username)
    return [{
        'course_id': unicode(cert['course_key']),
        'mode': cert['type']
    } for cert in all_certs if is_passing_status(cert['status'])]
Example #15
0
def get_completed_courses(student):
    """
    Determine which courses have been completed by the user.

    Args:
        student:
            User object representing the student

    Returns:
        iterable of dicts with structure {'course_id': course_key, 'mode': cert_type}

    """
    all_certs = certificate_api.get_certificates_for_user(student.username)
    return [
        {'course_id': unicode(cert['course_key']), 'mode': cert['type']}
        for cert in all_certs
        if certificate_api.is_passing_status(cert['status'])
    ]
 def _get_ordered_certificates_for_user(self, request, username):
     """
     Returns a user's certificates sorted by course name.
     """
     course_certificates = certificate_api.get_certificates_for_user(username)
     passing_certificates = []
     for course_certificate in course_certificates:
         if course_certificate.get('is_passing', False):
             course_key = course_certificate['course_key']
             try:
                 course_overview = CourseOverview.get_from_id(course_key)
                 course_certificate['course'] = course_overview
                 passing_certificates.append(course_certificate)
             except CourseOverview.DoesNotExist:
                 # This is unlikely to fail as the course should exist.
                 # Ideally the cert should have all the information that
                 # it needs. This might be solved by the Credentials API.
                 pass
     passing_certificates.sort(key=lambda certificate: certificate['course'].display_name_with_default)
     return passing_certificates
Example #17
0
    def course_runs_with_state(self):
        """
        Determine which course runs have been completed and failed by the user.

        Returns:
            dict with a list of completed and failed runs
        """
        course_run_certificates = certificate_api.get_certificates_for_user(
            self.user.username)
        completed_runs, failed_runs = [], []
        for certificate in course_run_certificates:
            course_data = {
                'course_run_id': unicode(certificate['course_key']),
                'type': certificate['type']
            }
            if certificate_api.is_passing_status(certificate['status']):
                completed_runs.append(course_data)
            else:
                failed_runs.append(course_data)
        return {'completed': completed_runs, 'failed': failed_runs}
Example #18
0
def award_program_certificates(username):
    """
    This task is designed to be called whenever a user's completion status
    changes with respect to one or more courses (primarily, when a course
    certificate is awarded).

    It will consult with a variety of APIs to determine whether or not the
    specified user should be awarded a certificate in one or more programs, and
    use the credentials service to create said certificates if so.

    This task may also be invoked independently of any course completion status
    change - for example, to backpopulate missing program credentials for a
    user.

    TODO: this is shelled out and incomplete for now.
    """

    # fetch the set of all course runs for which the user has earned a certificate
    LOGGER.debug('fetching all completed courses for user %s', username)
    user_certs = get_certificates_for_user(username)
    course_certs = [
        {'course_id': uc['course_id'], 'mode': uc['mode']}
        for uc in user_certs
        if uc['status'] in ('downloadable', 'generating')
    ]

    # invoke the Programs API completion check endpoint to identify any programs
    # that are satisfied by these course completions
    LOGGER.debug('determining completed programs for courses: %r', course_certs)
    program_ids = []  # TODO

    # determine which program certificates the user has already been awarded, if
    # any, and remove those, since they already exist.
    LOGGER.debug('fetching existing program certificates for %s', username)
    existing_program_ids = []  # TODO
    new_program_ids = list(set(program_ids) - set(existing_program_ids))

    # generate a new certificate for each of the remaining programs.
    LOGGER.debug('generating new program certificates for %s in programs: %r', username, new_program_ids)
    for program_id in new_program_ids:
        LOGGER.debug('calling credentials service to issue certificate for user %s in program %s', username, program_id)
Example #19
0
 def _get_ordered_certificates_for_user(self, request, username):
     """
     Returns a user's certificates sorted by course name.
     """
     course_certificates = certificate_api.get_certificates_for_user(
         username)
     passing_certificates = []
     for course_certificate in course_certificates:
         if course_certificate.get('is_passing', False):
             course_key = course_certificate['course_key']
             try:
                 course_overview = CourseOverview.get_from_id(course_key)
                 course_certificate['course'] = course_overview
                 passing_certificates.append(course_certificate)
             except CourseOverview.DoesNotExist:
                 # This is unlikely to fail as the course should exist.
                 # Ideally the cert should have all the information that
                 # it needs. This might be solved by the Credentials API.
                 pass
     passing_certificates.sort(key=lambda certificate: certificate['course']
                               .display_name_with_default)
     return passing_certificates
Example #20
0
 def test_get_certificates_for_user(self):
     """
     Test to get all the certificates for a user
     """
     certs = certs_api.get_certificates_for_user(self.student.username)
     self.assertEqual(len(certs), 2)
     self.assertEqual(certs[0]['username'], self.student.username)
     self.assertEqual(certs[1]['username'], self.student.username)
     self.assertEqual(certs[0]['course_key'], self.web_cert_course.id)
     self.assertEqual(certs[1]['course_key'], self.pdf_cert_course.id)
     self.assertEqual(certs[0]['created'], self.now)
     self.assertEqual(certs[1]['created'], self.now)
     self.assertEqual(certs[0]['type'], CourseMode.VERIFIED)
     self.assertEqual(certs[1]['type'], CourseMode.HONOR)
     self.assertEqual(certs[0]['status'], CertificateStatuses.downloadable)
     self.assertEqual(certs[1]['status'], CertificateStatuses.downloadable)
     self.assertEqual(certs[0]['is_passing'], True)
     self.assertEqual(certs[1]['is_passing'], True)
     self.assertEqual(certs[0]['grade'], '0.88')
     self.assertEqual(certs[1]['grade'], '0.99')
     self.assertEqual(certs[0]['download_url'], 'www.google.com')
     self.assertEqual(certs[1]['download_url'], 'www.gmail.com')
Example #21
0
    def course_runs_with_state(self):
        """
        Determine which course runs have been completed and failed by the user.

        Returns:
            dict with a list of completed and failed runs
        """
        course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)

        completed_runs, failed_runs = [], []
        for certificate in course_run_certificates:
            course_data = {
                'course_run_id': unicode(certificate['course_key']),
                'type': self._certificate_mode_translation(certificate['type']),
            }

            if certificate_api.is_passing_status(certificate['status']):
                completed_runs.append(course_data)
            else:
                failed_runs.append(course_data)

        return {'completed': completed_runs, 'failed': failed_runs}
Example #22
0
 def test_get_certificates_for_user(self):
     """
     Test to get all the certificates for a user
     """
     certs = certs_api.get_certificates_for_user(self.student.username)
     self.assertEqual(len(certs), 2)
     self.assertEqual(certs[0]['username'], self.student.username)
     self.assertEqual(certs[1]['username'], self.student.username)
     self.assertEqual(certs[0]['course_key'], self.web_cert_course.id)
     self.assertEqual(certs[1]['course_key'], self.pdf_cert_course.id)
     self.assertEqual(certs[0]['created'], self.now)
     self.assertEqual(certs[1]['created'], self.now)
     self.assertEqual(certs[0]['type'], CourseMode.VERIFIED)
     self.assertEqual(certs[1]['type'], CourseMode.HONOR)
     self.assertEqual(certs[0]['status'], CertificateStatuses.downloadable)
     self.assertEqual(certs[1]['status'], CertificateStatuses.downloadable)
     self.assertEqual(certs[0]['is_passing'], True)
     self.assertEqual(certs[1]['is_passing'], True)
     self.assertEqual(certs[0]['grade'], '0.88')
     self.assertEqual(certs[1]['grade'], '0.99')
     self.assertEqual(certs[0]['download_url'], 'www.google.com')
     self.assertEqual(certs[1]['download_url'], 'www.gmail.com')
Example #23
0
 def test_get_certificates_for_user(self):
     """
     Test to get all the certificates for a user
     """
     certs = get_certificates_for_user(self.student.username)
     assert len(certs) == 2
     assert certs[0]['username'] == self.student.username
     assert certs[1]['username'] == self.student.username
     assert certs[0]['course_key'] == self.web_cert_course.id
     assert certs[1]['course_key'] == self.pdf_cert_course.id
     assert certs[0]['created'] == self.now
     assert certs[1]['created'] == self.now
     assert certs[0]['type'] == CourseMode.VERIFIED
     assert certs[1]['type'] == CourseMode.HONOR
     assert certs[0]['status'] == CertificateStatuses.downloadable
     assert certs[1]['status'] == CertificateStatuses.downloadable
     assert certs[0]['is_passing'] is True
     assert certs[1]['is_passing'] is True
     assert certs[0]['grade'] == '0.88'
     assert certs[1]['grade'] == '0.99'
     assert certs[0]['download_url'] == 'www.google.com'
     assert certs[1]['download_url'] == 'www.gmail.com'
Example #24
0
def search_certificates(request):
    """
    Search for certificates for a particular user OR along with the given course.

    Supports search by either username or email address along with course id.

    First filter the records for the given username/email and then filter against the given course id (if given).
    Show the 'Regenerate' button if a record found in 'generatedcertificate' model otherwise it will show the Generate
    button.

    Arguments:
        request (HttpRequest): The request object.

    Returns:
        JsonResponse

    Example Usage:
        GET /certificates/[email protected]
        GET /certificates/[email protected]&course_id=xyz

        Response: 200 OK
        Content-Type: application/json
        [
            {
                "username": "******",
                "course_key": "edX/DemoX/Demo_Course",
                "type": "verified",
                "status": "downloadable",
                "download_url": "http://www.example.com/cert.pdf",
                "grade": "0.98",
                "created": 2015-07-31T00:00:00Z,
                "modified": 2015-07-31T00:00:00Z
            }
        ]

    """
    unbleached_filter = urllib.parse.unquote(
        urllib.parse.quote_plus(request.GET.get("user", "")))
    user_filter = bleach.clean(unbleached_filter)
    if not user_filter:
        msg = _("user is not given.")
        return HttpResponseBadRequest(msg)

    try:
        user = User.objects.get(Q(email=user_filter) | Q(username=user_filter))
    except User.DoesNotExist:
        return HttpResponseBadRequest(
            _("user '{user}' does not exist").format(user=user_filter))

    certificates = get_certificates_for_user(user.username)
    for cert in certificates:
        cert["course_key"] = str(cert["course_key"])
        cert["created"] = cert["created"].isoformat()
        cert["modified"] = cert["modified"].isoformat()
        cert["regenerate"] = not cert['is_pdf_certificate']

    course_id = urllib.parse.quote_plus(request.GET.get("course_id", ""),
                                        safe=':/')
    if course_id:
        try:
            course_key = CourseKey.from_string(course_id)
        except InvalidKeyError:
            return HttpResponseBadRequest(
                _("Course id '{course_id}' is not valid").format(
                    course_id=course_id))
        else:
            try:
                if CourseOverview.get_from_id(course_key):
                    certificates = [
                        certificate for certificate in certificates
                        if certificate['course_key'] == course_id
                    ]
                    if not certificates:
                        return JsonResponse([{
                            'username': user.username,
                            'course_key': course_id,
                            'regenerate': False
                        }])
            except CourseOverview.DoesNotExist:
                msg = _(
                    "The course does not exist against the given key '{course_key}'"
                ).format(course_key=course_key)
                return HttpResponseBadRequest(msg)

    return JsonResponse(certificates)
Example #25
0
def search_certificates(request):
    """
    Search for certificates for a particular user OR along with the given course.

    Supports search by either username or email address along with course id.

    First filter the records for the given username/email and then filter against the given course id (if given).
    Show the 'Regenerate' button if a record found in 'generatedcertificate' model otherwise it will show the Generate
    button.

    Arguments:
        request (HttpRequest): The request object.

    Returns:
        JsonResponse

    Example Usage:
        GET /certificates/[email protected]
        GET /certificates/[email protected]&course_id=xyz

        Response: 200 OK
        Content-Type: application/json
        [
            {
                "username": "******",
                "course_key": "edX/DemoX/Demo_Course",
                "type": "verified",
                "status": "downloadable",
                "download_url": "http://www.example.com/cert.pdf",
                "grade": "0.98",
                "created": 2015-07-31T00:00:00Z,
                "modified": 2015-07-31T00:00:00Z
            }
        ]

    """
    user_filter = urllib.unquote(urllib.quote_plus(request.GET.get("user", "")))
    if not user_filter:
        msg = _("user is not given.")
        return HttpResponseBadRequest(msg)

    try:
        user = User.objects.get(Q(email=user_filter) | Q(username=user_filter))
    except User.DoesNotExist:
        return HttpResponseBadRequest(_("user '{user}' does not exist").format(user=user_filter))

    certificates = api.get_certificates_for_user(user.username)
    for cert in certificates:
        cert["course_key"] = unicode(cert["course_key"])
        cert["created"] = cert["created"].isoformat()
        cert["modified"] = cert["modified"].isoformat()
        cert["regenerate"] = True

    course_id = urllib.quote_plus(request.GET.get("course_id", ""), safe=':/')
    if course_id:
        try:
            course_key = CourseKey.from_string(course_id)
        except InvalidKeyError:
            return HttpResponseBadRequest(_("Course id '{course_id}' is not valid").format(course_id=course_id))
        else:
            try:
                if CourseOverview.get_from_id(course_key):
                    certificates = [certificate for certificate in certificates
                                    if certificate['course_key'] == course_id]
                    if not certificates:
                        return JsonResponse([{'username': user.username, 'course_key': course_id, 'regenerate': False}])
            except CourseOverview.DoesNotExist:
                msg = _("The course does not exist against the given key '{course_key}'").format(course_key=course_key)
                return HttpResponseBadRequest(msg)

    return JsonResponse(certificates)
Example #26
0
def learner_profile_context(request, profile_username, user_is_staff):
    """Context for the learner profile page.

    Args:
        logged_in_user (object): Logged In user.
        profile_username (str): username of user whose profile is requested.
        user_is_staff (bool): Logged In user has staff access.
        build_absolute_uri_func ():

    Returns:
        dict

    Raises:
        ObjectDoesNotExist: the specified profile_username does not exist.
    """
    profile_user = User.objects.get(username=profile_username)
    logged_in_user = request.user

    own_profile = (logged_in_user.username == profile_username)

    account_settings_data = get_account_settings(request,
                                                 [profile_username])[0]

    preferences_data = get_user_preferences(profile_user, profile_username)

    #Added by Mahendra
    user_enrolled_courses = CourseEnrollment.objects.filter(
        user_id=profile_user.id, is_active=1)
    cid = []
    for courseid in user_enrolled_courses:
        course_id = courseid.course_id
        cid.append(course_id)

    instructor_courses = CourseAccessRole.objects.filter(
        user_id=profile_user.id, role='instructor')
    instrsuctor_courseids = []
    for courseid in instructor_courses:
        course_id = courseid.course_id
        instrsuctor_courseids.append(course_id)

    try:
        userprofile_extrainfo = extrafields.objects.get(
            user_id=profile_user.id)
    except Exception as e:
        userprofile_extrainfo, created = extrafields.objects.get_or_create(
            user_id=profile_user.id)

    course_data = CourseOverview.objects.all().filter(
        pk__in=cid).order_by('start')[::-1]
    instructor_course_delivered = CourseOverview.objects.all().filter(
        pk__in=instrsuctor_courseids).order_by('start')[::-1]
    experience_data = experience.objects.all().filter(
        user=profile_user.id).order_by('-year')
    education_data = education.objects.all().filter(
        user=profile_user.id).order_by('-id')
    award_data = awards.objects.all().filter(
        user=profile_user.id).order_by('-year')
    research_data = research_papers.objects.all().filter(
        user=profile_user.id).order_by('-id')
    featured_data = media_featured.objects.all().filter(
        user=profile_user.id).order_by('-id')
    clinic_hospital_data = clinic_hospital_address.objects.all().filter(
        user=profile_user.id).order_by('-id')
    userprofile = UserProfile.objects.get(user_id=profile_user.id)
    course_certificates = certificate_api.get_certificates_for_user(
        profile_user.username)
    awareness_videos = healthcare_awareness_videos.objects.all().filter(
        user=profile_user.id)

    context = {
        'own_profile':
        own_profile,
        'platform_name':
        configuration_helpers.get_value('platform_name',
                                        settings.PLATFORM_NAME),
        'data': {
            'profile_user_id':
            profile_user.id,
            'default_public_account_fields':
            settings.ACCOUNT_VISIBILITY_CONFIGURATION['public_fields'],
            'default_visibility':
            settings.ACCOUNT_VISIBILITY_CONFIGURATION['default_visibility'],
            'accounts_api_url':
            reverse("accounts_api", kwargs={'username': profile_username}),
            'preferences_api_url':
            reverse('preferences_api', kwargs={'username': profile_username}),
            'preferences_data':
            preferences_data,
            'account_settings_data':
            account_settings_data,
            'profile_image_upload_url':
            reverse('profile_image_upload',
                    kwargs={'username': profile_username}),
            'profile_image_remove_url':
            reverse('profile_image_remove',
                    kwargs={'username': profile_username}),
            'profile_image_max_bytes':
            settings.PROFILE_IMAGE_MAX_BYTES,
            'profile_image_min_bytes':
            settings.PROFILE_IMAGE_MIN_BYTES,
            'account_settings_page_url':
            reverse('account_settings'),
            'has_preferences_access':
            (logged_in_user.username == profile_username or user_is_staff),
            'own_profile':
            own_profile,
            'country_options':
            list(countries),
            'find_courses_url':
            marketing_link('COURSES'),
            'language_options':
            settings.ALL_LANGUAGES,
            'badges_logo':
            staticfiles_storage.url('certificates/images/backpack-logo.png'),
            'badges_icon':
            staticfiles_storage.url(
                'certificates/images/ico-mozillaopenbadges.png'),
            'backpack_ui_img':
            staticfiles_storage.url('certificates/images/backpack-ui.png'),
            'platform_name':
            configuration_helpers.get_value('platform_name',
                                            settings.PLATFORM_NAME),
            'social_platforms':
            settings.SOCIAL_PLATFORMS,
        },
        'show_program_listing':
        ProgramsApiConfig.is_enabled(),
        'show_dashboard_tabs':
        True,
        'disable_courseware_js':
        True,
        'nav_hidden':
        True,
        'records_url':
        get_credentials_records_url(),
        #Added by Mahendra
        'instructor_courses':
        instructor_course_delivered,
        'courses':
        course_data,
        'experience_data':
        experience_data,
        'education_data':
        education_data,
        'award_data':
        award_data,
        'research_data':
        research_data,
        'featured_data':
        featured_data,
        'clinic_hospital_data':
        clinic_hospital_data,
        'userprofile':
        userprofile,
        'userprofile_extrainfo':
        userprofile_extrainfo,
        'course_certificates':
        course_certificates,
        'awareness_videos':
        awareness_videos,
    }

    if own_profile or user_is_staff:
        achievements_fragment = LearnerAchievementsFragmentView(
        ).render_to_fragment(
            request,
            username=profile_user.username,
            own_profile=own_profile,
        )
        context['achievements_fragment'] = achievements_fragment

    if badges_enabled():
        context['data']['badges_api_url'] = reverse(
            "badges_api:user_assertions",
            kwargs={'username': profile_username})

    return context
Example #27
0
 def test_no_certificates_for_user(self):
     """
     Test the case when there are no certificates for a user.
     """
     assert get_certificates_for_user(self.student_no_cert.username) == []