def send(self, request):
if (not self.last_email) or self.last_email + timedelta(hours=12) < now(): # TODO: TIMEDELTA mit config
old_lang = translation.get_language()
translation.activate(self.user.language)
link = reverse('poll_vote', args=(self.poll.url,)) # TODO: hier direkt das poll oder das Vote?
email_content = render_to_string('invitations/mail_invite.txt', {
'receiver': self.user.username,
'creator': self.creator.username,
'link': link
})
try:
send_mail("Invitation to vote on {}".format(self.poll.title), email_content, None, [self.user.email])
self.last_email = now()
self.save()
except SMTPRecipientsRefused:
translation.activate(old_lang)
messages.error(
request, _("The mail server had an error sending the notification to {}".format(self.user.username))
)
translation.activate(old_lang)
else:
messages.error(
request, _("You have send an Email for {} in the last 12 Hours".format(self.user.username))
)
python类get_language()的实例源码
def _select_locale(self, request):
supported = request.event.locales
language = (
self._language_from_user(request, supported)
or self._language_from_cookie(request, supported)
or self._language_from_browser(request, supported)
or request.event.locale
)
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
with suppress(pytz.UnknownTimeZoneError):
tzname = request.event.timezone
timezone.activate(pytz.timezone(tzname))
request.timezone = tzname
def _send_invitation_mail(request, invitation, subject, template_name):
if not invitation.invitee.email:
return
old_lang = translation.get_language()
translation.activate(invitation.invitee.language)
template = loader.get_template('groups/mail_{0}.txt'.format(template_name))
message = template.render({
'invitation': invitation,
'site': get_current_site(request)
})
translation.activate(old_lang)
send_mail(settings.EMAIL_SUBJECT_PREFIX + subject,
message,
settings.DEFAULT_FROM_EMAIL,
[invitation.invitee.email],
fail_silently=True)
def configurePayment(self, **kwargs):
# URL de pago según el entorno
self.url = self.CECA_URL[self.parent.environment]
# Formato para Importe: según ceca, ha de tener un formato de entero positivo
self.importe = "{0:.2f}".format(float(self.parent.operation.amount)).replace(".", "")
# Idioma de la pasarela, por defecto es español, tomamos
# el idioma actual y le asignamos éste
self.idioma = self.IDIOMAS["es"]
lang = translation.get_language()
if lang in self.IDIOMAS:
self.idioma = self.IDIOMAS[lang]
####################################################################
## Paso 1.2. Preparación del TPV y Generación del número de operación
def configurePayment(self, **kwargs):
# URL de pago según el entorno
self.url = self.REDSYS_URL[self.parent.environment]
# Formato para Importe: según redsys, ha de tener un formato de entero positivo, con las dos últimas posiciones
# ocupadas por los decimales
self.importe = "{0:.2f}".format(float(self.parent.operation.amount)).replace(".", "")
if self.importe == "000":
self.importe = "0"
# Idioma de la pasarela, por defecto es español, tomamos
# el idioma actual y le asignamos éste
self.idioma = self.IDIOMAS["es"]
lang = translation.get_language()
if lang in self.IDIOMAS:
self.idioma = self.IDIOMAS[lang]
####################################################################
## Paso 1.2. Preparación del TPV y Generación del número de operación
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def pootle_context(request):
"""Exposes settings to templates."""
# FIXME: maybe we should expose relevant settings only?
return {
'settings': {
'POOTLE_TITLE': settings.POOTLE_TITLE,
'POOTLE_INSTANCE_ID': settings.POOTLE_INSTANCE_ID,
'POOTLE_CONTACT_ENABLED': (settings.POOTLE_CONTACT_ENABLED and
settings.POOTLE_CONTACT_EMAIL),
'POOTLE_SIGNUP_ENABLED': settings.POOTLE_SIGNUP_ENABLED,
'POOTLE_CACHE_TIMEOUT': settings.POOTLE_CACHE_TIMEOUT,
'TZ': settings.TIME_ZONE,
'TZ_OFFSET': TZ_OFFSET,
'DEBUG': settings.DEBUG,
},
'custom': settings.POOTLE_CUSTOM_TEMPLATE_CONTEXT,
'ALL_LANGUAGES': Language.live.cached_dict(translation.get_language(),
request.user.is_superuser),
'ALL_PROJECTS': Project.objects.cached_dict(request.user),
'SOCIAL_AUTH_PROVIDERS': _get_social_auth_providers(request),
'display_agreement': _agreement_context(request),
}
def try_geolocator_reverse(coords):
"""
Tries many times to get a geolocator object from coordinates,
or None.
"""
if settings.TESTING:
return test_mockers.geolocator_object(coords=coords)
attempts = 0
while attempts < settings.GOOSE_META["max_geolocation_attempts"]:
try:
position = geolocator.reverse(
coords, language=get_language().split('-')[0]
)
return position
except geopy.exc.GeopyError as e:
attempts += 1
if attempts == settings.GOOSE_META["max_geolocation_attempts"]:
debug_logger.error(
"Too much geopy errors ({}). Aborting.".format(str(e))
)
return None
def try_geolocator_geocode(address):
"""
Tries many times to get a geolocator object from an address,
or None.
"""
if settings.TESTING:
return test_mockers.geolocator_object(address=address)
attempts = 0
while attempts < settings.GOOSE_META["max_geolocation_attempts"]:
try:
position = geolocator.geocode(
address, language=get_language().split('-')[0]
)
return position
except geopy.exc.GeopyError as e:
attempts += 1
if attempts == settings.GOOSE_META["max_geolocation_attempts"]:
debug_logger.error(
"Too much geopy errors ({}). Aborting.".format(str(e))
)
return None
def record_history(self, sender, instance, **kwargs):
"""When a page is published, make a new PublishHistory object"""
from .models import EditHistory, PublishHistory
# Make sure we have the draft version.
if not instance.publisher_is_draft:
instance = publisher_draft
editings = EditHistory.objects.filter(
page_id=instance.id,
published_in__isnull=True,
)
if editings.count() == 0:
# No changes happened, skip!
return
public = instance.publisher_public
user_id = cache.get('cms-user-id')
history = PublishHistory.objects.create(
page=public, user_id=user_id, language=get_language())
history.editings = editings
history.save()
def cached_student(self):
if not self._cache_student_last_update or self._cache_student_last_update < timezone.now() - datetime.timedelta(
days=self._cache_student_days):
self.force_cache_student()
return AttrDict({
'pk': self.student_id,
'id': self.student_id,
'unicode': self._cache_student_name if get_language() != 'ja' else self._cache_student_japanese_name,
'name': self._cache_student_name,
'japanese_name': self._cache_student_japanese_name,
'image': self._cache_student_image,
'image_url': get_image_url_from_path(self._cache_student_image),
'http_image_url': get_http_image_url_from_path(self._cache_student_image),
'item_url': u'/student/{}/{}/'.format(self.student_id, tourldash(self._cache_student_name)),
'ajax_item_url': u'/ajax/student/{}/'.format(self.student_id),
})
# Cache totals
def render(self, name, value, attrs=None):
self.editor_options.setdefault('language', get_language())
attrs = attrs or {}
attrs.setdefault('class', '')
attrs['class'] += ' ckeditor-field'
output = super(DefaultWidget, self).render(name, value, attrs)
output += mark_safe('''
<script type="text/javascript">
window._ckeditor_confs = window._ckeditor_confs || {};
window._ckeditor_confs["%s"] = %s;
</script>
''' % (name, json.dumps(self.editor_options)))
return output
def get_static_map_url(longitude, latitude, zoom=None, width=None, height=None):
""" ?????????? URL ????????? ????? Google """
if not latitude or not longitude:
longitude, latitude = conf.DEFAULT_MAP_CENTER
point = _format_point(longitude, latitude)
return conf.STATIC_MAP_URL + parse.urlencode(dict(
center=point,
size='%dx%d' % (
width or conf.STATIC_MAP_WIDTH,
height or conf.STATIC_MAP_HEIGHT,
),
zoom=zoom or conf.STATIC_MAP_ZOOM,
maptype='roadmap',
language=get_language(),
markers='color:red|label:G|%s' % point,
))
def kolibri_language_globals(context):
lang_dir = "rtl" if get_language_bidi() else "ltr"
js = """
<script>
var languageCode = '{lang_code}';
var languageDir = '{lang_dir}';
var languages = JSON.parse('{languages}');
</script>
""".format(
lang_code=get_language(),
lang_dir=lang_dir,
languages=json.dumps({code: {
# Format to match the schema of the content Language model
'id': code,
'lang_name': name,
'lang_direction': get_language_info(code)['bidi']
} for code, name in settings.LANGUAGES}),
)
return mark_safe(js)
def _select_locale(self, request):
supported = request.event.locales if (hasattr(request, 'event') and request.event) else settings.LANGUAGES
language = (
self._language_from_user(request, supported)
or self._language_from_cookie(request, supported)
or self._language_from_browser(request, supported)
)
if hasattr(request, 'event') and request.event:
language = language or request.event.locale
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
with suppress(pytz.UnknownTimeZoneError):
if request.user.is_authenticated:
tzname = request.user.timezone
elif hasattr(request, 'event') and request.event:
tzname = request.event.timezone
else:
tzname = settings.TIME_ZONE
timezone.activate(pytz.timezone(tzname))
request.timezone = tzname
def cached_member(self):
if not self.member_id:
return None
if not self._cache_member_last_update or self._cache_member_last_update < timezone.now() - datetime.timedelta(days=self._cache_member_days):
self.force_cache_member()
return AttrDict({
'pk': self.member_id,
'id': self.member_id,
'unicode': self._cache_member_name if get_language() != 'ja' else self._cache_member_japanese_name,
'name': self._cache_member_name,
'japanese_name': self._cache_member_japanese_name,
'image': self._cache_member_image,
'image_url': get_image_url_from_path(self._cache_member_image),
'http_image_url': get_http_image_url_from_path(self._cache_member_image),
'item_url': u'/member/{}/{}/'.format(self.member_id, tourldash(self._cache_member_name)) if self.member_id else '#',
'ajax_item_url': u'/ajax/member/{}/'.format(self.member_id) if self.member_id else '',
})
# Cache event
def cached_event(self):
if not self._cache_event_last_update or self._cache_event_last_update < timezone.now() - datetime.timedelta(days=self._cache_event_days):
self.force_cache_event()
if not self._cache_event_id:
return None
return AttrDict({
'pk': self._cache_event_id,
'id': self._cache_event_id,
'unicode': self._cache_event_name if get_language() != 'ja' else self._cache_event_japanese_name,
'name': self._cache_event_name,
'japanese_name': self._cache_event_japanese_name,
'image': self._cache_event_image,
'image_url': get_image_url_from_path(self._cache_event_image),
'http_image_url': get_http_image_url_from_path(self._cache_event_image),
'item_url': u'/event/{}/{}/'.format(self._cache_event_id, tourldash(self._cache_event_name)),
'ajax_item_url': u'/ajax/event/{}/'.format(self._cache_event_id),
})
# Cache gacha
def __unicode__(self):
if self.id:
return u'{rarity} {member_name} - {attribute}{name}'.format(
rarity=self.rarity,
member_name=(
self.cached_member.japanese_name
if get_language() == 'ja'
else self.cached_member.name)
if self.cached_member else '',
attribute=self.attribute,
name=(u' - {}'.format(
self.japanese_name
if (get_language() == 'ja' and self.japanese_name) or not self.name
else self.name) if self.name or self.japanese_name else ''),
)
return u''
############################################################
# Owned Cards
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def __iter__(self):
yield 'js/bootstrap-datepicker.min.js'
lang = translation.get_language()
if lang:
lang = lang.lower()
# There is language name that length>2 or contains uppercase.
lang_map = {
'en-au': 'en-AU',
'en-gb': 'en-GB',
'en-us': 'en-us',
'fr-CH': 'fr-CH',
'it-ch': 'it-CH',
'nl-be': 'nl-BE',
'pt-br': 'pt-BR',
'rs-latin': 'rs-latin',
'sr-latin': 'sr-latin',
'zh-cn': 'zh-CN',
'zh-tw': 'zh-TW',
}
if len(lang) > 2:
lang = lang_map.get(lang, 'en-us')
if lang not in ('en', 'en-us'):
yield 'js/locales/bootstrap-datepicker.%s.min.js' % (lang)
def regex(self):
"""
Returns a compiled regular expression, depending upon the activated
language-code.
"""
language_code = get_language()
if language_code not in self._regex_dict:
if isinstance(self._regex, six.string_types):
regex = self._regex
else:
regex = force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def test_model_attributes(self):
posts = []
posts.append(MultiLanguagePost.objects.create(
title='first post',
slug='first-post',
))
posts.append(MultiLanguagePost.objects.create(
title='second post',
slug='second-post',
))
for language in [get_language()]:
with override(language):
for post in posts:
knock_create = post.as_knock(True)
self.assertEqual(knock_create['title'],
'new {0}'.format(post._meta.verbose_name))
self.assertEqual(knock_create['message'], post.title)
self.assertEqual(knock_create['language'], language)
def notify_items(**kwargs):
"""
Signal endpoint that actually sends knocks whenever an instance is created / saved
"""
instance = kwargs.get('instance')
created = kwargs.get('created', False)
if hasattr(instance, 'send_knock') and active_knocks(instance):
try:
# This is a stupid generic interface for multilanguage models (hvad / parler)
if hasattr(instance, 'get_available_languages'):
langs = instance.get_available_languages()
else:
langs = [get_language()]
for lang in langs:
with override(lang):
instance.send_knock(created)
return True
except AttributeError: # pragma: no cover
pass
return False
def regex(self):
"""
Return a compiled regular expression based on the activate language.
"""
language_code = get_language()
if language_code not in self._regex_dict:
regex = self._regex if isinstance(self._regex, six.string_types) else force_text(self._regex)
try:
compiled_regex = re.compile(regex, re.UNICODE)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e))
)
self._regex_dict[language_code] = compiled_regex
return self._regex_dict[language_code]
def to_email(email_class, email, language=None, **data):
"""
Send email to specified email address
"""
if language:
email_class().send([email], language=language, **data)
else:
email_class().send([email], translation.get_language(), **data)
def to_user(email_class, user, **data):
"""
Email user
"""
try:
email_class().send([user.email], user.language, **data)
except AttributeError:
# this is a fallback in case the user model does not have the language field
email_class().send([user.email], translation.get_language(), **data)
def to_staff(email_class, **data):
"""
Email staff users
"""
for user in get_user_model().objects.filter(is_staff=True):
try:
email_class().send([user.email], user.language, **data)
except AttributeError:
email_class().send([user.email], translation.get_language(), **data)
