def setUp(self):
domain = Domain.objects.create(name="test")
division = Division.objects.create(name="localities", domain=domain)
self.entity = Entity.objects.create(name="the moon", division=division,
id=settings.QNA_DEFAULT_ENTITY_ID)
self.common_user = User.objects.create_user("commoner",
"*****@*****.**", "pass")
self.candidate_user = User.objects.create_user("candidate",
"*****@*****.**", "pass")
self.candidate_user.profile.locality = self.entity
self.candidate_user.profile.is_candidate = True
self.candidate_user.profile.save()
self.editor_user = User.objects.create_user("editor",
"*****@*****.**", "pass")
self.editor_user.profile.locality = self.entity
self.editor_user.profile.is_editor = True
self.editor_user.profile.save()
self.q = Question.objects.create(author = self.common_user,
subject="why?", entity=self.entity)
self.a = self.q.answers.create(author = self.candidate_user,
content="because the world is round")
self.site1 = Site.objects.create(domain='abc.com')
self.site2 = Site.objects.create(domain='fun.com')
self.q.tags.create(name="abc")
self.q.tags.create(name="def")
translation.deactivate_all()
def __enter__(self):
# type: () -> None
self.old_language = translation.get_language()
if self.language is not None:
translation.activate(self.language)
else:
translation.deactivate_all()
def translation(language_code, deactivate=False):
"""
Port of django.utils.translation.override from Django 1.4
@param language_code: a language code or ``None``. If ``None``, translation
is disabled and raw translation strings are used
@param deactivate: If ``True``, when leaving the manager revert to the
default behaviour (i.e. ``settings.LANGUAGE_CODE``)
rather than the translation that was active prior to
entering.
"""
from django.utils import translation
original = translation.get_language()
if language_code is not None:
translation.activate(language_code)
else:
translation.deactivate_all()
try:
yield
finally:
if deactivate:
translation.deactivate()
else:
translation.activate(original)
def test_i18n(build_tree, render_template_tag, mock_template_context):
from sitetree.toolbox import register_i18n_trees
build_tree(
{'alias': 'i18tree'},
[{'title': 'My title', 'url': '/url_default/'}],
)
build_tree(
{'alias': 'i18tree_ru'},
[{'title': 'Заголовок', 'url': '/url_ru/'}],
)
register_i18n_trees(['i18tree'])
activate('en')
result = render_template_tag('sitetree', 'sitetree_tree from "i18tree"', mock_template_context())
assert '/url_default/' in result
assert 'My title' in result
activate('ru')
result = render_template_tag('sitetree', 'sitetree_tree from "i18tree"', mock_template_context())
assert '/url_ru/' in result
assert 'Заголовок' in result
deactivate_all()
def claiming(request, es=False):
if es is True:
activate('es')
else:
deactivate_all()
ages = {}
for age in AgeChoice.objects.all():
ages[age.age] = _(age.aside)
page = Page.objects.get(title='Claiming Social Security')
tips = {}
for tooltip in Tooltip.objects.all():
tips[tooltip.title] = tooltip.text
questions = {}
for q in Question.objects.all():
questions[q.slug] = q
final_steps = {}
for step in Step.objects.filter(title__contains='final_'):
final_steps[step.title] = step
if standalone:
base_template = "standalone_base.html"
else:
base_template = "%s/templates/base.html" % BASEDIR
cdict = {
'tstamp': datetime.datetime.now(),
'final_steps': final_steps,
'questions': questions,
'tips': tips,
'ages': ages,
'page': page,
'base_template': base_template,
'available_languages': ['en', 'es'],
}
return render_to_response('claiming.html', cdict)
def get_context(self, request, *args, **kwargs):
if self.language != 'en':
activate(self.language)
else:
deactivate_all()
return super(PortalSearchPage, self).get_context(
request, *args, **kwargs)
def test_evaluate_multiple(self):
from django.utils.translation import deactivate_all
deactivate_all() # So that we can test this "OR".
# Descriptor, solution, is_correct, variable_types.
tests = [
("100 | -100", "100", True, [Integer, Integer]),
("100 | -100", "-100", True, [Integer, Integer]),
("100 | -100", "200", False, [Integer, Integer]),
("100 | -100", "kifla", InvalidSolution, [Integer, Integer]),
("100 | sarma", "kifla", False, [Integer, String]),
("100 | sarma", "100", True, [Integer, String]),
("100 | sarma", "sarma", True, [Integer, String]),
("{1,2} | {1}", "1,2", True, [MultiSet, MultiSet]),
("{1,2} | {1}", "1", True, [MultiSet, MultiSet]),
("{1,2} | {1}", "2", False, [MultiSet, MultiSet]),
("sarma|sarma", "sarma", True, [String, String]),
("sarma|sarma", "sarma|sarma", False, [String, String]),
("sarma\\|sarma", "sarma|sarma", True, [String]),
("sarma\\|sarma", "sarma", False, [String]),
("sarma\\|sarma", "sarma|sarma", True, [String]),
("sarma\\\\|kifla", "kifla", True, [String, String]),
("sarma\\\\|kifla", "sarma\\", True, [String, String]),
("sarma\\\\|kifla", "sarma", False, [String, String]),
]
for descriptor, solution, is_correct, variable_types in tests:
self.assertVariableTypes(variable_types, [descriptor])
_tests = [(a, b, c) for a, b, c, d in tests]
self.assertMultipleEqualOrRaise(check_result, _tests)
def get_context(self, request, *args, **kwargs):
if self.language != 'en':
activate(self.language)
else:
deactivate_all()
context = super(
TagResultsPage, self).get_context(request, *args, **kwargs)
return context
def test_get_active(self):
deactivate_all()
# No active language, returns default
self.assertEqual(languages.get_active(), 'cs')
activate('en')
# Active language is returned
self.assertEqual(languages.get_active(), 'en')
def perform_authentication(self, request):
super().perform_authentication(request)
# Change current langugage if authentication is successful
# and we know the user's preference
if getattr(request.user, 'language', False):
activate(request.user.language)
else:
deactivate_all()
def __exit__(self, exc_type, exc_value, traceback):
# type: (Any, Any, Any) -> None
if self.old_language is None:
translation.deactivate_all()
elif self.deactivate:
translation.deactivate()
else:
translation.activate(self.old_language)
def test_get_sample_solution_multiple(self):
from django.utils.translation import deactivate_all
deactivate_all() # So that we can test this "OR".
tests = [
("00:50 | sarma | [biftek, kifla]", "00:50 OR sarma OR biftek,kifla"),
("100 | 100.00 | -100", "100 OR 100.00 OR -100"),
]
self.assertGetSampleSolution(tests)
def test_build_localized_field_name(self):
self.assertEqual(utils.build_localized_field_name('title', 'fr'), 'title_fr')
self.assertEqual(utils.build_localized_field_name('title', 'fr-ca'), 'title_fr_ca')
translation.deactivate_all()
self.assertEqual(utils.build_localized_field_name('title'), 'title_en')
translation.activate('it')
self.assertEqual(utils.build_localized_field_name('title'), 'title_it')
def render(self, context):
current_language = translation.get_language()
translation.deactivate_all()
rendered = self.nodelist.render(context)
translation.activate(current_language)
return rendered
def test_get_recovery_url_no_active_translation(self):
"""
When no translation is active, the locale is /en-US/.
This happens in management commands, such as the Django shell.
"""
user = self.user_model.objects.get(username='******')
deactivate_all()
url = user.get_recovery_url()
assert url.startswith('/en-US/users/account/recover/')
def wrapped(*args, **kwargs):
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
res = handle_func(*args, **kwargs)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return res
def execute(self, *args, **options):
"""
Try to execute this command, performing system checks if needed (as
controlled by attributes ``self.requires_system_checks`` and
``self.requires_model_validation``, except if force-skipped).
"""
if options.get('no_color'):
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options.get('stderr'), self.stderr.style_func)
if self.can_import_settings:
from django.conf import settings # NOQA
saved_locale = None
if not self.leave_locale_alone:
# Only mess with locales if we can assume we have a working
# settings file, because django.utils.translation requires settings
# (The final saying about whether the i18n machinery is active will be
# found in the value of the USE_I18N setting)
if not self.can_import_settings:
raise CommandError("Incompatible values of 'leave_locale_alone' "
"(%s) and 'can_import_settings' (%s) command "
"options." % (self.leave_locale_alone,
self.can_import_settings))
# Deactivate translations, because django-admin creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
if (self.requires_system_checks and
not options.get('skip_validation') and # Remove at the end of deprecation for `skip_validation`.
not options.get('skip_checks')):
self.check()
output = self.handle(*args, **options)
if output:
if self.output_transaction:
# This needs to be imported here, because it relies on
# settings.
from django.db import connections, DEFAULT_DB_ALIAS
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
if connection.ops.start_transaction_sql():
self.stdout.write(self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()))
self.stdout.write(output)
if self.output_transaction:
self.stdout.write('\n' + self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()))
finally:
if saved_locale is not None:
translation.activate(saved_locale)
def wrapped(*args, **kwargs):
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
res = handle_func(*args, **kwargs)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return res
def verbose_name_raw(self):
"""
There are a few places where the untranslated verbose name is needed
(so that we get the same value regardless of currently active
locale).
"""
lang = get_language()
deactivate_all()
raw = force_text(self.verbose_name)
activate(lang)
return raw
def wrapped(*args, **kwargs):
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
res = handle_func(*args, **kwargs)
#print('【django.core.management.base.no_transactions】res:', res)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return res
def test_field_value_pairs(self):
"""The |field_value_pairs filter does what it should"""
deactivate_all()
absence = factories.AbsenceFactory.create(
starts_on=dt.date(2020, 1, 1))
pairs = dict(field_value_pairs(absence))
self.assertEqual(pairs["Starts on"], "01.01.2020")
self.assertEqual(pairs["Ends on"], None)
self.assertEqual(pairs["Reason"], "vacation")
self.assertEqual(pairs["Is vacation"], "yes")
def render(self, context):
"""Render."""
current_language = translation.get_language()
translation.deactivate_all()
rendered = self.nodelist.render(context)
translation.activate(current_language)
return rendered
def verbose_name_raw(self):
"""
There are a few places where the untranslated verbose name is needed
(so that we get the same value regardless of currently active
locale).
"""
lang = get_language()
deactivate_all()
raw = force_text(self.verbose_name)
activate(lang)
return raw
def execute(self, *args, **options):
"""
尝试执行这个命令 如果需要执行系统检查
Try to execute this command, performing system checks if needed
(as controlled by the ``requires_system_checks`` attribute, except if force-skipped).
除非强制跳过
"""
# 1、判断颜色相关信息
if options['no_color']:
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options['stderr'],
self.stderr.style_func)
# 2、TODO 这个干嘛的？ 2021年7月2日14:16:43
saved_locale = None
if not self.leave_locale_alone:
# Deactivate translations, because django-admin creates database
# 停用 translations 因为django-admin创建数据库内容 ，像权限这些不应该包含translations
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
# 3、检查相关的选项
if self.requires_system_checks and not options.get('skip_checks'):
self.check()
if self.requires_migrations_checks:
self.check_migrations()
#4、 真正的执行 - nnd 接口，面向对象啊
output = self.handle(*args, **options)
if output:
if self.output_transaction:
connection = connections[options.get(
'database', DEFAULT_DB_ALIAS)]
output = '%s\n%s\n%s' % (
self.style.SQL_KEYWORD(
connection.ops.start_transaction_sql()),
output,
self.style.SQL_KEYWORD(
connection.ops.end_transaction_sql()),
)
self.stdout.write(output)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return output
def test_get_recovery_url_no_active_translation(self):
"""
When no translation is active, the locale is /en-US/.
This happens in management commands, such as the Django shell.
See: https://bugzilla.mozilla.org/show_bug.cgi?id=1477016
"""
user = self.user_model.objects.get(username="******")
deactivate_all()
url = user.get_recovery_url()
assert url.startswith("/en-US/users/account/recover/")
def test_language_override_no_course_force_lang_no_langcode(self):
if self.course.force_lang:
self.course.force_lang = ""
self.course.save()
translation.deactivate_all()
with LanguageOverride(course=self.course):
self.assertEqual(translation.get_language(), "de")
self.assertEqual(translation.ugettext("user"), u"Benutzer")
self.assertEqual(translation.get_language(), None)
self.assertEqual(translation.ugettext("whatever"), "whatever")
def setUp(self):
self.user = User.objects.create_superuser("admin", "*****@*****.**",
"blabla")
deactivate_all()
if settings.USE_CUSTOM_SITE:
self.test_site = CustomSite.objects.create(host="testserver",
is_default=True,
title="Test Site")
else:
self.test_site = Site.objects.create(host="testserver",
is_default=True)
def test_language_override_no_course_force_lang_no_langcode(self):
if self.course.force_lang:
self.course.force_lang = ""
self.course.save()
translation.deactivate_all()
with LanguageOverride(course=self.course):
self.assertEqual(translation.get_language(), "de")
self.assertEqual(translation.ugettext("user"), u"Benutzer")
self.assertEqual(translation.get_language(), None)
self.assertEqual(translation.ugettext("whatever"), "whatever")
def execute(self, *args, **options):
"""
Try to execute this command, performing system checks if needed (as
controlled by the ``requires_system_checks`` attribute, except if
force-skipped).
"""
if options.get('no_color'):
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options.get('stderr'), self.stderr.style_func)
saved_locale = None
if not self.leave_locale_alone:
# Only mess with locales if we can assume we have a working
# settings file, because django.utils.translation requires settings
# (The final saying about whether the i18n machinery is active will be
# found in the value of the USE_I18N setting)
if not self.can_import_settings:
raise CommandError("Incompatible values of 'leave_locale_alone' "
"(%s) and 'can_import_settings' (%s) command "
"options." % (self.leave_locale_alone,
self.can_import_settings))
# Deactivate translations, because django-admin creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
if (self.requires_system_checks and
not options.get('skip_validation') and # Remove at the end of deprecation for `skip_validation`.
not options.get('skip_checks')):
self.check()
output = self.handle(*args, **options)
if output:
if self.output_transaction:
# This needs to be imported here, because it relies on
# settings.
from django.db import connections, DEFAULT_DB_ALIAS
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
if connection.ops.start_transaction_sql():
self.stdout.write(self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()))
self.stdout.write(output)
if self.output_transaction:
self.stdout.write('\n' + self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()))
finally:
if saved_locale is not None:
translation.activate(saved_locale)
def _set_course_lang(self, action):
# type: (Text) -> None
if self.course.force_lang and self.course.force_lang.strip():
if action == "activate":
self.old_language = translation.get_language()
translation.activate(self.course.force_lang)
else:
if self.old_language is None:
# This should be a rare case, but get_language() can be None.
# See django.utils.translation.override.__exit__()
translation.deactivate_all()
else:
translation.activate(self.old_language)
def _set_course_lang(self, action):
# type: (Text) -> None
if self.course.force_lang and self.course.force_lang.strip():
if action == "activate":
self.old_language = translation.get_language()
translation.activate(self.course.force_lang)
else:
if self.old_language is None:
# This should be a rare case, but get_language() can be None.
# See django.utils.translation.override.__exit__()
translation.deactivate_all()
else:
translation.activate(self.old_language)
def execute(self, *args, **options):
"""
Try to execute this command, performing system checks if needed (as
controlled by the ``requires_system_checks`` attribute, except if
force-skipped).
"""
if options['no_color']:
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options['stderr'], self.stderr.style_func)
saved_locale = None
if not self.leave_locale_alone:
# Only mess with locales if we can assume we have a working
# settings file, because django.utils.translation requires settings
# (The final saying about whether the i18n machinery is active will be
# found in the value of the USE_I18N setting)
if not self.can_import_settings:
raise CommandError("Incompatible values of 'leave_locale_alone' "
"(%s) and 'can_import_settings' (%s) command "
"options." % (self.leave_locale_alone,
self.can_import_settings))
# Deactivate translations, because django-admin creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
if self.requires_system_checks and not options.get('skip_checks'):
self.check()
if self.requires_migrations_checks:
self.check_migrations()
output = self.handle(*args, **options)
if output:
if self.output_transaction:
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
output = '%s\n%s\n%s' % (
self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()),
output,
self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()),
)
self.stdout.write(output)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return output
def test_get_language(self):
# Full? Returns first level
translation.activate('en-us')
self.assertEqual(utils.get_language(), 'en')
# Unsupported? Returns fallback one
translation.activate('ru')
self.assertEqual(utils.get_fallback_language(), 'en')
self.assertEqual(utils.get_language(), utils.get_fallback_language())
# Deactivating all should returns fallback one
translation.deactivate_all()
self.assertEqual(utils.get_fallback_language(), 'en')
self.assertEqual(utils.get_language(), utils.get_fallback_language())
def test_can_redirect_article_from_legacy_urls(self):
from django.utils.translation import deactivate_all
article = ArticleFactory()
url = '/revue/{journal_code}/{issue_year}/v/n{issue_number}/{article_localidentifier}.html'.format( # noqa
journal_code=article.issue.journal.code,
issue_year=article.issue.year,
issue_number=article.issue.number,
article_localidentifier=article.localidentifier)
resp = self.client.get(url)
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/fr/" in resp.url
assert resp.status_code == 301
deactivate_all()
resp = self.client.get(url + "?lang=en")
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/en/" in resp.url
assert resp.status_code == 301
url = '/en/revue/{journal_code}/{issue_year}/v/n{issue_number}/{article_localidentifier}.html'.format( # noqa
journal_code=article.issue.journal.code,
issue_year=article.issue.year,
issue_number=article.issue.number,
article_localidentifier=article.localidentifier)
deactivate_all()
resp = self.client.get(url)
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/en/" in resp.url
assert resp.status_code == 301
def about(request, language='en'):
"""Return our 'about' calculation-explainer page in Engish or Spanish"""
if language == 'es':
activate('es')
es = True
else:
deactivate_all()
es = False
cdict = {
'base_template': base_template,
'available_languages': ['en', 'es'],
'es': es
}
return render_to_response('about.html', cdict)
def chlocale(url, locale):
"""
Changes the URL's locale prefix if the path is not locale-independent.
Otherwise removes locale prefix.
XXX: Taken from localeurl (https://bitbucket.org/carljm/django-localeurl/)
"""
def strip_script_prefix(url):
"""
Strips the SCRIPT_PREFIX from the URL. Because this function is meant for
use in templates, it assumes the URL starts with the prefix.
"""
assert url.startswith(urlresolvers.get_script_prefix()), \
"URL must start with SCRIPT_PREFIX: %s" % url
pos = len(urlresolvers.get_script_prefix()) - 1
return url[:pos], url[pos:]
def strip_path(path):
"""
Separates the locale prefix from the rest of the path. If the path does not
begin with a locale it is returned without change.
"""
SUPPORTED_LOCALES = dict(
(code.lower(), name) for code, name in settings.LANGUAGES)
# Issue #15. Sort locale codes to avoid matching e.g. 'pt' before 'pt-br'
LOCALES_RE = '|'.join(
sorted(SUPPORTED_LOCALES.keys(),
key=lambda i: len(i),
reverse=True))
PATH_RE = re.compile(r'^/(?P<locale>%s)(?P<path>.*)$' % LOCALES_RE,
re.I)
check = PATH_RE.match(path)
if check:
path_info = check.group('path') or '/'
if path_info.startswith('/'):
return check.group('locale'), path_info
return '', path
_, path = strip_script_prefix(url)
_, path = strip_path(path)
old_locale = translation.get_language()
translation.deactivate_all()
translation.activate(locale)
try:
url = locale + path
finally:
translation.activate(old_locale)
return '/' + url
def setUp(self):
domain = Domain.objects.create(name="test")
division = Division.objects.create(name="localities",
domain=domain,
index="3")
self.home = Entity.objects.create(name="earth",
division=division,
id=1111,
code="1111")
self.away = Entity.objects.create(name="the moon",
division=division,
id=9999,
code="41")
self.candidate_list = CandidateList.objects.create(name="list",
ballot="l",
entity=self.home)
self.common_user = User.objects.create_user("commoner",
"*****@*****.**",
"pass")
self.common_user.profile.locality = self.home
self.common_user.profile.save()
self.common2_user = User.objects.create_user("commoner2",
"*****@*****.**",
"pass")
self.common2_user.profile.locality = self.home
self.common2_user.profile.save()
self.candidate_user = User.objects.create_user(
"candidate", "*****@*****.**", "pass")
self.candidate_user.profile.locality = self.home
self.candidate_user.profile.save()
Candidate.objects.create(user=self.candidate_user,
candidate_list=self.candidate_list)
self.editor = User.objects.create_user("editor", "*****@*****.**",
"pass")
self.editor.profile.locality = self.home
self.editor.profile.is_editor = True
self.editor.profile.save()
self.q = Question.objects.create(author=self.common_user,
subject="why?",
entity=self.home)
self.a = self.q.answers.create(author=self.candidate_user,
content="because the world is round")
self.site1 = Site.objects.create(domain='abc.com')
self.site2 = Site.objects.create(domain='fun.com')
self.q.tags.create(name="abc")
self.q.tags.create(name="def")
translation.deactivate_all()
self.patch = patch('requests.session')
self.mock_request = self.patch.start()().request
def about(request, language='en'):
"""Return our 'about' calculation-explainer page in Engish or Spanish"""
if language == 'es':
activate('es')
es = True
else:
deactivate_all()
es = False
cdict = {
'base_template': base_template,
'available_languages': ['en', 'es'],
'es': es
}
return render_to_response('about.html', cdict)
def test_localized_ref(cls):
"""Tests whether the :see:LocalizedRef expression properly works."""
obj = cls.TestModel1.objects.create(name="bla bla")
for i in range(0, 10):
cls.TestModel2.objects.create(
text=LocalizedValue(
dict(
en="text_%d_en" % i,
ro="text_%d_ro" % i,
nl="text_%d_nl" % i,
)),
other=obj,
)
def create_queryset(ref):
return cls.TestModel1.objects.annotate(mytexts=ref).values_list(
"mytexts", flat=True)
# assert that it properly selects the currently active language
for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code)
queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset):
assert translation.get_language() in value
assert str(index) in value
# ensure that the default language is used in case no
# language is active at all
translation.deactivate_all()
queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset):
assert settings.LANGUAGE_CODE in value
assert str(index) in value
# ensures that overriding the language works properly
queryset = create_queryset(LocalizedRef("features__text", "ro"))
for index, value in enumerate(queryset):
assert "ro" in value
assert str(index) in value
# ensures that using this in combination with ArrayAgg works properly
queryset = create_queryset(
ArrayAgg(LocalizedRef("features__text", "ro"))).first()
assert isinstance(queryset, list)
for value in queryset:
assert "ro" in value
def test_date_ranges(self):
"""The date ranges utility returns expected values"""
deactivate_all()
self.assertEqual(
date_ranges(),
[
("2020-02-24", "2020-03-01", "this week"),
("2020-02-17", "2020-02-23", "last week"),
("2020-02-01", "2020-02-29", "this month"),
("2020-01-01", "2020-01-31", "last month"),
("2020-01-01", "2020-03-31", "this quarter"),
("2019-10-01", "2019-12-31", "last quarter"),
("2020-01-01", "2020-12-31", "this year"),
("2019-01-01", "2019-12-31", "last year"),
],
)
def chlocale(url, locale):
"""
Changes the URL's locale prefix if the path is not locale-independent.
Otherwise removes locale prefix.
XXX: Taken from localeurl (https://bitbucket.org/carljm/django-localeurl/)
"""
def strip_script_prefix(url):
"""
Strips the SCRIPT_PREFIX from the URL. Because this function is meant for
use in templates, it assumes the URL starts with the prefix.
"""
assert url.startswith(urlresolvers.get_script_prefix()), \
"URL must start with SCRIPT_PREFIX: %s" % url
pos = len(urlresolvers.get_script_prefix()) - 1
return url[:pos], url[pos:]
def strip_path(path):
"""
Separates the locale prefix from the rest of the path. If the path does not
begin with a locale it is returned without change.
"""
SUPPORTED_LOCALES = dict(
(code.lower(), name) for code, name in settings.LANGUAGES)
# Issue #15. Sort locale codes to avoid matching e.g. 'pt' before 'pt-br'
LOCALES_RE = '|'.join(
sorted(SUPPORTED_LOCALES.keys(), key=lambda i: len(i), reverse=True))
PATH_RE = re.compile(r'^/(?P<locale>%s)(?P<path>.*)$' % LOCALES_RE, re.I)
check = PATH_RE.match(path)
if check:
path_info = check.group('path') or '/'
if path_info.startswith('/'):
return check.group('locale'), path_info
return '', path
_, path = strip_script_prefix(url)
_, path = strip_path(path)
old_locale = translation.get_language()
translation.deactivate_all()
translation.activate(locale)
try:
url = locale + path
finally:
translation.activate(old_locale)
return '/' + url
def test_i18n(build_tree, template_render_tag, template_context):
from sitetree.toolbox import register_i18n_trees
build_tree(
{'alias': 'i18tree'},
[{'title': 'My title', 'url': '/url_default/'}],
)
build_tree(
{'alias': 'i18tree_ru'},
[{'title': 'Заголовок', 'url': '/url_ru/'}],
)
build_tree(
{'alias': 'i18tree_pt-br'},
[{'title': 'Meu Título', 'url': '/url_pt-br/'}],
)
build_tree(
{'alias': 'i18tree_zh-hans'},
[{'title': '我蒂特', 'url': '/url_zh-hans/'}],
)
register_i18n_trees(['i18tree'])
activate('en')
result = template_render_tag('sitetree', 'sitetree_tree from "i18tree"', template_context())
assert '/url_default/' in result
assert 'My title' in result
activate('ru')
result = template_render_tag('sitetree', 'sitetree_tree from "i18tree"', template_context())
assert '/url_ru/' in result
assert 'Заголовок' in result
activate('pt-br')
result = template_render_tag('sitetree', 'sitetree_tree from "i18tree"', template_context())
assert '/url_pt-br/' in result
assert 'Meu Título' in result
activate('zh-hans')
result = template_render_tag('sitetree', 'sitetree_tree from "i18tree"', template_context())
assert '/url_zh-hans/' in result
assert '我蒂特' in result
deactivate_all()
def about(request, language="en"):
"""Return our 'about' calculation-explainer page in Engish or Spanish"""
if language == "es":
activate("es")
es = True
else:
deactivate_all()
es = False
cdict = {
"base_template": base_template,
"available_languages": ["en", "es"],
"es": es,
"language": language,
"show_banner": True,
"show_mega_menu": True,
}
return render(request, "retirement_api/about.html", cdict)
def execute(self, *args, **options):
"""
Try to execute this command, performing system checks if needed (as
controlled by the ``requires_system_checks`` attribute, except if
force-skipped).
"""
if options['no_color']:
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options['stderr'],
self.stderr.style_func)
saved_locale = None
if not self.leave_locale_alone:
# Deactivate translations, because django-admin creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
if self.requires_system_checks and not options.get('skip_checks'):
self.check()
if self.requires_migrations_checks:
self.check_migrations()
output = self.handle(*args, **options)
if output:
if self.output_transaction:
connection = connections[options.get(
'database', DEFAULT_DB_ALIAS)]
output = '%s\n%s\n%s' % (
self.style.SQL_KEYWORD(
connection.ops.start_transaction_sql()),
output,
self.style.SQL_KEYWORD(
connection.ops.end_transaction_sql()),
)
self.stdout.write(output)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return output
def get_patterns(self):
self.discover_plugins()
# We want untranslated name of the plugin for its slug so we deactivate translation
lang = get_language()
deactivate_all()
try:
url_patterns = []
for plugin in self.get_all_plugins():
p = plugin()
slug = slugify(force_unicode(normalize_name(p.__class__.__name__)))
url_patterns += patterns("", url(r"^plugin/%s/" % (slug,), include(p.plugin_urls)))
finally:
# Reactivate translation
activate(lang)
return url_patterns
def test_localized_lookup(self):
"""Tests whether localized lookup properly works."""
self.TestModel.objects.create(text=LocalizedValue(
dict(en='text_en', ro='text_ro', nl='text_nl')), )
# assert that it properly lookups the currently active language
for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code)
assert self.TestModel.objects.filter(text='text_' +
lang_code).exists()
# ensure that the default language is used in case no
# language is active at all
translation.deactivate_all()
assert self.TestModel.objects.filter(text='text_en').exists()
# ensure that hstore lookups still work
assert self.TestModel.objects.filter(text__ro='text_ro').exists()
def get_translations_for_page(page):
translations = []
deactivate_all()
activate(page.language)
try:
trans_holder = page.get_children().get(title="Translations")
if page.live:
translations.append(page.specific)
translations.extend(trans_holder.get_children().live().specific())
except Page.DoesNotExist:
# Check if page exists within the translation folder
parent = page.get_parent()
if parent.title == "Translations":
if parent.get_parent().live:
translations.append(parent.get_parent().specific)
live_children = parent.get_children().live()
if live_children:
translations.extend(live_children.specific())
return translations
def execute(self, *args, **options):
"""
Try to execute this command, performing system checks if needed (as
controlled by the ``requires_system_checks`` attribute, except if
force-skipped).
"""
if options['no_color']:
self.style = no_style()
self.stderr.style_func = None
if options.get('stdout'):
self.stdout = OutputWrapper(options['stdout'])
if options.get('stderr'):
self.stderr = OutputWrapper(options['stderr'], self.stderr.style_func)
saved_locale = None
if not self.leave_locale_alone:
# Deactivate translations, because django-admin creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.deactivate_all()
try:
if self.requires_system_checks and not options.get('skip_checks'):
self.check()
if self.requires_migrations_checks:
self.check_migrations()
output = self.handle(*args, **options)
if output:
if self.output_transaction:
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
output = '%s\n%s\n%s' % (
self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()),
output,
self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()),
)
self.stdout.write(output)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return output
def test_permalink(self):
"""permalink property should be constructed from base url and absolute url, without any language code"""
current_lang = get_language()
# if non-default language is active, should stay activate
activate("he")
doc = Document.objects.create(id=1)
site_domain = Site.objects.get_current().domain.rstrip("/")
# document url should follow directly after site domain,
# with no language code
assert f"{site_domain}/documents/1/" in doc.permalink
# activated language code should persist
assert get_language() == "he"
# handle case whre no language active
deactivate_all()
assert f"{site_domain}/documents/1/" in doc.permalink
# reactivate previous default (in case it matters for other tests)
activate(current_lang)
def get_patterns(self):
self.discover_plugins()
# We want untranslated name of the plugin for its slug so we deactivate translation
lang = get_language()
deactivate_all()
try:
url_patterns = []
for plugin in self.registered_plugins:
p = plugin()
slug = slugify(force_str(normalize_name(p.__class__.__name__)))
url_patterns += [
re_path(r'^plugin/%s/' % (slug,), include(p.plugin_urls)),
]
finally:
# Reactivate translation
activate(lang)
return url_patterns
def test_i18n(source_listdics, settings):
table = Table(source=source_listdics, plugins=[I18nPlugin()])
assert len(table.get_assets_css()) == 1
assert len(table.get_assets_js()) == 1
config = table.get_config()
assert 'language' not in config # Unable to autodetect lang
activate('ru')
# Autodetect.
config = table.get_config()
assert 'Russian' in config['language']['url']
# Manual.
config = Table(source=source_listdics, plugins=[I18nPlugin('de')]).get_config()
assert 'German' in config['language']['url']
deactivate_all()
def move_all_color_into_groups(apps, schema_editor):
LocationGroupCategory = apps.get_model('mapdata', 'LocationGroupCategory')
category = LocationGroupCategory.objects.get(name='groups')
colors = {}
for model_name in ('Level', 'Space', 'Area', 'POI'):
model = apps.get_model('mapdata', model_name)
for obj in model.objects.filter(color__isnull=False):
colors.setdefault(obj.color, []).append(obj)
from c3nav.mapdata.models import Location
for color, objects in colors.items():
titles = {lang: [] for lang in set(chain(*(obj.titles.keys() for obj in objects)))}
for obj in objects:
for lang in titles.keys():
translation.activate(lang)
titles[lang].append(Location(titles=obj.titles).title)
translation.deactivate_all()
titles = {lang: ', '.join(values) for lang, values in titles.items()}
group = category.groups.create(can_search=False, can_describe=False, color=color, titles=titles)
for obj in objects:
obj.groups.add(group)
def setUp(self):
domain = Domain.objects.create(name="test")
division = Division.objects.create(name="localities", domain=domain)
self.entity = Entity.objects.create(name="the moon",
division=division,
id=settings.QNA_DEFAULT_ENTITY_ID)
self.common_user = User.objects.create_user("commoner",
"*****@*****.**",
"pass")
self.common_user.profile.locality = self.entity
self.common_user.profile.save()
self.common2_user = User.objects.create_user("commoner2",
"*****@*****.**",
"pass")
self.common2_user.profile.locality = self.entity
self.common2_user.profile.save()
self.candidate_user = User.objects.create_user(
"candidate", "*****@*****.**", "pass")
self.candidate_user.profile.locality = self.entity
self.candidate_user.profile.is_candidate = True
self.candidate_user.profile.save()
self.editor_user = User.objects.create_user("editor",
"*****@*****.**",
"pass")
self.editor_user.profile.locality = self.entity
self.editor_user.profile.is_editor = True
self.editor_user.profile.save()
self.q = Question.objects.create(author=self.common_user,
subject="why?",
entity=self.entity)
self.a = self.q.answers.create(author=self.candidate_user,
content="because the world is round")
self.site1 = Site.objects.create(domain='abc.com')
self.site2 = Site.objects.create(domain='fun.com')
self.q.tags.create(name="abc")
self.q.tags.create(name="def")
translation.deactivate_all()
self.patch = patch('requests.session')
self.mock_request = self.patch.start()().request
def setUp(self):
domain = Domain.objects.create(name="test")
division = Division.objects.create(name="localities", domain=domain, index="3")
self.home = Entity.objects.create(name="earth", division=division,
id=1111, code="1111")
self.away = Entity.objects.create(name="the moon", division=division,
id=9999, code="41")
self.candidate_list = CandidateList.objects.create(name="list", ballot="l",
entity=self.home)
self.common_user = User.objects.create_user("commoner",
"*****@*****.**", "pass")
self.common_user.profile.locality = self.home
self.common_user.profile.save()
self.common2_user = User.objects.create_user("commoner2",
"*****@*****.**", "pass")
self.common2_user.profile.locality = self.home
self.common2_user.profile.save()
self.candidate_user = User.objects.create_user("candidate",
"*****@*****.**", "pass")
self.candidate_user.profile.locality = self.home
self.candidate_user.profile.save()
Candidate.objects.create(user=self.candidate_user, candidate_list=self.candidate_list)
self.editor = User.objects.create_user("editor",
"*****@*****.**", "pass")
self.editor.profile.locality = self.home
self.editor.profile.is_editor = True
self.editor.profile.save()
self.q = Question.objects.create(author = self.common_user,
subject="why?", entity=self.home)
self.a = self.q.answers.create(author = self.candidate_user,
content="because the world is round")
self.site1 = Site.objects.create(domain='abc.com')
self.site2 = Site.objects.create(domain='fun.com')
self.q.tags.create(name="abc")
self.q.tags.create(name="def")
translation.deactivate_all()
self.patch = patch('requests.session')
self.mock_request = self.patch.start()().request
def claiming(request, es=False):
if es is True:
activate("es")
language = "es"
else:
language = "en"
deactivate_all()
ages = {}
for age in AgeChoice.objects.all():
ages[age.age] = _(age.aside)
page = Page.objects.get(title="Planning your Social Security claiming age")
tips = {}
for tooltip in Tooltip.objects.all():
tips[tooltip.title] = tooltip.text
questions = {}
for q in Question.objects.all():
questions[q.slug] = q
steps = {}
for step in Step.objects.all():
steps[step.title] = step.trans_instructions(language=language)
cdict = {
"tstamp": datetime.datetime.now(),
"steps": steps,
"questions": questions,
"tips": tips,
"ages": ages,
"page": page,
"base_template": base_template,
"available_languages": ["en", "es"],
"es": es,
"language": language,
"show_banner": True,
"show_mega_menu": True,
"about_view_name": "retirement_api:" + ("about_es" if es else "about"),
}
return render(request, "retirement_api/claiming.html", cdict)
def get_translations_for_page(page):
translations = []
deactivate_all()
if settings.ENABLE_SITE_LOCALIZATION:
activate(settings.LANGUAGE_CODE)
else:
activate(page.language)
try:
trans_holder = page.get_children().get(title="Translations")
if page.live:
translations.append(page.specific)
translations.extend(trans_holder.get_children().live().specific())
except Page.DoesNotExist:
# Check if page exists within the translation folder
parent = page.get_parent()
if parent.title == "Translations":
if parent.get_parent().live:
translations.append(parent.get_parent().specific)
live_children = parent.get_children().live()
if live_children:
translations.extend(live_children.specific())
return translations
def translation(language_code, deactivate=False):
"""
Port of django.utils.translation.override from Django 1.4
@param language_code: a language code or ``None``. If ``None``, translation
is disabled and raw translation strings are used
@param deactivate: If ``True``, when leaving the manager revert to the
default behaviour (i.e. ``settings.LANGUAGE_CODE``)
rather than the translation that was active prior to
entering.
"""
from django.utils import translation
original = translation.get_language()
if language_code is not None:
translation.activate(language_code)
else:
translation.deactivate_all()
try:
yield
finally:
if deactivate:
translation.deactivate()
else:
translation.activate(original)
def __enter__(self):
if self.language is not None:
translation.activate(self.language)
else:
translation.deactivate_all()
def tearDown(self):
translation.deactivate_all()