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)
