def test_publish_view_post(self):
"""
This posts to the publish view and checks that the page was published
"""
# Connect a mock signal handler to page_published signal
mock_handler = mock.MagicMock()
page_published.connect(mock_handler)
# Post to the publish page
response = self.client.post(self.url)
# Should be redirected to explorer page
self.assertEqual(response.status_code, 302)
# Check that the child pages were published
for child_page in self.pages_to_be_published:
self.assertTrue(Page.objects.get(id=child_page.id).live)
# Check that the child pages not to be published remain
for child_page in self.pages_not_to_be_published:
self.assertFalse(Page.objects.get(id=child_page.id).live)
# Check that the page_published signal was fired
self.assertEqual(mock_handler.call_count,
len(self.pages_to_be_published))
for i, child_page in enumerate(self.pages_to_be_published):
mock_call = mock_handler.mock_calls[i][2]
self.assertEqual(mock_call['sender'], child_page.specific_class)
self.assertEqual(mock_call['instance'], child_page)
self.assertIsInstance(mock_call['instance'],
child_page.specific_class)
def ready(self):
from .handlers import event_published_handler
from .models import EventPage, EventGeneralPage
page_published.connect(event_published_handler, sender=EventPage)
page_published.connect(event_published_handler, sender=EventGeneralPage)
logger.info('event_published_handler should be connected now')
def test_approve_moderation_view(self):
"""
This posts to the approve moderation view and checks that the page was approved
"""
# Connect a mock signal handler to page_published signal
mock_handler = mock.MagicMock()
page_published.connect(mock_handler)
# Post
response = self.client.post(
reverse('wagtailadmin_pages:approve_moderation',
args=(self.revision.id, )))
# Check that the user was redirected to the dashboard
self.assertRedirects(response, reverse('wagtailadmin_home'))
page = Page.objects.get(id=self.page.id)
# Page must be live
self.assertTrue(page.live,
"Approving moderation failed to set live=True")
# Page should now have no unpublished changes
self.assertFalse(
page.has_unpublished_changes,
"Approving moderation failed to set has_unpublished_changes=False")
# Check that the page_published signal was fired
self.assertEqual(mock_handler.call_count, 1)
mock_call = mock_handler.mock_calls[0][2]
self.assertEqual(mock_call['sender'], self.page.specific_class)
self.assertEqual(mock_call['instance'], self.page)
self.assertIsInstance(mock_call['instance'], self.page.specific_class)
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 subscribe(cls):
for model_class in cls.model_classes:
page_published.connect(
receiver=cls.populate,
sender=model_class,
dispatch_uid=model_class.__name__,
)
page_unpublished.connect(
receiver=cls.delete,
sender=model_class,
dispatch_uid=model_class.__name__,
)
def register_signal_handlers():
Image = get_image_model()
Document = get_document_model()
for model in get_page_models():
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 test_go_live_page_will_be_published(self):
# Connect a mock signal handler to page_published signal
signal_fired = [False]
signal_page = [None]
def page_published_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_published.connect(page_published_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
has_unpublished_changes=True,
go_live_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
page.save_revision(approved_go_live_at=timezone.now() -
timedelta(days=1))
p = Page.objects.get(slug="hello-world")
self.assertFalse(p.live)
self.assertTrue(
PageRevision.objects.filter(page=p).exclude(
approved_go_live_at__isnull=True).exists())
management.call_command("publish_scheduled_pages")
p = Page.objects.get(slug="hello-world")
self.assertTrue(p.live)
self.assertTrue(p.first_published_at)
self.assertFalse(p.has_unpublished_changes)
self.assertFalse(
PageRevision.objects.filter(page=p).exclude(
approved_go_live_at__isnull=True).exists())
# 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_create_simplepage_post_publish(self):
# Connect a mock signal handler to page_published signal
mock_handler = mock.MagicMock()
page_published.connect(mock_handler)
# Post
post_data = {
'title': "New page!",
'content': "Some content",
'slug': 'hello-world',
'action-publish': "Publish",
}
response = self.client.post(
reverse('wagtailadmin_pages:add',
args=('tests', 'simplepage', self.root_page.id)),
post_data)
# Find the page and check it
page = Page.objects.get(path__startswith=self.root_page.path,
slug='hello-world').specific
# Should be redirected to explorer
self.assertRedirects(
response,
reverse('wagtailadmin_explore', args=(self.root_page.id, )))
self.assertEqual(page.title, post_data['title'])
self.assertEqual(page.draft_title, post_data['title'])
self.assertIsInstance(page, SimplePage)
self.assertTrue(page.live)
self.assertTrue(page.first_published_at)
# Check that the page_published signal was fired
self.assertEqual(mock_handler.call_count, 1)
mock_call = mock_handler.mock_calls[0][2]
self.assertEqual(mock_call['sender'], page.specific_class)
self.assertEqual(mock_call['instance'], page)
self.assertIsInstance(mock_call['instance'], page.specific_class)
# treebeard should report no consistency problems with the tree
self.assertFalse(any(Page.find_problems()),
'treebeard found consistency problems')
def ready(self):
user_model = get_user_model()
post_save.connect(user_save_callback, sender=user_model)
# Interesting situation: we use this pattern to account for
# scrolling bugs in IE:
# http://snipplr.com/view/518/
# yet, url(null) trips up the ManifestStaticFilesStorage, so we
# monkeypatch the regex so that url(null) is ignored
storage.HashedFilesMixin.patterns = (("*.css", (
r"""(url\((?!null)['"]{0,1}\s*(.*?)["']{0,1}\))""",
(r"""(@import\s*["']\s*(.*?)["'])""", """@import url("%s")"""),
)), )
from v1.models.enforcement_action_page import EnforcementActionPage
page_published.connect(break_enforcement_cache,
sender=EnforcementActionPage)
page_unpublished.connect(break_enforcement_cache,
sender=EnforcementActionPage)
post_page_move.connect(break_enforcement_cache,
sender=EnforcementActionPage)
def test_go_live_page_will_be_published(self):
# Connect a mock signal handler to page_published signal
signal_fired = [False]
signal_page = [None]
def page_published_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_published.connect(page_published_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
has_unpublished_changes=True,
go_live_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
page.save_revision(approved_go_live_at=timezone.now() - timedelta(days=1))
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
management.call_command('publish_scheduled_pages')
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
self.assertTrue(p.first_published_at)
self.assertFalse(p.has_unpublished_changes)
self.assertFalse(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
# 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 subscribe(cls):
page_published.connect(
receiver=cls.populate,
sender=cls.model,
dispatch_uid=cls.model.__name__,
)
page_unpublished.connect(
receiver=cls.delete,
sender=cls.model,
dispatch_uid=cls.model.__name__,
)
for model in cls.subscriptions:
post_save.connect(
receiver=cls.populate_many,
sender=model,
dispatch_uid=f'{cls.model.__name__}-{model.__name__}',
)
page_unpublished.connect(
receiver=cls.populate_many,
sender=model,
dispatch_uid=f'{cls.model.__name__}-{model.__name__}',
)
def ready(self):
from .handlers import general_published_handler, send_to_automate
from .models import GeneralPage, TwoColumnGeneralPage
page_published.connect(general_published_handler, sender=GeneralPage)
page_published.connect(general_published_handler,
sender=TwoColumnGeneralPage)
logger.info('general_published_handler should be connected now')
# Send_to_automate deals with all publish events; not restricted to just home app models
page_published.connect(send_to_automate)
from wagtail.core.signals import page_published, page_unpublished
from wagtail.contrib.frontend_cache.utils import purge_page_from_cache
from blog.models import 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 ready(self):
from .handlers import product_published_handler
from .models import Product
page_published.connect(product_published_handler, sender=Product)
logger.info('product_published_handler should be connected now')
from django.core.management import call_command
from wagtail.core.signals import page_published, page_unpublished
def bake_site(sender, **kwargs):
'''
This helper function will trigger a re-build of the site automatically when
a page is published or unpublished so that the static HTML being served
gets synced with the changes published to the dynamic app.
'''
# TODO: either extend this function or call a different command so that we
# re-build and also re-deploy here.
call_command('build')
page_published.connect(bake_site)
page_unpublished.connect(bake_site)
from wagtail.core import hooks
from wagtail.core.signals import page_published
from .indexer import index_page
@hooks.register("after_create_page")
def index_after_create_page(request, page):
index_page(page)
@hooks.register("after_edit_page")
def index_after_edit_page(request, page):
index_page(page)
def post_publish(sender, instance, **kwargs):
index_page(instance)
page_published.connect(post_publish)
try:
page_files = {
s3_obj["Key"]
for s3_obj in page["Contents"]
if splitext(s3_obj["Key"])[1] == '.html'
}
bucket_html_keys.update(page_files)
except KeyError:
continue
# get diff of bucket keys vs uploaded s3 keys
bucket_html_keys_2_remove = bucket_html_keys.difference(
s3_html_keys_2_upload)
# upload whats being uploaded
for f in html_files_2_upload:
s3_client.upload_file(
Filename=f["Filename"],
Bucket=settings.AWS_STORAGE_BUCKET_NAME_DEPLOYMENT,
Key=f["Key"],
ExtraArgs={'ContentType': 'text/html'})
# remove whats being removed
for key in bucket_html_keys_2_remove:
s3_client.delete_object(
Bucket=settings.AWS_STORAGE_BUCKET_NAME_DEPLOYMENT, Key=key)
page_published.connect(prerender_pages)
page_unpublished.connect(prerender_pages)
def user_can_edit_obj(self, user, obj):
return False
def user_can_delete_obj(self, user, obj):
return False
class NetlifyDeploymentAdmin(ModelAdmin):
model = Deployment
permission_helper_class = NetlifyPermissions
menu_label = 'Netlify Deployments'
menu_icon = 'collapse-up'
menu_order = 1000
list_display = ('deployment_created', 'deployment_time',
'deployment_created_by')
form_fields_exclude = ('deployment_created_by', )
modeladmin_register(NetlifyDeploymentAdmin)
def trigger_deployment(**kwargs):
if settings.NETLIFY_AUTO_DEPLOY is not False:
revision = kwargs.get('revision')
deployment = Deployment(deployment_created_by=revision.user)
deployment.save()
page_published.connect(trigger_deployment)
page_unpublished.connect(trigger_deployment)
from django.db.models.signals import post_save
from django.dispatch import receiver
from wagtail.core.signals import page_published
from .functions import invalidate_cloudfront_caches
from .models import StickyNote, Footer, GiveToday
def clear_cloudfront_on_page_publish(sender, **kwargs):
invalidate_cloudfront_caches()
page_published.connect(clear_cloudfront_on_page_publish)
# These functions clear caches on non-page models that drive content on the website
@receiver(post_save, sender=StickyNote)
def clear_cloudfront_on_sticky_save(sender, **kwargs):
invalidate_cloudfront_caches()
@receiver(post_save, sender=Footer)
def clear_cloudfront_on_footer_save(sender, **kwargs):
invalidate_cloudfront_caches()
@receiver(post_save, sender=GiveToday)
def clear_cloudfront_on_give_save(sender, **kwargs):
invalidate_cloudfront_caches()
# First check if app is in debug mode
# and if we should perform sharing during
# debug. Defaults to False
share_in_debug = get_setting("SHARE_IN_DEBUG", required=False) or False
if settings.DEBUG and not share_in_debug:
return
# Check if the sender is a subclass of 'SocialMediaSharablePageMixin'
if not issubclass(sender, SocialMediaSharablePageMixin):
# If the sender does not inherit the mixin, it should not be shared.
return
# Check if sender is a registered Wagtail Page
if not sender in get_page_models():
return
# Get page instance
instance = kwargs["instance"]
# Check if page was already shared
if instance.was_shared:
return
# Share the page
share_page(instance)
# Register a receiver
page_published.connect(share_signal)
def register_signal_handlers():
for model in get_page_models():
page_published.connect(record_page_publish, sender=model)
# I tryed to convert excerpt to markdown using tomd without success
values = {
"content":
"Breaking news on OSR website !",
"embeds": [{
"title": instance.title,
"url": "https://openstudyroom.org" + instance.url,
"description": excerpt,
}]
}
r = requests.post(discord_url, json=values)
r.raise_for_status()
# Register two receivers
page_published.connect(send_to_discord, sender=EntryPage)
page_published.connect(send_to_discord, sender=StreamFieldEntryPage)
@receiver(post_save, sender=ForumPost)
def forum_post_to_discord(sender, instance, **kwargs):
# don't announce edits
instance.refresh_from_db()
if instance.updates_count > 0:
return
# don't announce private admins forums forum.
# This should be properly handled with a test if anonymous user can read forum.
parent_id = instance.topic.forum.parent
if parent_id is not None and parent_id.pk == 12:
return
if settings.DEBUG:
def user_can_delete_obj(self, user, obj):
return False
class NetlifyDeploymentAdmin(ModelAdmin):
model = Deployment
permission_helper_class = NetlifyPermissions
menu_label = 'Netlify Deployments'
menu_icon = 'collapse-up'
menu_order = 1000
list_display = ('deployment_created', 'deployment_time', 'deployment_created_by')
form_fields_exclude = ('deployment_created_by',)
modeladmin_register(NetlifyDeploymentAdmin)
def trigger_deployment(**kwargs):
if settings.NETLIFY_AUTO_DEPLOY:
user = ''
if kwargs.get('revision') is not None:
user = kwargs.get('revision').user
deployment = Deployment(deployment_created_by=user)
deployment.save()
page_published.connect(trigger_deployment)
page_unpublished.connect(trigger_deployment)
def register_signal_handlers():
page_published.connect(handle_publish,
dispatch_uid='wagtailbakery_page_published')
page_unpublished.connect(handle_unpublish,
dispatch_uid='wagtailbakery_page_unpublished')
content_panels = AbstractEmailForm.content_panels + [
ImageChooserPanel('image'),
StreamFieldPanel('body'),
InlinePanel('form_fields', label="Form fields"),
FieldPanel('thank_you_text', classname="full"),
MultiFieldPanel([
FieldRowPanel([
FieldPanel('from_address', classname="col6"),
FieldPanel('to_address', classname="col6"),
]),
FieldPanel('subject'),
], "Email"),
]
def deploy_to_netlify_on_change(**kwargs):
import requests
from django.conf import settings
try:
netlify_deploy_hook_url = getattr(settings, 'NETLIFY_DEPLOY_HOOK_URL')
except KeyError:
return
if not netlify_deploy_hook_url:
return
r = requests.post(netlify_deploy_hook_url)
r.raise_for_status()
page_published.connect(deploy_to_netlify_on_change)
page_unpublished.connect(deploy_to_netlify_on_change)
from .signals import notify
from notifications.models import Notification
def notify_after_page_published(sender, instance, **kwargs):
"""
In some cases, the page may not have any owner, for example the home page.
For now we don't send any notification for these page as the logic behind finiding to who send
a notification is not yet defined
"""
if instance.owner:
notify.send(instance, recipient=instance.owner, verb='published')
@receiver(post_save, sender=PageRevision)
def notify_after_revision_save(sender, instance, **kwargs):
if not instance.submitted_for_moderation:
return
# Get list of publishers
include_superusers = getattr(
settings, 'WAGTAILADMIN_NOTIFICATION_INCLUDE_SUPERUSERS', True)
recipients = users_with_page_permission(instance.page, 'publish',
include_superusers)
for recipient in recipients:
notify.send(instance.page, recipient=recipient, verb='submitted')
page_published.connect(notify_after_page_published)
,address=parent.address,type=event_type)
parent.add_child(instance=child)
else:
child[0].title = title
child[0].save()
parent.save()
#2. Go through all children - if slug does not match any of the provided dates delete it
all_children = parent.get_children()
all_slugs = set([instance.slug for instance in all_children])
new_slugs = set(new_slugs)
slugs_to_remove = RecurringEventChild.objects.filter(
slug__in=all_slugs.difference(new_slugs))
slugs_to_remove.delete()
def add_longitude_latitude(sender, **kwargs):
obj = kwargs['instance']
postcode_obj = Postcode.objects.filter(postcode=obj.postcode).first()
if postcode_obj:
obj.longitude = postcode_obj.longitude
obj.latitude = postcode_obj.latitude
obj.save()
# Register listeners for each page model class
page_published.connect(create_or_update_recurring_children,
sender=RecurringEventParent)
page_published.connect(add_longitude_latitude, sender=SingleDayEvent)
page_published.connect(add_longitude_latitude, sender=MultiDayEvent)
parent_page_type = [
"home.HomePage",
]
class MovieReview(BlogDetailPage):
template = "blog/post.html"
subpage_types = []
parent_page_type = [
"blog.BlogListingPage",
]
movie = models.ForeignKey(
"movies.Movie",
blank=False,
null=True,
on_delete=models.SET_NULL,
)
content_panels = Page.content_panels + [
SnippetChooserPanel("author"),
AutocompletePanel("movie"),
StreamFieldPanel("content"),
]
# Send notifications for certain types of posts
page_published.connect(notify_subscribers, sender=BlogDetailPage)
page_published.connect(notify_subscribers, sender=VideoProjectPage)
page_published.connect(notify_subscribers, sender=MovieReview)
return
page = kwargs['instance']
# First published check
if page.first_published_at != page.last_published_at:
return
if page.get_parent().title not in ['Articles']:
return
webhook = Webhook.partial(settings.DISCORD_WEBHOOK_ID,
settings.DISCORD_WEBHOOK_TOKEN,
adapter=RequestsWebhookAdapter())
embed = Embed(type="rich",
description='{}'.format(page.description),
colour=0x90E050)
embed.set_author(name=page.title,
url='https://{}{}'.format(settings.SITE_NAME, page.url),
icon_url="https://i.imgur.com/9UsXLG0.png")
if page.articlepage.feed_image:
embed.set_thumbnail(url='https://{}{}'.format(
settings.SITE_NAME,
page.articlepage.feed_image.get_rendition('fill-800x600').url))
embed.set_footer(text='{} | {}'.format(page.owner.username, (
page.first_published_at).strftime('%A %d %B - %H:%M').title()))
webhook.send(username='******', embed=embed)
# Register a receiver
page_published.connect(send_to_discord)
menu_icon = 'doc-full'
add_to_settings_menu = True
modeladmin_register(ArticleAdmin)
def _static_build_async(force=False,
pipeline=settings.STATIC_BUILD_PIPELINE,
**kwargs):
"""Calls each command in the static build pipeline in turn."""
log_prefix = 'Static build task'
for name, command in pipeline:
if settings.DEBUG and not force:
logger.info(f'{log_prefix} ‘{name}’ skipped.')
else:
logger.info(f'{log_prefix} ‘{name}’ started.')
call_command(command)
logger.info(f'{log_prefix} ‘{name}’ finished.')
def static_build(**kwargs):
"""Callback for Wagtail publish and unpublish signals."""
# Spawn a process to do the actual build.
process = Process(target=_static_build_async, kwargs=kwargs)
process.start()
page_published.connect(static_build)
page_unpublished.connect(static_build)
def ready(self):
from .handlers import journal_published_handler
from .models import JournalPage
page_published.connect(journal_published_handler, sender=JournalPage)
logger.info('journal_published_handler should be connected now')
def register_signal_handlers():
page_published.connect(request_site_recrawl, sender=JobListingPage)
def register_signal_handlers():
page_published.connect(
handle_publish, dispatch_uid='wagtailbakery_page_published')
page_unpublished.connect(
handle_unpublish, dispatch_uid='wagtailbakery_page_unpublished')
