Adding log for investigation

Logs added while fetching the
certificate template to investigate
LEARNER-6943s

lms/djangoapps/certificates/api.py

@@ -417,6 +417,12 @@ def _course_from_key(course_key):
 
 
 def _certificate_html_url(user_id, course_id, uuid):
+    """
+    :param user_id:
+    :param course_id:
+    :param uuid:
+    :return:
+    """
     if uuid:
         return reverse('certificates:render_cert_by_uuid', kwargs={'certificate_uuid': uuid})
     elif user_id and course_id:
@@ -426,6 +432,11 @@ def _certificate_html_url(user_id, course_id, uuid):
 
 
 def _certificate_download_url(user_id, course_id):
+    """
+    :param user_id:
+    :param course_id:
+    :return:
+    """
     try:
         user_certificate = GeneratedCertificate.eligible_certificates.get(
             user=user_id,
@@ -448,6 +459,12 @@ def has_html_certificates_enabled(course):
 
 
 def get_certificate_url(user_id=None, course_id=None, uuid=None):
+    """
+    :param user_id:
+    :param course_id:
+    :param uuid:
+    :return:
+    """
     url = ''
 
     course = _course_from_key(course_id)
@@ -490,7 +507,10 @@ def get_certificate_template(course_key, mode, language):
             mode=mode,
             course_key=course_key
         )
-        template = get_language_specific_template_or_default(language, org_mode_and_key_templates)
+        template = get_language_specific_template_or_default(language, org_mode_and_key_templates, course_key)
+        if template:
+            log.info("Template retrieved for course based on the course_key:{course_key}, mode:{mode} "
+                     "and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
 
     # since no template matched that course_key, only consider templates with empty course_key
     empty_course_key_templates = active_templates.filter(course_key=CourseKeyField.Empty)
@@ -499,44 +519,78 @@ def get_certificate_template(course_key, mode, language):
             organization_id=org_id,
             mode=mode
         )
-        template = get_language_specific_template_or_default(language, org_and_mode_templates)
+        template = get_language_specific_template_or_default(language, org_and_mode_templates, course_key)
+        if template:
+            log.info("Template retrieved for course:{course_key} based on the mode:{mode} "
+                     "and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
     if not template and org_id:  # get template by only org
         org_templates = empty_course_key_templates.filter(
             organization_id=org_id,
             mode=None
         )
-        template = get_language_specific_template_or_default(language, org_templates)
+        template = get_language_specific_template_or_default(language, org_templates, course_key)
+        if template:
+            log.info("Template retrieved for course:{course_key} and org_id:{org_id}".
+                     format(course_key=course_key, org_id=org_id))
     if not template and mode:  # get template by only mode
         mode_templates = empty_course_key_templates.filter(
             organization_id=None,
             mode=mode
         )
-        template = get_language_specific_template_or_default(language, mode_templates)
+        template = get_language_specific_template_or_default(language, mode_templates, course_key)
+        if template:
+            log.info("Template retrieved for course:{course_key} based on the mode:{mode} "
+                     "and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
     return template if template else None
 
 
-def get_language_specific_template_or_default(language, templates):
+def get_language_specific_template_or_default(language, templates, course_key):
     """
+    Note: adding course_key param for logging purpose
     Returns templates that match passed in language.
     Returns default templates If no language matches, or language passed is None
     """
     two_letter_language = _get_two_letter_language_code(language)
-    language_or_default_templates = list(templates.filter(Q(language=two_letter_language) | Q(language=None) | Q(language='')))
-    language_specific_template = get_language_specific_template(two_letter_language, language_or_default_templates)
+    log.info("Retrieved two letter language is {two_letter_language} for the language:{language} and "
+             "course:{course_key}".format(two_letter_language=two_letter_language, language=language,
+                                          course_key=course_key))
+
+    language_or_default_templates = list(templates.filter(Q(language=two_letter_language)
+                                                          | Q(language=None) | Q(language='')))
+    language_specific_template = get_language_specific_template(two_letter_language,
+                                                                language_or_default_templates, course_key)
     if language_specific_template:
+        log.info("Returning languages: {language} specific template for course:{course_key}".
+                 format(course_key=course_key, language=language))
         return language_specific_template
     else:
+        log.info("Returning all languages or default template for course:{course_key}".format(course_key=course_key))
         return get_all_languages_or_default_template(language_or_default_templates)
 
 
-def get_language_specific_template(language, templates):
+def get_language_specific_template(language, templates, course_key):
+    """
+    :param language:
+    :param templates:
+    :param course_key:
+    :return:
+    """
     for template in templates:
         if template.language == language:
+            log.info("{language} language specific template found for course:{course_key}".
+                     format(language=language, course_key=course_key))
             return template
+
+    log.info("{language} language specific template not found for course:{course_key}".
+             format(language=language, course_key=course_key))
     return None
 
 
 def get_all_languages_or_default_template(templates):
+    """
+    :param templates:
+    :return:
+    """
     for template in templates:
         if template.language == '':
             return template

lms/djangoapps/certificates/views/webview.py

@@ -553,6 +553,7 @@ def render_html_view(request, user_id, course_id):
     custom_template = None
     custom_template_language = None
     if settings.FEATURES.get('CUSTOM_CERTIFICATE_TEMPLATES_ENABLED', False):
+        log.info("Custom certificate for course {course_id}".format(course_id=course_id))
         custom_template, custom_template_language = _get_custom_template_and_language(
             course.id,
             user_certificate.mode,
@@ -565,6 +566,9 @@ def render_html_view(request, user_id, course_id):
     user_language = translation.get_language()
     certificate_language = custom_template_language if custom_template else user_language
 
+    log.info("certificate language is: {language} for the course:{course_key}".format(language=certificate_language,
+                                                                                      course_key=course_key))
+
     # Generate the certificate context in the correct language, then render the template.
     with translation.override(certificate_language):
         context = {'user_language': user_language}
@@ -639,7 +643,8 @@ def _get_catalog_data_for_course(course_key):
             except ValueError:
                 log.exception('Error occurred while parsing course run details')
         catalog_data['content_language'] = course_run_data.get('content_language')
-
+    log.info("catalog data received for course:{course_key} is : {catalog_data}".format(course_key=course_key,
+                                                                                        catalog_data=catalog_data))
     return catalog_data
 
 
@@ -649,6 +654,9 @@ def _get_custom_template_and_language(course_id, course_mode, course_language):
     combination, along with the language that should be used to render that template.
     """
     closest_released_language = get_closest_released_language(course_language) if course_language else None
+    log.info("closest released language for {course_id} is {closest_released_language} and course language was:"
+             " {course_language}".format(course_id=course_id, closest_released_language=closest_released_language,
+                                         course_language=course_language))
     template = get_certificate_template(course_id, course_mode, closest_released_language)
 
     if template and template.language: