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