def add_direction(value, arg=u"rtl_only"):
"""Adds direction to the element
:arguments:
arg
* rtl_only: Add the direction only in case of a
right-to-left language (default)
* both: add the direction in both case
* ltr_only: Add the direction only in case of a
left-to-right language
{{image_name|add_direction}} when image_name is 'start_arrow.png'
results in 'start_arrow_rtl.png' in case of RTL language, and
'start_arrow.png' or 'start_arrow_ltr.png' depends on `arg` value.
"""
if arg == u'rtl_only':
directions = (u'', u'_rtl')
elif arg == u'both':
directions = (u'_ltr', u'_rtl')
elif arg == u'ltr_only':
directions = (u'_ltr', u'')
else:
raise template.TemplateSyntaxError('add_direction can use arg with one of ["rtl_only", "both", "ltr_only"]')
parts = value.rsplit('.', 1)
if not len(parts):
return value
elif len(parts) == 1:
return value + directions[translation.get_language_bidi()]
else:
return '.'.join((parts[0]+directions[translation.get_language_bidi()],parts[1]))
def render(self, name, value, attrs=None):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, six.string_types):
value = self.deserialize(value)
if value:
# Check that srid of value and map match
if value.srid != self.map_srid:
try:
ogr = value.ogr
ogr.transform(self.map_srid)
value = ogr
except gdal.OGRException as err:
logger.error(
"Error transforming geometry from srid '%s' to srid '%s' (%s)" % (
value.srid, self.map_srid, err)
)
context = self.build_attrs(attrs,
name=name,
module='geodjango_%s' % name.replace('-', '_'), # JS-safe
serialized=self.serialize(value),
geom_type=gdal.OGRGeomType(self.attrs['geom_type']),
STATIC_URL=settings.STATIC_URL,
LANGUAGE_BIDI=translation.get_language_bidi(),
)
return loader.render_to_string(self.template_name, context)
def get_context(self, name, value, attrs):
context = super().get_context(name, value, attrs)
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if value and isinstance(value, str):
value = self.deserialize(value)
if value:
# Check that srid of value and map match
if value.srid and value.srid != self.map_srid:
try:
ogr = value.ogr
ogr.transform(self.map_srid)
value = ogr
except gdal.GDALException as err:
logger.error(
"Error transforming geometry from srid '%s' to srid '%s' (%s)",
value.srid, self.map_srid, err
)
if attrs is None:
attrs = {}
build_attrs_kwargs = {
'name': name,
'module': 'geodjango_%s' % name.replace('-', '_'), # JS-safe
'serialized': self.serialize(value),
'geom_type': gdal.OGRGeomType(self.attrs['geom_type']),
'STATIC_URL': settings.STATIC_URL,
'LANGUAGE_BIDI': translation.get_language_bidi(),
}
build_attrs_kwargs.update(attrs)
context.update(self.build_attrs(self.attrs, build_attrs_kwargs))
return context
def i18n(request):
from django.utils import translation
return {
'LANGUAGES': settings.LANGUAGES,
'LANGUAGE_CODE': translation.get_language(),
'LANGUAGE_BIDI': translation.get_language_bidi(),
}
def get_context(self, name, value, attrs=None, extra_context={}):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, six.text_type):
try:
value = geos.GEOSGeometry(value)
except (geos.GEOSException, ValueError):
value = None
value = None
# Defaulting the WKT value to a blank string
wkt = ''
if value:
srid = self.map_srid
if value.srid != srid:
try:
ogr = value.ogr
ogr.transform(srid)
wkt = ogr.wkt
except gdal.OGRException:
pass # wkt left as an empty string
else:
wkt = value.wkt
context = super(BaseGeometryWidget, self).get_context(name, wkt, attrs)
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
# Django >= 1.4 doesn't have ADMIN_MEDIA_PREFIX anymore, we must
# rely on contrib.staticfiles.
if hasattr(settings, 'ADMIN_MEDIA_PREFIX'):
context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
else:
context['ADMIN_MEDIA_PREFIX'] = settings.STATIC_URL + 'admin/'
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context
def get_context(self, name, value, attrs=None, extra_context={}):
# Defaulting the WKT value
wkt, location = '', None
if value:
try:
location = Area.objects.get(pk=int(value))
wkt = location.polygon.wkt
except ObjectDoesNotExist:
pass
context = super(ChooseAreaWidget, self).get_context(name, wkt,
attrs)
context['location'] = ""
context['value_pk'] = ""
if location:
context['location'] = unicode(location)
context['value_pk'] = location.pk
context['wkt'] = wkt
context['parent_table_name'] = '-'.join(name.split('-')[:-2] + ['group'])
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
# context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
context['area_types'] = AreaType.objects.exclude(txt_idx='circle').all()
context['available_locations'] = self.available_locations
return context
def marketing_link(name):
"""Returns the correct URL for a link to the marketing site
depending on if the marketing site is enabled
Since the marketing site is enabled by a setting, we have two
possible URLs for certain links. This function is to decides
which URL should be provided.
"""
# link_map maps URLs from the marketing site to the old equivalent on
# the Django site
link_map = settings.MKTG_URL_LINK_MAP
enable_mktg_site = microsite.get_value(
'ENABLE_MKTG_SITE',
settings.FEATURES.get('ENABLE_MKTG_SITE', False)
)
if enable_mktg_site and name in settings.MKTG_URLS:
# special case for when we only want the root marketing URL
if name == 'ROOT':
return settings.MKTG_URLS.get('ROOT')
if get_language_bidi():
return settings.MKTG_URLS.get('ROOT') + settings.MKTG_URLS.get(name)
else:
return settings.MKTG_URLS.get('ROOT') + 'en/' + settings.MKTG_URLS.get(name)
# only link to the old pages when the marketing site isn't on
elif not enable_mktg_site and name in link_map:
# don't try to reverse disabled marketing links
if link_map[name] is not None:
return reverse(link_map[name])
else:
log.debug("Cannot find corresponding link for name: %s", name)
return '#'
def i18n(request):
return {
'LANGUAGES': settings.LANGUAGES,
'LANG': (settings.LANGUAGE_URL_MAP.get(translation.get_language())
or translation.get_language()),
'DIR': 'rtl' if translation.get_language_bidi() else 'ltr',
}
def bidi(request):
"""Adds to the context BiDi related variables
LANGUAGE_DIRECTION -- Direction of current language ('ltr' or 'rtl')
LANGUAGE_START -- Start of language layout ('right' for rtl, 'left'
for 'ltr')
LANGUAGE_END -- End of language layout ('left' for rtl, 'right'
for 'ltr')
LANGUAGE_MARKER -- Language marker entity ('‏' for rtl, '&lrm'
for ltr)
"""
from django.utils import translation
from django.utils.safestring import mark_safe
if translation.get_language_bidi():
extra_context = {
'LANGUAGE_DIRECTION':'rtl',
'LANGUAGE_START':'right',
'LANGUAGE_END':'left',
'LANGUAGE_MARKER': mark_safe('‏'),
}
else:
extra_context = {
'LANGUAGE_DIRECTION':'ltr',
'LANGUAGE_START':'left',
'LANGUAGE_END':'right',
'LANGUAGE_MARKER': mark_safe('‎'),
}
return extra_context
def get_language_config():
"""
Creates a language configuration for TinyMCE4 based on Django project settings
:return: language- and locale-related parameters for TinyMCE 4
:rtype: dict
"""
config = {"language": get_language()[:2]}
if get_language_bidi():
config["directionality"] = "rtl"
else:
config["directionality"] = "ltr"
if mce_settings.USE_SPELLCHECKER:
from enchant import list_languages
enchant_languages = list_languages()
logger.debug("Enchant languages: {0}".format(enchant_languages))
lang_names = []
for lang, name in settings.LANGUAGES:
lang = convert_language_code(lang)
if lang not in enchant_languages:
lang = lang[:2]
if lang not in enchant_languages:
logger.error("Missing {0} spellchecker dictionary!".format(lang))
continue
if config.get("spellchecker_language") is None:
config["spellchecker_language"] = lang
lang_names.append("{0}={1}".format(name, lang))
config["spellchecker_languages"] = ",".join(lang_names)
return config
def _render_footer_html(request, show_openedx_logo, include_dependencies):
"""Render the footer as HTML.
Arguments:
show_openedx_logo (bool): If True, include the OpenEdX logo in the rendered HTML.
include_dependencies (bool): If True, include JavaScript and CSS dependencies.
Returns: unicode
"""
bidi = "rtl" if translation.get_language_bidi() else "ltr"
version = "edx" if settings.FEATURES.get("IS_EDX_DOMAIN") else "openedx"
css_name = settings.FOOTER_CSS[version][bidi]
context = {
"hide_openedx_link": not show_openedx_logo,
"footer_js_url": _footer_static_url(request, "js/footer-edx.js"),
"footer_css_urls": _footer_css_urls(request, css_name),
"bidi": bidi,
"include_dependencies": include_dependencies,
}
return (
render_to_response("footer-edx-v3.html", context)
if settings.FEATURES.get("IS_EDX_DOMAIN", False)
else render_to_response("footer.html", context)
)
def get_context(self, change=None):
"""Return context for rendering mail"""
result = {
'LANGUAGE_CODE': get_language(),
'LANGUAGE_BIDI': get_language_bidi(),
'current_site_url': get_site_url(),
'site_title': settings.SITE_TITLE,
'notification_name': self.verbose,
}
if not change:
return result
result['change'] = change
# Extract change attributes
attribs = (
'unit', 'translation', 'component', 'project', 'dictionary',
'comment', 'suggestion', 'whiteboard', 'alert',
'user',
'target', 'old', 'details',
)
for attrib in attribs:
result[attrib] = getattr(change, attrib)
if result['translation']:
result['translation_url'] = get_site_url(
result['translation'].get_absolute_url()
)
return result
def get_context(self, name, value, attrs=None, extra_context={}):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, basestring):
try:
value = geos.GEOSGeometry(value)
except (geos.GEOSException, ValueError):
value = None
if (value and
value.geom_type.upper() != self.geom_type and
self.geom_type != 'GEOMETRY'):
value = None
# Defaulting the WKT value to a blank string
wkt = ''
if value:
srid = self.map_srid
if value.srid != srid:
try:
ogr = value.ogr
ogr.transform(srid)
wkt = ogr.wkt
except gdal.OGRException:
pass # wkt left as an empty string
else:
wkt = value.wkt
context = super(BaseGeometryWidget, self).get_context(name, wkt, attrs)
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context
def _render_footer_html(request, show_openedx_logo, include_dependencies, include_language_selector, language):
"""Render the footer as HTML.
Arguments:
show_openedx_logo (bool): If True, include the OpenEdX logo in the rendered HTML.
include_dependencies (bool): If True, include JavaScript and CSS dependencies.
include_language_selector (bool): If True, include a language selector with all supported languages.
Returns: unicode
"""
bidi = 'rtl' if translation.get_language_bidi() else 'ltr'
css_name = settings.FOOTER_CSS['openedx'][bidi]
context = {
'hide_openedx_link': not show_openedx_logo,
'footer_js_url': _footer_static_url(request, 'js/footer-edx.js'),
'footer_css_urls': _footer_css_urls(request, css_name),
'bidi': bidi,
'include_dependencies': include_dependencies,
'include_language_selector': include_language_selector,
'language': language
}
return render_to_response("footer.html", context)
def _render_footer_html(request, show_openedx_logo, include_dependencies):
"""Render the footer as HTML.
Arguments:
show_openedx_logo (bool): If True, include the OpenEdX logo in the rendered HTML.
include_dependencies (bool): If True, include JavaScript and CSS dependencies.
Returns: unicode
"""
bidi = 'rtl' if translation.get_language_bidi() else 'ltr'
version = 'edx' if settings.FEATURES.get('IS_EDX_DOMAIN') else 'openedx'
css_name = settings.FOOTER_CSS[version][bidi]
context = {
'hide_openedx_link': not show_openedx_logo,
'footer_js_url': _footer_static_url(request, 'js/footer-edx.js'),
'footer_css_urls': _footer_css_urls(request, css_name),
'bidi': bidi,
'include_dependencies': include_dependencies,
}
return (
render_to_response("footer-edx-v3.html", context)
if settings.FEATURES.get("IS_EDX_DOMAIN", False)
else render_to_response("footer.html", context)
)
def i18n(request):
from django.utils import translation
context_extras = {}
context_extras['LANGUAGES'] = settings.LANGUAGES
context_extras['LANGUAGE_CODE'] = translation.get_language()
context_extras['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context_extras
def __init__(self, attrs={}, *args, **kwargs):
attrs['data-placeholder'] = kwargs.pop('overlay', None)
attrs['data-chosen-options'] = json.dumps(kwargs.pop('chosen_options', {'search_contains': True}))
attrs['class'] = "class" in attrs and self.add_to_css_class(
attrs['class'], 'chosen-select') or "chosen-select"
if get_language_bidi():
attrs['class'] = self.add_to_css_class(attrs['class'], 'chosen-rtl')
super(ChosenWidgetMixin, self).__init__(attrs, *args, **kwargs)
def __init__(self, attrs={}, *args, **kwargs):
attrs['data-placeholder'] = kwargs.pop('overlay', None)
attrs['class'] = "class" in attrs and self.add_to_css_class(
attrs['class'], 'chosen-select') or "chosen-select"
if get_language_bidi():
attrs['class'] = self.add_to_css_class(attrs['class'], 'chosen-rtl')
super(ChosenWidgetMixin, self).__init__(attrs, *args, **kwargs)
def i18n(request):
from django.utils import translation
return {
"LANGUAGES": settings.LANGUAGES,
"LANGUAGE_CODE": translation.get_language(),
"LANGUAGE_BIDI": translation.get_language_bidi(),
}
def get_notification_email(language, email, notification,
context=None, info=None):
"""Render notification email."""
context = context or {}
headers = {}
LOGGER.info(
'sending notification %s on %s to %s',
notification,
info,
email
)
with override('en' if language is None else language):
# Template name
context['subject_template'] = 'mail/{0}_subject.txt'.format(
notification
)
context['LANGUAGE_CODE'] = get_language()
context['LANGUAGE_BIDI'] = get_language_bidi()
# Adjust context
context['current_site_url'] = get_site_url()
context['site_title'] = settings.SITE_TITLE
# Render subject
subject = render_to_string(
context['subject_template'],
context
).strip()
# Render body
html_body = render_to_string(
'mail/{0}.html'.format(notification),
context
)
body = html2text(html_body)
# Define headers
headers['Auto-Submitted'] = 'auto-generated'
headers['X-AutoGenerated'] = 'yes'
headers['Precedence'] = 'bulk'
headers['X-Mailer'] = 'Weblate {0}'.format(VERSION)
# List of recipients
if email == 'ADMINS':
emails = [a[1] for a in settings.ADMINS]
else:
emails = [email]
# Return the mail content
return {
'subject': subject,
'body': body,
'to': emails,
'headers': headers,
'html_body': html_body,
}
def get_context(self, name, value, attrs=None, extra_context={}):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, six.text_type):
try:
value = geos.GEOSGeometry(value)
except (geos.GEOSException, ValueError):
value = None
if (
value and value.geom_type.upper() != self.geom_type and
self.geom_type != 'GEOMETRY'
):
value = None
# Defaulting the WKT value to a blank string
wkt = ''
geojson = ''
if value:
srid = self.map_srid
if not value.srid:
# If we're processing a form with errors, for some reason the
# SRID doesn't get set on the value, and the below
# ogr.transform always throws an exception (presumably because
# you can't transform from no SRID to self.map_srid). This just
# assumes it /should/ have been set the same as self.map_srid
# and proceeds appropriately.
ogr = value.ogr
value.srid = srid
wkt = ogr.wkt
geojson = ogr.geojson
elif value.srid != srid:
try:
ogr = value.ogr
ogr.transform(srid)
wkt = ogr.wkt
geojson = ogr.geojson
except gdal.OGRException:
pass # wkt left as an empty string
else:
wkt = value.wkt
geojson = value.geojson
if hasattr(self, 'as_geojson') and self.as_geojson:
context = super(BaseGeometryWidget, self).get_context(
name, geojson, attrs)
else:
context = super(BaseGeometryWidget, self).get_context(
name, wkt, attrs)
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
# Django >= 1.4 doesn't have ADMIN_MEDIA_PREFIX anymore, we must
# rely on contrib.staticfiles.
if hasattr(settings, 'ADMIN_MEDIA_PREFIX'):
context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
else:
context['ADMIN_MEDIA_PREFIX'] = settings.STATIC_URL + 'admin/'
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context
def i18n(request):
return {
'LANGUAGES':
get_language_mapping(),
'LANG': (settings.LANGUAGE_URL_MAP.get(translation.get_language())
or translation.get_language()),
'DIR':
'rtl' if translation.get_language_bidi() else 'ltr',
}
def i18n(request):
from django.utils import translation
context_extras = {}
context_extras['LANGUAGES'] = settings.LANGUAGES
context_extras['LANGUAGE_CODE'] = translation.get_language()
context_extras['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context_extras
def render_dir_rtl(context):
__M_caller = context.caller_stack._push_frame()
try:
__M_writer = context.writer()
return 'rtl' if get_language_bidi() else 'ltr'
return ''
finally:
context.caller_stack._pop_frame()
def i18n(request):
lang_url_map = settings.LANGUAGE_URL_MAP
return {
'LANGUAGES':
settings.LANGUAGES,
'LANG': (lang_url_map.get(translation.get_language())
or translation.get_language()),
'DIR':
'rtl' if translation.get_language_bidi() else 'ltr',
}
def get_context_data(self, *args, **kwargs):
context = super().get_context_data(*args, **kwargs)
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
language_form_kwargs = self.get_language_form_kwargs()
if self.translations_enabled:
context['language_switcher'] = {
'show': True,
'form': self.language_form_class(**language_form_kwargs),
}
return context
def bidi(request):
"""Adds to the context BiDi related variables
LANGUAGE_DIRECTION -- Direction of current language ('ltr' or 'rtl')
"""
if translation.get_language_bidi():
extra_context = { 'LANGUAGE_DIRECTION':'rtl', }
else:
extra_context = { 'LANGUAGE_DIRECTION':'ltr', }
return extra_context
def i18n(request):
lang_url_map = settings.LANGUAGE_URL_MAP
return {
"LANGUAGES":
settings.LANGUAGES,
"LANG": (lang_url_map.get(translation.get_language())
or translation.get_language()),
"DIR":
"rtl" if translation.get_language_bidi() else "ltr",
}
def get_meta_data(self):
model = registry.get_ra_model_by_name(self.kwargs['base_model'])
verbose_name = model._meta.verbose_name
verbose_name_plural = model._meta.verbose_name_plural
is_bidi = get_language_bidi()
if is_bidi:
page_title = '%s %s' % (ugettext('reports'), model._meta.verbose_name_plural)
else:
page_title = '%s %s' % (model._meta.verbose_name_plural, ugettext('reports'))
opts = model._meta
return verbose_name, verbose_name_plural, page_title, opts
def set_filter_form(self):
filter_type = self.request.GET.get('filter', None)
if filter_type == 'time':
return YearForm(initial={'all': True, 'filter': filter_type})
elif filter_type == 'location':
return LocationForm(initial={
'all': True,
'filter': filter_type
},
bidi=translation.get_language_bidi())
return None
def send_notification(notification, recipients, **kwargs):
if not recipients:
return
# HTML to text conversion
html2text = HTML2Text(bodywidth=78)
html2text.unicode_snob = True
html2text.ignore_images = True
html2text.pad_tables = True
# Logos
images = []
for name in ("email-logo.png", "email-logo-footer.png"):
filename = os.path.join(settings.STATIC_ROOT, name)
with open(filename, "rb") as handle:
image = MIMEImage(handle.read())
image.add_header("Content-ID", "<{}@cid.weblate.org>".format(name))
image.add_header("Content-Disposition", "inline", filename=name)
images.append(image)
# Context and subject
context = {
"LANGUAGE_CODE": get_language(),
"LANGUAGE_BIDI": get_language_bidi(),
}
context.update(kwargs)
subject = render_to_string("mail/{0}_subject.txt".format(notification),
context).strip()
context["subject"] = subject
# Render body
body = render_to_string("mail/{0}.html".format(notification),
context).strip()
# Prepare e-mail
email = EmailMultiAlternatives(
subject,
html2text.handle(body),
"*****@*****.**",
recipients,
)
email.mixed_subtype = "related"
for image in images:
email.attach(image)
email.attach_alternative(body, "text/html")
# Include invoice PDF if exists
if "invoice" in kwargs:
with open(kwargs["invoice"].pdf_path, "rb") as handle:
email.attach(
os.path.basename(kwargs["invoice"].pdf_path),
handle.read(),
"application/pdf",
)
email.send()
def css_dependencies():
"""
Returns list of CSS files that this XBlock depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
if get_language_bidi():
return get_css_dependencies('style-inline-discussion-rtl')
else:
return get_css_dependencies('style-inline-discussion')
def css_dependencies(self):
"""
Returns list of CSS files that this view depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
if get_language_bidi():
return self.get_css_dependencies('style-learner-dashboard-rtl')
else:
return self.get_css_dependencies('style-learner-dashboard')
def i18n(request):
context_extras = {}
context_extras['LANGUAGES'] = settings.LANGUAGES
if hasattr(request, 'LANGUAGE_CODE'):
context_extras['LANGUAGE_CODE'] = request.LANGUAGE_CODE
else:
context_extras['LANGUAGE_CODE'] = settings.LANGUAGE_CODE
from django.utils import translation
context_extras['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context_extras
def css_dependencies(self):
"""
Returns list of CSS files that this view depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
if get_language_bidi():
return self.get_css_dependencies('style-learner-dashboard-rtl')
else:
return self.get_css_dependencies('style-learner-dashboard')
def css_dependencies():
"""
Returns list of CSS files that this XBlock depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
if get_language_bidi():
return get_css_dependencies('style-inline-discussion-rtl')
else:
return get_css_dependencies('style-inline-discussion')
def get_notification_email(language,
email,
notification,
context=None,
info=None):
"""Render notification email."""
context = context or {}
headers = {}
LOGGER.info('sending notification %s on %s to %s', notification, info,
email)
with override('en' if language is None else language):
# Template name
context['subject_template'] = 'mail/{0}_subject.txt'.format(
notification)
context['LANGUAGE_CODE'] = get_language()
context['LANGUAGE_BIDI'] = get_language_bidi()
# Adjust context
context['current_site_url'] = get_site_url()
context['site_title'] = settings.SITE_TITLE
# Render subject
subject = render_to_string(context['subject_template'],
context).strip()
# Render body
html_body = render_to_string('mail/{0}.html'.format(notification),
context)
body = html2text(html_body)
# Define headers
headers['Auto-Submitted'] = 'auto-generated'
headers['X-AutoGenerated'] = 'yes'
headers['Precedence'] = 'bulk'
headers['X-Mailer'] = 'Weblate {0}'.format(VERSION)
# List of recipients
if email == 'ADMINS':
emails = [a[1] for a in settings.ADMINS]
else:
emails = [email]
# Return the mail content
return {
'subject': subject,
'body': body,
'to': emails,
'headers': headers,
'html_body': html_body,
}
def i18n(request):
"""Add current locale and language settings to the context."""
requested_lang = get_language()
actual_lang = settings.LANGUAGE_MAP.get(requested_lang, requested_lang)
return {
'LANGUAGES': settings.LANGUAGES,
'LANG_SHORT': f'{actual_lang}'[:2],
'LANG': actual_lang,
'LANG_LOWER': f'{actual_lang}'.lower(),
'LOCALE': to_locale(get_language()),
'DIR': 'rtl' if get_language_bidi() else 'ltr',
}
def render_to_pdf(template_name, pdf_filename=None, template_values=None, css_sheets=None):
context_extras = {'LANGUAGES': settings.LANGUAGES, 'LANGUAGE_CODE': translation.get_language(),
'LANGUAGE_BIDI': translation.get_language_bidi()}
template_values.update(context_extras)
html_content = render_to_string(template_name, template_values or {})
css_objs = [CSS(filename=finders.find(x)) for x in css_sheets] if css_sheets else []
html_obj = HTML(string=html_content)
if pdf_filename is None:
with tempfile.NamedTemporaryFile() as n:
pdf_filename = n.name
html_obj.write_pdf(pdf_filename, stylesheets=css_objs)
return pdf_filename
def css_dependencies(self):
"""
Returns list of CSS files that this view depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
is_right_to_left = get_language_bidi()
css_file = BOOTSTRAP_DISCUSSION_CSS_PATH
if is_right_to_left:
css_file = css_file.replace('.css', '-rtl.css')
return [css_file]
def field_choices(self, field, request, model_admin):
tree_level_indent = getattr(model_admin, 'tree_level_indent',
self.tree_level_indent)
language_bidi = get_language_bidi()
initial_choices = field.get_choices(include_blank=False)
pks = [pk for pk, val in initial_choices]
models = field.related_model._default_manager.filter(pk__in=pks)
levels_dict = {model.pk: model.get_depth() for model in models}
choices = []
for pk, val in initial_choices:
choices.append((pk, val, 'right' if language_bidi else 'left',
tree_level_indent * levels_dict[pk]))
return choices
def bidi(request):
"""Adds to the context BiDi related variables
LANGUAGE_DIRECTION -- Direction of current language ('ltr' or 'rtl')
"""
if translation.get_language_bidi():
extra_context = {
'LANGUAGE_DIRECTION': 'rtl',
}
else:
extra_context = {
'LANGUAGE_DIRECTION': 'ltr',
}
return extra_context
def field_choices(self, field, request, model_admin):
mptt_level_indent = getattr(model_admin, 'mptt_level_indent', self.mptt_level_indent)
language_bidi = get_language_bidi()
initial_choices = field.get_choices(include_blank=False)
pks = [pk for pk, val in initial_choices]
models = field.related_model._default_manager.filter(pk__in=pks)
levels_dict = {model.pk: getattr(model, model._mptt_meta.level_attr) for model in models}
choices = []
for pk, val in initial_choices:
padding_style = ' style="padding-%s:%spx"' % (
'right' if language_bidi else 'left',
mptt_level_indent * levels_dict[pk])
choices.append((pk, val, mark_safe(padding_style)))
return choices
def tenant_css_overrides_file():
"""
Django template tag that outputs the css import for a:
{% tenant_css_overrides_file %}
"""
if get_language_bidi():
file_path = configuration_helpers.get_value(
'css_overrides_file_rtl',
configuration_helpers.get_value('css_overrides_file'))
else:
file_path = configuration_helpers.get_value('css_overrides_file')
if file_path is not None:
return "<link href='{}' rel='stylesheet' type='text/css'>".format(
static(file_path))
else:
return ""
def microsite_css_overrides_file():
"""
Django template tag that outputs the css import for a:
{% microsite_css_overrides_file %}
"""
file_path = microsite.get_value('css_overrides_file', None)
if get_language_bidi():
file_path = microsite.get_value(
'css_overrides_file_rtl',
microsite.get_value('css_overrides_file')
)
else:
file_path = microsite.get_value('css_overrides_file')
if file_path is not None:
return "<link href='{}' rel='stylesheet' type='text/css'>".format(static(file_path))
else:
return ""
def microsite_css_overrides_file():
"""
Django template tag that outputs the css import for a:
{% microsite_css_overrides_file %}
"""
file_path = microsite.get_value('css_overrides_file', None)
if get_language_bidi():
file_path = microsite.get_value(
'css_overrides_file_rtl',
microsite.get_value('css_overrides_file')
)
else:
file_path = microsite.get_value('css_overrides_file')
if file_path is not None:
return "<link href='{}' rel='stylesheet' type='text/css'>".format(static(file_path))
else:
return ""
def css_dependencies(self):
"""
Returns list of CSS files that this view depends on.
The helper function that it uses to obtain the list of CSS files
works in conjunction with the Django pipeline to ensure that in development mode
the files are loaded individually, but in production just the single bundle is loaded.
"""
is_right_to_left = get_language_bidi()
if USE_BOOTSTRAP_FLAG.is_enabled():
css_file = BOOTSTRAP_DISCUSSION_CSS_PATH
if is_right_to_left:
css_file = css_file.replace('.css', '-rtl.css')
return [css_file]
elif is_right_to_left:
return self.get_css_dependencies('style-discussion-main-rtl')
else:
return self.get_css_dependencies('style-discussion-main')
def get_context(self, name, value, attrs=None, extra_context={}):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, six.text_type):
try:
value = geos.GEOSGeometry(value)
except (geos.GEOSException, ValueError):
value = None
if (
value and value.geom_type.upper() != self.geom_type and
self.geom_type != 'GEOMETRY'
):
value = None
# Defaulting the WKT value to a blank string
wkt = ''
if value:
srid = self.map_srid
if value.srid != srid:
try:
ogr = value.ogr
ogr.transform(srid)
wkt = ogr.wkt
except gdal.OGRException:
pass # wkt left as an empty string
else:
wkt = value.wkt
context = super(BaseGeometryWidget, self).get_context(name, wkt, attrs)
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
# Deprecated, we will remove this in a future release, it's no longer
# used. But we keep it here for now as it's documented in
# docs/geodjango.rst
# Django >= 1.4 doesn't have ADMIN_MEDIA_PREFIX anymore, we must
# rely on contrib.staticfiles.
if hasattr(settings, 'ADMIN_MEDIA_PREFIX'):
context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
else:
context['ADMIN_MEDIA_PREFIX'] = settings.STATIC_URL + 'admin/'
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context
def get_context(self,
change=None,
subscription=None,
extracontext=None,
changes=None):
"""Return context for rendering mail."""
result = {
"LANGUAGE_CODE": get_language(),
"LANGUAGE_BIDI": get_language_bidi(),
"current_site_url": get_site_url(),
"site_title": settings.SITE_TITLE,
"notification_name": self.verbose,
}
if changes is not None:
result["changes"] = changes
if subscription is not None:
result["unsubscribe_nonce"] = TimestampSigner().sign(
subscription.pk)
if extracontext:
result.update(extracontext)
if change:
result["change"] = change
# Extract change attributes
attribs = (
"unit",
"translation",
"component",
"project",
"glossary_term",
"comment",
"suggestion",
"announcement",
"alert",
"user",
"target",
"old",
"details",
)
for attrib in attribs:
result[attrib] = getattr(change, attrib)
if result.get("translation"):
result["translation_url"] = get_site_url(
result["translation"].get_absolute_url())
return result
def get_notification_emails(language,
recipients,
notification,
context=None,
info=None):
"""Render notification email."""
context = context or {}
headers = {}
LOGGER.info("sending notification %s on %s to %s", notification, info,
", ".join(recipients))
with override("en" if language is None else language):
# Template name
context["subject_template"] = "mail/{0}_subject.txt".format(
notification)
context["LANGUAGE_CODE"] = get_language()
context["LANGUAGE_BIDI"] = get_language_bidi()
# Adjust context
context["current_site_url"] = get_site_url()
context["site_title"] = settings.SITE_TITLE
# Render subject
subject = render_to_string(context["subject_template"],
context).strip()
context["subject"] = subject
# Render body
body = render_to_string("mail/{0}.html".format(notification), context)
# Define headers
headers["Auto-Submitted"] = "auto-generated"
headers["X-AutoGenerated"] = "yes"
headers["Precedence"] = "bulk"
headers["X-Mailer"] = USER_AGENT
# Return the mail content
return [{
"subject": subject,
"body": body,
"address": address,
"headers": headers
} for address in recipients]
def get_notification_emails(language,
recipients,
notification,
context=None,
info=None):
"""Render notification email."""
context = context or {}
headers = {}
LOGGER.info('sending notification %s on %s to %s', notification, info,
', '.join(recipients))
with override('en' if language is None else language):
# Template name
context['subject_template'] = 'mail/{0}_subject.txt'.format(
notification)
context['LANGUAGE_CODE'] = get_language()
context['LANGUAGE_BIDI'] = get_language_bidi()
# Adjust context
context['current_site_url'] = get_site_url()
context['site_title'] = settings.SITE_TITLE
# Render subject
subject = render_to_string(context['subject_template'],
context).strip()
context['subject'] = subject
# Render body
body = render_to_string('mail/{0}.html'.format(notification), context)
# Define headers
headers['Auto-Submitted'] = 'auto-generated'
headers['X-AutoGenerated'] = 'yes'
headers['Precedence'] = 'bulk'
headers['X-Mailer'] = 'Weblate {0}'.format(VERSION)
# Return the mail content
return [{
'subject': subject,
'body': body,
'address': address,
'headers': headers
} for address in recipients]
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 get_language_config():
"""
Creates a language configuration for TinyMCE4 based on Django project settings
:return: language- and locale-related parameters for TinyMCE 4
:rtype: dict
"""
language_code = convert_language_code(get_language()
or settings.LANGUAGE_CODE)
if not language_file_exists(language_code):
language_code = language_code[:2]
if not language_file_exists(language_code):
# Fall back to English if Tiny MCE 4 does not have required translation
language_code = 'en'
config = {'language': language_code}
if get_language_bidi():
config['directionality'] = 'rtl'
else:
config['directionality'] = 'ltr'
if mce_settings.USE_SPELLCHECKER:
try:
from enchant import list_languages
except ImportError as ex:
raise ImportError(
'To use spellchecker you need to install pyenchant first!'
).with_traceback(ex.__traceback__)
enchant_languages = list_languages()
if settings.DEBUG:
logger.info('Enchant languages: {0}'.format(enchant_languages))
lang_names = []
for lang, name in settings.LANGUAGES:
lang = convert_language_code(lang)
if lang not in enchant_languages:
lang = lang[:2]
if lang not in enchant_languages:
logger.error(
'Missing {0} spellchecker dictionary!'.format(lang))
continue
if config.get('spellchecker_language') is None:
config['spellchecker_language'] = lang
lang_names.append('{0}={1}'.format(name, lang))
config['spellchecker_languages'] = ','.join(lang_names)
return config
def get_language_config():
"""
Creates a language configuration for TinyMCE4 based on Django project settings
:return: language- and locale-related parameters for TinyMCE 4
:rtype: dict
"""
language_code = convert_language_code(get_language()
or settings.LANGUAGE_CODE)
if not language_file_exists(language_code):
language_code = language_code[:2]
if not language_file_exists(language_code):
# Fall back to English if Tiny MCE 4 does not have required translation
language_code = 'en'
config = {'language': language_code}
if get_language_bidi():
config['directionality'] = 'rtl'
else:
config['directionality'] = 'ltr'
return config
def get_context(self, name, value, attrs=None, extra_context={}):
# Defaulting the WKT value to a blank string
wkt, location = '', None
if value:
try:
location = Location.objects.get(pk=int(value))
wkt = location.point.wkt
except ObjectDoesNotExist:
pass
context = super(ChooseLocationWidget, self).get_context(name, wkt,
attrs)
context['location'] = ""
if location:
context['location'] = unicode(location)
context['attrs']['value'] = wkt
context['module'] = 'map_%s' % name.replace('-', '_')
context['name'] = name
# context['ADMIN_MEDIA_PREFIX'] = settings.ADMIN_MEDIA_PREFIX
context['LANGUAGE_BIDI'] = translation.get_language_bidi()
return context
def get_context(self, name, value, attrs=None):
# If a string reaches here (via a validation error on another
# field) then just reconstruct the Geometry.
if isinstance(value, six.string_types):
value = self.deserialize(value)
if value:
# Check that srid of value and map match
if value.srid != self.map_srid:
try:
ogr = value.ogr
ogr.transform(self.map_srid)
value = ogr
except gdal.GDALException as err:
logger.error(
"Error transforming geometry from srid '%s' to srid "
"'%s' (%s)", value.srid, self.map_srid, err)
if not attrs:
attrs = {}
attrs.update({
"name": name,
"module": 'geodjango_%s' % name.replace('-', '_'), # JS-safe
"serialized": self.serialize(value),
"geom_type": gdal.OGRGeomType(self.attrs['geom_type']),
"STATIC_URL": settings.STATIC_URL,
"LANGUAGE_BIDI": translation.get_language_bidi(),
})
context = self.build_attrs(
self.attrs or {},
attrs
)
# fallback if no id
if 'id' not in context:
context['id'] = name
return context
def _render_footer_html(request, show_openedx_logo, include_dependencies):
"""Render the footer as HTML.
Arguments:
show_openedx_logo (bool): If True, include the OpenEdX logo in the rendered HTML.
include_dependencies (bool): If True, include JavaScript and CSS dependencies.
Returns: unicode
"""
bidi = 'rtl' if translation.get_language_bidi() else 'ltr'
css_name = settings.FOOTER_CSS['openedx'][bidi]
context = {
'hide_openedx_link': not show_openedx_logo,
'footer_js_url': _footer_static_url(request, 'js/footer-edx.js'),
'footer_css_urls': _footer_css_urls(request, css_name),
'bidi': bidi,
'include_dependencies': include_dependencies,
}
return render_to_response("footer.html", context)
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)
