def getPreferredLanguages(self):
"""See the IRequestPreferredLanguages interface"""
codes = IUserPreferredLanguages(self.request).getPreferredLanguages()
languageset = getUtility(ILanguageSet)
languages = set()
for code in codes:
# We need to ensure that the code received contains only ASCII
# characters otherwise SQLObject will crash if it receives a query
# with non printable ASCII characters.
if isinstance(code, str):
try:
code = code.decode('ASCII')
except UnicodeDecodeError:
# skip language codes that can't be represented in ASCII
continue
else:
try:
code = code.encode('ASCII')
except UnicodeEncodeError:
# skip language codes that can't be represented in ASCII
continue
code = languageset.canonicalise_language_code(code)
try:
languages.add(languageset[code])
except KeyError:
pass
languages = [language for language in languages if language.visible]
return sorted(languages, key=lambda x: x.englishname)
def getPreferredLanguages(self):
# If the default locale negotiater can get a value,
# that means we had a parameter or one of the cookies
# (because of the subscriber that gets us here).
negotiated = default_locale_negotiator(self.request)
if negotiated:
return [negotiated]
# Here is where we would check for something during traversal,
# but we don't actually support that at this time because it
# relies on implementation details
# Is there a non-default user preference? Right now we know
# what a default is due to implementation details above. We also
# know for sure that we *have* a remote use, otherwise we wouldn't
# be here
remote_user = IPrincipal(self.request, None)
remote_user_langs = IUserPreferredLanguages(remote_user)
if remote_user_langs is not EnglishUserPreferredLanguagesImpl:
return remote_user_langs.getPreferredLanguages() # pylint:disable=too-many-function-args
# Ok, see what the HTTP request can come up with. Note that we're
# going to the Zope interface so that we don't get into an infinite
# loop
browser_request = IBrowserRequest(self.request)
browser_langs = IModifiableUserPreferredLanguages(browser_request)
return browser_langs.getPreferredLanguages() # pylint:disable=too-many-function-args
def preferred_language_locale_negotiator(request):
"""
A pyramid locale negotiator that piggybacks off
the preferred language support. We return a valid locale
name consisting of at most language-territory, but at least language.
A valid locale is one for which we have available locale data,
not necessarily one for which any translation data is available.
"""
# pylint:disable=too-many-function-args, assignment-from-no-return
# This code is similar to that in zope.publisher.http.HTTPRequest.
# it's point is to find the most specific available locale possible.
# We differ in that, instead of returning a generic default, we
# specifically return the english default. We also differ in that we
# return a locale name instead of a locale object.
result = EnglishUserPreferredLanguagesImpl.PREFERRED_LANGUAGES[0]
pref_langs = IUserPreferredLanguages(request, ())
if pref_langs:
pref_langs = pref_langs.getPreferredLanguages()
for lang in pref_langs:
parts = (lang.split('-') + [None, None])[:3]
try:
locales.getLocale(*parts)
result = lang
break
except LoadLocaleError: # pragma: no cover
continue
return result
def adjust_request_interface_for_preferred_languages(event):
"""
Checks the conditions outlined in this package's documentation and
adds a marker interface (:class:`.IPreferredLanguagesRequest`) to
the request if they hold true.
This is registered as a subscriber for Pyramid's
:class:`.IContextFound` event by this package's ``configure.zcml``
"""
request = event.request
# Does pyramid's default negotiator, which uses explicit settings
# like a request param or cookie have an answer? If so, we need
# our custom policy...these override the Accept-Language header
if default_locale_negotiator(request):
interface.alsoProvides(request, IPreferredLanguagesRequest)
return
# What about the zope/plone cookie?
if request.cookies.get('I18N_LANGUAGE'):
# For benefit of the default localization machinery
# in case it's used, copy
request._LOCALE_ = request.cookies.get('I18N_LANGUAGE')
interface.alsoProvides(request, IPreferredLanguagesRequest)
return
# Ok, is there an authenticated user with preferred languages?
# (We leave detecting defaults up to the actual policy)
remote_user = IPrincipal(request, None)
if remote_user and not IUnauthenticatedPrincipal.providedBy(remote_user):
remote_user_langs = IUserPreferredLanguages(remote_user)
if remote_user_langs and remote_user_langs.getPreferredLanguages(): # pylint:disable=too-many-function-args
interface.alsoProvides(request, IPreferredLanguagesRequest)
def normalize(self, text):
"""Returns a normalized Unicode string."""
locale = None
langs = IUserPreferredLanguages(self.context).getPreferredLanguages()
if langs:
locale = langs[0]
util = queryUtility(IURLNormalizer)
return util.normalize(text, locale=locale)
def hour_time_formatter(self, timeobj):
"""uses zope.i18n.locales to determine hour/min format
"""
#grab locale from request
languages = IUserPreferredLanguages(self.request)
langs = languages.getPreferredLanguages()
if langs:
parts = (langs[0].split('-') + [None, None])[:3]
else:
parts = (None, None, None)
locale = locales.getLocale(*parts)
#create formatted hour minute string
formatter = locale.dates.getFormatter('time', 'short')
return formatter.format(timeobj)
def _getLocale(request):
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
return None
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
return locales.getLocale(*parts)
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
return locales.getLocale(None, None, None)
def getLanguage(self):
"""
Ogone requires en_EN or en_US language id
We are parsing the request to get the right
Note: took this code from getpaid.ogone (thanks)
"""
languages = IUserPreferredLanguages(self.context.REQUEST)
langs = languages.getPreferredLanguages()
if langs:
language = langs[0]
else:
plone_props = getToolByName(self.context, 'portal_properties')
language = plone_props.site_properties.default_language
language = language.split('-')
if len(language) == 1:
language.append(language[0])
language = language[:2]
return "_".join(language)
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def browser_language(self):
language = 'en'
pl = IUserPreferredLanguages(self.request)
if pl is not None:
languages = pl.getPreferredLanguages()
for httplang in languages:
parts = (httplang.split('-') + [None, None])[:3]
if parts[0] == parts[1]:
# Avoid creating a country code for simple languages codes
parts = [parts[0], None, None]
try:
locale = locales.getLocale(*parts)
language = locale.getLocaleID().replace('_', '-').lower()
break
except LoadLocaleError:
# Just try the next combination
pass
return language
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Always add the template language to the available ones. This allows the
# template language to be picked without the need for a message catalog
# for every domain for it to be registered.
langs = list(langs) + TEMPLATE_LANGUAGE
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def setupLocale(self, request):
# slightly adapted from zope.publisher.http.HTTPRequest.setupLocale
if getattr(request, 'locale', None) is not None:
return
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
request.locale = locales.getLocale(None, None, None)
return
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
request.locale = locales.getLocale(*parts)
return
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
request.locale = locales.getLocale(None, None, None)
def _langs(self):
langs = IUserPreferredLanguages(self.request)
return langs.getPreferredLanguages()
def languages(self):
upl = IUserPreferredLanguages(self.request)
if ICookieLanguageSelector.providedBy(upl):
return upl.getLanguageList()
return None
def selected_lang(self):
upl = IUserPreferredLanguages(self.request)
return upl.getSelectedLanguage()
def language(self):
return IUserPreferredLanguages(self.request).getPreferredLanguages()[0]
