def test_change_root_page_locale_on_locale_deletion(self):
"""
On deleting the locale used for the root page (but no 'real' pages), the
root page should be reassigned to a new locale (the default one, if possible)
"""
# change 'real' pages first
Page.objects.filter(depth__gt=1).update(locale=Locale.objects.get(language_code="fr"))
self.assertEqual(Page.get_first_root_node().locale.language_code, "en")
Locale.objects.get(language_code="en").delete()
self.assertEqual(Page.get_first_root_node().locale.language_code, "fr")
def test_construct_queryset_hook(self):
page = SimplePage(title="Test shown", content="hello")
Page.get_first_root_node().add_child(instance=page)
page_not_shown = SimplePage(title="Test not shown", content="hello")
Page.get_first_root_node().add_child(instance=page_not_shown)
def filter_pages(pages, request):
return pages.filter(id=page.id)
with self.register_hook('construct_page_chooser_queryset', filter_pages):
response = self.get()
self.assertEqual(len(response.context['pages']), 1)
self.assertEqual(response.context['pages'][0].specific, page)
def test_construct_queryset_hook(self):
page = SimplePage(title="Test shown", content="hello")
Page.get_first_root_node().add_child(instance=page)
page_not_shown = SimplePage(title="Test not shown", content="hello")
Page.get_first_root_node().add_child(instance=page_not_shown)
def filter_pages(pages, request):
return pages.filter(id=page.id)
with self.register_hook('construct_page_chooser_queryset', filter_pages):
response = self.get()
self.assertEqual(len(response.context['pages']), 1)
self.assertEqual(response.context['pages'][0].specific, page)
def initialize_model(apps, schema_editor):
root_page = Page.get_first_root_node()
with transaction.atomic():
for page in Page.objects.child_of(root_page):
page.delete()
root_page = Page.get_first_root_node()
singlepage_content_type = ContentType.objects.get_for_model(SinglePage)
homepage = SinglePage(title="Machine Learning Lab",
slug='home',
show_in_menus=False,
content_type=singlepage_content_type)
root_page.add_child(instance=homepage)
homepage.add_child(
instance=SinglePage(title="Research",
slug='research',
show_in_menus=True,
content_type=singlepage_content_type))
homepage.add_child(
instance=SinglePage(title="People",
slug='people',
show_in_menus=True,
content_type=singlepage_content_type))
homepage.add_child(
instance=SinglePage(title="Courses",
slug='courses',
show_in_menus=True,
content_type=singlepage_content_type))
homepage.add_child(
instance=SinglePage(title="News",
slug='news',
show_in_menus=True,
content_type=singlepage_content_type))
homepage.add_child(
instance=SinglePage(title="Contact Us",
slug='contact-us',
show_in_menus=True,
content_type=singlepage_content_type))
Site.objects.create(
hostname="localhost",
root_page=homepage,
is_default_site=True,
site_name="mll.ce.sharif.edu",
)
def test_can_delete_default_locale_when_language_code_has_no_locale(self):
Locale.objects.create(language_code='fr')
self.assertTrue(Page.get_first_root_node().locale.language_code, 'en')
Page.objects.filter(depth__gt=1).delete()
response = self.post()
# Should redirect back to index
self.assertRedirects(response, reverse('wagtaillocales:index'))
# Check that the locale was deleted
self.assertFalse(Locale.objects.filter(language_code='en').exists())
# root node's locale should now have been reassigned to 'fr' despite that not matching
# LANGUAGE_CODE (because it's the only remaining Locale record)
self.assertTrue(Page.get_first_root_node().locale.language_code, 'fr')
def move_choose_destination(request, page_to_move_id, viewed_page_id=None):
page_to_move = get_object_or_404(Page, id=page_to_move_id)
page_perms = page_to_move.permissions_for_user(request.user)
if not page_perms.can_move():
raise PermissionDenied
if viewed_page_id:
viewed_page = get_object_or_404(Page, id=viewed_page_id)
else:
viewed_page = Page.get_first_root_node()
viewed_page.can_choose = page_perms.can_move_to(viewed_page)
child_pages = []
for target in viewed_page.get_children():
# can't move the page into itself or its descendants
target.can_choose = page_perms.can_move_to(target)
target.can_descend = (
not(target == page_to_move or
target.is_child_of(page_to_move)) and
target.get_children_count()
)
child_pages.append(target)
# Pagination
paginator, child_pages = paginate(request, child_pages, per_page=50)
return render(request, 'wagtailadmin/pages/move_choose_destination.html', {
'page_to_move': page_to_move,
'viewed_page': viewed_page,
'child_pages': child_pages,
})
def _setup_language_redirection(self):
"""First things first, tear down the dummy root page.
and setup our language_redirection page
"""
ContentType = apps.get_model("contenttypes.ContentType")
Page = apps.get_model("wagtailcore.Page")
Site = apps.get_model("wagtailcore.Site")
LanguageRedirectionPage = apps.get_model("cms.LanguageRedirectionPage")
# Delete the default homepage created by wagtail migrations If migration is run
# multiple times, it may have already been deleted
Page.objects.filter(id=2).delete()
# Get content type for LanguageRedirectionPage model
language_redirection_page_content_type = ContentType.objects.get(
model="languageredirectionpage", app_label="cms")
# Create the base language redirection page which is responsible to redirect
# the user to the language specific home pages
root = Page.get_first_root_node()
language_redirection_page = LanguageRedirectionPage(
title="codista.com",
draft_title="codista.com",
slug="root",
content_type=language_redirection_page_content_type,
show_in_menus=True,
)
root.add_child(instance=language_redirection_page)
# Create a site with the new LanguageRedirectionPage set as the root
Site.objects.create(
hostname="localhost",
root_page=language_redirection_page,
is_default_site=True,
site_name="codista.com",
)
def setUpTestData(cls):
cls.site = Site.objects.create(is_default_site=True,
root_page=Page.get_first_root_node())
cls.page1 = StandardPageFactory(show_in_menus=True)
cls.menu = MenuFactory()
# for the menu-items we need to establish a sort order (class Orderable)
cls.menuitem_ordinary = MenuItemFactory(menu=cls.menu,
sort_order=1,
title="Ordinary",
link_url='/ordinary/',
show_when='always')
cls.menuitem_guest = MenuItemFactory(menu=cls.menu,
sort_order=2,
title="Guest",
link_url='/guest/',
show_when='not_logged_in')
cls.menuitem_page1 = MenuItemFactory(menu=cls.menu,
sort_order=3,
link_page=cls.page1)
# switch on a second language
cls.foreign_language_code = [
code for code, lang in settings.LANGUAGES
if code != settings.LANGUAGE_CODE
][0]
cls.foreign_language = Language.objects.get_or_create(
code=cls.foreign_language_code)[0]
# note: Wagtailtrans automatically creates a language tree for every language that is defined
cls.foreign_page1 = TranslatablePage.objects.get(
language=cls.foreign_language, canonical_page=cls.page1)
def setUp(self):
self.login()
site = Site.objects.get()
page = Page.get_first_root_node()
home = HomePage(title='New America')
self.home_page = page.add_child(instance=home)
site.root_page = home
site.save()
self.our_people_page = self.home_page.add_child(
instance=OurPeoplePage(title='Our People', depth=3))
self.program_page = self.home_page.add_child(
instance=Program(title='OTI',
name='OTI',
description='OTI',
location=False,
depth=3))
self.second_program = self.home_page.add_child(
instance=Program(title='Education',
name='Education',
slug='education',
description='Education',
location=False,
depth=3))
self.subprogram_page = self.program_page.add_child(
instance=Subprogram(title='OTI Subprogram',
name='OTI Subprogram',
description='OTI Subprogram',
location=False,
depth=4))
self.second_subprogram_page = self.program_page.add_child(
instance=Subprogram(title='OTI Subprogram 2',
name='OTI Subprogram 2',
description='OTI Subprogram 2',
location=False,
depth=4))
self.program_articles_page = self.program_page.add_child(
instance=ProgramArticlesPage(title='Program Articles'))
self.test_person = Person(
title='Sana Javed',
slug='sana-javed',
first_name='Sana',
last_name='Javed',
role='Central Staff',
depth=4,
)
self.our_people_page.add_child(instance=self.test_person)
self.test_person.save()
self.article = self.program_articles_page.add_child(
instance=Article(title='Article 1', date='2016-02-02'))
PostAuthorRelationship(author=self.test_person,
post=self.article).save()
self.article_2 = self.program_articles_page.add_child(
instance=Article(title='Article 2', date='2016-05-02'))
PostAuthorRelationship(author=self.test_person,
post=self.article_2).save()
def setUpTestData(cls):
cls.factory = RequestFactory()
# Wagtail needs a site, e.g. to define url
# Page.get_first_root_node() is used by Wagtail to find the root page
cls.site = Site.objects.create(is_default_site=True, root_page=Page.get_first_root_node())
cls.team_member = TeamMemberFactory()
cls.course = CourseFactory()
cls.course_material = CourseMaterialFactory()
cls.footer = FooterTextFactory()
def create_homepage():
site = Site.objects.get()
page = Page.get_first_root_node()
home = HomePage(title='New America')
home_page = page.add_child(instance=home)
site.root_page = home
site.save()
return home_page
def setUpClass(cls):
super().setUpClass()
cls.test_page = SimplePage(title="test", slug='test', content="test")
cls.wagtail_root = Page.get_first_root_node()
cls.wagtail_root.add_child(instance=cls.test_page)
cls.test_page_group = Group.objects.create(name="Test page")
GroupPagePermission.objects.create(group=cls.test_page_group,
page=cls.test_page,
permission_type='edit')
def setUpTestData(cls):
cls.site = Site.objects.create(is_default_site=True,
root_page=Page.get_first_root_node())
cls.homepage = HomePageFactory()
cls.articleindexpage = ArticleIndexPageFactory(parent=cls.homepage)
cls.articlepage1 = ArticlePageFactory(parent=cls.articleindexpage)
cls.user = CustomUserFactory(email="*****@*****.**",
display_name="John")
cls.customcomment = CustomCommentFactory(object_pk=str(
cls.articlepage1.pk),
user=cls.user)
def test_can_delete_default_locale(self):
# The presence of the locale on the root page node (if that's the only thing using the
# locale) should not prevent deleting it
for lang in ('fr', 'de', 'pl', 'ja'):
Locale.objects.create(language_code=lang)
self.assertTrue(Page.get_first_root_node().locale.language_code, 'en')
Page.objects.filter(depth__gt=1).delete()
response = self.post()
# Should redirect back to index
self.assertRedirects(response, reverse('wagtaillocales:index'))
# Check that the locale was deleted
self.assertFalse(Locale.objects.filter(language_code='en').exists())
# root node's locale should now have been reassigned to the one matching the current
# LANGUAGE_CODE
self.assertTrue(Page.get_first_root_node().locale.language_code, 'de')
def setUp(self):
self.site_2_page = SimplePage(
title="Site 2 page",
slug="site_2_page",
content="Hello",
)
Page.get_first_root_node().add_child(instance=self.site_2_page)
self.site_2_subpage = SimplePage(
title="Site 2 subpage",
slug="site_2_subpage",
content="Hello again",
)
self.site_2_page.add_child(instance=self.site_2_subpage)
self.site_2 = Site.objects.create(
hostname='example.com',
port=8080,
root_page=Page.objects.get(pk=self.site_2_page.pk),
is_default_site=False)
self.about_us_page = SimplePage.objects.get(url_path='/home/about-us/')
def setUp(self):
self.login()
site = Site.objects.get()
page = Page.get_first_root_node()
home = HomePage(title='New America')
home_page = page.add_child(instance=home)
site.root_page = home
site.save()
# People objects to test template tags
# that create byline and determine author order
program_page_1 = home_page.add_child(
instance=Program(title='OTI',
name='OTI',
slug='oti',
description='OTI',
location=False,
depth=3))
program_page_1.save()
our_people_page = home_page.add_child(instance=OurPeoplePage(
title='Our People',
depth=3,
))
our_people_page.save()
self.first_person = Person(
title='First Person',
slug='first-person',
first_name='first',
last_name='person',
role='Central Staff',
depth=4,
)
our_people_page.add_child(instance=self.first_person)
# Using policy papers to test the other post types
all_policy_papers_home_page = home_page.add_child(
instance=AllPolicyPapersHomePage(title="Policy Papers"))
program_policy_papers_page = program_page_1.add_child(
instance=ProgramPolicyPapersPage(title='OTI Policy Papers',
slug='oti-policy-papers'))
self.policy_paper = PolicyPaper(title='Policy Paper 1',
slug='policy-paper-1',
date='2016-06-15',
depth=5)
program_policy_papers_page.add_child(instance=self.policy_paper)
self.policy_paper.save()
PostAuthorRelationship(author=self.first_person,
post=self.policy_paper).save()
all_policy_papers_home_page.save()
def _create(cls, model_class, *args, **kwargs):
try:
parent = kwargs.pop('parent')
except KeyError:
# no parent, appending page to root
parent = Page.get_first_root_node()
page = model_class(*args, **kwargs)
parent.add_child(instance=page)
return page
def setUp(self):
self.site_2_page = SimplePage(
title="Site 2 page",
slug="site_2_page",
content="Hello",
)
Page.get_first_root_node().add_child(instance=self.site_2_page)
self.site_2_subpage = SimplePage(
title="Site 2 subpage",
slug="site_2_subpage",
content="Hello again",
)
self.site_2_page.add_child(instance=self.site_2_subpage)
self.site_2 = Site.objects.create(
hostname='example.com',
port=8080,
root_page=Page.objects.get(pk=self.site_2_page.pk),
is_default_site=False
)
self.about_us_page = SimplePage.objects.get(url_path='/home/about-us/')
def setUpClass(cls):
super().setUpClass()
cls.test_page = SimplePage(title="test", slug='test', content="test")
cls.wagtail_root = Page.get_first_root_node()
cls.wagtail_root.add_child(instance=cls.test_page)
cls.test_page_group = Group.objects.create(name="Test page")
GroupPagePermission.objects.create(
group=cls.test_page_group,
page=cls.test_page,
permission_type='edit'
)
def _setup_home(self):
"""Creates the language specific home pages."""
# LanguageRedirectionPage = apps.get_model("cms.LanguageRedirectionPage")
# parent_page = LanguageRedirectionPage.objects.first()
Page.objects.filter(id=2).delete()
root = Page.get_first_root_node()
Site = apps.get_model("wagtailcore.Site")
# ContentType = apps.get_model("contenttypes.ContentType")
HomePage = apps.get_model("home.HomePage")
# homepage_content_type = ContentType.objects.get(
# model="homepage", app_label="home"
# )
# For each supported language, create a new homepage
# for language_code, label in settings.LANGUAGES:
# if language_code == "de":
# hero_title = "Wir sind Codista."
# hero_intro = "Eine Software-Agentur, die sich auf die partnerschaftliche Entwicklung von hochqualitativen, digitalen Produkten spezialisiert hat."
# title = "Home - Deutsch"
# services_teaser = "Wir sind spezialisiert auf die Entwicklung von innovativen Software-Lösungen. Mit langjähriger Erfahrung in Entwicklung und Design von Websites, Online-Plattformen, Web-Applikationen und SaaS Lösungen unterstützen wir Ihr Unternehmen in der Realisierung neuer Software-Produkte und der Verbesserung Ihrer Unternehmens-Prozesse."
# services_title = "Wir denken digital."
# team_teaser = "Wir sind ein eingespieltes Team aus Software-Entwicklungs Experten und Design Profis welches komplexe Web-Projekte für unsere Kunden realisiert. Wir stehen für Qualität, Innovation, Umsetzungsgeschwindigkeit, Zuverlässigkeit und lösungsorientiertes Handeln."
# team_title = "Wir sind ein eingespieltes Team aus Software-Entwicklungs Experten und Design Profis."
# team_teaser = "Wir stehen für Qualität, Innovation, Umsetzungsgeschwindigkeit, Zuverlässigkeit und lösungsorientiertes Handeln."
# elif language_code == "en":
title = "Home - English"
hero_title = "We are Codista."
hero_intro = "A software agency specializing in the partnership development of high quality digital products."
services_teaser = "We specialize in the development of innovative software solutions. With many years of experience in the development and design of websites, online platforms, web applications and SaaS solutions, we support your company in the realization of new software products and the improvement of your business processes."
services_title = "We think digitally."
team_title = "We are a well-established team of software development experts and design professionals."
team_teaser = "We stand for quality, innovation, speed of implementation, reliability and solution-oriented action."
# else:
# raise RuntimeError(f"unsupported language encountered: {language_code}")
homepage = HomePage(
# language=language_code,
title="St Louis DSA",
banner_title="We are the St. Louis Democratic Socialists of America!",
body="Lorem Ipsum blah blah blah",
# draft_title=title,
# slug=language_code,
# hero_title=hero_title,
# hero_intro=hero_intro,
# services_teaser=services_teaser,
# services_title=services_title,
# team_title=team_title,
# team_teaser=team_teaser,
# show_in_menus=True,
# content_type=homepage_content_type,
)
root.add_child(instance=homepage)
def get_queryset(self):
q = Q(page__in=UserPagePermissionsProxy(
self.request.user).explorable_pages().values_list('pk', flat=True))
root_page_permissions = Page.get_first_root_node(
).permissions_for_user(self.request.user)
if (self.request.user.is_superuser
or root_page_permissions.can_add_subpage()
or root_page_permissions.can_edit()):
# Include deleted entries
q = q | Q(page_id__in=Subquery(
PageLogEntry.objects.filter(deleted=True).values('page_id')))
return PageLogEntry.objects.filter(q)
def create_cms(self):
Page.objects.last().delete()
root = Page.get_first_root_node()
home = root.add_child(
instance=HomePage(**{"title": "The Hedera Project", "slug": ""})
)
Site.objects.all().delete()
Site.objects.create(
hostname='localhost',
site_name='Hedera',
root_page=home,
is_default_site=True
)
def test_homepage(self):
root = Page.get_first_root_node()
home = HomePage(
slug='homepageslug',
title='home page title',
heading='home page heading',
introduction='home page introduction',
request_for_comments_section_body='rfc section body',
working_groups_section_body='wg section body',
)
root.add_child(instance=home)
self.assertEqual(HomePage.objects.count(), 1)
Site.objects.all().delete()
Site.objects.create(
hostname='localhost',
root_page=home,
is_default_site=True,
site_name='testingsitename',
)
blogindex = BlogIndexPage(
slug='blog',
title='blog index title',
)
home.add_child(instance=blogindex)
blog = BlogPage(slug='blogpost',
title='blog title',
introduction='blog introduction',
body='blog body')
blogindex.add_child(instance=blog)
home.button_text = 'blog button text'
home.button_link = blog
home.save()
r = self.client.get(path=home.url)
self.assertEqual(r.status_code, 200)
self.assertIn(home.title.encode(), r.content)
self.assertIn(home.heading.encode(), r.content)
self.assertIn(home.introduction.encode(), r.content)
self.assertIn(home.button_text.encode(), r.content)
self.assertIn(('href="%s"' % blog.url).encode(), r.content)
def setUpTestData(cls):
cls.client = Client()
cls.factory = RequestFactory()
cls.site = Site.objects.create(is_default_site=True,
root_page=Page.get_first_root_node())
cls.homepage = HomePageFactory()
cls.articleindexpage = ArticleIndexPageFactory(parent=cls.homepage)
cls.articlepage1 = ArticlePageFactory(parent=cls.articleindexpage)
cls.foreign_language_code = [
code for code, lang in settings.LANGUAGES
if code != settings.LANGUAGE_CODE
][0]
cls.foreign_language = Language.objects.get_or_create(
code=cls.foreign_language_code)[0]
cls.foreign_articlepage1 = TranslatablePage.objects.get(
language=cls.foreign_language, canonical_page=cls.articlepage1)
def get_queryset(self):
q = Q(page__in=UserPagePermissionsProxy(
self.request.user).explorable_pages())
root_page_permissions = Page.get_first_root_node(
).permissions_for_user(self.request.user)
if (self.request.user.is_superuser
or root_page_permissions.can_add_subpage()
or root_page_permissions.can_edit()):
# Include deleted entries
q = q | Q(page_id__in=Subquery(
PageLogEntry.objects.filter(deleted=True).values('page_id')))
# Using prefech_related() on page, as select_related() generates an INNER JOIN,
# which filters out entries for deleted pages
return PageLogEntry.objects.filter(q).select_related(
'user', 'user__wagtail_userprofile').prefetch_related('page')
def test_standard_page(self):
root = Page.get_first_root_node()
home = HomePage(
slug='homepageslug',
title='home page title',
heading='home page heading',
introduction='home page introduction',
request_for_comments_section_body='rfc section body',
working_groups_section_body='wg section body',
)
root.add_child(instance=home)
Site.objects.all().delete()
Site.objects.create(
hostname='localhost',
root_page=home,
is_default_site=True,
site_name='testingsitename',
)
standardindex = StandardIndexPage(
slug='standardindex',
title='standard index page title',
introduction='standard index page introduction')
home.add_child(instance=standardindex)
standardpage = StandardPage(
slug='standard',
title='standard title',
introduction='standard introduction',
)
standardindex.add_child(instance=standardpage)
rindex = self.client.get(path=standardindex.url)
self.assertEqual(rindex.status_code, 200)
r = self.client.get(path=standardpage.url)
self.assertEqual(r.status_code, 200)
self.assertIn(standardpage.title.encode(), r.content)
self.assertIn(standardpage.introduction.encode(), r.content)
self.assertIn(('href="%s"' % standardindex.url).encode(), r.content)
def test_iesg_statement_page(self):
root = Page.get_first_root_node()
home = HomePage(
slug='homepageslug',
title='home page title',
heading='home page heading',
introduction='home page introduction',
request_for_comments_section_body='rfc section body',
working_groups_section_body='wg section body',
)
root.add_child(instance=home)
Site.objects.all().delete()
Site.objects.create(
hostname='localhost',
root_page=home,
is_default_site=True,
site_name='testingsitename',
)
iesg_statement_index = IESGStatementIndexPage(
slug='iesg_statement_index',
title='iesg statement index page title',
)
home.add_child(instance=iesg_statement_index)
iesg_statement_page = IESGStatementPage(
slug='iesgstatement',
title='iesg statement title',
introduction='iesg statement introduction',
)
iesg_statement_index.add_child(instance=iesg_statement_page)
rindex = self.client.get(path=iesg_statement_index.url)
self.assertEqual(rindex.status_code, 200)
def setUpTestData(cls):
cls.factory = RequestFactory()
# Wagtail needs a site, e.g. to define url
# Page.get_first_root_node() is used by Wagtail to find the root page
cls.site = Site.objects.create(is_default_site=True,
root_page=Page.get_first_root_node())
cls.homepage = HomePageFactory()
cls.articleindexpage = ArticleIndexPageFactory(parent=cls.homepage)
cls.themeindexpage = ThemeIndexPageFactory(parent=cls.homepage)
cls.theme1 = ThemeFactory()
cls.theme2 = ThemeFactory()
cls.themepage1 = ThemePageFactory(theme=cls.theme1,
parent=cls.themeindexpage)
cls.themepage2 = ThemePageFactory(theme=cls.theme2,
parent=cls.themeindexpage)
cls.articlepage1 = ArticlePageFactory(parent=cls.articleindexpage,
themes=(
cls.theme1,
cls.theme2,
),
featured=True)
cls.articlepage2 = ArticlePageFactory(parent=cls.articleindexpage,
themes=(cls.theme1, ))
def test_glossary_page(self):
root = Page.get_first_root_node()
home = HomePage(
slug='homepageslug',
title='home page title',
heading='home page heading',
introduction='home page introduction',
request_for_comments_section_body='rfc section body',
working_groups_section_body='wg section body',
)
root.add_child(instance=home)
Site.objects.all().delete()
Site.objects.create(
hostname='localhost',
root_page=home,
is_default_site=True,
site_name='testingsitename',
)
glossary = GlossaryPage(
slug='glossary',
title='glossary title',
introduction='glossary introduction',
)
home.add_child(instance=glossary)
r = self.client.get(path=glossary.url)
self.assertEqual(r.status_code, 200)
self.assertIn(glossary.title.encode(), r.content)
self.assertIn(glossary.introduction.encode(), r.content)
def test_form_page(self):
root = Page.get_first_root_node()
home = HomePage(
slug="homepageslug",
title="home page title",
heading="home page heading",
introduction="home page introduction",
request_for_comments_section_body="rfc section body",
working_groups_section_body="wg section body",
)
root.add_child(instance=home)
Site.objects.all().delete()
Site.objects.create(
hostname="localhost",
root_page=home,
is_default_site=True,
site_name="testingsitename",
)
form = FormPage(
slug="form",
title="form title",
intro="form introduction",
)
home.add_child(instance=form)
r = self.client.get(path=form.url)
self.assertEqual(r.status_code, 200)
self.assertIn(form.title.encode(), r.content)
self.assertIn(form.intro.encode(), r.content)
def _setup_pages(self):
root = Page.get_first_root_node()
home = HomePage(
slug="homepageslug",
title="home page title",
heading="home page heading",
introduction="home page introduction",
request_for_comments_section_body="rfc section body",
working_groups_section_body="wg section body",
)
root.add_child(instance=home)
Site.objects.all().delete()
Site.objects.create(
hostname="localhost",
root_page=home,
is_default_site=True,
site_name="testingsitename",
)
self.eventlisting = EventListingPage(
slug="eventlisting",
title="event listing page title",
introduction="event listing page introduction",
)
home.add_child(instance=self.eventlisting)
self.eventpage = EventPage(
slug="event",
title="event title",
introduction="event introduction",
)
self.eventlisting.add_child(instance=self.eventpage)
def get_root_page(self, request):
return Page.get_first_root_node()
def index(request, parent_page_id=None):
if parent_page_id:
parent_page = get_object_or_404(Page, id=parent_page_id)
else:
parent_page = Page.get_first_root_node()
# This will always succeed because of the @user_passes_test above.
root_page = get_explorable_root_page(request.user)
# If this page isn't a descendant of the user's explorable root page,
# then redirect to that explorable root page instead.
if not (
parent_page.pk == root_page.pk or
parent_page.is_descendant_of(root_page)
):
return redirect('wagtailadmin_explore', root_page.pk)
parent_page = parent_page.specific
pages = parent_page.get_children().prefetch_related('content_type', 'sites_rooted_here')
# Get page ordering
ordering = request.GET.get('ordering', '-latest_revision_created_at')
if ordering not in [
'title',
'-title',
'content_type',
'-content_type',
'live', '-live',
'latest_revision_created_at',
'-latest_revision_created_at',
'ord'
]:
ordering = '-latest_revision_created_at'
if ordering == 'ord':
# preserve the native ordering from get_children()
pass
elif ordering == 'latest_revision_created_at':
# order by oldest revision first.
# Special case NULL entries - these should go at the top of the list.
# Do this by annotating with Count('latest_revision_created_at'),
# which returns 0 for these
pages = pages.annotate(
null_position=Count('latest_revision_created_at')
).order_by('null_position', 'latest_revision_created_at')
elif ordering == '-latest_revision_created_at':
# order by oldest revision first.
# Special case NULL entries - these should go at the end of the list.
pages = pages.annotate(
null_position=Count('latest_revision_created_at')
).order_by('-null_position', '-latest_revision_created_at')
else:
pages = pages.order_by(ordering)
# Don't paginate if sorting by page order - all pages must be shown to
# allow drag-and-drop reordering
do_paginate = ordering != 'ord'
if do_paginate or pages.count() < 100:
# Retrieve pages in their most specific form, so that custom
# get_admin_display_title and get_url_parts methods on subclasses are respected.
# However, skip this on unpaginated listings with >100 child pages as this could
# be a significant performance hit. (This should only happen on the reorder view,
# and hopefully no-one is having to do manual reordering on listings that large...)
pages = pages.specific(defer=True)
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_explorer_page_queryset'):
pages = hook(parent_page, pages, request)
# Pagination
if do_paginate:
paginator, pages = paginate(request, pages, per_page=50)
return render(request, 'wagtailadmin/pages/index.html', {
'parent_page': parent_page.specific,
'ordering': ordering,
'pagination_query_params': "ordering=%s" % ordering,
'pages': pages,
'do_paginate': do_paginate,
})
def invoke(result):
data = result.data
# data = fake_get_directory()
cats = set([])
cat_objs = {}
dump = {}
loaded_ids = []
if EntityPage.objects.count():
[e.delete() for e in EntityPage.objects.all()]
if EntitiesIndexPage.objects.count():
[e.delete() for e in EntitiesIndexPage.objects.all()]
try:
root = Page.get_first_root_node()
directory_root = EntitiesIndexPage(title="C-Street Directory",
slug="directory")
root.add_child(instance=directory_root)
except ValidationError:
directory_root = EntitiesIndexPage.objects.get(slug="directory")
for slug, row in data.items():
logger.warn(repr(row))
if not row.get('category', ''):
continue
if not row.get('name', ''):
continue
cat_slug = slugify(row['category'])
if cat_slug not in cats:
logger.warn(f"Making a new category for {cat_slug}.")
cats.add(cat_slug)
dump[cat_slug] = []
cat_obj = EntitiesIndexPage(title=row['category'], slug=cat_slug)
cat_objs.update({cat_slug: cat_obj})
directory_root.add_child(instance=cat_obj)
logger.warn(f'We made a new category object named {cat_slug}.')
page_data = {
'title': row['name'],
'draft_title': '',
'slug': slug,
'data': row
}
with open('lib/cartomancer/testing/directory-dump.txt', 'a+') as f:
f.write(f"{repr(page_data)}\n\n")
try:
dump[cat_slug].append(EntityPage(**page_data))
except ValidationError:
logger.warn(f"Aborted adding page. Data dump:")
logger.warn(repr(row))
logger.warn(f"We have data for {len(cats)} categories.")
logger.warn(repr(dump))
for cat in cats:
[cat_objs[cat].add_child(instance=entity) for entity in dump[cat]]
logger.warn(f"Cat {cat}: {len(dump[cat])} pages created")
logger.warn("Everything seems to have gone alright.")
return True
def test_empty_queryset(self):
self.assertEqual(
Page.get_first_root_node(),
Page.objects.none().first_common_ancestor())
def test_all_pages_include_self_strict(self):
self.assertEqual(
Page.get_first_root_node(),
Page.objects.first_common_ancestor(include_self=True, strict=True))
def test_all_pages(self):
self.assertEqual(
Page.get_first_root_node(),
Page.objects.first_common_ancestor())
def index(request, parent_page_id=None):
if parent_page_id:
parent_page = get_object_or_404(Page, id=parent_page_id).specific
else:
parent_page = Page.get_first_root_node().specific
pages = parent_page.get_children().prefetch_related('content_type', 'sites_rooted_here')
# Get page ordering
ordering = request.GET.get('ordering', '-latest_revision_created_at')
if ordering not in [
'title',
'-title',
'content_type',
'-content_type',
'live', '-live',
'latest_revision_created_at',
'-latest_revision_created_at',
'ord'
]:
ordering = '-latest_revision_created_at'
if ordering == 'ord':
# preserve the native ordering from get_children()
pass
elif ordering == 'latest_revision_created_at':
# order by oldest revision first.
# Special case NULL entries - these should go at the top of the list.
# Do this by annotating with Count('latest_revision_created_at'),
# which returns 0 for these
pages = pages.annotate(
null_position=Count('latest_revision_created_at')
).order_by('null_position', 'latest_revision_created_at')
elif ordering == '-latest_revision_created_at':
# order by oldest revision first.
# Special case NULL entries - these should go at the end of the list.
pages = pages.annotate(
null_position=Count('latest_revision_created_at')
).order_by('-null_position', '-latest_revision_created_at')
else:
pages = pages.order_by(ordering)
# Don't paginate if sorting by page order - all pages must be shown to
# allow drag-and-drop reordering
do_paginate = ordering != 'ord'
if do_paginate:
# Retrieve pages in their most specific form.
# Only do this for paginated listings, as this could potentially be a
# very expensive operation when performed on a large queryset.
pages = pages.specific()
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_explorer_page_queryset'):
pages = hook(parent_page, pages, request)
# Pagination
if do_paginate:
paginator, pages = paginate(request, pages, per_page=50)
return render(request, 'wagtailadmin/pages/index.html', {
'parent_page': parent_page.specific,
'ordering': ordering,
'pagination_query_params': "ordering=%s" % ordering,
'pages': pages,
'do_paginate': do_paginate,
})
def browse(request, parent_page_id=None):
# A missing or empty page_type parameter indicates 'all page types'
# (i.e. descendants of wagtailcore.page)
page_type_string = request.GET.get('page_type') or 'wagtailcore.page'
user_perm = request.GET.get('user_perms', False)
try:
desired_classes = page_models_from_string(page_type_string)
except (ValueError, LookupError):
raise Http404
# Find parent page
if parent_page_id:
parent_page = get_object_or_404(Page, id=parent_page_id)
elif desired_classes == (Page,):
# Just use the root page
parent_page = Page.get_first_root_node()
else:
# Find the highest common ancestor for the specific classes passed in
# In many cases, such as selecting an EventPage under an EventIndex,
# this will help the administrator find their page quicker.
all_desired_pages = filter_page_type(Page.objects.all(), desired_classes)
parent_page = all_desired_pages.first_common_ancestor()
# Get children of parent page
pages = parent_page.get_children().specific()
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_page_chooser_queryset'):
pages = hook(pages, request)
# Filter them by page type
if desired_classes != (Page,):
# restrict the page listing to just those pages that:
# - are of the given content type (taking into account class inheritance)
# - or can be navigated into (i.e. have children)
choosable_pages = filter_page_type(pages, desired_classes)
descendable_pages = pages.filter(numchild__gt=0)
pages = choosable_pages | descendable_pages
can_choose_root = request.GET.get('can_choose_root', False)
# Do permission lookups for this user now, instead of for every page.
permission_proxy = UserPagePermissionsProxy(request.user)
# Parent page can be chosen if it is a instance of desired_classes
parent_page.can_choose = can_choose_page(
parent_page, permission_proxy, desired_classes, can_choose_root, user_perm)
# Pagination
# We apply pagination first so we don't need to walk the entire list
# in the block below
paginator, pages = paginate(request, pages, per_page=25)
# Annotate each page with can_choose/can_decend flags
for page in pages:
page.can_choose = can_choose_page(page, permission_proxy, desired_classes, can_choose_root, user_perm)
page.can_descend = page.get_children_count()
# Render
context = shared_context(request, {
'parent_page': parent_page,
'parent_page_id': parent_page.pk,
'pages': pages,
'search_form': SearchForm(),
'page_type_string': page_type_string,
'page_type_names': [desired_class.get_verbose_name() for desired_class in desired_classes],
'page_types_restricted': (page_type_string != 'wagtailcore.page')
})
return render_modal_workflow(
request,
'wagtailadmin/chooser/browse.html', None,
context,
json_data={'step': 'browse', 'parent_page_id': context['parent_page_id']},
)
