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, 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_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_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() 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]}