def edit_redirect_view(self, request, object_id):
"""Redirects to the admin change view and creates a draft version
if no draft exists yet.
"""
# This view always changes data so only POST requests should work
if request.method != 'POST':
return HttpResponseNotAllowed(
['POST'], _('This view only supports POST method.'))
version = self._get_edit_redirect_version(request, object_id)
if version is None:
raise Http404
# Redirect
# If the object is editable the cms editable view should be used, with the toolbar.
if is_editable_model(version.content.__class__):
url = get_object_edit_url(version.content)
# Or else, the standard edit view should be used
else:
url = reverse('admin:{app}_{model}_change'.format(
app=version.content._meta.app_label,
model=version.content._meta.model_name,
),
args=(version.content.pk, ))
return redirect(url)
def test_edit_endpoint_with_draft_file(self):
"""Edit endpoint contains draft file"""
self.add_plugin(self.draft_file_grouper.pk)
response = self.client.get(get_object_edit_url(
self.placeholder.source))
self.assertContains(response, self.draft_file.url)
def _get_instance_request(self,
instance,
user,
path=None,
edit=False,
preview=False,
structure=False,
lang_code='en',
disable=False):
if not path:
if edit:
path = get_object_edit_url(instance)
elif preview:
path = get_object_preview_url(instance)
elif structure:
path = get_object_structure_url(instance)
else:
path = instance.get_absolute_url()
request = RequestFactory().get(path)
request.session = {}
request.user = user
request.LANGUAGE_CODE = lang_code
request.GET = QueryDict('', mutable=True)
if edit:
request.GET['edit'] = None
else:
request.GET['edit_off'] = None
if disable:
request.GET[get_cms_setting('CMS_TOOLBAR_URL__DISABLE')] = None
return request
def test_add_aliases_submenu_to_admin_menu(self):
user = self.get_staff_user_with_std_permissions()
user.user_permissions.add(Permission.objects.get(
content_type__app_label='djangocms_alias',
codename='change_category'))
page_url = get_object_edit_url(self.page.get_title_obj(self.language))
with self.login_user_context(user):
response = self.client.get(page_url)
self.assertContains(response, '<span>Aliases')
def test_edit_endpoint_draft_page_rendering_draft_url(self):
add_plugin(
self.draft_pagecontent.placeholders.get(slot="content"),
"HtmlLink",
language=self.language,
url_grouper=self.url_grouper,
label="Draft URL plugin",
)
request_url = get_object_edit_url(self.draft_pagecontent, self.language)
with self.login_user_context(self.user):
response = self.client.get(request_url)
self.assertContains(response, "some/path/")
def get_editable_url(content_obj):
"""If the object is editable the cms editable view should be used, with the toolbar.
This method is provides the URL for it.
"""
if is_editable_model(content_obj.__class__):
url = get_object_edit_url(content_obj)
# Or else, the standard edit view should be used
else:
url = reverse('admin:{app}_{model}_change'.format(
app=content_obj._meta.app_label,
model=content_obj._meta.model_name,
),
args=(content_obj.pk, ))
return url
def test_change_language_menu_page_toolbar(self):
"""Check that patched PageToolbar.change_language_menu only provides
Add Translation links.
"""
version = PageVersionFactory(content__language="en")
PageContentWithVersionFactory(page=version.content.page, language="de")
PageContentWithVersionFactory(page=version.content.page, language="it")
page = version.content.page
page.update_languages(["en", "de", "it"])
request = self.get_page_request(
page=page,
path=get_object_edit_url(version.content),
user=self.get_superuser(),
)
request.toolbar.set_object(version.content)
request.toolbar.populate()
request.toolbar.post_template_populate()
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
# 3 out of 4 populated languages, Break, Add Translation menu, Copy all plugins
self.assertEqual(language_menu.get_item_count(), 6)
language_menu_dict = {
menu.name: [item for item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertIn("Add Translation", language_menu_dict.keys())
self.assertIn("Copy all plugins", language_menu_dict.keys())
self.assertNotIn("Delete Translation", language_menu_dict.keys())
self.assertEquals(
set([lang.name for lang in language_menu_dict["Add Translation"]]),
set(["Française..."]),
)
self.assertEquals(
set([lang.name
for lang in language_menu_dict["Copy all plugins"]]),
set(["from Italiano", "from Deutsche"]),
)
for item in language_menu_dict["Add Translation"]:
self.assertIn(admin_reverse("cms_pagecontent_add"), item.url)
self.assertIn("cms_page={}".format(page.pk), item.url)
lang_code = "fr" if "Française" in item.name else "it"
self.assertIn("language={}".format(lang_code), item.url)
def test_edit_endpoint_with_published_file_and_draft(self):
"""Edit endpoint contains draft file when there is a published
and a draft version."""
self.assertEqual(self.file.versions.all().count(), 1)
version = self.file.versions.all().first()
v2 = version.copy(self.superuser)
self.assertEqual(v2.state, DRAFT)
self.assertEqual(v2.grouper.pk, self.file.grouper.pk)
self.add_plugin(self.file_grouper.pk)
response = self.client.get(get_object_edit_url(
self.placeholder.source))
self.assertContains(response, v2.content.url)
# clean-up
v2.delete()
def test_default_cms_edit_button_is_used_for_non_versioned_model(self):
"""
The default cms edit button is present for a default model
"""
unversionedpoll = FancyPollFactory()
url = get_object_preview_url(unversionedpoll)
edit_url = get_object_edit_url(unversionedpoll)
with self.login_user_context(self.get_superuser()):
response = self.client.post(url)
found_button_list = find_toolbar_buttons("Edit",
response.wsgi_request.toolbar)
# Only one edit button exists
self.assertEqual(len(found_button_list), 1)
# The only edit button that exists is the standard cms button
self.assertEqual(found_button_list[0].url, edit_url)
def test_change_language_menu_page_toolbar(self):
"""Check that patched PageToolbar.change_language_menu only provide
Add Translation links.
"""
version = PageVersionFactory(content__language='en')
PageContentFactory(page=version.content.page, language='de')
page = version.content.page
page.update_languages(['en', 'de'])
request = self.get_page_request(
page=page,
path=get_object_edit_url(version.content),
user=self.get_superuser(),
)
request.toolbar.set_object(version.content)
request.toolbar.populate()
request.toolbar.post_template_populate()
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
# 4 languages, Break, Add Translation menu
self.assertEqual(language_menu.get_item_count(), 6)
language_menu_dict = {
menu.name: [item for item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertIn('Add Translation', language_menu_dict.keys())
self.assertNotIn('Delete Translation', language_menu_dict.keys())
self.assertNotIn('Copy all plugins', language_menu_dict.keys())
self.assertEquals(
set([l.name for l in language_menu_dict['Add Translation']]),
set(['Française...', 'Italiano...']),
)
for item in language_menu_dict['Add Translation']:
self.assertIn(admin_reverse('cms_pagecontent_add'), item.url)
self.assertIn('cms_page={}'.format(page.pk), item.url)
lang_code = 'fr' if 'Française' in item.name else 'it'
self.assertIn('language={}'.format(lang_code), item.url)
def test_change_language_menu_page_toolbar_language_selector_version_link(
self):
"""
Ensure that the correct version is navigated to in the language selector.
A real world scenario / issue seen:
- Version 3: Draft
- Version 2: Published
- Version 1: Archived
Version 1 was returned in the toolbar language selector which is incorrect,
the latest version 4 should be returned.
"""
superuser = self.get_superuser()
en_pagecontent_1 = PageContentWithVersionFactory(language="en")
page = en_pagecontent_1.page
de_pagecontent_1 = PageContentWithVersionFactory(page=page,
language="de")
# Create remaining 3 versions for it
it_pagecontent_1 = PageContentWithVersionFactory(
page=page, language="it", version__state=ARCHIVED)
it_pagecontent_1_version = it_pagecontent_1.versions.first()
# Make version 1 archived by publishing the new version 2
it_pagecontent_2 = PageContentWithVersionFactory(
page=page, language="it", version__state=PUBLISHED)
it_pagecontent_2_version = it_pagecontent_2.versions.first()
# Create a new draft, which is what we expect to use
it_pagecontent_3 = PageContentWithVersionFactory(page=page,
language="it",
version__state=DRAFT)
it_pagecontent_3_version = it_pagecontent_3.versions.first()
# Sanity check that all versions are int he state that we expect: Archived, Published, Draft
self.assertEqual(it_pagecontent_1_version.state, ARCHIVED)
self.assertEqual(it_pagecontent_2_version.state, PUBLISHED)
self.assertEqual(it_pagecontent_3_version.state, DRAFT)
page.update_languages(["en", "de", "it"])
request = self.get_page_request(
page=page,
path=get_object_edit_url(en_pagecontent_1),
user=superuser,
)
request.toolbar.set_object(en_pagecontent_1)
request.toolbar.populate()
request.toolbar.post_template_populate()
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
language_menu_item_names = [
item.name for item in language_menu.items if hasattr(item, "name")
]
self.assertIn("English", language_menu_item_names)
self.assertIn("Deutsche", language_menu_item_names)
self.assertIn("Italiano", language_menu_item_names)
en_item = self._get_toolbar_item_by_name(language_menu, "English")
en_preview_url = get_object_preview_url(en_pagecontent_1, "en")
de_item = self._get_toolbar_item_by_name(language_menu, "Deutsche")
de_preview_url = get_object_preview_url(de_pagecontent_1, "de")
it_item = self._get_toolbar_item_by_name(language_menu, "Italiano")
it_preview_url = get_object_preview_url(it_pagecontent_3, "it")
# Ensure that each menu item points to the correct url
self.assertEqual(en_item.url, en_preview_url)
self.assertEqual(de_item.url, de_preview_url)
self.assertEqual(it_item.url, it_preview_url)
def test_static_alias_shows_correct_content_for_versioning_states(self):
"""
The correct contents are shown when viewing the static alias:
- A draft page shows draft content
- A published page shows published content or nothing at all
"""
from djangocms_versioning.constants import PUBLISHED
category = Category.objects.create(
name=DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
alias = self._create_alias(
plugins=None,
name='test alias',
category=category,
published=True,
static_code="template_example_global_alias_code")
add_plugin(
alias.get_placeholder(language='en'),
'TextPlugin',
language='en',
body='Published content for: template_example_global_alias_code',
)
page = create_page(title="Static Code Test",
language='en',
template='static_alias.html',
limit_visibility_in_menu=None,
created_by=self.superuser)
# Publish the page and create a draft alias
self._publish(page, 'en')
version = self._get_version(alias, PUBLISHED, 'en')
draft = version.copy(self.superuser)
# Add draft content to the draft version
add_plugin(
draft.content.placeholder,
'TextPlugin',
language='en',
body=
'Updated Draft content for: template_example_global_alias_code',
)
page_content = page.get_title_obj("en")
page_live_url = page.get_absolute_url()
page_edit_url = get_object_edit_url(page_content, "en")
page_preview_url = get_object_preview_url(page_content, "en")
# The live page should still contain the published contents
live_response = self.client.get(page_live_url)
self.assertContains(
live_response,
'Published content for: template_example_global_alias_code')
self.assertNotContains(
live_response,
'Updated Draft content for: template_example_global_alias_code')
# The edit and preview url should show the draft contents
with self.login_user_context(self.superuser):
edit_response = self.client.get(page_edit_url)
preview_response = self.client.get(page_preview_url)
self.assertContains(
edit_response,
'Updated Draft content for: template_example_global_alias_code')
self.assertContains(
preview_response,
'Updated Draft content for: template_example_global_alias_code')
