def test_expired_page_will_be_unpublished(self):
# Connect a mock signal handler to page_unpublished signal
signal_fired = [False]
signal_page = [None]
def page_unpublished_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_unpublished.connect(page_unpublished_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
live=True,
has_unpublished_changes=False,
expire_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
management.call_command('publish_scheduled_pages')
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(p.has_unpublished_changes)
self.assertTrue(p.expired)
# Check that the page_published signal was fired
self.assertTrue(signal_fired[0])
self.assertEqual(signal_page[0], page)
self.assertEqual(signal_page[0], signal_page[0].specific)
def test_expired_page_will_be_unpublished(self):
# Connect a mock signal handler to page_unpublished signal
signal_fired = [False]
signal_page = [None]
def page_unpublished_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_unpublished.connect(page_unpublished_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
live=True,
expire_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
management.call_command('publish_scheduled_pages')
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(p.expired)
# Check that the page_published signal was fired
self.assertTrue(signal_fired[0])
self.assertEqual(signal_page[0], page)
self.assertEqual(signal_page[0], signal_page[0].specific)
def test_unpublish(self):
# set up a listener for the unpublish signal
unpublish_signals_fired = []
def page_unpublished_handler(sender, instance, **kwargs):
unpublish_signals_fired.append((sender, instance))
page_unpublished.connect(page_unpublished_handler)
events_index = Page.objects.get(url_path='/home/events/')
events_index.get_children().unpublish()
# Previously-live children of event index should now be non-live
christmas = EventPage.objects.get(url_path='/home/events/christmas/')
saint_patrick = SingleEventPage.objects.get(url_path='/home/events/saint-patrick/')
unpublished_event = EventPage.objects.get(url_path='/home/events/tentative-unpublished-event/')
self.assertFalse(christmas.live)
self.assertFalse(saint_patrick.live)
# Check that a signal was fired for each unpublished page
self.assertIn((EventPage, christmas), unpublish_signals_fired)
self.assertIn((SingleEventPage, saint_patrick), unpublish_signals_fired)
# a signal should not be fired for pages that were in the queryset
# but already unpublished
self.assertNotIn((EventPage, unpublished_event), unpublish_signals_fired)
def register_signal_handlers():
# Get list of models that are page types
indexed_models = [model for model in models.get_models() if issubclass(model, Page)]
# Loop through list and register signal handlers for each one
for model in indexed_models:
page_published.connect(page_published_signal_handler, sender=model)
page_unpublished.connect(page_unpublished_signal_handler, sender=model)
def register_signal_handlers():
"""
Connect handlers to page publish signals
"""
page_published.connect(handle_publish,
dispatch_uid='wagtailbakery_page_published')
page_unpublished.connect(handle_unpublish,
dispatch_uid='wagtailbakery_page_unpublished')
def register_signal_handlers():
# Get list of models that are page types
Page = apps.get_model('wagtailcore', 'Page')
indexed_models = [model for model in apps.get_models() if issubclass(model, Page)]
# Loop through list and register signal handlers for each one
for model in indexed_models:
page_published.connect(page_published_signal_handler, sender=model)
page_unpublished.connect(page_unpublished_signal_handler, sender=model)
def register_signal_handlers():
Image = get_image_model()
for model in PAGE_MODEL_CLASSES:
page_published.connect(purge_page_from_cache, sender=model)
page_unpublished.connect(purge_page_from_cache, sender=model)
post_save.connect(purge_image_from_cache, sender=Image)
post_delete.connect(purge_image_from_cache, sender=Image)
post_save.connect(purge_document_from_cache, sender=Document)
post_delete.connect(purge_document_from_cache, sender=Document)
def register_signal_handlers():
Image = get_image_model()
for model in PAGE_MODEL_CLASSES:
page_published.connect(purge_page_from_cache, sender=model)
page_unpublished.connect(purge_page_from_cache, sender=model)
post_save.connect(purge_image_from_cache, sender=Image)
post_delete.connect(purge_image_from_cache, sender=Image)
post_save.connect(purge_document_from_cache, sender=Document)
post_delete.connect(purge_document_from_cache, sender=Document)
def get_current(self):
current = PageRevision.objects.get(pk=self.page_revision.id).page.get_latest_revision()
try:
current_screenshot = PageRevisionScreenshot.objects.get(page_revision=current.pk)
if current.id != self.page_revision.id:
return True, current_screenshot
else:
return False, current_screenshot
except ObjectDoesNotExist:
return False, current
def get_previous(self):
page = PageRevision.objects.get(pk=self.page_revision.id).page
revisions = page.revisions.order_by('-created_at')
aslist = list(revisions.values_list('id', flat=True))
index = aslist.index(self.page_revision.id)
if index < len(aslist)-1:
previous = aslist[index+1]
try:
return True, PageRevisionScreenshot.objects.get(page_revision=previous)
except ObjectDoesNotExist:
return False, self
else:
return False, self
# Trigger notification every time page is published
page_published.connect(screenshot.process_page_published_async)
page_unpublished.connect(screenshot.process_page_unpublished_async)
# Sets all the revisions for a page's attribute to False when it's called
def update_all_revisions(instance, attr):
for revision in instance.revisions.all():
content = json.loads(revision.content_json)
if content[attr]:
content[attr] = False
revision.content_json = unicode(json.dumps(content), 'utf-8')
revision.save()
def unshare_all_revisions(sender, **kwargs):
update_all_revisions(kwargs['instance'], 'shared')
def unpublish_all_revisions(sender, **kwargs):
update_all_revisions(kwargs['instance'], 'live')
def configure_page_and_revision(sender, **kwargs):
from .wagtail_hooks import share, configure_page_revision, flush_akamai
share(page=kwargs['instance'], is_sharing=False, is_live=True)
configure_page_revision(page=kwargs['instance'], is_sharing=False, is_live=True)
flush_akamai(page=kwargs['instance'])
page_unshared.connect(unshare_all_revisions)
page_unpublished.connect(unpublish_all_revisions)
page_published.connect(configure_page_and_revision)
def register_signal_handlers():
if getattr(settings, 'WEBHOOKS_PAGE_PUBLISHED', None):
page_published.connect(page_published_signal_handler)
if getattr(settings, 'WEBHOOKS_PAGE_UNPUBLISHED', None):
page_unpublished.connect(page_unpublished_signal_handler)
def connect_page_signals_handlers():
page_published.connect(page_pub_receiver, sender=JournalPage)
page_unpublished.connect(page_unpub_receiver, sender=JournalPage)
page_published.connect(about_page_pub_receiver, sender=JournalAboutPage)
page_unpublished.connect(about_page_unpub_receiver,
sender=JournalAboutPage)
# Sets all the revisions for a page's attribute to False when it's called
def update_all_revisions(instance, attr):
for revision in instance.revisions.all():
content = json.loads(revision.content_json)
if content[attr]:
content[attr] = False
revision.content_json = unicode(json.dumps(content), 'utf-8')
revision.save()
def unshare_all_revisions(sender, **kwargs):
update_all_revisions(kwargs['instance'], 'shared')
def unpublish_all_revisions(sender, **kwargs):
update_all_revisions(kwargs['instance'], 'live')
def configure_page_and_revision(sender, **kwargs):
from .wagtail_hooks import share, configure_page_revision, flush_akamai
share(page=kwargs['instance'], is_sharing=False, is_live=True)
configure_page_revision(page=kwargs['instance'],
is_sharing=False,
is_live=True)
flush_akamai(page=kwargs['instance'], is_live=True)
page_unshared.connect(unshare_all_revisions)
page_unpublished.connect(unpublish_all_revisions)
page_published.connect(configure_page_and_revision)
from wagtail.wagtailcore.signals import page_published, page_unpublished
from wagtail.contrib.wagtailfrontendcache.utils import purge_page_from_cache
from blog.models import BlogIndexPage, BlogPost
def invalidate_frontend_cache_for_blog_index_page(sender, instance, **kwargs):
"""Invalidate the frontend cache for the parent BlogIndexPage of a BlogPost."""
blog_post = instance
# Recommended way to get parent page from https://github.com/wagtail/wagtail/issues/2779#issuecomment-228472829
blog_index_page = blog_post.get_parent()
if blog_index_page:
purge_page_from_cache(blog_index_page)
page_published.connect(
invalidate_frontend_cache_for_blog_index_page,
sender=BlogPost
)
page_unpublished.connect(
invalidate_frontend_cache_for_blog_index_page,
sender=BlogPost
)
def register_signal_handlers():
page_published.connect(handle_publish,
dispatch_uid='wagtailbakery_page_published')
page_unpublished.connect(handle_unpublish,
dispatch_uid='wagtailbakery_page_unpublished')
