def get_subject_label(course, index, sources, language, earnings, subject_names): no_data_available = translations.term_for_key(key="no_data_available", language=language) fallback = no_data_available attrib = "display_subject_name" for source in sources: try: if not earnings: fallback = get_subject_unavailable(course, source, language, index) if len(subject_names) == 1 and fallback == no_data_available: fallback = translations.term_for_key(key="this_course", language=language) _object = getattr(course, f'{source}')[index] except IndexError as e: continue if earnings: attrib = "subject_title_in_local_language" if has_valid_value(_object=_object, attrib=attrib): if not earnings and getattr(_object, attrib)() is None: return fallback else: return getattr(_object, attrib) return fallback
def set_message( unavailable_key: str, response_rate: str, aggregation_level: str, accordion: str, language, ) -> str: header = translations.term_for_key(key="this_course", language=language) override_accordions = [ translations.term_for_key(key="employment_15_months", language=language), translations.term_for_key(key="graduate_perceptions", language=language), ] if unavailable_key == "None": unavailable_key = "2" for key, value in unavailable_dict[unavailable_key].items(): resp = 1 if unavailable_key == "0" and response_rate else 0 if aggregation_level in key: try: result = value[resp] except IndexError: result = value[0] title = f"{result}_header" header = translations.term_for_key(key=title, language=language) if (aggregation_level in [ "21", "22", "23", "24" ]) and (accordion in override_accordions): header = temporary_override( aggregation_level=aggregation_level, language=language) return header
def set_unavailable(cls, course: Course, model_list_name: str, language: str, extra=False, header=None): if extra == "first": header = header body = get_unavailable(course=course, model_list_name=model_list_name, language=language, first=True) if course.is_ni_provider and "go" not in model_list_name: body = translations.term_for_key(key="unavailable_northern_ireland", language=language) else: if course.is_ni_provider and "go" not in model_list_name: body = translations.term_for_key(key="unavailable_northern_ireland", language=language) else: _object = getattr(course, model_list_name)[0] if "sector" not in model_list_name else None method = getattr(_object, "unavailable_body") if _object else None header = translations.term_for_key(key="no_data_available", language=language) body = method if extra == "final" or extra == "national": header = translations.term_for_key(key="no_data_available", language=language) return ["unavailable", header] if header is None: header = translations.term_for_key(key="no_data_available", language=language) if body is not None: return ["unavailable", header, body] else: return header
def presentable_distance_learning(course: Course, language: str) -> str: if int(course.distance_learning.code) == 1: return translations.term_for_key(key='yes', language=language) elif int(course.distance_learning.code) == 0: return translations.term_for_key(key="not_available", language=language) else: return translations.term_for_key(key="optional", language=language)
def get_sub_entry(language) -> List: list_sub_accordions = [ (translations.term_for_key(key="qualification_types", language=language), [0, 10]), (translations.term_for_key(key="ucas_tariff_points", language=language), [10, 13]), ] return list_sub_accordions
def get_sub_employment(language) -> List: list_sub_accordions = [ (translations.term_for_key(key="employment_after_the_course", language=language), [0, 9]), (translations.term_for_key(key="occupation_type", language=language), [9, 15]), ] return list_sub_accordions
def temporary_override(aggregation_level: str, language: str): if aggregation_level == "24": header = translations.term_for_key(key="this_course", language=language) return header elif aggregation_level in ["21", "22", "23"]: header = translations.term_for_key(key="message_1_header", language=language) return header
def override_replace(sub, language): if sub == translations.term_for_key(key="message_2_header", language=language): return translations.term_for_key(key="this_course", language=language) if sub == translations.term_for_key(key="message_3_header", language=language): return translations.term_for_key(key="message_4_header", language=language) return sub
def get_sub_earnings(language) -> List: list_sub_accordions = [ (translations.term_for_key(key="after_15_months", language=language), [0, 6]), (translations.term_for_key(key="after_3_years", language=language), [6, 11]), (translations.term_for_key(key="after_5_years", language=language), [11, 16]), ] return list_sub_accordions
def set_message(unavailable_key: str, aggregation_level: str, kis_level: str, language: str) -> str: message = earnings_dict[unavailable_key]["blank"] message = translations.term_for_key(key=message, language=language) if not aggregation_level == "blank": message = earnings_dict[unavailable_key][aggregation_level].get( kis_level) message = translations.term_for_key(key=message, language=language) return message
def presentable_course_length(course: Course, language: str) -> str: label = course.length.label # when switching databases some times this was a string some times it was an int. Remove if data normalised number_of_years = label if type(label) == int else int(label.split()[0]) if number_of_years > 1: word_year = translations.term_for_key(key="years", language=language) else: word_year = translations.term_for_key(key="year", language=language) label = f"{number_of_years} {word_year}" if not number_of_years == 0 else "" return label
def multiple_subjects(cls, course: Course, stat: str, model_list_name: str, language: str, prefix="", extra=False): response = dict(subject=[], values=[]) no_data = translations.term_for_key(key="no_data_available", language=language) for index, subject in enumerate(course.subject_names): subject_name = subject.display_subject_name() values = cls.set_unavailable( course=course, model_list_name=model_list_name, language=language, extra=extra ) if index < len(getattr(course, model_list_name)): _object = getattr(course, model_list_name)[index] method = getattr(_object, stat) if extra == "first": mode = translations.term_for_key(course.mode.label, language=language) course_string = f'{mode} {method} {translations.term_for_key("course", language=language)}' if method else values header = course_string if method else translations.term_for_key(key="no_data_available", language=language) values = cls.set_unavailable( course=course, model_list_name=model_list_name, language=language, extra=extra, header=header ) elif extra == "institution": institution = course.institution_name values = render_to_string( "courses/partials/institution_snippet.html", context=dict( additional_field=institution, field=f"{prefix}{method}" ) ) if method else values elif extra == "final": country = getattr(_object, "country") values = render_to_string( "courses/partials/country_population.html", context=dict( additional_field=country, field=method ) ) if method else values else: values = f"{prefix}{method}" if method else values response["values"].append(values) response["subject"].append(subject_name) return response
def get_context(self, request): context = super().get_context(request) language = self.get_language() context['institutions_list'] = InstitutionList.get_options()[language] context['language'] = language context['search_info'] = { 'institutions': "", 'number_options_selected': translations.term_for_key('number_options_selected', language), 'institution_name': translations.term_for_key('institution_name', language), 'select_all_results': translations.term_for_key('select_all_results', language), 'select_all_institutions': translations.term_for_key('select_all_institutions', language) } return context
def string_for_code(code: int, language: str, error: str) -> str: # called from multiple methods, if one requires a change # in terms of the string returned for the code, consider a new method vs editing this one if code == 0: option = translations.term_for_key(key='not_available', language=language) elif code == 1: option = translations.term_for_key(key='optional', language=language) elif code == 2: option = translations.term_for_key(key='compulsory', language=language) else: logger.warning(f"String for code not available: {code} {error}") option = {} return option
def __init__(self, jobs_data, display_language): self.display_language = display_language self.jobs = [] if jobs_data: self.aggregation = jobs_data.get('aggregation') self.number_of_students = jobs_data.get('number_of_students', 0) self.response_rate = str(jobs_data.get('response_rate', 0)) + '%' subject_data = jobs_data.get('subject', {}) self.subject_code = subject_data.get('code', '') self.subject_english = subject_data.get('english_label', '') self.subject_welsh = subject_data.get('welsh_label', '') unavailable_data = jobs_data.get('unavailable', {}) if unavailable_data == "": unavailable_data = {} self.unavailable_code = unavailable_data.get('code') self.unavailable_reason = unavailable_data.get('reason', '') self.unavailable_reason_english = unavailable_data.get('reason_english', '') self.unavailable_reason_welsh = unavailable_data.get('reason_welsh', '') self.unavailable_find_out_more_english = unavailable_data.get('find_out_more_english', '') self.unavailable_find_out_more_welsh = unavailable_data.get('find_out_more_welsh', '') self.unavailable_url_english = unavailable_data.get('url_english', '') self.unavailable_url_welsh = unavailable_data.get('url_welsh', '') if jobs_data.get('list'): for job in jobs_data.get('list'): job['job'] = translations.term_for_key( key=job['job'], language=self.display_language) self.jobs.append(Job(job, self.display_language))
def render_with_language_context(request, template, context, language, status=200): default = dict( page={"get_language": language, "compare_heading": translations.term_for_key("can_compare_courses", language)}) context = {**default, **context} return render(request, template, context, status=status)
def get_multiple_subjects(courses: List[Course], sources: List[str], language, earnings=False, override=False) -> Dict[str, List[str]]: subjects = dict(subject=[]) for course in courses: subject_list = list() subject_names = course.subject_names for index, subject_name in enumerate(subject_names): subject = get_subject_label(course, index, sources, language, earnings, subject_names) no_data_available = translations.term_for_key( key="no_data_available", language=language) # TODO: remove when the override is to be disabled # + remove override parameter from this function and graduate and employment context if override: subject = override_replace(subject, language) # End remove if not subject == no_data_available: subject_list.append(subject) subjects["subject"].append(subject_list) return subjects
def data_not_available(**kwargs): language = kwargs.get('language') subject = kwargs.get('subject') no_data = translations.term_for_key(key="no_data_available", language=language) if subject == no_data: return "hidden" return ""
def get_translation(*_, **kwargs): key = kwargs.get('key') language = kwargs.get('language') term = translations.term_for_key(key, language) if 'substitutions' in kwargs: term = term % kwargs.get('substitutions') return term
def presentable_course_mode(course: Course, language: str) -> str: # Create course mode label as we want it presented in template label = course.mode.label if label == "Both": response = f"{translations.term_for_key('Full-time', language=language)}/{translations.term_for_key('Part-time', language=language)}" else: response = translations.term_for_key(label, language=language) return response
def presentable_accreditation(course: Course, language: str) -> str: value = True if len(course.accreditations) > 0 else False none_text = translations.term_for_key(key='none_recorded', language=language) if value: return '<i class="fas fa-check-circle course_comparison-table__tick-icon"></i>' else: return f"-<br/>{none_text}"
def generate_dict(self) -> dict: alt_text = translations.term_for_key(key="open_tab", language=self.language) for course in self.courses: link = course.course_links['course_details'][0].link self.data['info']['values'].append( f"<a class='institution-link' href='{link}' target='_blank'>{course.institution_name}" f"<img src='/static/images/new_tab_icon.png' alt={alt_text}></a>" ) return self.data
def show_has_no_bookmarked_courses(request, language): # print("OPTIONS::: ", InstitutionList.get_options()[utils.get_language(request.get_full_path())]) context = dict( institutions_list=InstitutionList.get_options()[language], search_info={ 'institutions': "", 'number_options_selected': translations.term_for_key('number_options_selected', language), 'institution_name': translations.term_for_key('institution_name', language), 'select_all_results': translations.term_for_key('select_all_results', language), 'select_all_institutions': translations.term_for_key('select_all_institutions', language) } ) return render_with_language_context( request=request, template='courses/comparison/has_no_saved_courses.html', context=context, language=language, status=206 )
def set_unavailable(cls, course: Course, model_list: str, language: str, index=0): try: accordion = translations.term_for_key(key="graduate_perceptions", language=language) _object = getattr(course, model_list)[index] body = getattr(_object, "unavailable_reason_body") header = get_unavailable(course=course, model_list=model_list, language=language, index=index, accordion=accordion) except Exception as e: header = translations.term_for_key(key="no_data_available", language=language) _object = getattr(course, "display_no_data")() body = _object["reason"] return ["unavailable", header, body]
def nav_menu_render(request): url = request.get_full_path() language = get_language(url) search_page = get_page_for_language(language, HomePage.objects.all()) comparison_page = get_page_for_language(language, CourseComparisonPage.objects.all()) bookmark_page = get_page_for_language(language, CourseManagePage.objects.all()) brand_logo = { 'img': 'images/logos/nav_logo_english.svg', 'url': '/' } if language == enums.languages.ENGLISH else { 'img': 'images/logos/nav_logo_welsh.svg', 'url': '/cy/' } return { 'navigation': { 'brand_logo': brand_logo, 'primary_menu': get_menu(Menu, language, 'menu_items'), 'comp_menu': [ {'label': translations.term_for_key(key='search', language=language), 'img': static('images/search_icon.svg'), 'url': search_page.url if search_page else None, 'alt': 'Search Page'}, {'label': translations.term_for_key(key='compare', language=language), 'img': static('images/compare_icon.svg'), 'url': comparison_page.url if comparison_page else None, 'alt': 'Comparison'}, {'label': translations.term_for_key(key='saved', language=language), 'img': static('images/white-bookmark.svg'), 'url': bookmark_page.url if bookmark_page else None, 'alt': 'Saved', 'additional': True} ], 'footer_menu': get_menu(Footer, language, 'footer_items') } }
def get_translations(request): if request.is_ajax(): if request.method == 'POST': response = [] body = json.loads(request.body.decode('utf-8')) # print("body as json = ", body) language = body['language'] if len(body['terms']) > 25: raise Exception("to big") terms = body['terms'] for key in terms: response.append( translations.term_for_key(key, language=language)) return JsonResponse(response, safe=False) return HttpResponse("invalid", status=400)
def get_sub_satisfaction(language) -> List: list_sub_accordions = [ (translations.term_for_key(key="teaching_on_my_course", language=language), [1, 2, 3, 4]), (translations.term_for_key(key="learning_opportunities", language=language), [5, 6, 7]), (translations.term_for_key(key="assessment_and_feedback", language=language), [8, 9, 10, 11]), (translations.term_for_key(key="academic_support", language=language), [12, 13, 14]), (translations.term_for_key(key="organisation_and_management", language=language), [15, 16, 17]), (translations.term_for_key(key="learning_resources", language=language), [18, 19, 20]), (translations.term_for_key(key="learning_community", language=language), [21, 22]), (translations.term_for_key(key="student_voice", language=language), [23, 24, 25, 26]) ] return list_sub_accordions
def set_unavailable(cls, course: Course, model_list: str, language: str, index=0): # noinspection PyBroadException if index < len(getattr(course, model_list)): _object = getattr(course, model_list)[index] body = getattr(_object, "unavailable_reason_body") header = get_unavailable(course=course, model_list=model_list, language=language, index=index) else: header = translations.term_for_key(key="no_data_available", language=language) _object = getattr(course, "display_no_data")() body = _object["reason"] return ["unavailable", header, body, index]
def set_course_links(self, links, language): link_objs = {'course_details': [], 'costs_support': []} if enums.uni_link_keys.COURSE in links: link_objs.get('course_details').append( CourseLink(translations.term_for_key(enums.uni_link_keys.COURSE, self.display_language), links.get(enums.uni_link_keys.COURSE), enums.languages_map.get(language))) if enums.uni_link_keys.TEACHING_METHODS in links: link_objs.get('course_details').append( CourseLink(translations.term_for_key(enums.uni_link_keys.TEACHING_METHODS, self.display_language), links.get(enums.uni_link_keys.TEACHING_METHODS), enums.languages_map.get(language))) if enums.uni_link_keys.ASSESSMENT in links: link_objs.get('course_details').append( CourseLink(translations.term_for_key(enums.uni_link_keys.ASSESSMENT, self.display_language), links.get(enums.uni_link_keys.ASSESSMENT), enums.languages_map.get(language))) if enums.uni_link_keys.EMPLOYMENT in links: link_objs.get('course_details').append( CourseLink(translations.term_for_key(enums.uni_link_keys.EMPLOYMENT, self.display_language), links.get(enums.uni_link_keys.EMPLOYMENT), enums.languages_map.get(language))) if enums.uni_link_keys.COSTS in links: link_objs.get('costs_support').append( CourseLink(translations.term_for_key(enums.uni_link_keys.COSTS, self.display_language), links.get(enums.uni_link_keys.COSTS), enums.languages_map.get(language))) if self.locations and self.locations[0].links and enums.uni_link_keys.ACCOMMODATION in self.locations[0].links: link_objs.get('costs_support').append( CourseLink(translations.term_for_key(enums.uni_link_keys.ACCOMMODATION, self.display_language), self.locations[0].links.get( enums.uni_link_keys.ACCOMMODATION), enums.languages_map.get(language))) if enums.uni_link_keys.FINANCIAL_SUPPORT in links: link_objs.get('costs_support').append( CourseLink(translations.term_for_key(enums.uni_link_keys.FINANCIAL_SUPPORT, self.display_language), links.get(enums.uni_link_keys.FINANCIAL_SUPPORT), enums.languages_map.get(language))) return link_objs
def term_for_key(self, key, language): return translations.term_for_key(key=key, language=language)