def get(self, *args, **kwargs):
# Log the user out.
auth.logout(self.request)
# Set session key that middleware will use to force
# Shibboleth reauthentication.
self.request.session[LOGOUT_SESSION_KEY] = True
# Get target url in order of preference.
target = (LOGOUT_REDIRECT_URL
or quote(self.request.GET.get(self.redirect_field_name))
or quote(self.request.build_absolute_uri()))
logout = LOGOUT_URL % target
return redirect(logout)
def get(self, *args, **kwargs):
# Remove session value that is forcing Shibboleth reauthentication.
self.request.session.pop(LOGOUT_SESSION_KEY, None)
login = ('%s?target=%s' %
(settings.LOGIN_URL,
quote(self.request.GET.get(self.redirect_field_name))))
return redirect(login)
def login_link(request):
"""
This assumes your login link is the Shibboleth login page for your server
and uses the 'target' url parameter.
"""
full_path = quote(request.get_full_path())
login = reverse('shibboleth:login')
ll = "%s?target=%s" % (login, full_path)
return { 'login_link': ll }
def login_link(request):
"""
This assumes your login link is the Shibboleth login page for your server
and uses the 'target' url parameter.
"""
full_path = quote(request.get_full_path())
login = reverse('shibauth_rit:shibauth_login')
login_link = "%s?target=%s" % (login, full_path)
return {'login_link': login_link}
def login_link(request):
"""
By default: this assumes your login link is the Shibboleth login page for your server
and uses the 'target' url parameter.
"""
full_path = LOGIN_REDIRECT_URL or quote(request.get_full_path())
login = reverse('shibboleth:login')
ll = "%s?%s=%s" % (login, LOGIN_URL_PARAMETER, full_path)
return {'login_link': ll}
def logout_link(request, *args):
"""
This assumes your login link is the Shibboleth login page for your server
and uses the 'target' url parameter.
e.g: https://school.edu/Shibboleth.sso/Login
"""
#LOGOUT_REDIRECT_URL specifies a default logout page that will always be used when
#users logout from Shibboleth.
target = LOGOUT_REDIRECT_URL or quote(request.build_absolute_uri())
logout = reverse('shibboleth:logout')
ll = "%s?target=%s" % (logout, target)
return {'logout_link': ll}
def logout_link(request, *args):
"""
This assumes your login link is the Shibboleth login page for your server
and uses the 'target' url parameter.
e.g: https://school.edu/Shibboleth.sso/Login
"""
from app_settings import LOGOUT_URL, LOGOUT_REDIRECT_URL
#LOGOUT_REDIRECT_URL specifies a default logout page that will always be used when
#users logout from Shibboleth.
target = LOGOUT_REDIRECT_URL or quote(request.build_absolute_uri())
logout = reverse('shibboleth:logout')
ll = "%s?target=%s" % (logout, target)
return { 'logout_link': ll }
def form_valid(self, form):
profile = form.cleaned_data['profile']
user = profile.user
if user is None:
url = '%s?next=%s' % (reverse('newuser', kwargs={
'pk': profile.pk
}), urllib_parse.quote(form.cleaned_data['next']))
return HttpResponseRedirect(url)
password = form.cleaned_data['password']
user = authenticate(username=user.username, password=password)
if user is None:
form.add_error('password', 'Forkert kodeord')
return self.form_invalid(form)
login(self.request, user)
logger.info("Login %s", profile, extra=self.request.log_data)
return HttpResponseRedirect(form.cleaned_data['next'])
def form_valid(self, form):
profile = form.cleaned_data['profile']
user = profile.user
if user is None:
url = '%s?next=%s' % (
reverse('newuser', kwargs={'pk': profile.pk}),
urllib_parse.quote(form.cleaned_data['next']))
return HttpResponseRedirect(url)
password = form.cleaned_data['password']
user = authenticate(username=user.username, password=password)
if user is None:
form.add_error('password', 'Forkert kodeord')
return self.form_invalid(form)
login(self.request, user)
logger.info("Login %s", profile,
extra=self.request.log_data)
return HttpResponseRedirect(form.cleaned_data['next'])
def export_glossaries_to_TBX(glossaries,
desired_languages=None,
export_all_definitions=False,
export_terms="all"):
if desired_languages is None:
desired_languages = []
if not glossaries:
raise Http404
elif len(glossaries) == 1:
glossary_data = glossaries[0]
else:
glossary_description = _("TBX file created by exporting the following "
"glossaries: ")
glossaries_names_list = []
for gloss in glossaries:
glossaries_names_list.append(gloss.name)
glossary_description += ", ".join(glossaries_names_list)
glossary_data = {
"name": _("Terminator TBX exported glossary"),
"description": glossary_description,
}
data = {
'glossary': glossary_data,
'concepts': [],
}
preferred = AdministrativeStatus.objects.get(name="Preferred")
admitted = AdministrativeStatus.objects.get(name="Admitted")
not_recommended = AdministrativeStatus.objects.get(name="Not recommended")
concept_qs = Concept.objects.filter(glossary__in=glossaries).order_by(
"glossary", "id")
#Give template an indication of whether any related concepts are used:
data["use_related_concepts"] = Concept.objects.filter(
related_concepts__id__in=concept_qs, ).exists()
translation_filter = Q()
if export_terms == 'preferred':
translation_filter |= Q(administrative_status=preferred)
elif export_terms == 'preferred+admitted':
translation_filter |= Q(administrative_status=preferred)
translation_filter |= Q(administrative_status=admitted)
elif export_terms == 'preferred+admitted+not_recommended':
translation_filter |= Q(administrative_status__in=(preferred, admitted,
not_recommended))
# Only the finished summary messages are exported
summary_filter = Q(is_finalized=True)
definition_filter = Q()
if not export_all_definitions:
definition_filter &= Q(is_finalized=True)
# Assume that there is at least a term or a definition for a used language.
glossary_filter = Q(concept__glossary__in=glossaries)
translations = Translation.objects.filter(glossary_filter
& translation_filter)
definitions = Definition.objects.filter(glossary_filter
& definition_filter)
used_languages = set(
translations.values_list('language', flat=True).distinct())
used_languages.update(
definitions.values_list('language', flat=True).distinct())
used_languages.difference_update(set(desired_languages))
used_languages = sorted(used_languages)
def key_func(obj):
return (obj.concept_id, obj.language_id)
def query_lookup_dict(qs):
results = {}
for key, group in groupby(qs, key_func):
results[key] = list(group)
return results
translations = translations.select_related(
'part_of_speech',
'grammatical_number',
'grammatical_gender',
'administrative_status',
'administrative_status_reason',
)
if "sqlite" in settings.DATABASES['default']['ENGINE']:
# SQLite can't handle more than 999 translations (by default). We do it
# in batches so that testing with SQLite is still possible.
bool(translations)
for i in range(0, len(translations), 999):
prefetch_related_objects(translations[i:i + 999],
"corpusexample_set",
"contextsentence_set")
else:
translations = translations.prefetch_related("corpusexample_set",
"contextsentence_set")
tr_dict = query_lookup_dict(translations)
def_dict = query_lookup_dict(definitions)
resources = ExternalResource.objects.filter(glossary_filter)
resource_dict = query_lookup_dict(resources)
summaries = ConceptInLanguage.objects.filter(
glossary_filter & summary_filter).only('summary')
summary_dict = query_lookup_dict(summaries)
def generate_concepts():
#generator so that we don't keep things in memory
for concept in concept_qs.iterator():
concept_data = {
'concept': concept,
'languages': [],
'externalresources': resource_dict.get((concept.id, None), [])
}
for language_code in used_languages:
key = (concept.id, language_code)
lang_translations = tr_dict.get(key, [])
lang_resources = resource_dict.get(key, [])
lang_summary_message = summary_dict.get(key, None)
if lang_summary_message:
assert len(lang_summary_message) == 1
lang_summary_message = lang_summary_message[0].summary
lang_definition = def_dict.get(key, None)
if lang_definition:
assert len(lang_definition) == 1
lang_definition = lang_definition[0]
if not any((lang_translations, lang_resources, lang_definition,
lang_summary_message)):
# no real content
continue
lang_data = {
'iso_code': language_code,
'translations': lang_translations,
'externalresources': lang_resources,
'definition': lang_definition,
'summarymessage': lang_summary_message,
}
concept_data['languages'].append(lang_data)
if concept_data['languages']:
yield concept_data
data['concepts'] = generate_concepts()
#TODO:
# Raise Http404 if there are no concepts in the resulting glossary
#if not data['concepts']:
# raise Http404
# Important enough? Can't easily do with generator.
# Create the HttpResponse object with the appropriate header.
response = HttpResponse(content_type='application/x-tbx')
if len(glossaries) == 1:
from django.utils.six.moves.urllib_parse import quote
encoded_name = b"%s.tbx" % quote(glossaries[0].name).encode('utf-8')
response[
'Content-Disposition'] = "attachment; filename=\"%s\"; filename*=UTF-8''%s" % (
encoded_name, encoded_name)
# http://test.greenbytes.de/tech/tc2231/
# The encoding of filename is wrong, but seems like it will trigger the
# right bugs in older browsers that don't support filename* to actually
# display the right filename.
else:
response[
'Content-Disposition'] = 'attachment; filename=terminator_several_exported_glossaries.tbx'
# Create the response
t = loader.get_template('export.tbx')
response.write(t.render({'data': data}))
return response
