def get_breadcrumb(self):
from cms.models import Page
model = self.placeholder._get_attached_model() or Page
breadcrumb = []
for parent in self.get_ancestors():
try:
url = force_text(
admin_reverse("%s_%s_edit_plugin" % (model._meta.app_label, model._meta.model_name),
args=[parent.pk]))
except NoReverseMatch:
url = force_text(
admin_reverse("%s_%s_edit_plugin" % (Page._meta.app_label, Page._meta.model_name),
args=[parent.pk]))
breadcrumb.append({'title': force_text(parent.get_plugin_name()), 'url': url})
try:
url = force_text(
admin_reverse("%s_%s_edit_plugin" % (model._meta.app_label, model._meta.model_name),
args=[self.pk]))
except NoReverseMatch:
url = force_text(
admin_reverse("%s_%s_edit_plugin" % (Page._meta.app_label, Page._meta.model_name),
args=[self.pk]))
breadcrumb.append({'title': force_text(self.get_plugin_name()), 'url': url})
return breadcrumb
def test_undo_slug_collision(self):
data1 = self.get_new_page_data()
data2 = self.get_new_page_data()
data1['slug'] = 'page1'
data2['slug'] = 'page2'
with self.login_user_context(self.get_superuser()):
response = self.client.post(URL_CMS_PAGE_ADD, data1)
self.assertEqual(response.status_code, 302)
response = self.client.post(URL_CMS_PAGE_ADD, data2)
self.assertEqual(response.status_code, 302)
page1 = Page.objects.get(title_set__slug='page1')
page2 = Page.objects.get(title_set__slug='page2')
data1['slug'] = 'page3'
response = self.client.post(URL_CMS_PAGE_CHANGE % page1.pk, data1)
self.assertEqual(response.status_code, 302)
data2['slug'] = 'page1'
response = self.client.post(URL_CMS_PAGE_CHANGE % page2.pk, data2)
self.assertEqual(response.status_code, 302)
undo_url = admin_reverse("cms_page_undo", args=[page1.pk])
response = self.client.post(undo_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(Title.objects.get(page=page1).slug, 'page3')
response = self.client.get(admin_reverse("cms_page_changelist"))
self.assertEqual(response.status_code, 200)
response = self.client.get('/en/?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertEqual(response.status_code, 200)
response = self.client.get('/en/page1/?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertEqual(response.status_code, 200)
def add_history_menu(self):
if self.toolbar.edit_mode and self.page:
refresh = self.toolbar.REFRESH_PAGE
history_menu = self.toolbar.get_or_create_menu(HISTORY_MENU_IDENTIFIER, _('History'), position=2)
if is_installed('reversion'):
import reversion
from reversion.models import Revision
versions = reversion.get_for_object(self.page)
if self.page.revision_id:
current_revision = Revision.objects.get(pk=self.page.revision_id)
has_undo = versions.filter(revision__pk__lt=current_revision.pk).exists()
has_redo = versions.filter(revision__pk__gt=current_revision.pk).exists()
else:
has_redo = False
has_undo = versions.count() > 1
undo_action = admin_reverse('cms_page_undo', args=(self.page.pk,))
redo_action = admin_reverse('cms_page_redo', args=(self.page.pk,))
history_menu.add_ajax_item(_('Undo'), action=undo_action, disabled=not has_undo, on_success=refresh)
history_menu.add_ajax_item(_('Redo'), action=redo_action, disabled=not has_redo, on_success=refresh)
history_menu.add_break(HISTORY_MENU_BREAK)
revert_action = admin_reverse('cms_page_revert_page', args=(self.page.pk, self.current_lang))
revert_question = _('Are you sure you want to revert to live?')
history_menu.add_ajax_item(_('Revert to live'), action=revert_action, question=revert_question,
disabled=not self.page.is_dirty(self.current_lang), on_success=refresh)
history_menu.add_modal_item(_('View history'), url=admin_reverse('cms_page_history', args=(self.page.pk,)))
def add_admin_menu(self):
admin_menu = self.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER, self.current_site.name)
# Users button
self.add_users_button(admin_menu)
# sites menu
if get_cms_setting('PERMISSION'):
sites_queryset = get_user_sites_queryset(self.request.user)
else:
sites_queryset = Site.objects.all()
if len(sites_queryset) > 1:
sites_menu = admin_menu.get_or_create_menu('sites', _('Sites'))
sites_menu.add_sideframe_item(_('Admin Sites'), url=admin_reverse('sites_site_changelist'))
sites_menu.add_break(ADMIN_SITES_BREAK)
for site in sites_queryset:
sites_menu.add_link_item(site.name, url='http://%s' % site.domain,
active=site.pk == self.current_site.pk)
# admin
admin_menu.add_sideframe_item(_('Administration'), url=admin_reverse('index'))
admin_menu.add_break(ADMINISTRATION_BREAK)
# cms users
admin_menu.add_sideframe_item(_('User settings'), url=admin_reverse('cms_usersettings_change'))
admin_menu.add_break(USER_SETTINGS_BREAK)
# logout
self.add_logout_button(admin_menu)
def populate(self):
# always use draft if we have a page
self.page = get_page_draft(self.request.current_page)
if not self.page:
# Nothing to do
return
# check global permissions if CMS_PERMISSIONS is active
if get_cms_setting('PERMISSION'):
has_global_current_page_change_permission = has_page_change_permission(self.request)
else:
has_global_current_page_change_permission = False
# check if user has page edit permission
can_change = self.request.current_page and self.request.current_page.has_change_permission(self.request)
if has_global_current_page_change_permission or can_change:
try:
mypageextension = MyPageExtension.objects.get(extended_object_id=self.page.id)
except MyPageExtension.DoesNotExist:
mypageextension = None
try:
if mypageextension:
url = admin_reverse('extensionapp_mypageextension_change', args=(mypageextension.pk,))
else:
url = admin_reverse('extensionapp_mypageextension_add') + '?extended_object=%s' % self.page.pk
except NoReverseMatch:
# not in urls
pass
else:
not_edit_mode = not self.toolbar.edit_mode
current_page_menu = self.toolbar.get_or_create_menu('page')
current_page_menu.add_modal_item(_('Page Extension'), url=url, disabled=not_edit_mode)
def get_breadcrumb(self):
from cms.models import Page
model = self.placeholder._get_attached_model()
if not model:
model = Page
breadcrumb = []
if not self.parent_id:
try:
url = force_unicode(
admin_reverse(
"%s_%s_edit_plugin" % (model._meta.app_label, model._meta.module_name), args=[self.pk]
)
)
except NoReverseMatch:
url = force_unicode(
admin_reverse("%s_%s_edit_plugin" % (Page._meta.app_label, Page._meta.module_name), args=[self.pk])
)
breadcrumb.append({"title": force_unicode(self.get_plugin_name()), "url": url})
return breadcrumb
for parent in self.get_ancestors(False, True):
try:
url = force_unicode(
admin_reverse(
"%s_%s_edit_plugin" % (model._meta.app_label, model._meta.module_name), args=[parent.pk]
)
)
except NoReverseMatch:
url = force_unicode(
admin_reverse(
"%s_%s_edit_plugin" % (Page._meta.app_label, Page._meta.module_name), args=[parent.pk]
)
)
breadcrumb.append({"title": force_unicode(parent.get_plugin_name()), "url": url})
return breadcrumb
def get_title_extension_admin(self, language=None):
"""
Get the admin urls for the title extensions menu items, depending on whether a TitleExtension instance exists
for each Title in the current page.
A single language can be passed to only work on a single title.
Return a list of tuples of the title extension and the url; the extension is None if no instance exists,
the url is None is no admin is registered for the extension.
"""
page = self._get_page()
urls = []
if language:
titles = page.get_title_obj(language),
else:
titles = page.title_set.all()
# Titles
for title in titles:
try:
title_extension = self.model.objects.get(extended_object_id=title.pk)
except self.model.DoesNotExist:
title_extension = None
try:
if title_extension:
admin_url = admin_reverse(
'%s_%s_change' % (self.model._meta.app_label, self.model._meta.model_name),
args=(title_extension.pk,))
else:
admin_url = "%s?extended_object=%s" % (
admin_reverse('%s_%s_add' % (self.model._meta.app_label, self.model._meta.model_name)),
title.pk)
except NoReverseMatch: # pragma: no cover
admin_url = None
if admin_url:
urls.append((title_extension, admin_url))
return urls
def populate(self):
# always use draft if we have a page
self.page = get_page_draft(self.request.current_page)
if not self.page:
# Nothing to do
return
if user_can_change_page(self.request.user, page=self.page):
try:
mypageextension = MyPageExtension.objects.get(extended_object_id=self.page.id)
except MyPageExtension.DoesNotExist:
mypageextension = None
try:
if mypageextension:
url = admin_reverse('extensionapp_mypageextension_change', args=(mypageextension.pk,))
else:
url = admin_reverse('extensionapp_mypageextension_add') + '?extended_object=%s' % self.page.pk
except NoReverseMatch:
# not in urls
pass
else:
not_edit_mode = not self.toolbar.edit_mode
current_page_menu = self.toolbar.get_or_create_menu('page')
current_page_menu.add_modal_item(_('Page Extension'), url=url, disabled=not_edit_mode)
def get_page_extension_admin(self):
"""
Get the admin url for the page extension menu item, depending on whether a PageExtension instance exists
for the current page or not.
Return a tuple of the current extension and the url; the extension is None if no instance exists,
the url is None is no admin is registered for the extension.
"""
page = self._get_page()
# Page extension
try:
page_extension = self.model.objects.get(extended_object_id=page.pk)
except self.model.DoesNotExist:
page_extension = None
try:
if page_extension:
admin_url = admin_reverse(
'%s_%s_change' % (self.model._meta.app_label, self.model._meta.model_name),
args=(page_extension.pk,))
else:
admin_url = "%s?extended_object=%s" % (
admin_reverse('%s_%s_add' % (self.model._meta.app_label, self.model._meta.model_name)),
self.page.pk)
except NoReverseMatch: # pragma: no cover
admin_url = None
return page_extension, admin_url
def populate(self):
def can(actions, model):
try:
# Py2
basestring = basestring
except NameError:
# Py3
basestring = (str, bytes)
if isinstance(actions, basestring):
actions = [actions]
for action in actions:
perm = 'aldryn_jobs.%(action)s_%(model)s' % {
'action': action, 'model': model
}
if not self.request.user.has_perm(perm):
return False
return True
if self.is_current_app and (can(['add', 'change'], 'jobopening') or
can(['add', 'change'], 'jobsconfig')):
menu = self.toolbar.get_or_create_menu('jobs-app', _('Jobs'))
# try to reuse resolver_match instead of doing double work with
# cache issues, see comments inside of get_jobopening_from_path
current_url = getattr(self.request, 'resolver_match', None)
jobsconfig = self.get_jobs_config()
language = get_language_from_request(self.request, check_path=True)
job_opening = get_jobopening_from_path(
self.request.path, language, current_url=current_url
)
if jobsconfig and can(['add', 'change'], 'jobsconfig'):
url = admin_reverse('aldryn_jobs_jobsconfig_change',
args=(jobsconfig.pk, ))
menu.add_modal_item(_('Configure application'), url)
if can(['add', 'change'], 'jobcategory'):
if job_opening and job_opening.category:
url = admin_reverse('aldryn_jobs_jobcategory_change',
args=(job_opening.category.pk, ))
menu.add_modal_item(_('Edit category'), url, active=True)
base_url = admin_reverse('aldryn_jobs_jobcategory_add')
url = "{base}?app_config={config}".format(
base=base_url, config=jobsconfig.pk if jobsconfig else None)
menu.add_modal_item(_('Add new category'), url)
if can(['add', 'change'], 'jobopening'):
if job_opening:
url = admin_reverse(
'aldryn_jobs_jobopening_change',
args=(job_opening.pk,)
)
menu.add_modal_item(_('Edit job opening'), url, active=True)
menu.add_modal_item(
_('Add new job opening'),
admin_reverse('aldryn_jobs_jobopening_add')
)
def add_plugin(self, request):
"""
POST request should have the following data:
- placeholder_id
- plugin_type
- plugin_language
- plugin_parent (optional)
"""
parent = None
plugin_type = request.POST['plugin_type']
placeholder_id = request.POST.get('placeholder_id', None)
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
parent_id = request.POST.get('plugin_parent', None)
language = request.POST.get('plugin_language') or get_language_from_request(request)
if not self.has_add_plugin_permission(request, placeholder, plugin_type):
return HttpResponseForbidden(force_unicode(_('You do not have permission to add a plugin')))
try:
has_reached_plugin_limit(placeholder, plugin_type, language,
template=self.get_placeholder_template(request, placeholder))
except PluginLimitReached as er:
return HttpResponseBadRequest(er)
# page add-plugin
if not parent_id:
position = request.POST.get('plugin_order',
CMSPlugin.objects.filter(language=language, placeholder=placeholder).count())
# in-plugin add-plugin
else:
parent = get_object_or_404(CMSPlugin, pk=parent_id)
placeholder = parent.placeholder
position = request.POST.get('plugin_order',
CMSPlugin.objects.filter(language=language, parent=parent).count())
# placeholder (non-page) add-plugin
# Sanity check to make sure we're not getting bogus values from JavaScript:
if settings.USE_I18N:
if not language or not language in [lang[0] for lang in settings.LANGUAGES]:
return HttpResponseBadRequest(force_unicode(_("Language must be set to a supported language!")))
if parent and parent.language != language:
return HttpResponseBadRequest(force_unicode(_("Parent plugin language must be same as language!")))
else:
language = settings.LANGUAGE_CODE
plugin = CMSPlugin(language=language, plugin_type=plugin_type, position=position, placeholder=placeholder)
if parent:
plugin.position = CMSPlugin.objects.filter(parent=parent).count()
plugin.parent_id = parent.pk
plugin.save()
self.post_add_plugin(request, placeholder, plugin)
response = {
'url': force_unicode(
admin_reverse("%s_%s_edit_plugin" % (self.model._meta.app_label, self.model._meta.model_name),
args=[plugin.pk])),
'delete': force_unicode(
admin_reverse("%s_%s_delete_plugin" % (self.model._meta.app_label, self.model._meta.model_name),
args=[plugin.pk])),
'breadcrumb': plugin.get_breadcrumb(),
}
return HttpResponse(json.dumps(response), content_type='application/json')
def populate(self):
if not self.is_current_app:
return
menu = self.toolbar.get_or_create_menu("poll-app", _("Polls"))
menu.add_sideframe_item(name=_("Poll list"), url=admin_reverse("polls_poll_changelist"))
menu.add_modal_item(name=_("Add new poll"), url=admin_reverse("polls_poll_add"))
def test_undo_redo(self):
"""
Test that you can revert a plugin
"""
with self.login_user_context(self.user):
self.assertEqual(Page.objects.all().count(), 2)
self.assertEqual(Title.objects.all().count(), 2)
self.assertEqual(CMSPlugin.objects.all().count(), 2)
self.assertEqual(Revision.objects.all().count(), 4)
self.assertEqual(Placeholder.objects.count(), 5)
ctype = ContentType.objects.get_for_model(Page)
revision = Revision.objects.all()[2]
Version.objects.get(content_type=ctype, revision=revision)
page = Page.objects.all()[0]
undo_url = admin_reverse("cms_page_undo", args=[page.pk])
response = self.client.post(undo_url)
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertTrue(page.revision_id != 0)
rev = page.revision_id
redo_url = admin_reverse("cms_page_redo", args=[page.pk])
response = self.client.post(redo_url)
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertTrue(page.revision_id != rev)
txt = Text.objects.all()[0]
edit_url = URL_CMS_PLUGIN_EDIT + str(txt.pk) + "/"
response = self.client.post(edit_url, {"body": "Hello World2"})
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertEqual(page.revision_id, 0)
self.assertEqual(2, CMSPlugin.objects.all().count())
placeholderpk = page.placeholders.filter(slot="body")[0].pk
post_data = {}
get_data = {
'plugin_type': "TextPlugin",
'plugin_language': settings.LANGUAGES[0][0],
'placeholder_id': placeholderpk,
}
add_url = URL_CMS_PLUGIN_ADD + '?' + urlencode(get_data)
response = self.client.post(add_url, post_data)
self.assertEqual(response.status_code, 302)
pk = CMSPlugin.objects.all()[2].pk
# now edit the plugin
edit_url = URL_CMS_PLUGIN_EDIT + str(pk) + "/"
response = self.client.get(edit_url)
self.assertEqual(response.status_code, 200)
response = self.client.post(edit_url, {"body": "Hello World"})
self.assertEqual(response.status_code, 200)
self.assertEqual(3, CMSPlugin.objects.all().count())
self.client.post(undo_url)
self.client.post(undo_url)
self.assertEqual(2, CMSPlugin.objects.all().count())
self.assertEqual(Placeholder.objects.count(), 5)
def test_undo_redo(self):
"""
Test that you can revert a plugin
"""
with self.login_user_context(self.user):
self.assertEqual(Page.objects.all().count(), 2)
self.assertEqual(Title.objects.all().count(), 2)
self.assertEqual(CMSPlugin.objects.all().count(), 2)
self.assertEqual(Revision.objects.all().count(), 5)
self.assertEqual(Placeholder.objects.count(), 5)
ctype = ContentType.objects.get_for_model(Page)
revision = Revision.objects.all()[2]
Version.objects.get(content_type=ctype, revision=revision)
page = Page.objects.all()[0]
undo_url = admin_reverse("cms_page_undo", args=[page.pk])
response = self.client.post(undo_url)
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertTrue(page.revision_id != 0)
rev = page.revision_id
redo_url = admin_reverse("cms_page_redo", args=[page.pk])
response = self.client.post(redo_url)
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertTrue(page.revision_id != rev)
txt = Text.objects.all()[0]
edit_url = URL_CMS_PLUGIN_EDIT + str(txt.pk) + "/"
response = self.client.post(edit_url, {"body": "Hello World2"})
self.assertEqual(response.status_code, 200)
page = Page.objects.all()[0]
self.assertEqual(page.revision_id, 0)
self.assertEqual(2, CMSPlugin.objects.all().count())
placeholderpk = page.placeholders.filter(slot="body")[0].pk
plugin_data = {
"plugin_type": "TextPlugin",
"plugin_language": settings.LANGUAGES[0][0],
"placeholder_id": placeholderpk,
"plugin_parent": "",
}
response = self.client.post(URL_CMS_PLUGIN_ADD, plugin_data)
self.assertEqual(response.status_code, 200)
# now edit the plugin
edit_url = (
URL_CMS_PLUGIN_EDIT + response.content.decode("utf8").split("edit-plugin/")[1].split("/")[0] + "/"
)
response = self.client.get(edit_url)
self.assertEqual(response.status_code, 200)
response = self.client.post(edit_url, {"body": "Hello World"})
self.assertEqual(response.status_code, 200)
self.assertEqual(3, CMSPlugin.objects.all().count())
self.client.post(undo_url)
self.client.post(undo_url)
self.assertEqual(2, CMSPlugin.objects.all().count())
self.assertEqual(Placeholder.objects.count(), 5)
def populate(self):
admin_menu = self.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER)
position = admin_menu.find_first(Break, identifier=ADMINISTRATION_BREAK)
if position:
position -= 1
else:
position = 0
category_menu = admin_menu.get_or_create_menu('category', _('Category'), position=position)
category_menu.add_sideframe_item(_('Categories'), url=admin_reverse('sampleapp_category_changelist'))
category_menu.add_modal_item(_('Add Category'), url=admin_reverse('sampleapp_category_add'))
def test_add_plugin_alias(self):
page_en = api.create_page("PluginOrderPage", "col_two.html", "en",
slug="page1", published=True, in_navigation=True)
ph_en = page_en.placeholders.get(slot="col_left")
text_plugin_1 = api.add_plugin(ph_en, "TextPlugin", "en", body="I'm the first")
with self.login_user_context(self.get_superuser()):
response = self.client.post(admin_reverse('cms_create_alias'), data={'plugin_id': text_plugin_1.pk})
self.assertEqual(response.status_code, 200)
response = self.client.post(admin_reverse('cms_create_alias'), data={'placeholder_id': ph_en.pk})
self.assertEqual(response.status_code, 200)
def populate(self):
config = self.get_app_config(EventsConfig)
if not config:
return
event = get_object_from_request(Event, self.request)
if self.request.user:
user = self.request.user
chg_event_perm = user.has_perm('aldryn_events.change_event')
add_event_perm = user.has_perm('aldryn_events.add_event')
del_event_perm = user.has_perm('aldryn_events.delete_event')
chg_config_perm = user.has_perm(
'aldryn_events.change_eventsconfig')
add_config_perm = user.has_perm('aldryn_events.add_eventsconfig')
event_perms = [chg_event_perm, add_event_perm, del_event_perm]
config_perms = [chg_config_perm, add_config_perm]
if any(event_perms + config_perms):
menu = self.toolbar.get_or_create_menu(
'events-app', _('Events'))
if chg_config_perm:
url = admin_reverse('aldryn_events_eventsconfig_change',
args=[config.pk, ])
menu.add_modal_item(_('Edit App Configuration'), url=url)
if chg_config_perm and any(event_perms):
menu.add_break()
if chg_event_perm:
url = admin_reverse('aldryn_events_event_changelist')
menu.add_sideframe_item(_('Events list'), url=url)
if add_event_perm:
url = admin_reverse('aldryn_events_event_add')
# preselect the current app config
url = '{0}?app_config={1}'.format(url, config.pk)
menu.add_modal_item(_('Add event'), url=url)
if chg_event_perm and event:
url = admin_reverse('aldryn_events_event_change',
args=[event.pk, ])
menu.add_modal_item(_('Edit event'), url=url, active=True)
if del_event_perm and event:
redirect_url = self.get_on_delete_redirect_url(event)
url = admin_reverse('aldryn_events_event_delete',
args=[event.pk, ])
menu.add_modal_item(_('Delete event'), url=url,
on_close=redirect_url)
def _get_url(self, key, pk=None):
model = self._get_attached_model()
args = []
if pk:
args.append(pk)
if not model:
return admin_reverse('cms_page_%s' % key, args=args)
else:
app_label = model._meta.app_label
model_name = model.__name__.lower()
return admin_reverse('%s_%s_%s' % (app_label, model_name, key), args=args)
def get_menu_items(self, menu):
urls = {}
with override(self.current_lang):
urls['news'] = admin_reverse('oscar_news_news_changelist')
urls['add_news'] = admin_reverse('oscar_news_news_add')
urls['categories'] = admin_reverse('oscar_news_newscategory_changelist')
urls['add_category'] = admin_reverse('oscar_news_newscategory_add')
menu.add_sideframe_item(_('News overview'), url=urls['news'])
menu.add_modal_item(_('Add news'), url=urls['add_news'])
menu.add_break('news-menu-break')
menu.add_sideframe_item(_('News categories'), url=urls['categories'])
menu.add_modal_item(_('Add category'), url=urls['add_category'])
def populate(self):
config = self.__get_newsblog_config()
if not config:
# Do nothing if there is no NewsBlog app_config to work with
return
user = getattr(self.request, 'user', None)
menu = self.toolbar.get_or_create_menu('newsblog-app',
config.get_app_title())
if self.request.user.has_perm('aldryn_newsblog.change_newsblogconfig'):
menu.add_modal_item(
_('Configure application'),
url=admin_reverse(
'aldryn_newsblog_newsblogconfig_change',
args=(config.pk, )
),
)
if self.request.user.has_perm('aldryn_newsblog.change_article'):
menu.add_sideframe_item(
_('Article list'),
url="{base}?app_config__id__exact={config}".format(
base=admin_reverse('aldryn_newsblog_article_changelist'),
config=config.pk,
),
)
if self.request.user.has_perm('aldryn_newsblog.add_article'):
menu.add_modal_item(
_('Add new article'),
url="{base}?app_config={config}&owner={owner}".format(
base=admin_reverse('aldryn_newsblog_article_add'),
config=config.pk,
owner=user.pk,
),
)
view_name = self.request.resolver_match.view_name
if (view_name == '{0}:article-detail'.format(config.namespace) and
self.request.user.has_perm('aldryn_newsblog.change_article')):
kwargs = self.request.resolver_match.kwargs
articles = Article.objects
if hasattr(kwargs, 'slug'):
articles = articles.translated(slug=kwargs['slug'])
elif hasattr(kwargs, 'pk'):
articles = articles.filter(pk=kwargs['pk'])
articles = articles.all()
if articles.exists():
menu.add_modal_item(_('Edit article'), admin_reverse(
'aldryn_newsblog_article_change', args=(
articles[0].pk,)), active=True,)
def populate(self):
def can(action, model):
perm = 'aldryn_faq.%(action)s_%(model)s' % {
'action': action, 'model': model}
return self.request.user.has_perm(perm)
config = self.__get_newsblog_config()
if not config:
return
menu = self.toolbar.get_or_create_menu('faq-app', _('FAQ'))
if can('change', 'faqconfig'):
menu.add_modal_item(
_('Configure application'),
url=admin_reverse(
'aldryn_faq_faqconfig_change',
args=(config.pk, )
),
)
if can('add', 'category') or can('change', 'category'):
if can('add', 'category'):
menu.add_modal_item(
_('Add category'),
url=admin_reverse('aldryn_faq_category_add')
)
category = getattr(self.request, request_faq_category_identifier, None)
if category and can('change', 'category'):
url = reverse(
'admin:aldryn_faq_category_change',
args=(category.pk,),
)
menu.add_modal_item(_('Edit category'), url, active=True)
if category and can('add', 'question'):
params = ('?category=%s&language=%s' %
(category.pk, self.request.LANGUAGE_CODE))
menu.add_modal_item(
_('Add question'),
admin_reverse('aldryn_faq_question_add') + params
)
question = getattr(self.request, request_faq_question_identifier, None)
if question and can('change', 'question'):
url = reverse(
'admin:aldryn_faq_question_change', args=(question.pk,))
menu.add_modal_item(_('Edit question'), url, active=True)
def test_admin_title_extension(self):
with self.login_user_context(self.admin):
# add a new extension
response = self.client.get(
admin_reverse('extensionapp_mytitleextension_add') + '?extended_object=%s' % self.page_title_without_extension.pk
)
self.assertEqual(response.status_code, 200)
# make sure there is no extension yet
self.assertFalse(MyTitleExtension.objects.filter(extended_object=self.page_title_without_extension).exists())
post_data = {
'extra_title': 'my extra title'
}
self.client.post(
admin_reverse('extensionapp_mytitleextension_add') + '?extended_object=%s' % self.page_title_without_extension.pk,
post_data, follow=True
)
created_title_extension = MyTitleExtension.objects.get(extended_object=self.page_title_without_extension)
# can delete extension
self.client.post(
admin_reverse('extensionapp_mytitleextension_delete', args=(created_title_extension.pk,)),
{'post': 'yes'}, follow=True
)
self.assertFalse(MyTitleExtension.objects.filter(extended_object=self.page_title_without_extension).exists())
# accessing the add view on a page that already has an extension should redirect
response = self.client.get(
admin_reverse('extensionapp_mytitleextension_add') + '?extended_object=%s' % self.page_title.pk
)
self.assertRedirects(response, admin_reverse('extensionapp_mytitleextension_change', args=(self.title_extension.pk,)))
# saving an extension should work without the GET parameter
post_data = {
'extra_title': 'my extra text'
}
self.client.post(
admin_reverse('extensionapp_mytitleextension_change', args=(self.title_extension.pk,)),
post_data, follow=True
)
self.assertTrue(MyTitleExtension.objects.filter(extra_title='my extra text', pk=self.title_extension.pk).exists())
with self.login_user_context(self.no_page_permission_user):
# can't save if user does not have permissions to change the page
post_data = {
'extra_title': 'try to change extra text'
}
response = self.client.post(
admin_reverse('extensionapp_mytitleextension_change', args=(self.title_extension.pk,)),
post_data, follow=True
)
self.assertEqual(response.status_code, 403)
# can't delete without page permission
response = self.client.post(
admin_reverse('extensionapp_mytitleextension_delete', args=(self.title_extension.pk,)),
{'post': 'yes'}, follow=True
)
self.assertEqual(response.status_code, 403)
self.assertTrue(MyTitleExtension.objects.filter(extended_object=self.page_title).exists())
def populate(self):
if not self.is_current_app:
return
menu = self.toolbar.get_or_create_menu('resource-app', _('Resources'))
menu.add_sideframe_item(
name=_('Resource list'),
url=admin_reverse('resources_resource_changelist'),
)
menu.add_modal_item(
name=_('Add new resource'),
url=admin_reverse('resources_resource_add'),
)
def populate(self):
if not self.is_current_app:
return
menu = self.toolbar.get_or_create_menu('poll-app', _('Polls'))
menu.add_sideframe_item(
name=_('Poll list'),
url=admin_reverse('polls_poll_changelist'),
)
menu.add_modal_item(
name=_('Add new poll'),
url=admin_reverse('polls_poll_add'),
)
def test_edit_ph(self):
"""
Test editing a *NON PAGE* plugin
"""
page, placeholder, superuser, staff = self.get_data()
plugin = add_plugin(placeholder, 'TextPlugin', 'en', body='body')
url = admin_reverse('placeholderapp_example1_edit_plugin', args=(plugin.pk,))
plugin_data = {
'body': 'newbody',
'language': 'en',
'plugin_id': plugin.pk,
}
plugin = self.reload(plugin)
self.assertEqual(plugin.body, 'body')
# log the user out and try to edit a plugin using PlaceholderAdmin
self.client.logout()
response = self.client.post(url, plugin_data)
# since the user is not logged in, they should be prompted to log in.
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, '/en/admin/login/?next=%s' % url)
plugin = self.reload(plugin)
self.assertEqual(plugin.body, 'body')
# now log a staff user without permissions in and do the same as above.
self.client.login(username=getattr(staff, get_user_model().USERNAME_FIELD),
password=getattr(staff, get_user_model().USERNAME_FIELD))
response = self.client.post(url, plugin_data)
# the user is logged in and the security check fails, so it should 403.
self.assertEqual(response.status_code, 403)
plugin = self.reload(plugin)
self.assertEqual(plugin.body, 'body')
def add_logout_button(self, parent):
# If current page is not published or has view restrictions user is redirected to the home page:
# * published page: no redirect
# * unpublished page: redirect to the home page
# * published page with login_required: redirect to the home page
# * published page with view permissions: redirect to the home page
if (self.page and self.page.is_published(self.current_lang) and not self.page.login_required and
page_permissions.user_can_view_page(AnonymousUser(), page=self.page)):
on_success = self.toolbar.REFRESH_PAGE
else:
on_success = '/'
# We'll show "Logout Joe Bloggs" if the name fields in auth.User are completed, else "Logout jbloggs". If
# anything goes wrong, it'll just be "Logout".
user_name = self.get_username()
logout_menu_text = _('Logout %s') % user_name if user_name else _('Logout')
parent.add_ajax_item(
logout_menu_text,
action=admin_reverse('logout'),
active=True,
on_success=on_success,
method='GET',
)
def test_user_in_admin_index(self):
endpoint = admin_reverse('app_list', args=['cms'])
staff_user = self.get_staff_user_with_no_permissions()
self.add_permission(staff_user, 'change_pageuser')
self.add_page_permission(
staff_user,
self._permissions_page,
can_change_permissions=True,
)
with self.login_user_context(staff_user):
response = self.client.get(endpoint)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'<a href="/en/admin/cms/pageuser/">Users (page)</a>',
html=True,
)
endpoint = self.get_admin_url(PageUser, 'changelist')
with self.login_user_context(staff_user):
response = self.client.get(endpoint)
self.assertEqual(response.status_code, 200)
def test_user_cant_change_others_group(self):
"""
User cant change a group created by another user,
even with can_change_permissions set to True.
"""
admin = self.get_superuser()
group = self._get_group(created_by=admin)
staff_user = self.get_staff_user_with_no_permissions()
endpoint = self.get_admin_url(PageUserGroup, 'change', group.pk)
redirect_to = admin_reverse('index')
data = model_to_dict(group)
data['_continue'] = '1'
data['name'] = 'New test group'
self.add_permission(staff_user, 'change_pageusergroup')
self.add_page_permission(
staff_user,
self._permissions_page,
can_change_permissions=True,
)
with self.login_user_context(staff_user):
response = self.client.post(endpoint, data)
# Since Django 1.11 404 results in redirect to the admin home
if DJANGO_1_10:
self.assertEqual(response.status_code, 404)
else:
self.assertRedirects(response, redirect_to)
msgs = CookieStorage(response)._decode(response.cookies['messages'].value)
self.assertTrue(msgs[0], PageUserGroup._meta.verbose_name)
self.assertTrue(msgs[0], 'ID "%s"' % group.pk)
self.assertFalse(self._group_exists('New test group'))
def add_view(self, request, form_url='', extra_context=None):
"""
This is a special case add view for the Text Plugin. Plugins should
never have to create an instance on a GET request, but unfortunately
the way the Text Plugin works (allowing child plugins on add), there is
no way around here.
If you're reading this code to learn how to write your own CMS Plugin,
please read another plugin as you should not do what this plugin does.
"""
if not hasattr(self, 'add_view_check_request'):
# pre 3.1 compatiblity
return super(TextPlugin, self).add_view(
request, form_url, extra_context
)
result = self.add_view_check_request(request)
if isinstance(result, HttpResponse):
return result
text = Text.objects.create(
language=request.GET['plugin_language'],
placeholder_id=request.GET['placeholder_id'],
parent_id = request.GET.get(
'plugin_parent', None
),
plugin_type='TextPlugin',
body=''
)
return HttpResponseRedirect(
admin_reverse('cms_page_edit_plugin', args=(text.pk,))
)
def add_publish_button(self, classes=('cms_btn-action', 'cms_btn-publish',)):
# only do dirty lookups if publish permission is granted else button isn't added anyway
if self.toolbar.edit_mode and self.has_publish_permission():
classes = list(classes or [])
pk = self.page.pk if self.page else 0
dirty = (bool(self.dirty_statics) or
(self.page and (self.page.is_dirty(self.current_lang) or
self.page_is_pending(self.page, self.current_lang))))
if dirty:
classes.append('cms_btn-publish-active')
if self.dirty_statics or (self.page and self.page.is_published(self.current_lang)):
title = _('Publish changes')
else:
title = _('Publish page now')
classes.append('cms_publish-page')
params = {}
if self.dirty_statics:
params['statics'] = ','.join(str(sp.pk) for sp in self.dirty_statics)
if self.in_apphook():
params['redirect'] = self.request.path_info
with force_language(self.current_lang):
url = admin_reverse('cms_page_publish_page', args=(pk, self.current_lang))
url = add_url_parameters(url, params)
self.toolbar.add_button(title, url=url, extra_classes=classes,
side=self.toolbar.RIGHT, disabled=not dirty)
def get_module_url(module_):
return admin_reverse('cms_modules_list') + '#cms-plugin-{}'.format(
module_.pk)
def get_category_list_endpoint(self):
return admin_reverse(CATEGORY_LIST_URL_NAME)
def response_post_save_change(self, request, obj):
post_url = admin_reverse('index', current_app=self.admin_site.name)
return HttpResponseRedirect(post_url)
def get_create_alias_endpoint(self):
return admin_reverse(CREATE_ALIAS_URL_NAME)
def populate(self):
user = getattr(self.request, 'user', None)
try:
view_name = self.request.resolver_match.view_name
except AttributeError:
view_name = None
if user and view_name:
language = get_language_from_request(self.request, check_path=True)
group = person = None
if view_name == 'aldryn_people:group-detail':
group = get_obj_from_request(Group, self.request)
elif view_name in [
'aldryn_people:person-detail',
'aldryn_people:download_vcard'
]:
person = get_obj_from_request(Person, self.request)
if person and person.groups:
group = person.primary_group
elif view_name in [
'aldryn_people:group-list',
]:
pass
else:
# We don't appear to be on any aldryn_people views so this
# menu shouldn't even be here.
return
menu = self.toolbar.get_or_create_menu('people-app', "People")
change_group_perm = user.has_perm('aldryn_people.change_group')
add_group_perm = user.has_perm('aldryn_people.add_group')
group_perms = [change_group_perm, add_group_perm]
change_person_perm = user.has_perm('aldryn_people.change_person')
add_person_perm = user.has_perm('aldryn_people.add_person')
person_perms = [change_person_perm, add_person_perm]
if change_group_perm:
url = admin_reverse('aldryn_people_group_changelist')
menu.add_sideframe_item(_('Group list'), url=url)
if add_group_perm:
url_args = {}
if language:
url_args.update({"language": language})
url = get_admin_url('aldryn_people_group_add', **url_args)
menu.add_modal_item(_('Add new group'), url=url)
if change_group_perm and group:
url = get_admin_url('aldryn_people_group_change', [
group.pk,
])
menu.add_modal_item(_('Edit group'), url=url, active=True)
if any(group_perms) and any(person_perms):
menu.add_break()
if change_person_perm:
url = admin_reverse('aldryn_people_person_changelist')
menu.add_sideframe_item(_('Person list'), url=url)
if add_person_perm:
url_args = {}
if group:
url_args['groups'] = group.pk
if language:
url_args['language'] = language
url = get_admin_url('aldryn_people_person_add', **url_args)
menu.add_modal_item(_('Add new person'), url=url)
if change_person_perm and person:
url = admin_reverse('aldryn_people_person_change',
args=(person.pk, ))
menu.add_modal_item(_('Edit person'), url=url, active=True)
def change_language_menu(self):
if self.toolbar.edit_mode_active and isinstance(
self.toolbar.obj, AliasContent):
can_change = self.request.user.has_perm(
get_model_permission_codename(Alias, 'change'), )
else:
can_change = False
if can_change:
alias_content = self.toolbar.obj
language_menu = self.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
if not language_menu:
return None
languages = get_language_dict(self.current_site.pk)
current_placeholder = alias_content.placeholder
remove = [(code, languages.get(code, code))
for code in alias_content.alias.get_languages()
if code in languages]
add = [code for code in languages.items() if code not in remove]
copy = [(code, name) for code, name in languages.items()
if code != self.current_lang and (
code, name) in remove and current_placeholder]
if add or remove or copy:
language_menu.add_break(ALIAS_LANGUAGE_BREAK)
if add:
add_plugins_menu = language_menu.get_or_create_menu(
'{0}-add'.format(LANGUAGE_MENU_IDENTIFIER),
_('Add Translation'),
)
add_url = admin_reverse('djangocms_alias_aliascontent_add')
for code, name in add:
url = add_url_parameters(add_url,
language=code,
alias=alias_content.alias_id)
add_plugins_menu.add_modal_item(name, url=url)
if remove:
remove_plugins_menu = language_menu.get_or_create_menu(
'{0}-del'.format(LANGUAGE_MENU_IDENTIFIER),
_('Delete Translation'),
)
disabled = len(remove) == 1
for code, name in remove:
alias_content = alias_content.alias.get_content(
language=code,
show_draft_content=True,
)
translation_delete_url = admin_reverse(
'djangocms_alias_aliascontent_delete',
args=(alias_content.pk, ),
)
url = add_url_parameters(translation_delete_url,
language=code)
remove_plugins_menu.add_modal_item(name,
url=url,
disabled=disabled)
if copy:
copy_plugins_menu = language_menu.get_or_create_menu(
'{0}-copy'.format(LANGUAGE_MENU_IDENTIFIER),
_('Copy all plugins'))
title = _('from %s')
question = _(
'Are you sure you want to copy all plugins from %s?')
try:
copy_url = admin_reverse('cms_placeholder_copy_plugins')
except NoReverseMatch:
copy_url = admin_reverse(
'djangocms_alias_alias_copy_plugins')
for code, name in copy:
source_placeholder = alias_content.alias.get_placeholder(
language=code,
show_draft_content=True,
)
copy_plugins_menu.add_ajax_item(
title % name,
action=copy_url,
data={
'source_language': code,
'source_placeholder_id': source_placeholder.pk,
'target_language': self.current_lang,
'target_placeholder_id': current_placeholder.pk,
},
question=question % name,
on_success=self.toolbar.REFRESH_PAGE)
def add_view(self, request, form_url='', extra_context=None):
if 'plugin' in request.GET:
# CMS >= 3.4 compatibility
self.cms_plugin_instance = self._get_plugin_or_404(
request.GET['plugin'])
if getattr(self, 'cms_plugin_instance', None):
# This can happen if the user did not properly cancel the plugin
# and so a "ghost" plugin instance is left over.
# The instance is a record that points to the Text plugin
# but is not a real text plugin instance.
return super().add_view(request, form_url, extra_context)
if not self.has_add_permission(request):
# this permission check is done by Django on the normal
# workflow of adding a plugin.
# This is NOT the normal workflow because we create a plugin
# on GET request to the /add/ endpoint and so we bypass
# django's add_view, thus bypassing permission check.
message = gettext('You do not have permission to add a plugin.')
return HttpResponseForbidden(force_text(message))
try:
# CMS 3.3 compatibility
data = self.validate_add_request(request)
except AttributeError:
# CMS >= 3.4 compatibility
_data = self._cms_initial_attributes
data = {
'plugin_language': _data['language'],
'placeholder_id': _data['placeholder'],
'parent': _data['parent'],
'position': _data['position'],
'plugin_type': _data['plugin_type'],
'plugin_parent': _data['parent'],
}
except PermissionDenied:
message = gettext('You do not have permission to add a plugin.')
return HttpResponseForbidden(force_text(message))
except ValidationError as error:
return HttpResponseBadRequest(error.message)
# Sadly we have to create the CMSPlugin record on add GET request
# because we need this record in order to allow the user to add
# child plugins to the text (image, link, etc..)
plugin = CMSPlugin.objects.create(
language=data['plugin_language'],
plugin_type=data['plugin_type'],
position=data['position'],
placeholder=data['placeholder_id'],
parent=data.get('plugin_parent'),
)
query = request.GET.copy()
query['plugin'] = str(plugin.pk)
success_url = admin_reverse('cms_page_add_plugin')
# Because we've created the cmsplugin record
# we need to delete the plugin when a user cancels.
success_url += '?delete-on-cancel&' + query.urlencode()
return HttpResponseRedirect(success_url)
def delete_plugin(self, request, plugin_id):
plugin = self._get_plugin_from_id(plugin_id)
if not self.has_delete_plugin_permission(request, plugin):
return HttpResponseForbidden(force_str(
_("You do not have permission to delete this plugin")))
opts = plugin._meta
router.db_for_write(opts.model)
get_deleted_objects_additional_kwargs = {'request': request}
deleted_objects, __, perms_needed, protected = get_deleted_objects(
[plugin], admin_site=self.admin_site,
**get_deleted_objects_additional_kwargs
)
if request.POST: # The user has already confirmed the deletion.
if perms_needed:
raise PermissionDenied(_("You do not have permission to delete this plugin"))
obj_display = force_str(plugin)
placeholder = plugin.placeholder
plugin_tree_order = placeholder.get_plugin_tree_order(
language=plugin.language,
parent_id=plugin.parent_id,
)
operation_token = self._send_pre_placeholder_operation(
request,
operation=operations.DELETE_PLUGIN,
plugin=plugin,
placeholder=placeholder,
tree_order=plugin_tree_order,
)
plugin.delete()
placeholder.mark_as_dirty(plugin.language, clear_cache=False)
reorder_plugins(
placeholder=placeholder,
parent_id=plugin.parent_id,
language=plugin.language,
)
self.log_deletion(request, plugin, obj_display)
self.message_user(request, _('The %(name)s plugin "%(obj)s" was deleted successfully.') % {
'name': force_str(opts.verbose_name), 'obj': force_str(obj_display)})
# Avoid query by removing the plugin being deleted
# from the tree order list
new_plugin_tree_order = list(plugin_tree_order)
new_plugin_tree_order.remove(plugin.pk)
self._send_post_placeholder_operation(
request,
operation=operations.DELETE_PLUGIN,
token=operation_token,
plugin=plugin,
placeholder=placeholder,
tree_order=new_plugin_tree_order,
)
return HttpResponseRedirect(admin_reverse('index', current_app=self.admin_site.name))
plugin_name = force_str(plugin.get_plugin_class().name)
if perms_needed or protected:
title = _("Cannot delete %(name)s") % {"name": plugin_name}
else:
title = _("Are you sure?")
context = {
"title": title,
"object_name": plugin_name,
"object": plugin,
"deleted_objects": deleted_objects,
"perms_lacking": perms_needed,
"protected": protected,
"opts": opts,
"app_label": opts.app_label,
}
request.current_app = self.admin_site.name
return TemplateResponse(
request, "admin/cms/page/plugin/delete_confirmation.html", context
)
def clear_placeholder(self, request, placeholder_id):
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
language = request.GET.get('language')
if placeholder.pk == request.toolbar.clipboard.pk:
# User is clearing the clipboard, no need for permission
# checks here as the clipboard is unique per user.
# There could be a case where a plugin has relationship to
# an object the user does not have permission to delete.
placeholder.clear(language)
return HttpResponseRedirect(admin_reverse('index', current_app=self.admin_site.name))
if not self.has_clear_placeholder_permission(request, placeholder, language):
return HttpResponseForbidden(force_str(_("You do not have permission to clear this placeholder")))
opts = Placeholder._meta
router.db_for_write(Placeholder)
plugins = placeholder.get_plugins_list(language)
get_deleted_objects_additional_kwargs = {'request': request}
deleted_objects, __, perms_needed, protected = get_deleted_objects(
plugins, admin_site=self.admin_site,
**get_deleted_objects_additional_kwargs
)
obj_display = force_str(placeholder)
if request.POST:
# The user has already confirmed the deletion.
if perms_needed:
return HttpResponseForbidden(force_str(_("You do not have permission to clear this placeholder")))
operation_token = self._send_pre_placeholder_operation(
request,
operation=operations.CLEAR_PLACEHOLDER,
plugins=plugins,
placeholder=placeholder,
)
placeholder.clear(language)
placeholder.mark_as_dirty(language, clear_cache=False)
self.log_deletion(request, placeholder, obj_display)
self.message_user(request, _('The placeholder "%(obj)s" was cleared successfully.') % {
'obj': obj_display})
self._send_post_placeholder_operation(
request,
operation=operations.CLEAR_PLACEHOLDER,
token=operation_token,
plugins=plugins,
placeholder=placeholder,
)
return HttpResponseRedirect(admin_reverse('index', current_app=self.admin_site.name))
if perms_needed or protected:
title = _("Cannot delete %(name)s") % {"name": obj_display}
else:
title = _("Are you sure?")
context = {
"title": title,
"object_name": _("placeholder"),
"object": placeholder,
"deleted_objects": deleted_objects,
"perms_lacking": perms_needed,
"protected": protected,
"opts": opts,
"app_label": opts.app_label,
}
request.current_app = self.admin_site.name
return TemplateResponse(request, "admin/cms/page/plugin/delete_confirmation.html", context)
def change_language_menu(self):
if self.toolbar.edit_mode_active and self.page:
can_change = page_permissions.user_can_change_page(
user=self.request.user,
page=self.page,
site=self.current_site,
)
else:
can_change = False
if can_change:
language_menu = self.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
if not language_menu:
return None
languages = get_language_dict(self.current_site.pk)
remove = [(code, languages.get(code, code))
for code in self.page.get_languages()
if code in languages]
add = [l for l in languages.items() if l not in remove]
copy = [(code, name) for code, name in languages.items()
if code != self.current_lang and (code, name) in remove]
if add or remove or copy:
language_menu.add_break(ADD_PAGE_LANGUAGE_BREAK)
if add:
add_plugins_menu = language_menu.get_or_create_menu(
'{0}-add'.format(LANGUAGE_MENU_IDENTIFIER),
_('Add Translation'))
if self.page.is_page_type:
page_change_url = admin_reverse('cms_pagetype_change',
args=(self.page.pk, ))
else:
page_change_url = admin_reverse('cms_page_change',
args=(self.page.pk, ))
for code, name in add:
url = add_url_parameters(page_change_url, language=code)
add_plugins_menu.add_modal_item(name, url=url)
if remove:
if self.page.is_page_type:
translation_delete_url = admin_reverse(
'cms_pagetype_delete_translation',
args=(self.page.pk, ))
else:
translation_delete_url = admin_reverse(
'cms_page_delete_translation', args=(self.page.pk, ))
remove_plugins_menu = language_menu.get_or_create_menu(
'{0}-del'.format(LANGUAGE_MENU_IDENTIFIER),
_('Delete Translation'))
disabled = len(remove) == 1
for code, name in remove:
url = add_url_parameters(translation_delete_url,
language=code)
remove_plugins_menu.add_modal_item(name,
url=url,
disabled=disabled)
if copy:
copy_plugins_menu = language_menu.get_or_create_menu(
'{0}-copy'.format(LANGUAGE_MENU_IDENTIFIER),
_('Copy all plugins'))
title = _('from %s')
question = _(
'Are you sure you want to copy all plugins from %s?')
if self.page.is_page_type:
page_copy_url = admin_reverse('cms_pagetype_copy_language',
args=(self.page.pk, ))
else:
page_copy_url = admin_reverse('cms_page_copy_language',
args=(self.page.pk, ))
for code, name in copy:
copy_plugins_menu.add_ajax_item(
title % name,
action=page_copy_url,
data={
'source_language': code,
'target_language': self.current_lang
},
question=question % name,
on_success=self.toolbar.REFRESH_PAGE)
def add_admin_menu(self):
if not self._admin_menu:
self._admin_menu = self.toolbar.get_or_create_menu(
ADMIN_MENU_IDENTIFIER, self.current_site.name)
# Users button
self.add_users_button(self._admin_menu)
# sites menu
sites_queryset = Site.objects.order_by('name')
if len(sites_queryset) > 1:
sites_menu = self._admin_menu.get_or_create_menu(
'sites', _('Sites'))
sites_menu.add_sideframe_item(
_('Admin Sites'),
url=admin_reverse('sites_site_changelist'))
sites_menu.add_break(ADMIN_SITES_BREAK)
for site in sites_queryset:
sites_menu.add_link_item(
site.name,
url='http://%s' % site.domain,
active=site.pk == self.current_site.pk)
# admin
self._admin_menu.add_sideframe_item(_('Administration'),
url=admin_reverse('index'))
self._admin_menu.add_break(ADMINISTRATION_BREAK)
# cms users settings
self._admin_menu.add_sideframe_item(
_('User settings'),
url=admin_reverse('cms_usersettings_change'))
self._admin_menu.add_break(USER_SETTINGS_BREAK)
# clipboard
if self.toolbar.edit_mode_active:
# True if the clipboard exists and there's plugins in it.
clipboard_is_bound = self.toolbar.clipboard_plugin
self._admin_menu.add_link_item(
_('Clipboard...'),
url='#',
extra_classes=['cms-clipboard-trigger'],
disabled=not clipboard_is_bound)
self._admin_menu.add_link_item(
_('Clear clipboard'),
url='#',
extra_classes=['cms-clipboard-empty'],
disabled=not clipboard_is_bound)
self._admin_menu.add_break(CLIPBOARD_BREAK)
# Disable toolbar
self._admin_menu.add_link_item(
_('Disable toolbar'),
url='?%s' % get_cms_setting('CMS_TOOLBAR_URL__DISABLE'))
self._admin_menu.add_break(TOOLBAR_DISABLE_BREAK)
self._admin_menu.add_link_item(
_('Shortcuts...'),
url='#',
extra_classes=('cms-show-shortcuts', ))
self._admin_menu.add_break(SHORTCUTS_BREAK)
# logout
self.add_logout_button(self._admin_menu)
def get_module_add_url(module_):
return admin_reverse('cms_add_module', args=[module_.pk])
def get_list_aliases_endpoint(self, category_pk):
return admin_reverse(
LIST_ALIASES_URL_NAME,
args=[category_pk],
)
def get_admin_url(name, language, args):
with force_language(language):
return admin_reverse(name, args=args)
def test_publish_missing_page(self):
superuser = self.get_superuser()
with self.login_user_context(superuser):
response = self.client.post(
admin_reverse("cms_page_publish_page", args=[999999, 'en']))
self.assertEqual(response.status_code, 404)
def test_admin_title_extension(self):
with self.login_user_context(self.admin):
# add a new extension
response = self.client.get(
admin_reverse('extensionapp_mytitleextension_add') +
'?extended_object=%s' % self.page_title_without_extension.pk)
self.assertEqual(response.status_code, 200)
# make sure there is no extension yet
self.assertFalse(
MyTitleExtension.objects.filter(
extended_object=self.page_title_without_extension).exists(
))
post_data = {'extra_title': 'my extra title'}
self.client.post(
admin_reverse('extensionapp_mytitleextension_add') +
'?extended_object=%s' % self.page_title_without_extension.pk,
post_data,
follow=True)
created_title_extension = MyTitleExtension.objects.get(
extended_object=self.page_title_without_extension)
# can delete extension
self.client.post(admin_reverse(
'extensionapp_mytitleextension_delete',
args=(created_title_extension.pk, )), {'post': 'yes'},
follow=True)
self.assertFalse(
MyTitleExtension.objects.filter(
extended_object=self.page_title_without_extension).exists(
))
# accessing the add view on a page that already has an extension should redirect
response = self.client.get(
admin_reverse('extensionapp_mytitleextension_add') +
'?extended_object=%s' % self.page_title.pk)
self.assertRedirects(
response,
admin_reverse('extensionapp_mytitleextension_change',
args=(self.title_extension.pk, )))
# saving an extension should work without the GET parameter
post_data = {'extra_title': 'my extra text'}
self.client.post(admin_reverse(
'extensionapp_mytitleextension_change',
args=(self.title_extension.pk, )),
post_data,
follow=True)
self.assertTrue(
MyTitleExtension.objects.filter(
extra_title='my extra text',
pk=self.title_extension.pk).exists())
with self.login_user_context(self.no_page_permission_user):
# can't save if user does not have permissions to change the page
post_data = {'extra_title': 'try to change extra text'}
response = self.client.post(admin_reverse(
'extensionapp_mytitleextension_change',
args=(self.title_extension.pk, )),
post_data,
follow=True)
self.assertEqual(response.status_code, 403)
# can't delete without page permission
response = self.client.post(admin_reverse(
'extensionapp_mytitleextension_delete',
args=(self.title_extension.pk, )), {'post': 'yes'},
follow=True)
self.assertEqual(response.status_code, 403)
self.assertTrue(
MyTitleExtension.objects.filter(
extended_object=self.page_title).exists())
def add_page_menu(self):
if self.page and self.has_page_change_permission():
edit_mode = self.toolbar.edit_mode
refresh = self.toolbar.REFRESH_PAGE
# menu for current page
current_page_menu = self.toolbar.get_or_create_menu(
PAGE_MENU_IDENTIFIER, _('Page'), position=1)
# page operations menu
add_page_menu = current_page_menu.get_or_create_menu(
PAGE_MENU_ADD_IDENTIFIER, _('Add Page'))
app_page_url = admin_reverse('cms_page_add')
add_page_menu_modal_items = ((_('New Page'), {
'edit': 1,
'position': 'last-child',
'target': self.page.parent_id or ''
}), (_('New Sub Page'), {
'edit': 1,
'position': 'last-child',
'target': self.page.pk
}), (_('Duplicate this Page'), {
'copy_target': self.page.pk
}))
for title, params in add_page_menu_modal_items:
params.update(language=self.toolbar.language)
add_page_menu.add_modal_item(title,
url=add_url_parameters(
app_page_url, params))
# first break
current_page_menu.add_break(PAGE_MENU_FIRST_BREAK)
# page edit
page_edit_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
current_page_menu.add_link_item(_('Edit this Page'),
disabled=edit_mode,
url=page_edit_url)
# page settings
page_settings_url = admin_reverse('cms_page_change',
args=(self.page.pk, ))
page_settings_url = add_url_parameters(
page_settings_url, language=self.toolbar.language)
current_page_menu.add_modal_item(_('Page settings'),
url=page_settings_url,
disabled=not edit_mode,
on_close=refresh)
# templates menu
if self.toolbar.build_mode or edit_mode:
templates_menu = current_page_menu.get_or_create_menu(
'templates', _('Templates'))
action = admin_reverse('cms_page_change_template',
args=(self.page.pk, ))
for path, name in get_cms_setting('TEMPLATES'):
active = self.page.template == path
if path == TEMPLATE_INHERITANCE_MAGIC:
templates_menu.add_break(TEMPLATE_MENU_BREAK)
templates_menu.add_ajax_item(name,
action=action,
data={'template': path},
active=active,
on_success=refresh)
# second break
current_page_menu.add_break(PAGE_MENU_SECOND_BREAK)
# advanced settings
advanced_url = admin_reverse('cms_page_advanced',
args=(self.page.pk, ))
advanced_url = add_url_parameters(advanced_url,
language=self.toolbar.language)
advanced_disabled = not self.page.has_advanced_settings_permission(
self.request) or not edit_mode
current_page_menu.add_modal_item(_('Advanced settings'),
url=advanced_url,
disabled=advanced_disabled)
# permissions
if self.permissions_activated:
permissions_url = admin_reverse('cms_page_permissions',
args=(self.page.pk, ))
permission_disabled = not edit_mode or not self.page.has_change_permissions_permission(
self.request)
current_page_menu.add_modal_item(_('Permissions'),
url=permissions_url,
disabled=permission_disabled)
# dates settings
dates_url = admin_reverse('cms_page_dates', args=(self.page.pk, ))
current_page_menu.add_modal_item(_('Publishing dates'),
url=dates_url,
disabled=not edit_mode)
# third break
current_page_menu.add_break(PAGE_MENU_THIRD_BREAK)
# navigation toggle
nav_title = _(
'Hide in navigation') if self.page.in_navigation else _(
'Display in navigation')
nav_action = admin_reverse('cms_page_change_innavigation',
args=(self.page.pk, ))
current_page_menu.add_ajax_item(nav_title,
action=nav_action,
disabled=not edit_mode,
on_success=refresh)
# publisher
if self.title:
if self.title.published:
publish_title = _('Unpublish page')
publish_url = admin_reverse('cms_page_unpublish',
args=(self.page.pk,
self.current_lang))
else:
publish_title = _('Publish page')
publish_url = admin_reverse('cms_page_publish_page',
args=(self.page.pk,
self.current_lang))
current_page_menu.add_ajax_item(publish_title,
action=publish_url,
disabled=not edit_mode,
on_success=refresh)
# fourth break
current_page_menu.add_break(PAGE_MENU_FOURTH_BREAK)
# delete
delete_url = admin_reverse('cms_page_delete',
args=(self.page.pk, ))
on_delete_redirect_url = self.get_on_delete_redirect_url()
current_page_menu.add_modal_item(_('Delete page'),
url=delete_url,
on_close=on_delete_redirect_url,
disabled=not edit_mode)
# last break
current_page_menu.add_break(PAGE_MENU_LAST_BREAK)
# page type
page_type_url = admin_reverse('cms_page_add_page_type')
page_type_url = add_url_parameters(page_type_url,
copy_target=self.page.pk,
language=self.toolbar.language)
current_page_menu.add_modal_item(_('Save as Page Type'),
page_type_url,
disabled=not edit_mode)
def get_detach_alias_plugin_endpoint(self, plugin_pk):
return admin_reverse(
DETACH_ALIAS_PLUGIN_URL_NAME,
args=[plugin_pk],
)
def populate(self):
if not self.is_current_app:
return
#Menus Portfolio
menu = self.toolbar.get_or_create_menu(
'portfolio_cms_integration-portfolio', # a unique key for this menu
'Portfolio', # the text that should appear in the menu
)
menu.add_sideframe_item(
name='Portfolio list', # name of the new menu item
url=admin_reverse(
'portfolio_app_portfolio_changelist'
), # the URL it should open with appname_model_name_changelist
)
menu.add_modal_item(
name='Add a new portfolio', # name of the new menu item
url=admin_reverse(
'portfolio_app_portfolio_add'), # the URL it should open with
)
#Buttons Portfolio
buttonlist = self.toolbar.add_button_list()
buttonlist.add_sideframe_button(
name='Portfolio list',
url=admin_reverse('portfolio_app_portfolio_changelist'),
)
buttonlist.add_modal_button(
name='Add a new portfolio',
url=admin_reverse('portfolio_app_portfolio_add'),
)
# Menus Project
project = self.toolbar.get_or_create_menu(
'portfolio_cms_integration-project', # a unique key for this menu
'Project', # the text that should appear in the menu
)
project.add_modal_item(
name='Project list', # name of the new menu item
url=admin_reverse(
'portfolio_app_project_changelist'
), # the URL it should open with appname_model_name_changelist
)
project.add_modal_item(
name='Add a new Project', # name of the new menu item
url=admin_reverse(
'portfolio_app_project_add'), # the URL it should open with
)
# Menus Blog
blog = self.toolbar.get_or_create_menu(
'portfolio_cms_integration-blog', # a unique key for this menu
'Blog', # the text that should appear in the menu
)
blog.add_modal_item(
name='Blog list', # name of the new menu item
url=admin_reverse(
'portfolio_app_blog_changelist'
), # the URL it should open with appname_model_name_changelist
)
blog.add_modal_item(
name='Add a new Blog', # name of the new menu item
url=admin_reverse(
'portfolio_app_blog_add'), # the URL it should open with
)
def get_custom_admin_url(self, plugin_class, name):
plugin_type = plugin_class.__name__.lower()
url_name = '%s_%s_%s' % (plugin_class.model._meta.app_label,
plugin_type, name)
return admin_reverse(url_name)
def get_url(self):
return admin_reverse(SELECT2_ALIAS_URL_NAME)
def get_value(self, context, viewname, args, kwargs):
return admin_reverse(viewname, args=args, kwargs=kwargs)
def setUp(self):
self.select2_endpoint = admin_reverse(SELECT2_CONTENT_OBJECT_URL_NAME)
self.superuser = self.get_superuser()
def add_page_settings_button(self, extra_classes=('cms-btn-action',)):
url = '%s?language=%s' % (admin_reverse('cms_page_change', args=[self.page.pk]), self.toolbar.language)
self.toolbar.add_modal_button(_('Page settings'), url, side=self.toolbar.RIGHT, extra_classes=extra_classes)
def test_view_response_with_invalid_int_menu_content(self):
preview_url = admin_reverse("djangocms_navigation_menuitem_preview",
kwargs={"menu_content_id": 99})
response = self.client.get(preview_url)
self.assertEqual(response.status_code, 404)
def add_page_menu(self):
if self.page and self.has_page_change_permission():
edit_mode = self.toolbar.edit_mode
refresh = self.toolbar.REFRESH_PAGE
# menu for current page
# NOTE: disabled if the current path is "deeper" into the
# application's url patterns than its root. This is because
# when the Content Manager is at the root of the app-hook,
# some of the page options still make sense.
current_page_menu = self.toolbar.get_or_create_menu(
PAGE_MENU_IDENTIFIER, _('Page'), position=1, disabled=self.in_apphook() and not self.in_apphook_root())
# page operations menu
add_page_menu = current_page_menu.get_or_create_menu(PAGE_MENU_ADD_IDENTIFIER, _('Create Page'))
app_page_url = admin_reverse('cms_page_add')
new_page_params = {'edit': 1, 'position': 'last-child'}
if self.page.parent_id:
new_page_params['target'] = self.page.parent_id
add_page_menu_modal_items = (
(_('New Page'), new_page_params),
(_('New Sub Page'), {'edit': 1, 'position': 'last-child', 'target': self.page.pk}),
(_('Duplicate this Page'), {'copy_target': self.page.pk})
)
for title, params in add_page_menu_modal_items:
params.update(language=self.toolbar.language)
add_page_menu.add_modal_item(title, url=add_url_parameters(app_page_url, params))
# first break
current_page_menu.add_break(PAGE_MENU_FIRST_BREAK)
# page edit
page_edit_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
current_page_menu.add_link_item(_('Edit this Page'), disabled=edit_mode, url=page_edit_url)
# page settings
page_settings_url = admin_reverse('cms_page_change', args=(self.page.pk,))
page_settings_url = add_url_parameters(page_settings_url, language=self.toolbar.language)
current_page_menu.add_modal_item(_('Page settings'), url=page_settings_url, disabled=not edit_mode,
on_close=refresh)
# advanced settings
advanced_url = admin_reverse('cms_page_advanced', args=(self.page.pk,))
advanced_url = add_url_parameters(advanced_url, language=self.toolbar.language)
advanced_disabled = not self.page.has_advanced_settings_permission(self.request) or not edit_mode
current_page_menu.add_modal_item(_('Advanced settings'), url=advanced_url, disabled=advanced_disabled)
# templates menu
if self.toolbar.build_mode or edit_mode:
templates_menu = current_page_menu.get_or_create_menu('templates', _('Templates'))
action = admin_reverse('cms_page_change_template', args=(self.page.pk,))
for path, name in get_cms_setting('TEMPLATES'):
active = self.page.template == path
if path == TEMPLATE_INHERITANCE_MAGIC:
templates_menu.add_break(TEMPLATE_MENU_BREAK)
templates_menu.add_ajax_item(name, action=action, data={'template': path}, active=active,
on_success=refresh)
# page type
page_type_url = admin_reverse('cms_page_add_page_type')
page_type_url = add_url_parameters(page_type_url, copy_target=self.page.pk, language=self.toolbar.language)
current_page_menu.add_modal_item(_('Save as Page Type'), page_type_url, disabled=not edit_mode)
# second break
current_page_menu.add_break(PAGE_MENU_SECOND_BREAK)
# permissions
if self.permissions_activated:
permissions_url = admin_reverse('cms_page_permissions', args=(self.page.pk,))
permission_disabled = not edit_mode or not self.page.has_change_permissions_permission(self.request)
current_page_menu.add_modal_item(_('Permissions'), url=permissions_url, disabled=permission_disabled)
# dates settings
dates_url = admin_reverse('cms_page_dates', args=(self.page.pk,))
current_page_menu.add_modal_item(_('Publishing dates'), url=dates_url, disabled=not edit_mode)
# third break
current_page_menu.add_break(PAGE_MENU_THIRD_BREAK)
# navigation toggle
nav_title = _('Hide in navigation') if self.page.in_navigation else _('Display in navigation')
nav_action = admin_reverse('cms_page_change_innavigation', args=(self.page.pk,))
current_page_menu.add_ajax_item(nav_title, action=nav_action, disabled=not edit_mode, on_success=refresh)
# publisher
if self.title:
if self.title.published:
publish_title = _('Unpublish page')
publish_url = admin_reverse('cms_page_unpublish', args=(self.page.pk, self.current_lang))
else:
publish_title = _('Publish page')
publish_url = admin_reverse('cms_page_publish_page', args=(self.page.pk, self.current_lang))
current_page_menu.add_ajax_item(publish_title, action=publish_url, disabled=not edit_mode,
on_success=refresh)
# fourth break
current_page_menu.add_break(PAGE_MENU_FOURTH_BREAK)
history_menu = current_page_menu.get_or_create_menu(HISTORY_MENU_IDENTIFIER, _('History'))
if is_installed('reversion'):
from cms.utils.reversion_hacks import reversion, Revision
versions = reversion.get_for_object(self.page)
if self.page.revision_id:
current_revision = Revision.objects.get(pk=self.page.revision_id)
has_undo = versions.filter(revision__pk__lt=current_revision.pk).exists()
has_redo = versions.filter(revision__pk__gt=current_revision.pk).exists()
else:
has_redo = False
has_undo = versions.count() > 1
undo_action = admin_reverse('cms_page_undo', args=(self.page.pk,))
redo_action = admin_reverse('cms_page_redo', args=(self.page.pk,))
history_menu.add_ajax_item(_('Undo'), action=undo_action, disabled=not has_undo, on_success=refresh)
history_menu.add_ajax_item(_('Redo'), action=redo_action, disabled=not has_redo, on_success=refresh)
history_menu.add_break(HISTORY_MENU_BREAK)
revert_action = admin_reverse('cms_page_revert_page', args=(self.page.pk, self.current_lang))
revert_question = _('Are you sure you want to revert to live?')
is_enabled = self.page.is_dirty(self.current_lang) and self.page.publisher_public
history_menu.add_ajax_item(_('Revert to live'), action=revert_action, question=revert_question,
disabled=not is_enabled,
on_success=refresh, extra_classes=('cms-toolbar-revert',))
history_menu.add_modal_item(_('View history'), url=admin_reverse('cms_page_history', args=(self.page.pk,)))
# last break
current_page_menu.add_break(PAGE_MENU_LAST_BREAK)
# delete
delete_url = admin_reverse('cms_page_delete', args=(self.page.pk,))
on_delete_redirect_url = self.get_on_delete_redirect_url()
current_page_menu.add_modal_item(_('Delete page'), url=delete_url, on_close=on_delete_redirect_url,
disabled=not edit_mode)
def get_admin_url(self, model, action, *args):
opts = model._meta
url_name = "{}_{}_{}".format(opts.app_label, opts.model_name, action)
return admin_reverse(url_name, args=args)
def get_alias_usage_view_url(alias, **kwargs):
url = admin_reverse(USAGE_ALIAS_URL_NAME, args=[alias.pk])
return add_url_parameters(url, **ChainMap(kwargs))
def add_page_menu(self):
if self.page:
edit_mode = self.toolbar.edit_mode_active
refresh = self.toolbar.REFRESH_PAGE
can_change = user_can_change_page(
user=self.request.user,
page=self.page,
site=self.current_site,
)
# menu for current page
# NOTE: disabled if the current path is "deeper" into the
# application's url patterns than its root. This is because
# when the Content Manager is at the root of the app-hook,
# some of the page options still make sense.
current_page_menu = self.toolbar.get_or_create_menu(
PAGE_MENU_IDENTIFIER,
_('Page'),
position=1,
disabled=self.in_apphook() and not self.in_apphook_root())
new_page_params = {'edit': 1}
new_sub_page_params = {'edit': 1, 'parent_node': self.page.node_id}
if self.page.is_page_type:
add_page_url = admin_reverse('cms_pagetype_add')
advanced_url = admin_reverse('cms_pagetype_advanced',
args=(self.page.pk, ))
page_settings_url = admin_reverse('cms_pagetype_change',
args=(self.page.pk, ))
duplicate_page_url = admin_reverse('cms_pagetype_duplicate',
args=[self.page.pk])
else:
add_page_url = admin_reverse('cms_page_add')
advanced_url = admin_reverse('cms_page_advanced',
args=(self.page.pk, ))
page_settings_url = admin_reverse('cms_page_change',
args=(self.page.pk, ))
duplicate_page_url = admin_reverse('cms_page_duplicate',
args=[self.page.pk])
can_add_root_page = page_permissions.user_can_add_page(
user=self.request.user,
site=self.current_site,
)
if self.page.parent_page:
new_page_params['parent_node'] = self.page.parent_page.node_id
can_add_sibling_page = page_permissions.user_can_add_subpage(
user=self.request.user,
target=self.page.parent_page,
)
else:
can_add_sibling_page = can_add_root_page
can_add_sub_page = page_permissions.user_can_add_subpage(
user=self.request.user,
target=self.page,
)
# page operations menu
add_page_menu = current_page_menu.get_or_create_menu(
PAGE_MENU_ADD_IDENTIFIER,
_('Create Page'),
)
add_page_menu_modal_items = (
(_('New Page'), new_page_params, can_add_sibling_page),
(_('New Sub Page'), new_sub_page_params, can_add_sub_page),
)
for title, params, has_perm in add_page_menu_modal_items:
params.update(language=self.toolbar.request_language)
add_page_menu.add_modal_item(
title,
url=add_url_parameters(add_page_url, params),
disabled=not has_perm,
)
add_page_menu.add_modal_item(
_('Duplicate this Page'),
url=add_url_parameters(
duplicate_page_url,
{'language': self.toolbar.request_language}),
disabled=not can_add_sibling_page,
)
# first break
current_page_menu.add_break(PAGE_MENU_FIRST_BREAK)
# page edit
page_edit_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
current_page_menu.add_link_item(_('Edit this Page'),
disabled=edit_mode,
url=page_edit_url)
# page settings
page_settings_url = add_url_parameters(
page_settings_url, language=self.toolbar.request_language)
settings_disabled = not edit_mode or not can_change
current_page_menu.add_modal_item(_('Page settings'),
url=page_settings_url,
disabled=settings_disabled,
on_close=refresh)
# advanced settings
advanced_url = add_url_parameters(
advanced_url, language=self.toolbar.request_language)
can_change_advanced = self.page.has_advanced_settings_permission(
self.request.user)
advanced_disabled = not edit_mode or not can_change_advanced
current_page_menu.add_modal_item(_('Advanced settings'),
url=advanced_url,
disabled=advanced_disabled)
# templates menu
if edit_mode:
if self.page.is_page_type:
action = admin_reverse('cms_pagetype_change_template',
args=(self.page.pk, ))
else:
action = admin_reverse('cms_page_change_template',
args=(self.page.pk, ))
if can_change_advanced:
templates_menu = current_page_menu.get_or_create_menu(
'templates',
_('Templates'),
disabled=not can_change,
)
for path, name in get_cms_setting('TEMPLATES'):
active = self.page.template == path
if path == TEMPLATE_INHERITANCE_MAGIC:
templates_menu.add_break(TEMPLATE_MENU_BREAK)
templates_menu.add_ajax_item(name,
action=action,
data={'template': path},
active=active,
on_success=refresh)
# page type
if not self.page.is_page_type:
page_type_url = admin_reverse('cms_pagetype_add')
page_type_url = add_url_parameters(
page_type_url,
source=self.page.pk,
language=self.toolbar.request_language)
page_type_disabled = not edit_mode or not can_add_root_page
current_page_menu.add_modal_item(_('Save as Page Type'),
page_type_url,
disabled=page_type_disabled)
# second break
current_page_menu.add_break(PAGE_MENU_SECOND_BREAK)
# permissions
if self.permissions_activated:
permissions_url = admin_reverse('cms_page_permissions',
args=(self.page.pk, ))
permission_disabled = not edit_mode
if not permission_disabled:
permission_disabled = not page_permissions.user_can_change_page_permissions(
user=self.request.user,
page=self.page,
)
current_page_menu.add_modal_item(_('Permissions'),
url=permissions_url,
disabled=permission_disabled)
if not self.page.is_page_type:
# dates settings
dates_url = admin_reverse('cms_page_dates',
args=(self.page.pk, ))
current_page_menu.add_modal_item(
_('Publishing dates'),
url=dates_url,
disabled=(not edit_mode or not can_change),
)
# third break
current_page_menu.add_break(PAGE_MENU_THIRD_BREAK)
# navigation toggle
nav_title = _(
'Hide in navigation') if self.page.in_navigation else _(
'Display in navigation')
nav_action = admin_reverse('cms_page_change_innavigation',
args=(self.page.pk, ))
current_page_menu.add_ajax_item(
nav_title,
action=nav_action,
disabled=(not edit_mode or not can_change),
on_success=refresh,
)
# publisher
if self.title and not self.page.is_page_type:
if self.title.published:
publish_title = _('Unpublish page')
publish_url = admin_reverse('cms_page_unpublish',
args=(self.page.pk,
self.current_lang))
else:
publish_title = _('Publish page')
publish_url = admin_reverse('cms_page_publish_page',
args=(self.page.pk,
self.current_lang))
user_can_publish = user_can_publish_page(self.request.user,
page=self.page)
current_page_menu.add_ajax_item(
publish_title,
action=publish_url,
disabled=not edit_mode or not user_can_publish,
on_success=refresh,
)
if self.current_lang and not self.page.is_page_type:
# revert to live
current_page_menu.add_break(PAGE_MENU_FOURTH_BREAK)
revert_action = admin_reverse('cms_page_revert_to_live',
args=(self.page.pk,
self.current_lang))
revert_question = _('Are you sure you want to revert to live?')
# Only show this action if the page has pending changes and a public version
is_enabled = (edit_mode and can_change
and self.page.is_dirty(self.current_lang)
and self.page.publisher_public)
current_page_menu.add_ajax_item(
_('Revert to live'),
action=revert_action,
question=revert_question,
disabled=not is_enabled,
on_success=refresh,
extra_classes=('cms-toolbar-revert', ),
)
# last break
current_page_menu.add_break(PAGE_MENU_LAST_BREAK)
# delete
if self.page.is_page_type:
delete_url = admin_reverse('cms_pagetype_delete',
args=(self.page.pk, ))
else:
delete_url = admin_reverse('cms_page_delete',
args=(self.page.pk, ))
delete_disabled = not edit_mode or not user_can_delete_page(
self.request.user, page=self.page)
on_delete_redirect_url = self.get_on_delete_redirect_url()
current_page_menu.add_modal_item(_('Delete page'),
url=delete_url,
on_close=on_delete_redirect_url,
disabled=delete_disabled)
def get_delete_alias_endpoint(self, alias_pk):
return admin_reverse(
DELETE_ALIAS_URL_NAME,
args=[alias_pk],
)
