def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.spanish_mexico = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='es-mx',
is_active=True)
# Creates a section under the main page
self.english_section = self.mk_section(
self.section_index, title='English section')
# Creates a sub-section under the section
self.english_subsection = self.mk_section(
self.english_section, title='English subsection')
# Login
self.user = self.login()
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.new_section = self.mk_section(
self.section_index,
title="New Section",
extra_style_hints='primary')
self.new_section2 = self.mk_section(
self.new_section, title="New Section 2")
self.new_section3 = self.mk_section(
self.section_index, title="New Section 3", slug="new-section-3")
self.new_section4 = self.mk_section(
self.new_section2, title="New Section 4", slug="new-section-4")
self.new_section5 = self.mk_section(
self.new_section,
title="New Section 5", slug="new-section-5",
extra_style_hints='secondary')
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='es',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind2')
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.spanish_mexico = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='es-mx',
is_active=True)
# Creates a section under the main page
self.english_section = self.mk_section(self.section_index,
title='English section')
# Creates a sub-section under the section
self.english_subsection = self.mk_section(self.english_section,
title='English subsection')
# Login
self.user = self.login()
def setUp(self):
self.main = self.mk_main(title='main1',
slug='main1',
path='00010002',
url_path='/main1/')
self.client = Client(HTTP_HOST=self.main.get_site().hostname)
self.form_index = FormsIndexPage.objects.child_of(self.main).first()
self.section_index = SectionIndexPage.objects.child_of(
self.main).first()
self.site_settings = SiteSettings.for_site(self.main.get_site())
self.site_settings.enable_tag_navigation = True
self.site_settings.save()
self.banner_message = ("Share your opinions and stories, " +
"take polls, win fun prizes.")
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(Site.objects.first()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(self.section_index, title='Your mind')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french')
def setUp(self):
self.main = self.mk_main(
title='main1', slug='main1', path='00010002', url_path='/main1/')
self.client = Client(HTTP_HOST=self.main.get_site().hostname)
self.site_settings = SiteSettings.for_site(self.main.get_site())
self.yourmind = self.mk_section(
SectionIndexPage.objects.child_of(self.main).first(),
title='Your mind')
self.article = self.mk_article(self.yourmind, title='article')
self.article.save_revision().publish()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
self.fr_article = self.mk_article_translation(
self.article, self.french)
self.fr_yourmind = self.mk_section_translation(
self.yourmind, self.french)
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='es',
is_active=True)
self.arabic = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='ar',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind')
self.yourbody = self.mk_section(
self.section_index, title='Your body')
self.yourmind_sub = self.mk_section(
self.yourmind, title='Your mind subsection')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french')
self.yourmind_sub_fr = self.mk_section_translation(
self.yourmind_sub, self.french,
title='Your mind subsection in french')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='es',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind2')
self.yourmind_sub2 = self.mk_section(
self.yourmind2, title='Your mind subsection2')
self.site_settings = SiteSettings.for_site(main.get_site())
self.site_settings2 = SiteSettings.for_site(self.main2.get_site())
self.site_settings.enable_clickable_tags = True
self.site_settings.enable_tag_navigation = True
self.site_settings.save()
def test_move_method_of_article_page_copies_over_languages(self):
self.assertFalse(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
article = self.mk_articles(self.yourmind, 1)[0]
fr_article = self.mk_article_translation(article, self.french)
fr_article.move(self.yourmind2)
self.assertTrue(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
self.assertFalse(
Languages.for_site(self.main2.get_site()).languages.filter(
locale='fr').first().is_active)
def test_move_method_of_article_page_copies_over_languages(self):
self.assertFalse(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
article = self.mk_articles(self.yourmind, 1)[0]
fr_article = self.mk_article_translation(article, self.french)
fr_article.move(self.yourmind2)
self.assertTrue(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
self.assertFalse(
Languages.for_site(
self.main2.get_site()).languages.filter(
locale='fr').first().is_active)
def test_two_sites_point_to_one_root_page(self):
# assert that there is only one site rooted at main
self.assertEqual(self.main.sites_rooted_here.count(), 1)
client_1 = Client()
# add a site that points to the same root page
site_2 = Site.objects.create(hostname=generate_slug('site2'),
port=80,
root_page=self.main)
# create a link buetween the current langauges and the new site
Languages.objects.create(site_id=site_2.pk)
SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(site_2),
locale='en',
is_active=True)
client_2 = Client(HTTP_HOST=site_2.hostname)
# assert that there are now two sites rooted at main
self.assertEqual(self.main.sites_rooted_here.count(), 2)
# create molo form page
molo_form_page, molo_form_field = \
self.create_molo_form_page(
parent=self.forms_index,
homepage_button_text='share your story yo')
# assert that both sites render the form
response = client_1.get('/molo-forms-main-1/test-form/')
self.assertEqual(response.status_code, 200)
response = client_2.get(site_2.root_url +
'/molo-forms-main-1/test-form/')
self.assertEqual(response.status_code, 200)
def test_two_sites_point_to_one_root_page(self):
# assert that there is only one site rooted at main
self.assertEquals(self.main.sites_rooted_here.count(), 1)
client_1 = Client()
# add a site that points to the same root page
site_2 = Site.objects.create(
hostname=generate_slug('site2'), port=80, root_page=self.main)
# create a link buetween the current langauges and the new site
Languages.objects.create(
site_id=site_2.pk)
SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(site_2),
locale='en',
is_active=True)
client_2 = Client(HTTP_HOST=site_2.hostname)
# assert that there are now two sites rooted at main
self.assertEquals(self.main.sites_rooted_here.count(), 2)
# create molo survey page
molo_survey_page, molo_survey_form_field = \
self.create_molo_survey_page(
parent=self.surveys_index,
homepage_button_text='share your story yo')
# assert that both sites render the survey
response = client_1.get('/surveys-main-1/test-survey/')
self.assertEquals(response.status_code, 200)
response = client_2.get(
site_2.root_url + '/surveys-main-1/test-survey/')
self.assertEquals(response.status_code, 200)
def test_submit_to_local_ga_translated_articlepage_title(
self, mock_submit_tracking):
"""requests for article with tags should
make a submit tracking with a cd6 value in the
custom params containing all the article tags"""
french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(Site.objects.first()),
locale='fr',
is_active=True)
french_article = self.mk_article_translation(self.article2, french)
french_article.title = "french translation of article"
french_article.save_revision().publish()
request = RequestFactory().get(
'/sections-main1-1/{}/{}/'.format(
self.yourmind.slug,
french_article.slug),
HTTP_HOST='localhost',
HTTP_X_DCMGUID="0000-000-01"
)
request.COOKIES[settings.LANGUAGE_COOKIE_NAME] = french.locale
request.site = self.main.get_site()
middleware = GemMoloGoogleAnalyticsMiddleware()
middleware.process_response(
request, self.response)
# check that the tilte of the article in the main languge is used
mock_submit_tracking.assert_called_once_with(
'local_ga_tracking_code',
request, self.response,
{'cd5': self.article2.title,
"cd3": 'Visitor',
'cd1': "0000-000-01",
})
def get_queryset(self):
'''
Only serve site-specific languages
'''
request = self.request
return (Languages.for_site(request.site)
.languages.filter().order_by('pk'))
def render_translations(context, page):
from molo.core.models import TranslatablePageMixinNotRoutable
if not issubclass(type(page.specific), TranslatablePageMixinNotRoutable):
return {}
if not page.specific.language.is_main_language:
return {}
languages = [
(l.locale, str(l))
for l in Languages.for_site(
context['request'].site.root_page.get_site()).languages.filter(
is_main_language=False)]
translated = []
for code, title in languages:
if page.specific.translated_pages.filter(
language__locale=code).exists():
translated.append({
'locale': {'title': title, 'code': code},
'translated':
page.specific.translated_pages.filter(
language__locale=code).first()})
else:
translated.append({
'locale': {'title': title, 'code': code},
'translated': []})
return {
'translations': translated,
'page': page
}
def get_queryset(self):
'''
Only serve site-specific languages
'''
request = self.request
return (Languages.for_site(
request.site).languages.filter().order_by('pk'))
def show_main_language_only(parent_page, pages, request):
main_language = Languages.for_site(
request.site).languages.filter(is_main_language=True).first()
if pages and main_language and parent_page.depth > 2:
if isinstance(pages, QuerySet):
for page in pages:
has_lang = hasattr(page.specific, 'language')
if 'indexpage' in page.slug or not has_lang:
continue
elif not page.specific:
pages = pages.exclude(pk=page.pk)
elif not page.specific.language:
pages = pages.exclude(pk=page.pk)
elif page.specific.language.pk != main_language.pk:
pages = pages.exclude(pk=page.pk)
return pages
else:
specific_pages = [page.specific for page in pages]
new_pages = [
page for page in specific_pages
if page.language and page.language.pk == main_language.pk
]
return new_pages
return pages
def setUp(self):
self.mk_main()
language_setting = Languages.for_site(self.main.get_site())
SiteLanguageRelation.objects.create(
language_setting=language_setting,
locale='en',
)
zulu = SiteLanguageRelation.objects.create(
language_setting=language_setting,
locale='zu',
)
xhosa = SiteLanguageRelation.objects.create(
language_setting=language_setting,
locale='xh',
)
self.login()
self.page_english = self.mk_article(self.main, title='En')
self.page_xhosa = self.mk_article_translation(
self.page_english, xhosa, title='Xh')
self.page_zulu = self.mk_article_translation(
self.page_english, zulu, title='Zu')
def test_two_sites_point_to_one_root_page(self):
# assert that there is only one site rooted at main
self.assertEqual(self.main.sites_rooted_here.count(), 1)
client_1 = Client()
# add a site that points to the same root page
site_2 = Site.objects.create(hostname=generate_slug('site2'),
port=80,
root_page=self.main)
# create a link buetween the current langauges and the new site
Languages.objects.create(site_id=site_2.pk)
SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(site_2),
locale='en',
is_active=True)
client_2 = Client(HTTP_HOST=site_2.hostname)
# assert that there are now two sites rooted at main
self.assertEqual(self.main.sites_rooted_here.count(), 2)
# assert that the correct hostname is returned for both sites
response = client_1.get('/sections-main-1/your-mind/')
self.assertEqual(response.status_code, 200)
response = client_2.get(site_2.root_url +
'/sections-main-1/your-mind/')
self.assertEqual(response.status_code, 200)
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.index = PersonaIndexPage(title='Personae', slug="personae")
self.main.add_child(instance=self.index)
self.index.save_revision().publish()
self.page = PersonaPage(title="child", slug="child")
self.index.add_child(instance=self.page)
self.page.save_revision().publish()
self.client = Client()
# Login
self.user = self.login()
site = Site.objects.get(is_default_site=True)
setting = SettingsProxy(site)
self.persona_settings = setting['usermetadata']['PersonaeSettings']
self.persona_settings.persona_required = True
self.persona_settings.save()
self.site_settings = setting['core']['SiteSettings']
self.site_settings.ga_tag_manager = 'GTM-xxxx'
self.site_settings.save()
def copy_translation_pages(page, new_page):
from molo.core.models import Languages
# Only copy translations for TranslatablePageMixin
if not hasattr(page.specific, 'copy_language'):
return 'Not translatable page'
current_site = page.get_site()
destination_site = new_page.get_site()
if current_site is not destination_site and (page.depth > 2):
page.specific.copy_language(current_site, destination_site)
languages = Languages.for_site(destination_site).languages
if languages.filter(is_main_language=True).exists():
new_page.language = languages.filter(is_main_language=True).first()
for translation in page.specific.translated_pages.all():
new_lang = translation.specific.copy_language(current_site,
destination_site)
new_translation = translation.copy(to=new_page.get_parent())
new_translation.language = new_lang
new_translation.specific.translated_pages.add(new_page)
new_page.specific.translated_pages.add(new_translation)
new_page.save()
new_translation.save()
for translated_page in \
page.specific.translated_pages.all():
translations = page.specific.translated_pages.all().\
exclude(language__pk=translated_page.language.pk)
for translation in translations:
translated_page.translated_pages.add(translation)
translated_page.save()
new_translation.save()
def load_article_info(self, request):
"""get the tags in an article if the request is for an article page"""
path = request.get_full_path()
path_components = [
component for component in path.split('/') if component
]
article_info = {}
try:
page, args, kwargs = request.site.root_page.specific.route(
request, path_components)
if issubclass(type(page.specific), ArticlePage):
tags_str = ""
main_lang = Languages.for_site(request.site).languages.filter(
is_main_language=True).first()
locale_code = get_locale_code(
get_language_from_request(request))
if main_lang.locale == locale_code:
article_info['cd5'] = page.specific.title
else:
article_info['cd5'] = page.specific.get_main_language_page(
).title
qs = load_tags_for_article(
{
'locale_code': 'en',
'request': request
}, page)
if qs:
for q in qs:
tags_str += "|" + q.title
article_info.update({'cd6': tags_str[1:]})
return article_info
except Http404:
return article_info
return article_info
def setUp(self):
# make main one with section and sub section with fr translations
self.mk_main()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind', slug='yourmind')
self.yourmind_sub = self.mk_section(
self.yourmind, title='Your mind subsection')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french',
slug='yourmind_fr')
self.yourmind_sub_fr = self.mk_section_translation(
self.yourmind_sub, self.french,
title='Your mind subsection in french')
# make main 2 with different section to main 1
self.mk_main2()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.french2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='fr',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind', slug='yourmind')
self.yourmind_sub2 = self.mk_section(
self.yourmind2, title='Your mind subsection2')
self.yourmind_fr2 = self.mk_section_translation(
self.yourmind2, self.french2, title='Your mind in french',
slug='yourmind_fr')
# create main 3 with nothing
self.mk_main3()
def setUp(self):
# make main one with section and sub section with fr translations
self.mk_main()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind', slug='yourmind')
self.yourmind_sub = self.mk_section(
self.yourmind, title='Your mind subsection')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french',
slug='yourmind_fr')
self.yourmind_sub_fr = self.mk_section_translation(
self.yourmind_sub, self.french,
title='Your mind subsection in french')
# make main 2 with different section to main 1
self.mk_main2()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.french2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='fr',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind', slug='yourmind')
self.yourmind_sub2 = self.mk_section(
self.yourmind2, title='Your mind subsection2')
self.yourmind_fr2 = self.mk_section_translation(
self.yourmind2, self.french2, title='Your mind in french',
slug='yourmind_fr')
# create main 3 with nothing
self.mk_main3()
def locale(request):
locale_code = get_locale_code(get_language_from_request(request))
languages = Languages.for_site(request.site).languages.filter(
is_active=True)
return {
'locale_code': locale_code,
'languages': languages,
'selected_language': languages.filter(locale=locale_code).first()}
def get_language(site, locale):
language_cache_key = 'get_pages_language_{}_{}'.format(site.pk, locale)
language = cache.get(language_cache_key)
if not language:
language = Languages.for_site(site).languages.filter(
locale=locale).first()
cache.set(language_cache_key, language, None)
return language
def get_language(site, locale):
language_cache_key = 'get_pages_language_{}_{}'.format(site.pk, locale)
language = cache.get(language_cache_key)
if not language:
language = Languages.for_site(site).languages.filter(
locale=locale).first()
cache.set(language_cache_key, language, None)
return language
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.yourmind = self.mk_section(self.section_index, title='Your mind')
def test_copy_method_of_article_page_copies_over_languages(self):
self.assertFalse(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
article = self.mk_articles(self.yourmind, 1)[0]
LanguageRelation.objects.create(page=article, language=self.english2)
self.mk_article_translation(article, self.french)
article2 = article.copy(to=self.yourmind2)
copy_translation_pages(article, article2)
self.assertTrue(
Languages.for_site(
self.main2.get_site()).languages.filter(locale='fr').exists())
self.assertFalse(
Languages.for_site(self.main2.get_site()).languages.filter(
locale='fr').first().is_active)
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.main = Main.objects.all().first()
self.factory = RequestFactory()
def get_context(self):
languages = Languages.for_site(self.request.site).languages.all()
return {
'summaries': [{
'language': l.get_locale_display(),
'total': ArticlePage.objects.all().filter(
language=l).count()
}for l in languages],
}
def locale(request):
locale_code = get_locale_code(get_language_from_request(request))
languages = Languages.for_site(
request.site).languages.filter(is_active=True)
return {
'locale_code': locale_code,
'languages': languages,
'selected_language': languages.filter(locale=locale_code).first()
}
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.mylife = self.mk_section(
self.section_index, title='My life')
self.yourmind = self.mk_section(
self.section_index, title='Your mind')
self.yourmind_sub = self.mk_section(
self.yourmind, title='Your mind subsection')
self.yourmind_sub2 = self.mk_section(
self.yourmind, title='Your mind subsection2')
self.yourmind_sub3 = self.mk_section(
self.yourmind, title='Your mind subsection3')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.english2 = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main2.get_site()),
locale='en',
is_active=True)
self.french2 = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main2.get_site()),
locale='fr',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind2')
self.yourmind_sub11 = self.mk_section(
self.yourmind2, title='Your mind subsection11')
self.yourmind_sub22 = self.mk_section(
self.yourmind2, title='Your mind subsection22')
self.yourmind_sub33 = self.mk_section(
self.yourmind2, title='Your mind subsection33')
def get_context(self):
languages = Languages.for_site(self.request.site).languages.all()
return {
'summaries': [{
'language':
l.get_locale_display(),
'total':
ArticlePage.objects.all().filter(language=l).count()
} for l in languages],
}
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.mylife = self.mk_section(self.section_index, title='My life')
self.yourmind = self.mk_section(self.section_index, title='Your mind')
self.yourmind_sub = self.mk_section(self.yourmind,
title='Your mind subsection')
self.yourmind_sub2 = self.mk_section(self.yourmind,
title='Your mind subsection2')
self.yourmind_sub3 = self.mk_section(self.yourmind,
title='Your mind subsection3')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.english2 = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main2.get_site()),
locale='en',
is_active=True)
self.french2 = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main2.get_site()),
locale='fr',
is_active=True)
self.yourmind2 = self.mk_section(self.section_index2,
title='Your mind2')
self.yourmind_sub11 = self.mk_section(self.yourmind2,
title='Your mind subsection11')
self.yourmind_sub22 = self.mk_section(self.yourmind2,
title='Your mind subsection22')
self.yourmind_sub33 = self.mk_section(self.yourmind2,
title='Your mind subsection33')
def test_site_languages(self):
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='sp',
is_active=False)
response = self.client.get('/')
self.assertContains(response, 'English')
self.assertContains(response, 'français')
self.assertNotContains(response, 'español')
def process_request(self, request):
if request.path.startswith('/admin/pages/') and \
not request.path.startswith('/admin/pages/moderation/'):
current_site = Site.find_for_request(request)
func, args, kwargs = resolve(request.path)
if args:
p_site = Page.objects.get(pk=args[-1]).specific.get_site()
if p_site and not current_site == p_site:
return redirect('%s%s' % (p_site.root_url, request.path))
if not Languages.for_site(request.site).languages.all().exists():
return redirect('%s/admin/' % request.site.root_url)
def test_site_languages(self):
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='sp',
is_active=False)
response = self.client.get('/')
self.assertContains(response, 'English')
self.assertContains(response, 'français')
self.assertNotContains(response, 'español')
def process_request(self, request):
if request.path.startswith('/admin/pages/') and \
not request.path.startswith('/admin/pages/moderation/'):
current_site = Site.find_for_request(request)
func, args, kwargs = resolve(request.path)
if args:
p_site = Page.objects.get(pk=args[-1]).specific.get_site()
if p_site and not current_site == p_site:
return redirect('%s%s' % (p_site.root_url, request.path))
if not Languages.for_site(request.site).languages.all().exists():
return redirect('%s/admin/' % request.site.root_url)
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind')
self.surveys_index = SurveysIndexPage.objects.child_of(
self.main).first()
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.language_setting = Languages.objects.create(
site_id=self.main.get_site().pk)
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='sp',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(self.section_index, title='Your mind')
self.article = ArticlePage(title='Test Article', slug='test-article')
self.yourmind.add_child(instance=self.article)
self.article.save_revision().publish()
def setUp(self):
self.client = Client()
# Creates Main language
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
# Creates a section under the index page
self.english_section = self.mk_section(
self.section_index, title='English section')
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.user = User.objects.create_user(
'test', '*****@*****.**', 'test')
self.content_type = ContentType.objects.get_for_model(self.user)
self.client = Client()
def handle(self, *args, **options):
locale_code = options.get('locale', None)
mains = Main.objects.all()
for main in mains:
section_index = SectionIndexPage.objects.child_of(main).first()
main_lang = Languages.for_site(main.get_site()).languages.filter(
is_active=True, is_main_language=True).first()
sections = SectionPage.objects.descendant_of(section_index).filter(
languages__language__is_main_language=True).live()
translated_sections = SectionPage.objects.descendant_of(
section_index).filter(
languages__language__is_main_language=False).live()
for translated_section in translated_sections:
translated_section.image = None
translated_section.save_revision().publish()
if section_index and main_lang:
if main_lang.locale == locale_code:
for section in sections:
if section.title == "Girl Stories":
section.slug = "girl-stories"
image = Image.objects.filter(title=section.slug +
".png").first()
if image:
section.image = image
section.extra_style_hints = section.slug
section.save_revision().publish()
else:
self.stdout.write(
self.style.NOTICE(
'Image "%s" does not exist in "%s"' %
(section.slug, main)))
else:
self.stdout.write(
self.style.NOTICE(
'Main language of "%s" is not "%s".'
' The main language is "%s"' %
(main.get_site(), locale_code, main_lang)))
else:
if not section_index:
self.stdout.write(
self.style.NOTICE(
'Section Index Page does not exist in "%s"' %
main))
if not main_lang:
self.stdout.write(
self.style.NOTICE(
'Main language does not exist in "%s"' % main))
def handle(self, **options):
mains = Main.objects.all()
tags = {}
with open('data/tags.csv') as tags_csv:
reader = csv.DictReader(tags_csv)
if mains:
for row in reader:
key = row.pop('Tags')
tags[key] = row
for main in mains:
tag_index = TagIndexPage.objects.child_of(main).first()
main_lang = Languages.for_site(main.get_site()).languages.filter(
is_active=True, is_main_language=True).first()
child_languages = Languages.for_site(
main.get_site()).languages.filter(
is_active=True, is_main_language=False).all()
if main_lang:
add_tags(self, main_lang, child_languages, tag_index, tags)
else:
self.stdout.write(
self.style.NOTICE('Main language does not exist in "%s"' %
main))
def setUp(self):
self.mk_main()
self.main = Main.objects.all().first()
self.language_setting = Languages.objects.create(
site_id=self.main.get_site().pk)
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='sp',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your mind')
self.article = ArticlePage(title='Test Article', slug='test-article')
self.yourmind.add_child(instance=self.article)
self.article.save_revision().publish()
def setUp(self):
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
self.yourmind = self.mk_section(
self.section_index, title='Your Mind')
self.yourmind_fr = self.mk_section_translation(
self.yourmind, self.french, title='Your mind in french')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='es',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind2')
User.objects.create_superuser(
username='******', password='******', email='*****@*****.**')
self.client.login(username='******', password='******')
def setUp(self):
self.client = Client()
# Creates Main language
self.mk_main()
main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='en',
is_active=True)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale='fr',
is_active=True)
# Creates a section under the index page
self.english_section = self.mk_section(
self.section_index, title='English section')
self.mk_main2()
self.main2 = Main.objects.all().last()
self.language_setting2 = Languages.objects.create(
site_id=self.main2.get_site().pk)
self.english2 = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='en',
is_active=True)
self.spanish = SiteLanguageRelation.objects.create(
language_setting=self.language_setting2,
locale='es',
is_active=True)
self.yourmind2 = self.mk_section(
self.section_index2, title='Your mind2')
self.yourmind_sub2 = self.mk_section(
self.yourmind2, title='Your mind subsection2')
def handle(self, *args, **options):
# first add all the translations to the main language Page
# and add the main language page as a translated page
# to the translated pages
for main in Main.objects.all():
try:
main_language = Languages.for_site(
main.get_site()).languages.get(is_main_language=True)
except ObjectDoesNotExist:
self.stdout.write(self.style.NOTICE(
'Main with pk "%s"'
'is missing a main language'
% (main.pk)))
continue
pages = Page.objects.all().exclude(depth__in=[1, 2, 3])
for page in pages:
if page.specific.language and (
page.specific.language.pk == main_language.pk):
for translation in PageTranslation.objects.filter(
page=page):
if translation.page and \
translation.translated_page and \
translation.translated_page.specific.language and \
translation.translated_page.pk != translation.page.pk:
page.specific.translated_pages.add(
translation.translated_page.specific)
translation.translated_page.specific.\
translated_pages.add(page.specific)
page.save()
translation.translated_page.save()
else:
self.stdout.write(self.style.NOTICE(
'Translation with pk "%s"'
'is missing page/translated_page'
% (translation.pk)))
# loop through all translated_pages on the main language page and
# add all the translations to the rest of the translated pages
# except the language that it is in
for page in Page.objects.all().exclude(depth__in=[1, 2, 3]):
if page.specific.language and (
page.specific.language.pk == main_language.pk):
for translated_page in \
page.specific.translated_pages.all():
translations = page.specific.translated_pages.all().\
exclude(language__pk=translated_page.language.pk)
for translation in translations:
translated_page.translated_pages.add(translation)
translated_page.save()
def handle(self, *args, **options):
new_language_locale = options.get('new_language_locale', None)
mains = Main.objects.all()
if mains.count() != 1:
self.stdout.write(self.style.ERROR(
'This command only works for apps with one wagtail site'))
exit(1)
main = mains.first()
old_main_langauge = SiteLanguageRelation.objects.get(
is_main_language=True)
if not main:
self.stdout.write(self.style.ERROR(
'Main page does not exist'))
# add the new language if necessary
desired_main_language = SiteLanguage.objects.filter(
locale=new_language_locale)
if not desired_main_language.exists():
new_language = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(main.get_site()),
locale=new_language_locale,
is_active=True)
self.stdout.write(self.style.NOTICE(
'New Language %s created' %
new_language.locale))
else:
self.stdout.write(self.style.NOTICE(
'Language %s already exists' %
desired_main_language.first().locale))
new_language = new_language = SiteLanguageRelation.objects.get(
locale=new_language_locale)
# switch the language relation to the new language
for relation in LanguageRelation.objects.filter(
language__is_main_language=True):
relation.language = new_language
relation.page.specific.language = new_language
relation.save()
new_language.is_main_language = True
new_language.save()
old_main_langauge.is_main_language = False
old_main_langauge.is_active = False
old_main_langauge.save()
self.stdout.write(self.style.SUCCESS(
'Main language swopped from %s to %s' %
(old_main_langauge.locale, new_language.locale)))
def setUp(self):
self.mk_main()
self.client = Client()
self.main = Main.objects.all().first()
self.english = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='en',
is_active=True)
self.english_section = self.mk_section(
self.section_index, title='English section')
self.mk_article(self.english_section)
User.objects.create_superuser(
username="******", email="*****@*****.**", password="******"
)
self.client.login(username="******", password="******")
def handle(self, **options):
csv_name = options.get('csv_name', None)
mains = Main.objects.all()
dates = {}
with open(csv_name) as dates_csv:
reader = csv.DictReader(dates_csv)
if mains:
for row in reader:
dates[row['slug']] = row['date']
for main in mains:
main_lang = Languages.for_site(main.get_site()).languages.filter(
is_active=True, is_main_language=True).first()
if main_lang:
add_dates(self, main_lang, main, dates)
else:
self.stdout.write(self.style.NOTICE(
'Main language does not exist in "%s"' % main))
def rotate_content(day=None):
""" this method gets the parameters that are needed for rotate_latest
and rotate_featured_in_homepage methods, and calls them both"""
# getting the content rotation settings from site settings
for main in Main.objects.all():
site = main.sites_rooted_here.all().first()
main_lang = Languages.for_site(site).languages.filter(
is_main_language=True).first()
index = SectionIndexPage.objects.live().child_of(main).first()
site_settings = SiteSettings.for_site(site)
if day is None:
day = timezone.now().weekday()
# calls the two rotate methods with the necessary params
if main and index:
rotate_latest(main_lang, index, main, site_settings, day)
rotate_featured_in_homepage(main_lang, day, main)
def add_translation(request, page_id, locale):
_page = get_object_or_404(Page, id=page_id)
page = _page.specific
if not issubclass(type(page), TranslatablePageMixinNotRoutable):
messages.add_message(
request, messages.INFO, _('That page is not translatable.'))
return redirect(reverse('wagtailadmin_home'))
# redirect to edit page if translation already exists for this locale
translated_page = page.translated_pages.filter(language__locale=locale)
if translated_page.exists():
return redirect(
reverse('wagtailadmin_pages:edit', args=[
translated_page.first().id]))
# create translation and redirect to edit page
language = Languages.for_site(request.site).languages.filter(
locale=locale).first()
if not language:
raise Http404
new_title = str(language) + " translation of %s" % page.title
new_slug = generate_slug(new_title)
translation = page.__class__(
title=new_title, slug=new_slug, language=language)
page.get_parent().add_child(instance=translation)
translation.save_revision()
# add the translation the new way
page.specific.translated_pages.add(translation)
page.save()
translation.specific.translated_pages.add(page)
translation.save()
for translated_page in \
page.specific.translated_pages.all():
translations = page.specific.translated_pages.all().\
exclude(language__pk=translated_page.language.pk)
for translation in translations:
translated_page.translated_pages.add(translation)
translated_page.save()
# make sure new translation is in draft mode
translation.unpublish()
return redirect(
reverse('wagtailadmin_pages:edit', args=[translation.id]))
def show_main_language_only(parent_page, pages, request):
main_language = Languages.for_site(request.site).languages.filter(
is_main_language=True).first()
if pages and main_language and parent_page.depth > 2:
if isinstance(pages, QuerySet):
for page in pages:
if not page.specific:
pages = pages.exclude(pk=page.pk)
elif not page.specific.language:
pages = pages.exclude(pk=page.pk)
elif page.specific.language.pk != main_language.pk:
pages = pages.exclude(pk=page.pk)
return pages
else:
specific_pages = [page.specific for page in pages]
new_pages = [page for page in specific_pages
if page.language and
page.language.pk == main_language.pk]
return new_pages
return pages
def test_language_list_view(self):
api_client = Client()
url = "/api/v2/languages/"
response = api_client.get(url)
self.assertEqual(response.status_code, 200)
obj = json.loads(response.content)['items']
self.assertEqual(len(obj), 1)
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
response = api_client.get(url)
obj = json.loads(response.content)['items']
self.assertEqual(response.status_code, 200)
self.assertEqual(len(obj), 2)
def test_language_detail_view(self):
self.french = SiteLanguageRelation.objects.create(
language_setting=Languages.for_site(self.main.get_site()),
locale='fr',
is_active=True)
api_client = Client()
url = "/api/v2/languages/"
response = api_client.get("{}{}/".format(url, self.english.id))
self.assertEqual(response.status_code, 200)
obj = json.loads(response.content)
self.assertEqual(obj['locale'], 'en')
self.assertEqual(obj['is_main_language'], True)
self.assertEqual(obj['is_active'], True)
response = api_client.get("{}{}/".format(url, self.french.id))
self.assertEqual(response.status_code, 200)
obj = json.loads(response.content)
self.assertEqual(obj['locale'], 'fr')
self.assertEqual(obj['is_main_language'], False)
self.assertEqual(obj['is_active'], True)
def handle(self, *args, **options):
csv_name = options.get('csv_name', None)
locale = options.get('locale', None)
mains = Main.objects.all()
articles = {}
with open(csv_name) as articles_tags:
reader = csv.reader(articles_tags)
if mains:
for row in reader:
key = row[0]
articles[key] = row[1:]
for main in mains:
section_index = SectionIndexPage.objects.child_of(main).first()
tag_index = TagIndexPage.objects.child_of(main).first()
main_lang = Languages.for_site(main.get_site()).languages.filter(
is_active=True, is_main_language=True).first()
if section_index and tag_index and main_lang:
if main_lang.locale == locale:
for article_slug in articles:
article = ArticlePage.objects.descendant_of(
section_index).filter(slug=article_slug).first()
if article:
for tag_title in articles.get(article_slug):
tag = Tag.objects.child_of(tag_index).filter(
title=tag_title.strip()).first()
if tag:
if not article.nav_tags.filter(
tag__title=tag):
article_page_tag = ArticlePageTags(
page=article, tag=tag)
article_page_tag.save()
else:
self.stdout.write(self.style.WARNING(
'Tag "%s" has been already asigned'
' to "%s" in "%s"'
% (tag, article, main)))
else:
self.stdout.write(self.style.NOTICE(
'Tag "%s" does not exist in "%s"'
% (tag_title, main)))
else:
self.stdout.write(self.style.ERROR(
'Article "%s" does not exist in "%s"'
% (article_slug, main.get_site())))
else:
self.stdout.write(self.style.NOTICE(
'Main language of "%s" is not "%s".'
' The main language is "%s"'
% (main.get_site(), Locale(locale).english_name,
main_lang)))
else:
if not section_index:
self.stdout.write(self.style.NOTICE(
'Section Index Page does not exist in "%s"' % main))
if not tag_index:
self.stdout.write(self.style.NOTICE(
'Tag Index Page does not exist in "%s"' % main))
if not main_lang:
self.stdout.write(self.style.NOTICE(
'Main language does not exist in "%s"' % main))