Removing logs

Removing all the logs added for
the investigation of learner-6943

lms/djangoapps/certificates/api.py

@@ -414,12 +414,6 @@ 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:
@@ -429,11 +423,6 @@ def _certificate_html_url(user_id, course_id, uuid):
 
 
 def _certificate_download_url(user_id, course_id, user_certificate=None):
-    """
-    :param user_id:
-    :param course_id:
-    :return:
-    """
     if not user_certificate:
         try:
             user_certificate = GeneratedCertificate.eligible_certificates.get(
@@ -460,12 +449,6 @@ def has_html_certificates_enabled(course):
 
 
 def get_certificate_url(user_id=None, course_id=None, uuid=None, user_certificate=None):
-    """
-    :param user_id:
-    :param course_id:
-    :param uuid:
-    :return:
-    """
     url = ''
 
     course = _course_from_key(course_id)
@@ -508,10 +491,7 @@ 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, course_key)
-        if template:
-            log.info(u"Template retrieved for course based on the course_key:{course_key}, mode:{mode} "
-                     u"and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
+        template = get_language_specific_template_or_default(language, org_mode_and_key_templates)
 
     # 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)
@@ -520,83 +500,47 @@ 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, course_key)
-        if template:
-            log.info(u"Template retrieved for course:{course_key} based on the mode:{mode} "
-                     u"and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
+        template = get_language_specific_template_or_default(language, org_and_mode_templates)
     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, course_key)
-        if template:
-            log.info(u"Template retrieved for course:{course_key} and org_id:{org_id}".
-                     format(course_key=course_key, org_id=org_id))
+        template = get_language_specific_template_or_default(language, org_templates)
     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, course_key)
-        if template:
-            log.info(u"Template retrieved for course:{course_key} based on the mode:{mode} "
-                     u"and org_id:{org_id}".format(course_key=course_key, mode=mode, org_id=org_id))
+        template = get_language_specific_template_or_default(language, mode_templates)
     return template if template else None
 
 
-def get_language_specific_template_or_default(language, templates, course_key):
+def get_language_specific_template_or_default(language, templates):
     """
-    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)
-    log.info(
-        u"Retrieved two letter language is {two_letter_language} for the language:{language} and "
-        u"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)
+                                                                language_or_default_templates)
     if language_specific_template:
-        log.info(u"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, course_key):
-    """
-    :param language:
-    :param templates:
-    :param course_key:
-    :return:
-    """
+def get_language_specific_template(language, templates):
     for template in templates:
         if template.language == language:
-            log.info(u"{language} language specific template found for course:{course_key}".
-                     format(language=language, course_key=course_key))
             return template
-
-    log.info(u"{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

@@ -631,18 +631,12 @@ def _get_catalog_data_for_course(course_key):
 
     catalog_data = {}
     course_run_fields = []
-    log.info(u"language specific template is:{lang} and include hours of effort is:{hof} for the course:{course_key}"
-             .format(lang=course_certificate_settings.language_specific_templates_enabled,
-                     hof=course_certificate_settings.include_hours_of_effort,
-                     course_key=course_key))
     if course_certificate_settings.language_specific_templates_enabled:
         course_run_fields.append('content_language')
     if course_certificate_settings.include_hours_of_effort:
         course_run_fields.extend(['weeks_to_complete', 'max_effort'])
 
     if course_run_fields:
-        log.info(u'requesting following fields:{course_run_fields} for the course:{course_key}'.
-                 format(course_run_fields=course_run_fields, course_key=course_key))
         course_run_data = get_course_run_details(course_key, course_run_fields)
         if course_run_data.get('weeks_to_complete') and course_run_data.get('max_effort'):
             try:
@@ -675,16 +669,11 @@ def _get_custom_template_and_language(course_id, course_mode, course_language):
     template = get_certificate_template(course_id, course_mode, closest_released_language)
 
     if template and template.language:
-        log.info("Returning template for course: {course_id} and template language is {language}".format(
-            course_id=course_id, language=template.language))
         return (template, closest_released_language)
     elif template:
         user_language = translation.get_language()
-        log.info("Returning template for course: {course_id} and template language is returned from settings"
-                 " {language}".format(course_id=course_id, language=user_language))
         return (template, user_language)
     else:
-        log.info("No template found for course: {course_id}" .format(course_id=course_id))
         return (None, None)