def get_absolute_url(self, language=None, slug=None):
language = language or get_current_language()
if not slug:
slug = self.known_translation_getter(
'slug', default=None, language_code=language)[0] or ''
kwargs = {}
# since appconfig may be null/None, do not produce Attribute errors.
permalink_type = getattr(self.appconfig, 'permalink_type', '')
if 'P' in permalink_type:
kwargs.update({"category_pk": self.pk})
elif 'S' in permalink_type:
kwargs.update({"category_slug": slug})
else:
kwargs = {'category_pk': self.pk, 'category_slug': slug}
if self.appconfig_id and self.appconfig.namespace:
namespace = '{0}:'.format(self.appconfig.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}faq-category'.format(namespace), kwargs=kwargs)
def get_absolute_url(self, language=None):
if self.external_url:
return self.external_url
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if not slug: # news not translated in given language
if self.category:
return self.category.get_absolute_url(language=language)
try:
return get_page_url('latest-news', language)
except ImproperlyConfigured:
return '/'
kwargs = {
'year': self.publication_start.year,
'month': self.publication_start.month,
'day': self.publication_start.day,
'slug': slug
}
category_slug = get_slug_in_language(self.category, language)
if category_slug:
kwargs['category_slug'] = category_slug
return reverse('aldryn_news:news-detail', kwargs=kwargs)
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if not slug: # news not translated in given language
if self.category:
return self.category.get_absolute_url(language=language)
try:
return get_page_url('latest-news', language)
except ImproperlyConfigured:
return '/'
kwargs = {
'year': self.publication_start.year,
'month': self.publication_start.month,
'day': self.publication_start.day,
'slug': slug
}
category_slug = get_slug_in_language(self.category, language)
if category_slug:
kwargs['category_slug'] = category_slug
return reverse('news-detail', kwargs=kwargs)
def get_search_data(self, language=None, request=None):
"""
Provides an index for use with Haystack, or, for populating
Article.translations.search_data.
"""
if not self.pk:
return ''
if language is None:
language = get_current_language()
if request is None:
request = get_request(language=language)
description = self.safe_translation_getter('lead_in', '')
text_bits = [strip_tags(description)]
for category in self.categories.all():
text_bits.append(
force_unicode(category.safe_translation_getter('name')))
for tag in self.tags.all():
text_bits.append(force_unicode(tag.name))
if self.content:
plugins = self.content.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
plugin_text_content = ' '.join(
get_plugin_index_data(base_plugin, request))
text_bits.append(plugin_text_content)
return ' '.join(text_bits)
def published(self):
"""
Returns True only if the service (is_published == True) AND has a
published_date that has passed.
"""
language = get_current_language()
return self.published_for_language(language)
def all_translations(self, obj):
"""This is an adapter for the functionality that was in HVAD but not
in Parler.
"""
available = list(obj.get_available_languages())
langs = []
for lang, _ in settings.LANGUAGES:
if lang in available:
langs.append(lang)
available.remove(lang)
langs += available
for idx, lang in enumerate(langs):
change_form_url = reverse(
'admin:{app_label}_{model_name}_change'.format(
app_label=obj._meta.app_label.lower(),
model_name=obj.__class__.__name__.lower(),
), args=(obj.id, )
)
link = '<a href="{url}?language={lang}">{lang}</a>'.format(
url=change_form_url,
lang=lang,
)
if lang == get_current_language():
link = "<strong>{0}</strong>".format(link)
langs[idx] = link
return ', '.join(langs)
def get_absolute_url(self, language=None):
"""
Given a thing object, return its URL. If language fallbacks are
configured, then this should respect them. However, we should **never**
try to do anything with the ``redirect_on_fallback`` settings in CMS
and Parler here. That responsibility lies in the views.
Essentially, if a caller provides an object that has a valid **active**
language, then this will return a valid URL, not NoReverseMatch.
However, if the caller attempts to request the URL, but the object does
not have an **active** language translation, this may indeed, return a
NoReverseMatch.
:param language: The *desired* language.
:return: The URL in the desired language, or a fallback, if configured.
"""
if not language:
language = get_current_language() or get_default_language()
slug, language = self.known_translation_getter('slug',
None,
language_code=language)
kwargs = {'slug': slug}
with override(language):
return reverse('things:thing-detail', kwargs=kwargs)
def get_absolute_url(self, language=None, slug=None):
language = language or get_current_language()
if not slug:
slug = self.known_translation_getter(
'slug', default=None, language_code=language)[0] or ''
if not slug:
slug = self.slug
kwargs = {}
try:
permalink_type = self.appconfig.permalink_type
except AttributeError:
permalink_type = "Ss"
if 'P' in permalink_type:
kwargs.update({"category_pk": self.pk})
elif 'S' in permalink_type:
kwargs.update({"category_slug": slug})
else:
kwargs = {'category_pk': self.pk, 'category_slug': slug}
if self.appconfig_id and self.appconfig.namespace:
namespace = '{0}:'.format(self.appconfig.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}faq-category'.format(namespace), kwargs=kwargs)
def get_absolute_url(self, language=None):
"""
Returns the absolute_url of this question object, respecting the
configured fallback languages.
"""
if language is None:
language = get_current_language()
category_slug = self.category.known_translation_getter(
'slug',
default=None,
language_code=language
)[0] or ''
try:
namespace = self.category.appconfig.namespace
except:
namespace = False
if namespace and category_slug:
with override(language):
url_name = '{0}:faq-answer'.format(namespace)
url_kwargs = {
'pk': self.pk,
'category_pk': self.category.pk,
'category_slug': category_slug,
}
return reverse(url_name, kwargs=url_kwargs)
# No suitable translations exist, return the category's url
return self.category.get_absolute_url(language)
def get_absolute_url(self, language=None):
"""Returns the url for this Article in the selected permalink format."""
if not language:
language = get_current_language()
kwargs = {}
permalink_type = self.app_config.permalink_type
if 'y' in permalink_type:
kwargs.update(year=self.publishing_date.year)
if 'm' in permalink_type:
kwargs.update(month="%02d" % self.publishing_date.month)
if 'd' in permalink_type:
kwargs.update(day="%02d" % self.publishing_date.day)
if 'i' in permalink_type:
kwargs.update(pk=self.pk)
if 's' in permalink_type:
slug, lang = self.known_translation_getter(
'slug', default=None, language_code=language)
if slug and lang:
site_id = getattr(settings, 'SITE_ID', None)
if get_redirect_on_fallback(language, site_id):
language = lang
kwargs.update(slug=slug)
if self.app_config and self.app_config.namespace:
namespace = '{0}:'.format(self.app_config.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}article-detail'.format(namespace), kwargs=kwargs)
def get_search_data(self, language=None, request=None):
"""
Provides an index for use with Haystack, or, for populating
Article.translations.search_data.
"""
if not self.pk:
return ''
if language is None:
language = get_current_language()
if request is None:
request = get_request(language=language)
description = self.safe_translation_getter('lead_in', '')
text_bits = [strip_tags(description)]
for category in self.categories.all():
text_bits.append(
force_text(category.safe_translation_getter('name')))
for tag in self.article_tags.all():
text_bits.append(force_text(tag.name))
if self.content:
plugins = self.content.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
plugin_text_content = ' '.join(
get_plugin_index_data(base_plugin, request))
text_bits.append(plugin_text_content)
return ' '.join(text_bits)
def get_search_data(self, language=None, request=None):
"""
Provides an index for use with Haystack, or, for populating
Event.translations.search_data.
"""
if not self.pk:
return ''
if language is None:
language = get_current_language()
if request is None:
request = get_request(language=language)
text_bits = [self.first_name]
text_bits.append(self.last_name)
text_bits.append(self.safe_translation_getter('function', ''))
description = self.safe_translation_getter('description', '')
text_bits.append(strip_tags(description))
for category in self.categories.all():
text_bits.append(
force_unicode(category.safe_translation_getter('name')))
for service in self.services.all():
text_bits.append(
force_unicode(service.safe_translation_getter('title')))
if self.content:
plugins = self.content.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
plugin_text_content = ' '.join(
get_plugin_index_data(base_plugin, request))
text_bits.append(plugin_text_content)
return ' '.join(text_bits)
def get_page_choices(lang=None):
from django.core.cache import cache
lang = lang or i18n.get_current_language()
page_choices = cache.get(get_page_cache_key(lang))
if page_choices is None:
site_choices, page_choices = update_site_and_page_choices(lang)
return page_choices
def get_absolute_url(self, language=None):
"""Returns the url for this Article in the selected permalink format."""
if not language:
language = get_current_language()
kwargs = {}
permalink_type = self.app_config.permalink_type
if 'y' in permalink_type:
kwargs.update(year=self.publishing_date.year)
if 'm' in permalink_type:
kwargs.update(month="%02d" % self.publishing_date.month)
if 'd' in permalink_type:
kwargs.update(day="%02d" % self.publishing_date.day)
if 'i' in permalink_type:
kwargs.update(pk=self.pk)
if 's' in permalink_type:
slug, lang = self.known_translation_getter(
'slug', default=None, language_code=language)
if slug and lang:
site_id = getattr(settings, 'SITE_ID', None)
if get_redirect_on_fallback(language, site_id):
language = lang
kwargs.update(slug=slug)
if self.app_config and self.app_config.namespace:
namespace = '{0}:'.format(self.app_config.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}article-detail'.format(namespace), kwargs=kwargs)
def get_absolute_url(self, language=None, slug=None):
language = language or get_current_language()
if not slug:
slug = self.known_translation_getter(
'slug', default=None, language_code=language)[0] or ''
kwargs = {}
try:
permalink_type = self.appconfig.permalink_type
except AttributeError:
permalink_type = "Ss"
if 'P' in permalink_type:
kwargs.update({"category_pk": self.pk})
elif 'S' in permalink_type:
kwargs.update({"category_slug": slug})
else:
kwargs = {'category_pk': self.pk, 'category_slug': slug}
if self.appconfig_id and self.appconfig.namespace:
namespace = '{0}:'.format(self.appconfig.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}faq-category'.format(namespace), kwargs=kwargs)
def create_variant(self, combo, language=None):
"""
Create a variant with the given `combo` object from
the `get_combinations` method.
"""
if self.is_group:
if not language:
language = get_current_language()
slug = combo['slug']
code = combo['code'] or Product.objects.latest('pk').pk + 1
num = 0
while Product.objects.translated(slug=slug).exists():
num = num + 1
slug = '%s-%d' % (combo['slug'], num)
while Product.objects.filter(
code=code, translations__language_code=language).exists():
code = int(code) + 1
variant, created = Product.objects.get_or_create(
code=code, kind=Product.VARIANT, group=self)
variant.set_current_language(language)
variant.name = combo['name']
variant.slug = slug
variant.save()
if created:
for attr_value in combo['attributes'].values():
attr = Attribute.objects.get(code=attr_value['code'])
if attr_value['value'] == '' and attr.nullable:
choice = None
else:
choice = attr.choices.get(pk=attr_value['choice'])
AttributeValue.objects.create(attribute=attr,
product=variant,
choice=choice)
return variant
def get_absolute_url(self, language=None):
language = language or self.get_current_language()
if not language:
language = get_current_language()
slug = self.safe_translation_getter('slug', language_code=language)
category_slug = self.category.safe_translation_getter(
'slug', language_code=language)
namespace = getattr(self.category.app_config, "namespace",
"aldryn_jobs")
with force_language(language):
try:
# FIXME: does not looks correct return category url here
if not slug:
return self.category.get_absolute_url(language=language)
kwargs = {
'category_slug': category_slug,
'job_opening_slug': slug,
}
return reverse('{0}:job-opening-detail'.format(namespace),
kwargs=kwargs,
current_app=self.category.app_config.namespace)
except NoReverseMatch:
# FIXME: this is wrong, if have some problem in reverse
# we should know
return "/%s/" % language
def get_search_data(self, language=None, request=None):
"""
Provides an index for use with Haystack, or, for populating
Service.translations.search_data.
"""
if not self.pk:
return ''
if language is None:
language = get_current_language()
if request is None:
request = get_request(language=language)
title = self.safe_translation_getter('title', '')
description = self.safe_translation_getter('lead_in', '')
text_bits = [title, strip_tags(description)]
if ADD_CATEGORIES_TO_SEARCH_DATA:
for category in self.categories.all():
text_bits.append(
force_unicode(category.safe_translation_getter('name')))
if self.content:
plugins = self.content.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
plugin_text_content = ' '.join(
get_plugin_index_data(base_plugin, request))
text_bits.append(plugin_text_content)
return ' '.join(text_bits)
def get_content(self, language=None, show_draft_content=False):
if not language:
language = get_current_language()
try:
return self._content_cache[language]
except KeyError:
qs = self.contents.select_related(
'alias__category', ).prefetch_related('placeholders').filter(
language=language)
if show_draft_content and is_versioning_enabled():
from djangocms_versioning.constants import DRAFT, PUBLISHED
from djangocms_versioning.helpers import remove_published_where
# Ensure that we are getting the latest valid content, the top most version can become
# archived with a previous version re-published
qs = remove_published_where(qs)
qs = qs.filter(
Q(versions__state=DRAFT)
| Q(versions__state=PUBLISHED)).order_by(
'-versions__created')
self._content_cache[language] = qs.first()
return self._content_cache[language]
def test_index_multilingual(self):
self.index = ArticleIndex()
content0 = self.rand_str(prefix='content0_')
self.setup_categories()
article_1 = self.create_article(content=content0,
lead_in=u'lead in text',
title=u'a title')
article_2 = self.create_article(content=content0,
lead_in=u'lead in text',
title=u'second title')
for article in (article_1, article_2):
for category in (self.category1, self.category2):
article.categories.add(category)
with switch_language(article_2, 'de'):
article_2.title = u'de title'
article_2.lead_in = u'de lead in'
article_2.save()
LANGUAGES = add_default_language_settings(PARLER_LANGUAGES_HIDE)
with override_parler_settings(PARLER_LANGUAGES=LANGUAGES):
with smart_override('de'):
language = get_current_language()
# english-only article is excluded
qs = self.index.index_queryset(language)
self.assertEqual(qs.count(), 1)
self.assertEqual(
qs.translated(language, title__icontains='title').count(),
1)
# the language is correctly setup
for article_de in qs:
self.assertEqual(self.index.get_title(article_de),
'de title')
self.assertEqual(self.index.get_description(article_de),
'de lead in')
def get_absolute_url(self, language=None):
"""
Given a thing object, return its URL. If language fallbacks are
configured, then this should respect them. However, we should **never**
try to do anything with the ``redirect_on_fallback`` settings in CMS
and Parler here. That responsibility lies in the views.
Essentially, if a caller provides an object that has a valid **active**
language, then this will return a valid URL, not NoReverseMatch.
However, if the caller attempts to request the URL, but the object does
not have an **active** language translation, this may indeed, return a
NoReverseMatch.
:param language: The *desired* language.
:return: The URL in the desired language, or a fallback, if configured.
"""
if not language:
language = get_current_language() or get_default_language()
slug, language = self.known_translation_getter(
'slug', None, language_code=language)
kwargs = {'slug': slug}
with override(language):
return reverse('things:thing-detail', kwargs=kwargs)
def get_search_data(self, request=None):
"""
Provides an index for use with Haystack, or, for populating
Event.translations.search_data.
"""
if not self.pk:
return ''
language = self.title.language
if language is None:
language = get_current_language()
if request is None:
request = get_request(language=language)
text_bits = []
placeholder = self.get_placeholder()
if placeholder:
plugins = placeholder.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
try:
plugin_text_content = ' '.join(
get_plugin_index_data(base_plugin, request))
except:
plugin_text_content = ''
text_bits.append(plugin_text_content)
text_bits.append(self.title.title)
text_bits.append(self.title.meta_description or '')
return ' '.join(text_bits)
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
with switch_language(self, language):
return reverse(
'blogit_tag_detail',
kwargs={'slug': self.safe_translation_getter('slug')})
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with force_language(language):
if not slug: # category not translated in given language
return '/%s/' % language
kwargs = {'category_slug': slug}
return reverse('aldryn_faq:faq-category', kwargs=kwargs)
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
with switch_language(self, language):
try:
return reverse('shopit-product-detail', args=[self.safe_translation_getter('slug')])
except NoReverseMatch: # pragma: no cover
pass
def get_public_url(self, language=None):
if not language:
language = get_current_language()
if not TRANSLATE_IS_PUBLISHED and self.is_published:
return self.get_absolute_url(language)
if (TRANSLATE_IS_PUBLISHED and \
(self.safe_translation_getter('is_published_trans', language_code=language, any_language=False) or False)):
return self.get_absolute_url(language)
return ''
def published(self):
"""
Returns True only if the article (is_published == True) AND has a
published_date that has passed.
"""
language = get_current_language()
if TRANSLATE_IS_PUBLISHED:
return self.safe_translation_getter('is_published_trans', language_code=language, any_language=False) or False
return self.is_published
def get_plugins(self, language=None):
if not language:
language = get_current_language()
try:
return self._plugins_cache[language]
except KeyError:
placeholder = self.get_placeholder(language)
plugins = placeholder.get_plugins_list() if placeholder else []
self._plugins_cache[language] = plugins
return self._plugins_cache[language]
def get_default_language(self, using):
"""
When using multiple languages, this allows us to specify a fallback based on the
backend being used.
"""
if using and not using == DEFAULT_ALIAS and LANGUAGE_FROM_ALIAS:
return LANGUAGE_FROM_ALIAS(using)
else:
return get_current_language() or settings.LANGUAGE_CODE
def get_default_language(self, using):
"""
When using multiple languages, this allows us to specify a fallback based on the
backend being used.
"""
if using and not using == DEFAULT_ALIAS and LANGUAGE_FROM_ALIAS:
return LANGUAGE_FROM_ALIAS(using)
else:
return get_current_language() or settings.LANGUAGE_CODE
def get_vcard_url(self, language=None):
if not language:
language = get_current_language()
slug = self.safe_translation_getter(
'slug', None, language_code=language, any_language=False)
if slug:
kwargs = {'slug': slug}
else:
kwargs = {'pk': self.pk}
with override(language):
return reverse('aldryn_people:download_vcard', kwargs=kwargs)
def get_articles(self, request):
"""
Returns a queryset of the latest N articles. N is the plugin setting:
latest_articles.
"""
queryset = Article.objects
if not self.get_edit_mode(request):
queryset = queryset.published()
queryset = queryset.active_translations(
get_current_language()).filter(app_config=self.app_config)
return queryset[:self.latest_articles]
def get_articles(self, request):
if not self.article_count:
return Article.objects.none()
queryset = Article.objects
if not self.get_edit_mode(request):
queryset = queryset.published()
queryset = queryset.active_translations(get_current_language()).filter(
app_config=self.app_config,
is_featured=True,
)
return queryset[:self.article_count]
def get_articles(self, request):
if not self.article_count:
return Article.objects.none()
queryset = Article.objects
if not self.get_edit_mode(request):
queryset = queryset.published()
queryset = queryset.active_translations(get_current_language()).filter(
app_config=self.app_config,
is_featured=True,
)
return queryset[:self.article_count]
def get_absolute_url(self, language=None):
if not language:
language = get_current_language() or get_default_language()
slug, language = self.known_translation_getter(
'slug', None, language_code=language)
if slug:
kwargs = {'slug': slug}
else:
kwargs = {'pk': self.pk}
with override(language):
return reverse('aldryn_people:group-detail', kwargs=kwargs)
def get_absolute_url(self, language=None):
if not language:
language = get_current_language() # pragma: no cover
url_name = 'shopit-%s-detail' % self._meta.model.__name__.lower()
with switch_language(self, language):
try:
return reverse(url_name, args=[self.get_path()])
except NoReverseMatch: # pragma: no cover
pass
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if slug:
return reverse('aldryn_blog:category-posts', kwargs={'category': slug})
# category not translated in given language
try:
return reverse('aldryn_blog:latest-posts')
except (ImproperlyConfigured, NoReverseMatch):
return '/%s' % language
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if not slug: # category not translated in given language
try:
return get_page_url('latest-news', language)
except ImproperlyConfigured:
return '/'
kwargs = {'category_slug': slug}
return reverse('aldryn_news:news-category', kwargs=kwargs)
def get_articles(self, request):
"""
Returns a queryset of the latest N articles. N is the plugin setting:
latest_articles.
"""
queryset = Article.objects
if not self.get_edit_mode(request):
queryset = queryset.published()
queryset = queryset.active_translations(get_current_language()).filter(
app_config=self.app_config
)
return queryset[:self.latest_articles]
def create_all_variants(self, language=None):
"""
Creates all missing variants for the group.
"""
if self.is_group:
variants = []
if not language:
language = get_current_language()
for combo in self.get_combinations():
if not combo['pk'] or language not in combo['languages']:
variants.append(self.create_variant(combo, language=language))
return variants
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if not slug: # category not translated in given language
try:
return get_page_url('latest-news', language)
except ImproperlyConfigured:
return '/'
kwargs = {'category_slug': slug}
return reverse('news-category', kwargs=kwargs)
def get_absolute_url(self, language=None):
language = language or get_current_language()
slug = get_slug_in_language(self, language)
with override(language):
if slug:
return reverse('aldryn_blog:category-posts',
kwargs={'category': slug})
# category not translated in given language
try:
return reverse('aldryn_blog:latest-posts')
except (ImproperlyConfigured, NoReverseMatch):
return '/%s' % language
def get_absolute_url(self, language=None):
language = language or get_current_language()
category = self.category
try:
translation = get_translation(self, language_code=language)
except models.ObjectDoesNotExist:
translation = None
cat_slug = get_slug_in_language(category, language)
if translation and cat_slug:
with force_language(language):
return reverse('aldryn_faq:faq-answer', args=(cat_slug, self.pk))
else:
return category.get_absolute_url(language)
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
with switch_language(self, language):
if bs.POST_DETAIL_DATE_URL:
return reverse('blogit_post_detail_date', kwargs={
'year': self.date_published.year,
'month': self.date_published.month,
'day': self.date_published.day,
'slug': self.safe_translation_getter('slug'),
})
return reverse('blogit_post_detail', kwargs={
'slug': self.safe_translation_getter('slug')})
def save(self, *args, **kwargs):
if not self.importance:
Campaign.reorder_importance()
language = get_current_language()
activate(language=language)
self.slug = slugify(self.title)
return_value = super(Campaign, self).save(*args, **kwargs)
if self.is_active():
self.index_in_elasticsearch(1)
else:
self.deindex_in_elasticsearch()
return return_value
def clean(self):
super(Ministry, self).clean()
language = get_current_language()
activate(language)
ministry = Ministry.objects.active_translations(name=self.name).filter(
government_structure=self.government_structure, )
if self.pk:
ministry = ministry.exclude(pk=self.pk)
if ministry.first():
message = _(
"ministries's name and government structure, are not unique.")
raise ValidationError({'government_structure': message})
def update_site_and_page_choices(lang=None):
lang = lang or i18n.get_current_language()
SITE_CHOICES_KEY = get_site_cache_key(lang)
PAGE_CHOICES_KEY = get_page_cache_key(lang)
title_queryset = (Title.objects.drafts()
.select_related('page', 'page__site')
.order_by('page__tree_id', 'page__lft', 'page__rght'))
pages = defaultdict(SortedDict)
sites = {}
for title in title_queryset:
page = pages[title.page.site.pk].get(title.page.pk, {})
page[title.language] = title
pages[title.page.site.pk][title.page.pk] = page
sites[title.page.site.pk] = title.page.site.name
site_choices = []
page_choices = [('', '----')]
try:
fallbacks = i18n.get_fallback_languages(lang)
except LanguageError:
fallbacks = []
language_order = [lang] + fallbacks
for sitepk, sitename in sites.items():
site_choices.append((sitepk, sitename))
site_page_choices = []
for titles in pages[sitepk].values():
title = None
for language in language_order:
title = titles.get(language)
if title:
break
if not title:
continue
indent = u" " * title.page.level
page_title = mark_safe(u"%s%s" % (indent, title.title))
site_page_choices.append((title.page.pk, page_title))
page_choices.append((sitename, site_page_choices))
from django.core.cache import cache
# We set it to 1 day here because we actively invalidate this cache.
cache.set(SITE_CHOICES_KEY, site_choices, 86400)
cache.set(PAGE_CHOICES_KEY, page_choices, 86400)
return site_choices, page_choices
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
slug, language = self.known_translation_getter(
'slug', None, language_code=language)
if slug:
kwargs = {'slug': slug}
else:
kwargs = {'pk': self.pk}
with override(language):
# do not fail with 500 error so that if detail view can't be
# resolved we still can use plugins.
try:
url = reverse('aldryn_people:person-detail', kwargs=kwargs)
except NoReverseMatch:
url = ''
return url
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
with switch_language(self, language):
if bs.POST_DETAIL_DATE_URL:
return reverse(
"blogit_post_detail_date",
kwargs={
"year": self.date_published.year,
"month": self.date_published.month,
"day": self.date_published.day,
"slug": self.safe_translation_getter("slug"),
},
)
return reverse("blogit_post_detail", kwargs={"slug": self.safe_translation_getter("slug")})
def get_text_from_placeholder(placeholder, language=None, request=None):
"""
Returns rendered and strippet text from given placeholder
"""
if not placeholder:
return ''
if not language:
language = get_current_language()
if not request:
request = get_request(language)
bits = []
plugins = placeholder.cmsplugin_set.filter(language=language)
for base_plugin in plugins:
instance, plugin_type = base_plugin.get_plugin_instance()
if instance is None:
continue
bits.append(instance.render_plugin(context=RequestContext(request)))
return force_unicode(strip_tags(' '.join(bits)))
def get_absolute_url(self, language=None):
"""
Returns the absolute_url of this question object, respecting the
configured fallback languages.
"""
language = language or get_current_language()
category_slug = self.category.known_translation_getter(
'slug', default='', language_code=language)[0]
question_slug = self.known_translation_getter(
'slug', default='', language_code=language)[0]
try:
namespace = self.category.appconfig.namespace
except AttributeError:
namespace = False
permalink_type = self.category.appconfig.permalink_type
kwargs = {}
if 'P' in permalink_type:
kwargs.update({"category_pk": self.category.pk})
elif 'S' in permalink_type:
kwargs.update({"category_slug": category_slug})
else:
kwargs = {
'category_pk': self.category.pk,
'category_slug': category_slug
}
if 'p' in permalink_type:
kwargs.update({"pk": self.pk})
else:
kwargs.update({"slug": question_slug})
if namespace and category_slug:
with override(language):
url_name = '{0}:faq-answer'.format(namespace)
return reverse(url_name, kwargs=kwargs)
# No suitable translation exists, return the category's url
return self.category.get_absolute_url(language)
def get_absolute_url(self, language=None, slug=None):
if language is None:
language = get_current_language()
if slug is None:
slug = self.known_translation_getter(
'slug',
default=None,
language_code=language
)[0] or ''
kwargs = {'category_pk': self.pk, 'category_slug': slug}
if self.appconfig_id and self.appconfig.namespace:
namespace = '{0}:'.format(self.appconfig.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}faq-category'.format(namespace), kwargs=kwargs)
def known_translation_getter(self, field, default=None,
language_code=None, any_language=False):
"""
This is meant to act like HVAD/Parler's safe_translation_getter() but
respects the fallback preferences as defined in
`settings.CMS_LANGUAGES` and returns both the translated field value
and the language it represents as a tuple: (value, language).
If no suitable language is found, then it returns (default, None)
"""
# NOTE: We're using the CMS fallbacks here, rather than the Parler
# fallbacks, the developer should ensure that their project's Parler
# settings match the CMS settings.
try:
object_languages = self.get_available_languages()
assert hasattr(object_languages, '__iter__')
except [KeyError, AssertionError]:
raise ImproperlyConfigured(
"TranslationHelperMixin must be used with a model defining"
"get_available_languages() that returns a list of available"
"language codes. E.g., django-parler's TranslatableModel.")
language_code = (
language_code or get_current_language() or get_default_language())
site_id = getattr(settings, 'SITE_ID', None)
languages = [language_code] + get_fallback_languages(
language_code, site_id=site_id)
# Grab the first language that is common to our list of fallbacks and
# the list of available languages for this object.
if languages and object_languages:
language_code = next(
(lang for lang in languages if lang in object_languages), None)
if language_code:
value = self.safe_translation_getter(field,
default=default, language_code=language_code)
return (value, language_code)
# No suitable translation exists
return (default, None)
def get_absolute_url(self, language=None):
if not language:
language = get_current_language()
kwargs = {}
slug, slug_lang = self.known_translation_getter(
'slug', default=None, language_code=language)
kwargs.update(slug=slug)
if slug and slug_lang:
site_id = getattr(settings, 'SITE_ID', None)
if get_redirect_on_fallback(language, site_id):
language = slug_lang
if self.app_config_id and self.app_config.namespace:
namespace = '{0}:'.format(self.app_config.namespace)
else:
namespace = ''
with override(language):
return reverse('{0}events_detail'.format(namespace), kwargs=kwargs)
def all_translations(self, obj):
"""
Adds a property to the list_display that lists all translations with
links directly to their change forms. Includes CSS to style the links
to looks like tags with color indicating current language, active and
inactive translations.
A similar capability is in HVAD, and now there is this for
Parler-based projects.
"""
available = list(obj.get_available_languages())
current = get_current_language()
langs = []
for code, lang_name in settings.LANGUAGES:
classes = ["lang-code", ]
title = force_text(lang_name)
if code == current:
classes += ["current", ]
if code in available:
classes += ["active", ]
title += " (translated)"
else:
title += " (untranslated)"
change_form_url = admin_reverse(
'{app_label}_{model_name}_change'.format(
app_label=obj._meta.app_label.lower(),
model_name=obj.__class__.__name__.lower(),
), args=(obj.id, )
)
link = ('<a class="{classes}" href="{url}?language={code}" ' +
'title="{title}">{code}</a>').format(
classes=' '.join(classes),
url=change_form_url,
code=code,
title=title,
)
langs.append(link)
return ''.join(langs)
def test_index_multilingual(self):
self.index = ArticleIndex()
content0 = self.rand_str(prefix='content0_')
self.setup_categories()
article_1 = self.create_article(
content=content0, lead_in=u'lead in text', title=u'a title')
article_2 = self.create_article(
content=content0, lead_in=u'lead in text', title=u'second title')
for article in (article_1, article_2):
for tag_name in ('tag 1', 'tag2'):
article.tags.add(tag_name)
for category in (self.category1, self.category2):
article.categories.add(category)
with switch_language(article_2, 'de'):
article_2.title = u'de title'
article_2.lead_in = u'de lead in'
article_2.save()
LANGUAGES = add_default_language_settings(PARLER_LANGUAGES_HIDE)
with override_parler_settings(PARLER_LANGUAGES=LANGUAGES):
with smart_override('de'):
language = get_current_language()
# english-only article is excluded
qs = self.index.index_queryset(language)
self.assertEqual(qs.count(), 1)
self.assertEqual(
qs.translated(language, title__icontains='title').count(),
1
)
# the language is correctly setup
for article_de in qs:
self.assertEqual(
self.index.get_title(article_de), 'de title')
self.assertEqual(
self.index.get_description(article_de), 'de lead in')
def cms_seoutils_alternate(context):
page = context.get('current_page')
if page is not None:
current_language = get_current_language()
return {'alternate': [v for k, v in get_alternate(page).items()
if k != current_language]}
