def add_subpage(request, parent_page_id):
"""Override wagtail view to prevent creation of limited pages"""
parent_page = get_object_or_404(Page, id=parent_page_id).specific
if not parent_page.permissions_for_user(request.user).can_add_subpage():
raise PermissionDenied
page_types = [
(model.get_verbose_name(), model._meta.app_label,
model._meta.model_name)
for model in type(parent_page).creatable_subpage_models()
if model.can_create_at(parent_page) and can_create(request, model)
]
# sort by lower-cased version of verbose name
page_types.sort(key=lambda page_type: page_type[0].lower())
if len(page_types) == 1:
# Only one page type is available - redirect straight to the create form rather than
# making the user choose
verbose_name, app_label, model_name = page_types[0]
return redirect('wagtailadmin_pages:add', app_label, model_name,
parent_page.id)
return render(
request, 'wagtailadmin/pages/add_subpage.html', {
'parent_page': parent_page,
'page_types': page_types,
'next': get_valid_next_url_from_request(request),
})
def unpublish(request, page_id):
page = get_object_or_404(Page, id=page_id).specific
user_perms = UserPagePermissionsProxy(request.user)
if not user_perms.for_page(page).can_unpublish():
raise PermissionDenied
next_url = get_valid_next_url_from_request(request)
include_descendants = request.POST.get('include_descendants', False)
page.unpublish()
if include_descendants:
live_descendant_pages = page.get_descendants().live().specific()
for live_descendant_page in live_descendant_pages:
if user_perms.for_page(live_descendant_page).can_unpublish():
live_descendant_page.unpublish()
messages.success(request,
_('Page \'{0}\' unpublished.').format(
page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit',
args=(page.id, )), _('Edit'))
])
page.release_id = request.POST.get('release', None)
page.save_revision(request.user)
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', page.get_parent().id)
def publish(request, page_id):
page = get_object_or_404(Page, id=page_id).specific
user_perms = UserPagePermissionsProxy(request.user)
if not user_perms.for_page(page).can_publish():
raise PermissionDenied
next_url = pages.get_valid_next_url_from_request(request)
if request.method == 'POST':
page.get_latest_revision().publish()
messages.success(request, _("Page '{0}' published.").format(page.get_admin_display_title()), buttons=[
messages.button(reverse('wagtailadmin_pages:edit', args=(page.id,)), _('Edit'))
])
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', page.get_parent().id)
return render(request, 'wagtailadmin/pages/confirm_publish.html', {
'page': page,
'next': next_url,
})
def copy(request, app_label, model_name, id):
# Validate snippet has been registered and title_field is set.
meta = snippet_copy_registry.get(app_label, model_name)
if meta is None:
raise Exception("This snippet isn't registered as copyable")
try:
model = apps.get_model(app_label, model_name)
except LookupError:
raise Http404
permission = get_permission_name('change', model)
if not request.user.has_perm(permission):
return permission_denied(request)
snippet = get_object_or_404(model, id=id)
# Create the form
form = meta['copy_form_class'](request.POST or None, snippet=snippet, title_field_name=meta['title_field_name'])
next_url = get_valid_next_url_from_request(request)
for fn in hooks.get_hooks('before_copy_snippet'):
result = fn(request, snippet)
if hasattr(result, 'status_code'):
return result
# Check if user is submitting
if request.method == 'POST':
if form.is_valid():
# Copy the snippet
new_snippet = form.copy()
# Give a success message back to the user
messages.success(request, _(f"{snippet.get_snippet_verbose_name()} '{snippet}' has been copied.").format(snippet))
for fn in hooks.get_hooks('after_copy_snippet'):
result = fn(request, snippet, new_snippet)
if hasattr(result, 'status_code'):
return result
if next_url:
return redirect(next_url)
if 'wagtail.contrib.modeladmin' in settings.INSTALLED_APPS:
url_helper = AdminURLHelper(new_snippet)
return redirect(url_helper.get_action_url('edit', quote(new_snippet.pk)))
return redirect('wagtailsnippets:edit', app_label, model_name, new_snippet.id)
return render(request, 'wagtailsnippetscopy/copy.html', {
'snippet': snippet,
'app_label': app_label,
'model_name': model_name,
'form': form,
'next': next_url,
})
def delete_related_variants(request, page):
if not isinstance(page, models.PersonalisablePageMixin) \
or not page.personalisation_metadata.is_canonical:
return
# Get a list of related personalisation metadata for all the related
# variants.
variants_metadata = (page.personalisation_metadata.variants_metadata.
select_related('variant'))
next_url = get_valid_next_url_from_request(request)
if request.method == 'POST':
parent_id = page.get_parent().id
with transaction.atomic():
# To ensure variants are deleted for all descendants, start with
# the deepest ones, and explicitly delete variants and metadata
# for all of them, including the page itself. Otherwise protected
# foreign key constraints are violated. Only consider canonical
# pages.
for metadata in PersonalisablePageMetadata.objects.filter(
canonical_page__in=page.get_descendants(inclusive=True),
variant=F("canonical_page"),
).order_by('-canonical_page__depth'):
for variant_metadata in metadata.variants_metadata.select_related(
'variant'):
# Call delete() on objects to trigger any signals or hooks.
variant_metadata.variant.delete()
metadata.delete()
metadata.canonical_page.delete()
msg = _("Page '{0}' and its variants deleted.")
messages.success(request, msg.format(page.get_admin_display_title()))
for fn in hooks.get_hooks('after_delete_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_id)
return render(
request,
'wagtailadmin/pages/wagtail_personalisation/confirm_delete.html', {
'page':
page,
'descendant_count':
page.get_descendant_count(),
'next':
next_url,
'variants':
Page.objects.filter(
pk__in=variants_metadata.values_list('variant_id'))
})
def delete_related_variants(request, page):
if not isinstance(page, models.PersonalisablePageMixin) \
or not page.personalisation_metadata.is_canonical:
return
# Get a list of related personalisation metadata for all the related
# variants.
variants_metadata = (
page.personalisation_metadata.variants_metadata
.select_related('variant')
)
next_url = get_valid_next_url_from_request(request)
if request.method == 'POST':
parent_id = page.get_parent().id
variants_metadata = variants_metadata.select_related('variant')
with transaction.atomic():
for metadata in variants_metadata.iterator():
# Call delete() on objects to trigger any signals or hooks.
metadata.variant.delete()
# Delete the page's main variant and the page itself.
page.personalisation_metadata.delete()
page.delete()
msg = _("Page '{0}' and its variants deleted.")
messages.success(
request,
msg.format(page.get_admin_display_title())
)
for fn in hooks.get_hooks('after_delete_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_id)
return render(
request,
'wagtailadmin/pages/wagtail_personalisation/confirm_delete.html', {
'page': page,
'descendant_count': page.get_descendant_count(),
'next': next_url,
'variants': Page.objects.filter(
pk__in=variants_metadata.values_list('variant_id')
)
}
)
def update_page_from_import(request, page, parsed_doc):
"""
Renders an edit page with the content of the page replaced with the content in the given document
"""
page.update_from_import(parsed_doc, request.user)
edit_handler = page.get_edit_handler()
edit_handler = edit_handler.bind_to(request=request, instance=page)
form_class = edit_handler.get_form_class()
next_url = get_valid_next_url_from_request(request)
form = form_class(instance=page)
has_unsaved_changes = True
edit_handler = edit_handler.bind_to(form=form)
return render(
request,
"wagtailadmin/pages/edit.html",
{
"page":
page,
"page_for_status":
page,
"content_type":
page.content_type,
"edit_handler":
edit_handler,
"action_menu":
PageActionMenu(
request, view="edit", page=page,
parent_page=page.get_parent()),
"preview_modes":
page.preview_modes,
"form":
form,
"next":
next_url,
"has_unsaved_changes":
has_unsaved_changes,
},
)
def create_page_from_import(request, parent_page, page_class, parsed_doc):
"""
Renders a pre-populated create page based on a parsed document for a Page model with ContentImportMixin
"""
page = page_class.create_from_import(parsed_doc, request.user)
edit_handler = page_class.get_edit_handler()
edit_handler = edit_handler.bind_to(request=request, instance=page)
form_class = edit_handler.get_form_class()
next_url = get_valid_next_url_from_request(request)
form = form_class(instance=page, parent_page=parent_page)
has_unsaved_changes = False
edit_handler = edit_handler.bind_to(form=form)
return render(
request,
"wagtailadmin/pages/create.html",
{
"content_type":
page.content_type,
"page_class":
page_class,
"parent_page":
parent_page,
"edit_handler":
edit_handler,
"action_menu":
PageActionMenu(request, view="create", parent_page=parent_page),
"preview_modes":
page.preview_modes,
"form":
form,
"next":
next_url,
"has_unsaved_changes":
has_unsaved_changes,
},
)
def copy(request, page_id):
page = Page.objects.get(id=page_id)
page = page.specific
newest_revision = page.get_latest_revision()
# Parent page defaults to parent of source page
parent_page = page.get_parent()
# Check if the user has permission to publish subpages on the parent
can_publish = parent_page.permissions_for_user(
request.user).can_publish_subpage()
# Create the form
form = CopyForm(request.POST or None,
user=request.user,
page=page,
can_publish=can_publish)
next_url = get_valid_next_url_from_request(request)
for fn in hooks.get_hooks('before_copy_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
# Check if user is submitting
if request.method == 'POST':
# Prefill parent_page in case the form is invalid (as prepopulated value for the form field,
# because ModelChoiceField seems to not fall back to the user given value)
parent_page = Page.objects.get(id=request.POST['new_parent_page'])
if form.is_valid():
# Receive the parent page (this should never be empty)
if form.cleaned_data['new_parent_page']:
parent_page = form.cleaned_data['new_parent_page']
if not page.permissions_for_user(request.user).can_copy_to(
parent_page, form.cleaned_data.get('copy_subpages')):
raise PermissionDenied
# Re-check if the user has permission to publish subpages on the new parent
can_publish = parent_page.permissions_for_user(
request.user).can_publish_subpage()
new_page = newest_revision.as_page_object().copy(
recursive=form.cleaned_data.get('copy_subpages'),
to=parent_page,
update_attrs={
'title': form.cleaned_data['new_title'],
'slug': form.cleaned_data['new_slug'],
},
keep_live=(can_publish
and form.cleaned_data.get('publish_copies')),
user=request.user,
)
# Give a success message back to the user
if form.cleaned_data.get('copy_subpages'):
messages.success(
request,
_('Page \'{0}\' and {1} subpages copied.').format(
page.get_admin_display_title(),
new_page.get_descendants().count()))
else:
messages.success(
request,
_('Page \'{0}\' copied.').format(
page.get_admin_display_title()))
for fn in hooks.get_hooks('after_copy_page'):
result = fn(request, page, new_page)
if hasattr(result, 'status_code'):
return result
# Redirect to explore of parent page
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_page.id)
return render(request, 'wagtailadmin/pages/copy.html', {
'page': page,
'form': form,
'next': next_url,
})
def edit(request, page_id):
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
real_page_record = get_object_or_404(Page, id=page_id)
latest_revision = real_page_record.get_latest_revision()
page = real_page_record.get_latest_revision_as_page()
parent = page.get_parent()
content_type = ContentType.objects.get_for_model(page)
page_class = content_type.model_class()
page_perms = page.permissions_for_user(request.user)
if not page_perms.can_edit():
raise PermissionDenied
for fn in hooks.get_hooks('before_edit_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
edit_handler = page_class.get_edit_handler()
form_class = edit_handler.get_form_class()
next_url = get_valid_next_url_from_request(request)
errors_debug = None
if request.method == 'POST':
form = form_class(request.POST,
request.FILES,
instance=page,
parent_page=parent)
if form.is_valid() and not page.locked:
page = form.save(commit=False)
is_publishing = bool(request.POST.get(
'action-publish')) and page_perms.can_publish()
is_unpublishing = bool(request.POST.get(
'action-unpublish')) and page_perms.can_unpublish()
is_submitting = bool(request.POST.get('action-submit'))
is_reverting = bool(request.POST.get('revision'))
# If a revision ID was passed in the form, get that revision so its
# date can be referenced in notification messages
if is_reverting:
previous_revision = get_object_or_404(
page.revisions, id=request.POST.get('revision'))
# Save revision
revision = page.save_revision(
user=request.user,
submitted_for_moderation=is_submitting,
)
# store submitted go_live_at for messaging below
go_live_at = page.go_live_at
# Publish
if is_publishing:
revision.publish()
# Need to reload the page because the URL may have changed, and we
# need the up-to-date URL for the "View Live" button.
page = page.specific_class.objects.get(pk=page.pk)
# Page is being published now
if is_reverting:
message = _(
'Revision from {0} of page \'{1}\' has been published.'
).format(
previous_revision.created_at.strftime(
'%d %b %Y %H:%M'), page.get_admin_display_title())
else:
message = _('Page \'{0}\' has been published.').format(
page.get_admin_display_title())
buttons = []
if page.url is not None:
buttons.append(
messages.button(page.url,
_('View live'),
new_window=True))
buttons.append(
messages.button(
reverse('wagtailadmin_pages:edit', args=(page_id, )),
_('Edit')))
messages.success(request, message, buttons=buttons)
# Unpublish
if is_unpublishing:
release_for_unpublish = request.POST.get('release')
release = Release.objects.get(id=release_for_unpublish)
release.remove_page(page_id)
messages.success(request,
_('Page \'{0}\' unpublished.').format(
page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit',
args=(page.id, )), _('Edit'))
])
elif is_submitting:
message = _(
'Page \'{0}\' has been submitted for moderation.').format(
page.get_admin_display_title())
messages.success(request,
message,
buttons=[
messages.button(reverse(
'wagtailadmin_pages:view_draft',
args=(page_id, )),
_('View draft'),
new_window=True),
messages.button(
reverse('wagtailadmin_pages:edit',
args=(page_id, )), _('Edit'))
])
if not send_notification(page.get_latest_revision().id,
'submitted', request.user.pk):
messages.error(
request,
_('Failed to send notifications to moderators'))
else: # Saving
if is_reverting:
message = _(
'Page \'{0}\' has been replaced with revision from {1}.'
).format(
page.get_admin_display_title(),
previous_revision.created_at.strftime(
'%d %b %Y %H:%M'))
else:
message = _('Page \'{0}\' has been updated.').format(
page.get_admin_display_title())
messages.success(request, message)
for fn in hooks.get_hooks('after_edit_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
if is_publishing or is_submitting:
# we're done here - redirect back to the explorer
if next_url:
# redirect back to 'next' url if present
return redirect(next_url)
# redirect back to the explorer
return redirect('wagtailadmin_explore', page.get_parent().id)
else:
# Just saving - remain on edit page for further edits
target_url = reverse('wagtailadmin_pages:edit', args=[page.id])
if next_url:
# Ensure the 'next' url is passed through again if present
target_url += '?next=%s' % urlquote(next_url)
return redirect(target_url)
else:
if page.locked:
messages.error(
request, _('The page could not be saved as it is locked'))
else:
messages.validation_error(
request,
_('The page could not be saved due to validation errors'),
form)
edit_handler = edit_handler.bind_to_instance(instance=page,
form=form,
request=request)
errors_debug = (repr(edit_handler.form.errors) + repr(
[(name, formset.errors)
for (name, formset) in edit_handler.form.formsets.items()
if formset.errors]))
has_unsaved_changes = True
else:
edit_handler = page_class.get_edit_handler()
form_class = edit_handler.get_form_class()
class CustomPageForm(form_class):
def __init__(self, *args, **kwargs):
super(CustomPageForm, self).__init__(*args, **kwargs)
self.fields['release'].queryset = self.fields[
'release'].queryset.filter(site=self.instance.get_site())
form = CustomPageForm(instance=page, parent_page=parent)
edit_handler = edit_handler.bind_to_instance(instance=page,
form=form,
request=request)
has_unsaved_changes = False
# Check for revisions still undergoing moderation and warn
if latest_revision and latest_revision.submitted_for_moderation:
buttons = []
if page.live:
buttons.append(
messages.button(
reverse('wagtailadmin_pages:revisions_compare',
args=(page.id, 'live', latest_revision.id)),
_('Compare with live version')))
messages.warning(request,
_('This page is currently awaiting moderation'),
buttons=buttons)
if page.live and page.has_unpublished_changes:
# Page status needs to present the version of the page containing the correct live URL
page_for_status = real_page_record.specific
else:
page_for_status = page
rendition = None
try:
rendition = SiteSettings.objects.get(site=page.get_site()).rendition
except SiteSettings.DoesNotExist:
pass
return render(
request, 'wagtailadmin/pages/edit.html', {
'page': page,
'page_for_status': page_for_status,
'content_type': content_type,
'edit_handler': edit_handler,
'errors_debug': errors_debug,
'preview_modes': page.preview_modes,
'form': form,
'next': next_url,
'has_unsaved_changes': has_unsaved_changes,
'rendition': rendition,
})
def copy(request, page_id):
page = Page.objects.get(id=page_id)
# Parent page defaults to parent of source page
parent_page = page.get_parent()
# Check if the user has permission to publish subpages on the parent
can_publish = parent_page.permissions_for_user(request.user).can_publish_subpage()
# Create the form
form = CopyForm(request.POST or None, user=request.user, page=page, can_publish=can_publish)
next_url = get_valid_next_url_from_request(request)
for fn in hooks.get_hooks('before_copy_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
# Check if user is submitting
if request.method == 'POST':
# Prefill parent_page in case the form is invalid (as prepopulated value for the form field,
# because ModelChoiceField seems to not fall back to the user given value)
parent_page = Page.objects.get(id=request.POST['new_parent_page'])
if form.is_valid():
# Receive the parent page (this should never be empty)
if form.cleaned_data['new_parent_page']:
parent_page = form.cleaned_data['new_parent_page']
if not page.permissions_for_user(request.user).can_copy_to(
parent_page,
form.cleaned_data.get('copy_subpages')):
raise PermissionDenied
# Re-check if the user has permission to publish subpages on the new parent
can_publish = parent_page.permissions_for_user(request.user).can_publish_subpage()
# build translated attrs
translated_attrs = {}
for lang in mt_settings.AVAILABLE_LANGUAGES:
new_title_field = build_localized_fieldname("new_title", lang)
if form.cleaned_data.get(new_title_field):
title_field = build_localized_fieldname("title", lang)
new_slug_field = build_localized_fieldname("new_slug", lang)
slug_field = build_localized_fieldname("slug", lang)
translated_attrs.update({
'{}'.format(title_field): form.cleaned_data[new_title_field],
'{}'.format(slug_field): form.cleaned_data[new_slug_field],
})
# Copy the page
new_page = page.copy(
recursive=form.cleaned_data.get('copy_subpages'),
to=parent_page,
update_attrs=translated_attrs,
keep_live=(can_publish and form.cleaned_data.get('publish_copies')),
user=request.user,
)
# Give a success message back to the user
if form.cleaned_data.get('copy_subpages'):
messages.success(
request,
_("Page '{0}' and {1} subpages copied.").format(
page.get_admin_display_title(),
new_page.get_descendants().count())
)
else:
messages.success(request, _("Page '{0}' copied.").format(
page.get_admin_display_title()))
for fn in hooks.get_hooks('after_copy_page'):
result = fn(request, page, new_page)
if hasattr(result, 'status_code'):
return result
# Redirect to explore of parent page
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_page.id)
return render(request, 'wagtailadmin/pages/copy.html', {
'page': page,
'form': form,
'next': next_url,
})
def before_copy_page(request, page):
parent_page = page.get_parent()
can_publish = parent_page.permissions_for_user(request.user).can_publish_subpage()
form = PatchedCopyForm(request.POST or None, user=request.user, page=page, can_publish=can_publish)
next_url = get_valid_next_url_from_request(request)
if request.method == 'POST':
# Prefill parent_page in case the form is invalid (as prepopulated value for the form field,
# because ModelChoiceField seems to not fall back to the user given value)
parent_page = Page.objects.get(id=request.POST['new_parent_page'])
if form.is_valid():
# Receive the parent page (this should never be empty)
if form.cleaned_data['new_parent_page']:
parent_page = form.cleaned_data['new_parent_page']
if not page.permissions_for_user(request.user).can_copy_to(parent_page,
form.cleaned_data.get('copy_subpages')):
raise PermissionDenied
# Re-check if the user has permission to publish subpages on the new parent
can_publish = parent_page.permissions_for_user(request.user).can_publish_subpage()
update_attrs = {}
for code, name in settings.LANGUAGES:
if wmt_settings.TRANSLATE_SLUGS:
slug = build_localized_fieldname('slug', code)
else:
slug = 'slug'
title = build_localized_fieldname('title', code)
update_attrs[slug] = form.cleaned_data["new_{}".format(slug)]
update_attrs[title] = form.cleaned_data["new_{}".format(title)]
# Copy the page
new_page = page.copy(
recursive=form.cleaned_data.get('copy_subpages'),
to=parent_page,
update_attrs=update_attrs,
keep_live=(can_publish and form.cleaned_data.get('publish_copies')),
user=request.user,
)
# Give a success message back to the user
if form.cleaned_data.get('copy_subpages'):
messages.success(
request,
_("Page '{0}' and {1} subpages copied.").format(
page.get_admin_display_title(), new_page.get_descendants().count())
)
else:
messages.success(request, _("Page '{0}' copied.").format(page.get_admin_display_title()))
for fn in hooks.get_hooks('after_copy_page'):
result = fn(request, page, new_page)
if hasattr(result, 'status_code'):
return result
# Redirect to explore of parent page
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_page.id)
return render(request, 'modeltranslation_copy.html', {
'page': page,
'form': form,
'next': next_url
})
def create(request, content_type_app_name, content_type_model_name,
parent_page_id):
parent_page = get_object_or_404(Page, id=parent_page_id).specific
parent_page_perms = parent_page.permissions_for_user(request.user)
if not parent_page_perms.can_add_subpage():
raise PermissionDenied
try:
content_type = ContentType.objects.get_by_natural_key(
content_type_app_name, content_type_model_name)
except ContentType.DoesNotExist:
raise Http404
# Get class
page_class = content_type.model_class()
# Make sure the class is a descendant of Page
if not issubclass(page_class, Page):
raise Http404
# page must be in the list of allowed subpage types for this parent ID
if page_class not in parent_page.creatable_subpage_models():
raise PermissionDenied
if not page_class.can_create_at(parent_page):
raise PermissionDenied
for fn in hooks.get_hooks('before_create_page'):
result = fn(request, parent_page, page_class)
if hasattr(result, 'status_code'):
return result
page = page_class(owner=request.user)
edit_handler = page_class.get_edit_handler()
form_class = edit_handler.get_form_class()
next_url = get_valid_next_url_from_request(request)
if request.method == 'POST':
form = form_class(request.POST,
request.FILES,
instance=page,
parent_page=parent_page)
if form.is_valid():
page = form.save(commit=False)
# Save page
parent_page.add_child(instance=page)
# Save revision
page.save_revision(
user=request.user,
submitted_for_moderation=False,
)
messages.success(
request,
_('Page \'{0}\' created.').format(
page.get_admin_display_title()))
for fn in hooks.get_hooks('after_create_page'):
result = fn(request, page)
if hasattr(result, 'status_code'):
return result
# Just saving - remain on edit page for further edits
target_url = reverse('experiments_oneyouvariant_edit',
args=[page.id])
if next_url:
# Ensure the 'next' url is passed through again if present
target_url += '?next=%s' % urlquote(next_url)
return redirect(target_url)
else:
messages.validation_error(
request,
_('The page could not be created due to validation errors'),
form)
edit_handler = edit_handler.bind_to_instance(instance=page,
form=form,
request=request)
has_unsaved_changes = True
else:
parent_page_json = parent_page.to_json()
page = page_class.from_json(parent_page_json)
slug = hashlib.sha224(
base64.b64encode(str(time.time()).encode('utf-8'))).hexdigest()
page.slug = '%s-v%s' % (page.slug, slug[:6])
page.title = '%s (describe the variant)' % page.title
signals.init_new_page.send(sender=create,
page=page,
parent=parent_page)
form = form_class(instance=page, parent_page=parent_page)
edit_handler = edit_handler.bind_to_instance(instance=page,
form=form,
request=request)
has_unsaved_changes = False
return render(
request, 'wagtailadmin/custom_add_footer.html', {
'content_type': content_type,
'page_class': page_class,
'parent_page': parent_page,
'edit_handler': edit_handler,
'preview_modes': page.preview_modes,
'form': form,
'next': next_url,
'has_unsaved_changes': has_unsaved_changes,
})
def publish(request, page_id):
page = get_object_or_404(Page, id=page_id).specific
user_perms = UserPagePermissionsProxy(request.user)
if not user_perms.for_page(page).can_publish():
raise PermissionDenied
next_url = pages.get_valid_next_url_from_request(request)
if request.method == 'POST':
page.get_latest_revision().publish()
# TODO: clean up copypasta when coa-publisher phases out previously AWS publish pipeline
# Show success message if there is a publish_janis_branch set (for netlify builds)
# Or default to show success message on Staging and Production (follow existing AWS implementation pattern)
try:
publish_janis_branch = getattr(JanisBranchSettings.objects.first(),
'publish_janis_branch')
except:
publish_janis_branch = None
if settings.ISSTAGING or settings.ISPRODUCTION:
messages.success(request,
_("Page '{0}' published.").format(
page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit',
args=(page.id, )), _('Edit'))
])
elif settings.ISLOCAL:
messages.warning(
request,
_("Page '{0}' not published. You're running on a local environment."
).format(page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit', args=(page.id, )),
_('Edit'))
])
elif publish_janis_branch:
messages.success(request,
_("Page '{0}' published.").format(
page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit',
args=(page.id, )), _('Edit'))
])
else:
messages.warning(
request,
_("Page '{0}' not published. No `publish_janis_branch` was set."
).format(page.get_admin_display_title()),
buttons=[
messages.button(
reverse('wagtailadmin_pages:edit', args=(page.id, )),
_('Edit'))
])
if next_url:
return redirect(next_url)
# return redirect('wagtailadmin_explore', page.get_parent().id)
return redirect('/admin/pages/search/')
return render(request, 'wagtailadmin/pages/confirm_publish.html', {
'page': page,
'next': next_url,
})
def custom_admin_round_copy_view(request, page):
# Custom view to handle copied Round pages.
# https://github.com/wagtail/wagtail/blob/124827911463f0cb959edbb9d8d5685578540bd3/wagtail/admin/views/pages.py#L824
# Parent page defaults to parent of source page
parent_page = page.get_parent()
# Check if the user has permission to publish subpages on the parent
can_publish = parent_page.permissions_for_user(
request.user).can_publish_subpage()
form = CopyForm(request.POST or None,
user=request.user,
page=page,
can_publish=can_publish)
next_url = get_valid_next_url_from_request(request)
# Prefill parent_page in case the form is invalid (as prepopulated value for the form field,
# because ModelChoiceField seems to not fall back to the user given value)
parent_page = Page.objects.get(id=request.POST['new_parent_page'])
if form.is_valid():
# Receive the parent page (this should never be empty)
if form.cleaned_data['new_parent_page']:
parent_page = form.cleaned_data['new_parent_page']
if not page.permissions_for_user(request.user).can_copy_to(
parent_page, form.cleaned_data.get('copy_subpages')):
raise PermissionDenied
# Re-check if the user has permission to publish subpages on the new parent
can_publish = parent_page.permissions_for_user(
request.user).can_publish_subpage()
# Copy the page
new_page = page.copy(
recursive=form.cleaned_data.get('copy_subpages'),
to=parent_page,
update_attrs={
'title': form.cleaned_data['new_title'],
'slug': form.cleaned_data['new_slug'],
'start_date': None,
'end_date': None,
},
keep_live=(can_publish
and form.cleaned_data.get('publish_copies')),
user=request.user,
)
messages.info(
request,
_(("Please select the date in the copied page. "
"Newly copied pages have NONE value for the start and end date"
)))
# Give a success message back to the user
if form.cleaned_data.get('copy_subpages'):
messages.success(
request,
_("Page '{0}' and {1} subpages copied.").format(
page.get_admin_display_title(),
new_page.get_descendants().count()))
else:
messages.success(
request,
_("Page '{0}' copied.").format(page.get_admin_display_title()))
for fn in hooks.get_hooks('after_copy_page'):
result = fn(request, page, new_page)
if hasattr(result, 'status_code'):
return result
# Redirect to explore of parent page
if next_url:
return redirect(next_url)
return redirect('wagtailadmin_explore', parent_page.id)
