def create_pages():
from cms.models import Placeholder
from cms.api import create_page, add_plugin, publish_page
from django.conf import settings
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
placeholder = {}
with open('starting_page.json') as data_file:
content = json.load(data_file)
try:
# try to get a feature template with fallback
template = settings.CMS_TEMPLATES[1][0]
if template != 'feature.html':
template = settings.CMS_TEMPLATES[0][0]
except IndexError:
template = settings.CMS_TEMPLATES[0][0]
lang = settings.LANGUAGES[0][0]
page = create_page(_('Home'), template, lang)
placeholder['main'] = page.placeholders.get(slot='content')
try:
# try to get a feature placeholder
placeholder_feature = page.placeholders.get(slot='feature')
add_plugin(placeholder_feature,
'TextPlugin',
lang,
body=content['feature'])
except Placeholder.DoesNotExist:
# fallback, add it to the
add_plugin(placeholder['main'],
'TextPlugin',
lang,
body=content['feature'])
# Add main content to a MultiColumnPlugin
multi_columns_plugin = add_plugin(placeholder['main'], 'MultiColumnPlugin',
lang)
for column_content in content['main']:
col = add_plugin(placeholder['main'],
'ColumnPlugin',
lang,
target=multi_columns_plugin,
**{'width': '33%'})
add_plugin(placeholder['main'],
'TextPlugin',
lang,
body=column_content,
target=col)
# In order to publish the page there needs to be at least one user
if User.objects.count() > 0:
try:
publish_page(page, User.objects.all()[0], lang)
except TypeError:
# supporting old cms versions
publish_page(page, User.objects.all()[0])
def _test_relation(self, publisher_is_draft):
placeholder = self.flavors_page.placeholders.get(slot='body')
chocolate_plugin = api.add_plugin(
placeholder,
'FlavorPlugin',
self.LANGUAGE,
name=self.CHOCOLATE
)
chocolate = chocolate_plugin.flavor
John = models.Photographer.objects.create(
name=self.JOHN,
favorite=chocolate
)
api.publish_page(
self.flavors_page,
self.superuser,
self.LANGUAGE
)
chocolate_of_interest = models.Flavor.objects.get(
name=self.CHOCOLATE,
placeholder__page__publisher_is_draft=publisher_is_draft
)
self.assertEqual(
chocolate_of_interest.fans.get().name,
self.JOHN
)
def _test_relation(self, publisher_is_draft):
placeholder = self.sundeas_page.placeholders.get(slot='body')
strawberry_sauce = models.Sauce.objects.create(
name=self.STRAWBERRY_SAUCE
)
spaghetti_ice_cream_plugin = api.add_plugin(
placeholder,
'SundeaPlugin',
self.LANGUAGE,
name=self.SPAGHETTI_ICE_CREAM
)
spaghetti_ice_cream = spaghetti_ice_cream_plugin.sundea
spaghetti_ice_cream.sauces.add(strawberry_sauce)
api.publish_page(
self.sundeas_page,
self.superuser,
self.LANGUAGE
)
spaghetti_ice_cream_of_interest = models.Sundea.objects.get(
name=self.SPAGHETTI_ICE_CREAM,
placeholder__page__publisher_is_draft=publisher_is_draft
)
self.assertEqual(
spaghetti_ice_cream_of_interest.sauces.get().name,
self.STRAWBERRY_SAUCE
)
def test_slave_can_add_page_under_slave_home(self):
with self.login_user_context(self.user_slave):
# move to admin.py?
# url = URL_CMS_PAGE_ADD + "?target=%d&position=last-child" % slave_page.pk
# can he even access it over get?
# response = self.client.get(url)
# self.assertEqual(response.status_code, 200)
# add page
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page, created_by=self.user_slave)
# adds user_slave as page moderator for this page
# public model shouldn't be available yet, because of the moderation
# moderators and approval ok?
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertObjectExist(Title.objects, slug="page")
self.assertObjectDoesNotExist(Title.objects.public(), slug="page")
self.assertTrue(has_generic_permission(page.pk, self.user_slave, "publish", 1))
# publish as slave, published as user_master before
publish_page(page, self.user_slave, 'en')
def test_publish_button_after_moderation_request_approved(self):
self.setup_toolbar(self.pg3, self.user) # pg3 => moderation request is approved
publish_page(page=self.pg3, user=self.user, language="en")
buttons = sum([item.buttons for item in self.toolbar_right_items if isinstance(item, Dropdown)], [])
self.assertEqual(len(buttons), 2)
self.assertEqual(force_text(buttons[0].name), 'Publish page changes')
self.assertEqual(force_text(buttons[1].name), 'Cancel request')
def test_subtree_with_super(self):
# create page under root
page = create_page("page", "nav_playground.html", "en")
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage", "nav_playground.html", "en",
parent=page)
self.assertFalse(subpage.publisher_public)
# tree id must be the same
self.assertEqual(page.tree_id, subpage.tree_id)
# publish both of them
page = self.reload(page)
page = publish_page(page, self.user_super, 'en')
# reload subpage, there were an tree_id change
subpage = self.reload(subpage)
self.assertEqual(page.tree_id, subpage.tree_id)
subpage = publish_page(subpage, self.user_super, 'en')
# tree id must stay the same
self.assertEqual(page.tree_id, subpage.tree_id)
# published pages must also have the same tree_id
self.assertEqual(page.publisher_public.tree_id, subpage.publisher_public.tree_id)
#check attributes
self.check_published_page_attributes(page)
self.check_published_page_attributes(subpage)
def test_subtree_needs_approval(self):
# create page under slave_page
page = create_page("parent", "nav_playground.html", "en",
parent=self.home_page)
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage", "nav_playground.html", "en", parent=page)
self.assertFalse(subpage.publisher_public)
# publish both of them in reverse order
subpage = publish_page(subpage, self.user_master, 'en')
# subpage should not be published, because parent is not published
# yet, should be marked as `publish when parent`
self.assertFalse(subpage.publisher_public)
# publish page (parent of subage), so subpage must be published also
page = publish_page(page, self.user_master, 'en')
self.assertNotEqual(page.publisher_public, None)
# reload subpage, it was probably changed
subpage = self.reload(subpage)
# parent was published, so subpage must be also published..
self.assertNotEqual(subpage.publisher_public, None)
#check attributes
self.check_published_page_attributes(page)
self.check_published_page_attributes(subpage)
def handle(self, *args, **options):
if not args:
return
page_id, = args
parser = etree.HTMLParser()
selector = CSSSelector('body')
# content = selector(tree.getroot())
dict_list = []
blame = models.User.objects.filter(is_superuser=True)[0]
main_page = Page.objects.get(id=page_id)
sub_pages = main_page.get_descendants()
for page in sub_pages:
page = page.get_draft_object()
en = page.get_title_obj('en')
titles = Title.objects.filter(page=page).exclude(language='en')
for title in titles:
title.title = en.title
title.slug = en.slug
title.save()
print ('Updating title of page {} language {}'.format(title.page_id, title.language))
for l in dict(settings.LANGUAGES).keys():
try:
api.publish_page(page, blame, l)
except Exception as e:
pass
def test_render_page(self):
self.test_add_iconlist_plugin()
api.publish_page(self.page, self.superuser, self.language)
response = self.client.get(self.page.get_absolute_url())
self.assertTrue("icon-list-container" in response.rendered_content)
self.assertTrue("superservice" in response.rendered_content)
def test_moderator_flags(self):
"""Add page under slave_home and check its flag
"""
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page)
# No public version
self.assertIsNone(page.publisher_public)
self.assertFalse(page.publisher_public_id)
# check publish box
page = publish_page(page, self.user_slave, 'en')
# public page must not exist because of parent
self.assertFalse(page.publisher_public)
# waiting for parents
self.assertEqual(page.get_publisher_state('en'), PUBLISHER_STATE_PENDING)
# publish slave page
self.slave_page = self.slave_page.reload()
slave_page = publish_page(self.slave_page, self.user_master, 'en')
self.assertFalse(page.publisher_public)
self.assertTrue(slave_page.publisher_public)
def test_page_added_by_slave_can_be_published_approved_by_user_master(
self):
# add page
page = create_page("page",
"nav_playground.html",
"en",
parent=self.slave_page,
created_by=self.user_slave)
# same as test_slave_can_add_page_under_slave_home
self.assertEqual(page.get_moderator_queryset().count(), 1)
self.assertEqual(page.moderator_state, Page.MODERATOR_CHANGED)
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertTrue(
has_generic_permission(page.pk, self.user_master, "publish",
page.site.pk))
# should be True user_master should have publish permissions for childred aswell
# don't test for published since publishing must be approved
publish_page(page, self.user_master)
# user_master is moderator for top level page / but can't approve descendants?
# approve / publish as user_master
# user master should be able to approve descendants
page = approve_page(page, self.user_master)
def test_slave_can_add_page_under_slave_home(self):
with self.login_user_context(self.user_slave):
# move to admin.py?
# url = URL_CMS_PAGE_ADD + "?target=%d&position=last-child" % slave_page.pk
# can he even access it over get?
# response = self.client.get(url)
# self.assertEqual(response.status_code, 200)
# add page
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page, created_by=self.user_slave)
# adds user_slave as page moderator for this page
# public model shouldn't be available yet, because of the moderation
# removed test cases since Title object does not inherit from Publisher anymore
#self.assertObjectExist(Title.objects, slug=page_data['slug'])
#self.assertObjectDoesNotExist(Title.objects.public(), slug=page_data['slug'])
# moderators and approvement ok?
self.assertEqual(page.get_moderator_queryset().count(), 1)
self.assertEqual(page.moderator_state, Page.MODERATOR_CHANGED)
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertTrue(has_generic_permission(page.pk, self.user_slave, "publish", 1))
# publish as slave, published as user_master before
publish_page(page, self.user_slave)
# user_slave is moderator for this page
# approve / publish as user_slave
# user master should be able to approve aswell
page = approve_page(page, self.user_slave)
def test_subtree_needs_approval(self):
# create page under slave_page
page = create_page("parent", "nav_playground.html", "en",
parent=self.home_page)
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage", "nav_playground.html", "en", parent=page)
self.assertFalse(subpage.publisher_public)
# publish both of them in reverse order
subpage = publish_page(subpage, self.user_master, 'en')
# subpage should not be published, because parent is not published
# yet, should be marked as `publish when parent`
self.assertFalse(subpage.publisher_public)
# publish page (parent of subage), so subpage must be published also
page = publish_page(page, self.user_master, 'en')
self.assertNotEqual(page.publisher_public, None)
# reload subpage, it was probably changed
subpage = self.reload(subpage)
# parent was published, so subpage must be also published..
self.assertNotEqual(subpage.publisher_public, None)
#check attributes
self.check_published_page_attributes(page)
self.check_published_page_attributes(subpage)
def test_render_page(self):
self.test_add_slider_plugin()
api.publish_page(self.page, self.superuser, self.language)
response = self.client.get(self.page.get_absolute_url())
self.assertTrue("slider-wrapper" in response.rendered_content)
self.assertTrue("single-image" in response.rendered_content)
def test_subtree_with_super(self):
# create page under root
page = create_page("page", "nav_playground.html", "en")
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage", "nav_playground.html", "en",
parent=page)
self.assertFalse(subpage.publisher_public)
# tree id must be the same
self.assertEqual(page.tree_id, subpage.tree_id)
# publish both of them
page = self.reload(page)
page = publish_page(page, self.user_super)
# reload subpage, there were an tree_id change
subpage = self.reload(subpage)
self.assertEqual(page.tree_id, subpage.tree_id)
subpage = publish_page(subpage, self.user_super)
# tree id must stay the same
self.assertEqual(page.tree_id, subpage.tree_id)
# published pages must also have the same tree_id
self.assertEqual(page.publisher_public.tree_id, subpage.publisher_public.tree_id)
#check attributes
self.check_published_page_attributes(page)
self.check_published_page_attributes(subpage)
def test_publish_page(self):
page_attrs = self._get_default_create_page_arguments()
page_attrs['language'] = 'en'
page_attrs['published'] = False
page = create_page(**page_attrs)
self.assertFalse(page.is_published('en'))
self.assertEqual(page.changed_by, 'script')
user = get_user_model().objects.create_user(username='******', email='*****@*****.**',
password='******')
# Initially no permission
self.assertRaises(PermissionDenied, publish_page, page, user, 'en')
user.is_staff = True
user.save()
# Permissions are cached on user instances, so create a new one.
user = get_user_model().objects.get(pk=user.pk)
self.add_permission(user, 'change_page')
self.add_permission(user, 'publish_page')
gpp = GlobalPagePermission.objects.create(user=user, can_change=True, can_publish=True)
gpp.sites.add(page.site)
publish_page(page, user, 'en')
# Reload the page to get updates.
page = page.reload()
self.assertTrue(page.is_published('en'))
self.assertEqual(page.changed_by, user.get_username())
def create_essential_pages(page_publisher):
languages = [entry[0] for entry in settings.LANGUAGES]
if not Page.objects.count():
create_page(
title='Home',
template='cms/content-types/homepage.html',
language=languages[0],
published=True
)
# Having the Home page in all languages is not essential.
if not Page.objects.filter(reverse_id='search-results').exists():
search_page = create_page(
title='Search',
template='cms/content-types/page.html',
language=languages[0],
apphook='AldrynSearchApphook',
reverse_id='search-results',
published=True
)
# The search results page must exist in all languages.
for lang in languages[1:]:
create_title(language=lang, title='Search', page=search_page)
publish_page(page=search_page, user=page_publisher, language=lang)
def handle(self, *args, **options):
if not args:
return
page_id, = args
parser = etree.HTMLParser()
selector = CSSSelector('body')
# content = selector(tree.getroot())
dict_list = []
blame = models.User.objects.filter(is_superuser=True)[0]
main_page = Page.objects.get(id=page_id)
sub_pages = main_page.get_descendants()
for page in sub_pages:
page = page.get_draft_object()
en = page.get_title_obj('en')
titles = Title.objects.filter(page=page).exclude(language='en')
for title in titles:
title.title = en.title
title.slug = en.slug
title.save()
print('Updating title of page {} language {}'.format(
title.page_id, title.language))
for l in dict(settings.LANGUAGES).keys():
try:
api.publish_page(page, blame, l)
except Exception as e:
pass
def test_publish_page(self):
page_attrs = self._get_default_create_page_arguments()
page_attrs['language'] = 'en'
page_attrs['published'] = False
page = create_page(**page_attrs)
self.assertFalse(page.is_published('en'))
self.assertEqual(page.changed_by, 'script')
user = get_user_model().objects.create_user(
username='******', email='*****@*****.**', password='******')
# Initially no permission
self.assertRaises(PermissionDenied, publish_page, page, user, 'en')
user.is_staff = True
user.save()
# Permissions are cached on user instances, so create a new one.
user = get_user_model().objects.get(pk=user.pk)
self.add_permission(user, 'change_page')
self.add_permission(user, 'publish_page')
gpp = GlobalPagePermission.objects.create(user=user,
can_change=True,
can_publish=True)
gpp.sites.add(page.node.site)
publish_page(page, user, 'en')
# Reload the page to get updates.
page = page.reload()
self.assertTrue(page.is_published('en'))
self.assertEqual(page.changed_by, user.get_username())
def test_moderator_flags(self):
"""Add page under slave_home and check its flag
"""
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page)
# No public version
self.assertIsNone(page.publisher_public)
self.assertFalse(page.publisher_public_id)
# check publish box
page = publish_page(page, self.user_slave, 'en')
# public page must not exist because of parent
self.assertFalse(page.publisher_public)
# waiting for parents
self.assertEqual(page.get_publisher_state('en'), PUBLISHER_STATE_PENDING)
# publish slave page
self.slave_page = self.slave_page.reload()
slave_page = publish_page(self.slave_page, self.user_master, 'en')
self.assertFalse(page.publisher_public)
self.assertTrue(slave_page.publisher_public)
def save(self, commit=True):
self.save_m2m = lambda: None
data = self.cleaned_data
version_id = data.get('version_id', '')
title = data.get('title', '')
comment = data.get('comment', '')
draft = data['draft']
language = data.get('language', '')
# Detect case when editing version
is_version_page = draft.get_root().title_set.filter(
title__in=[BIN_ROOT_TITLE, VERSION_ROOT_TITLE]).exists()
if not is_version_page:
# Publish page first...
if hasattr(self, 'publish_on_save') and self.publish_on_save:
from cms.utils.permissions import get_current_user
user = get_current_user()
if isinstance(user, string_types):
user = User.objects.get(username=user)
publish_page(draft, user, language)
# Create Version second...
return PageVersion.create_version(draft,
language,
version_parent=None,
comment=comment,
title=title,
version_id=version_id)
def test_one_page_en_it(self):
from cms.models import Page
page = self.create_page(language='en', template='page.html')
page = Page.objects.get(pk=page.pk)
title = create_title('it', 'ciao', page)
# unpublished
elem = self.get_page(page, 'en')
links = [e.attrib for e in elem.findall('head/link')]
self.assertEqual(links, [])
# publish title
publish_page(page, self.get_superuser(), 'it')
# get en
elem = self.get_page(page, 'en')
links = [e.attrib for e in elem.findall('head/link')]
self.assertEqual(
links,
[{'href': 'http://example.com/it/', 'rel': 'alternate',
'hreflang': 'it'}])
# get it
elem = self.get_page(page, 'it')
links = [e.attrib for e in elem.findall('head/link')]
self.assertEqual(
links,
[{'href': 'http://example.com/en/', 'rel': 'alternate',
'hreflang': 'en'}])
def test_subtree_needs_approvement(self):
# create page under slave_page
page = create_page("parent", "nav_playground.html", "en",
parent=self.home_page)
self.assertFalse(page.publisher_public)
# create subpage uner page
subpage = create_page("subpage", "nav_playground.html", "en", parent=page)
self.assertFalse(subpage.publisher_public)
# publish both of them in reverse order
subpage = publish_page(subpage, self.user_master, True)
# subpage should not be published, because parent is not published
# yet, should be marked as `publish when parent`
self.assertFalse(subpage.publisher_public)
# pagemoderator state must be set
self.assertEqual(subpage.moderator_state, Page.MODERATOR_APPROVED_WAITING_FOR_PARENTS)
# publish page (parent of subage), so subpage must be published also
page = publish_page(page, self.user_master, True)
self.assertNotEqual(page.publisher_public, None)
# reload subpage, it was probably changed
subpage = self.reload_page(subpage)
# parent was published, so subpage must be also published..
self.assertNotEqual(subpage.publisher_public, None)
#check attributes
self.check_published_page_attributes(page)
self.check_published_page_attributes(subpage)
def setUp(self):
# create super user
self.user_super = self._create_user("super", is_superuser=True)
self.user_staff = self._create_user("staff")
self.user_master = self._create_user("master")
self.user_slave = self._create_user("slave")
self.user_normal = self._create_user("normal", is_staff=False)
self.user_normal.user_permissions.add(
Permission.objects.get(codename='publish_page'))
with self.login_user_context(self.user_super):
self.home_page = create_page("home", "nav_playground.html", "en",
created_by=self.user_super)
# master page & master user
self.master_page = create_page("master", "nav_playground.html", "en")
# create non global, non staff user
self.user_non_global = User(username="******", is_active=True)
self.user_non_global.set_password("nonglobal")
self.user_non_global.save()
# assign master user under home page
assign_user_to_page(self.home_page, self.user_master,
grant_on=ACCESS_DESCENDANTS, grant_all=True)
# and to master page
assign_user_to_page(self.master_page, self.user_master,
grant_on=ACCESS_PAGE_AND_DESCENDANTS, grant_all=True)
# slave page & slave user
self.slave_page = create_page("slave-home", "nav_playground.html", "en",
parent=self.master_page, created_by=self.user_super)
assign_user_to_page(self.slave_page, self.user_slave, grant_all=True)
# create page_b
page_b = create_page("pageB", "nav_playground.html", "en", created_by=self.user_super)
# Normal user
# it's allowed for the normal user to view the page
assign_user_to_page(page_b, self.user_normal, can_view=True)
# create page_a - sample page from master
page_a = create_page("pageA", "nav_playground.html", "en",
created_by=self.user_super)
assign_user_to_page(page_a, self.user_master,
can_add=True, can_change=True, can_delete=True, can_publish=True,
can_move_page=True)
# publish after creating all drafts
publish_page(self.home_page, self.user_super)
publish_page(self.master_page, self.user_super)
self.page_b = publish_page(page_b, self.user_super)
def test_relation_not_published_when_target_not_public(self):
api.publish_page(self.sundeas_page, self.superuser, self.LANGUAGE)
banana_split_of_interest = models.Sundea.objects.get(
name=self.BANANA_SPLIT,
placeholder__page__publisher_is_draft=False)
self.assertRaises(ObjectDoesNotExist,
banana_split_of_interest.flavors.get)
def test_slave_can_add_page_under_slave_home(self):
with self.login_user_context(self.user_slave):
# move to admin.py?
# url = URL_CMS_PAGE_ADD + "?target=%d&position=last-child" % slave_page.pk
# can he even access it over get?
# response = self.client.get(url)
# self.assertEqual(response.status_code, 200)
# add page
page = create_page("page",
"nav_playground.html",
"en",
parent=self.slave_page,
created_by=self.user_slave)
# adds user_slave as page moderator for this page
# public model shouldn't be available yet, because of the moderation
# moderators and approval ok?
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertObjectExist(Title.objects, slug="page")
self.assertObjectDoesNotExist(Title.objects.public(), slug="page")
self.assertTrue(user_can_publish_page(self.user_slave, page))
# publish as slave, published as user_master before
publish_page(page, self.user_slave, 'en')
def test_render_page(self):
self.test_add_iconlist_plugin()
api.publish_page(self.page, self.superuser, self.language)
response = self.client.get(self.page.get_absolute_url())
self.assertTrue("icon-list-container" in response.rendered_content)
self.assertTrue("superservice" in response.rendered_content)
def test_subtree_needs_approval(self):
# create page under slave_page
page = create_page("parent",
"nav_playground.html",
"en",
parent=self.home_page)
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage",
"nav_playground.html",
"en",
parent=page,
published=False)
# publish both of them in reverse order
subpage = publish_page(subpage, self.user_master, 'en')
# subpage should not be published, because parent is not published
self.assertNeverPublished(subpage)
# publish page (parent of subage)
page = publish_page(page, self.user_master, 'en')
self.assertPublished(page)
self.assertNeverPublished(subpage)
subpage = publish_page(subpage, self.user_master, 'en')
self.assertPublished(subpage)
def test_create_home_page(self):
page = create_home_page()
publish_page(page, self.user_admin, language=settings.LANGUAGE_CODE)
assert page.is_published(language=settings.LANGUAGE_CODE)
page_id = page.id
page.delete()
assert not Page.objects.filter(id=page_id).exists()
def test_subtree_with_super(self):
# create page under root
page = create_page("page", "nav_playground.html", "en")
self.assertFalse(page.publisher_public)
# create subpage under page
subpage = create_page("subpage",
"nav_playground.html",
"en",
parent=page)
self.assertFalse(subpage.publisher_public)
# tree id must be the same
self.assertEqual(page.node.path[0:4], subpage.node.path[0:4])
# publish both of them
page = self.reload(page)
page = publish_page(page, self.user_super, 'en')
# reload subpage, there were an path change
subpage = self.reload(subpage)
self.assertEqual(page.node.path[0:4], subpage.node.path[0:4])
subpage = publish_page(subpage, self.user_super, 'en')
# tree id must stay the same
self.assertEqual(page.node.path[0:4], subpage.node.path[0:4])
def test_extension_found_performance(self, rf, django_assert_num_queries):
request = rf.get('/')
request.user = User.objects.create(username='******', is_superuser=True)
page = create_page('Test Page', 'INHERIT', 'en-us')
publish_page(page, request.user, 'en-us')
page.refresh_from_db()
ExtensionModel.objects.create(
extended_object=page.get_public_object().get_title_obj(), name='public')
context = Context({'request': request})
template = Template((
'{%% load cms_helpers %%}'
'{%% page_titleextension %s "extensionmodel" %%}'
) % page.pk)
info = (
'1 query get draft page, '
'1 query get public page, '
'1 query get title, '
'1 query get extension'
)
with django_assert_num_queries(4, info=info):
assert template.render(context) == 'public'
# Rendering another time should be cached and not hit the DB
with django_assert_num_queries(0, info=info):
assert template.render(context) == 'public'
def test_toolbar_switch_urls(self):
user = self.get_superuser()
user_settings = UserSettings(language="en", user=user)
placeholder = Placeholder(slot="clipboard")
placeholder.save()
user_settings.clipboard = placeholder
user_settings.save()
page = create_page("page", "nav_playground.html", "en", published=True)
create_title("fr", "french home", page)
publish_page(page, user, "fr")
with self.login_user_context(user):
response = self.client.get(
"/fr/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertContains(
response,
"/fr/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF'), 1,
200)
response = self.client.get(
"/fr/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF'))
self.assertContains(
response,
"/fr/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'), 1,
200)
def test_relation_copied_when_first_origin_and_then_target_published(self):
api.publish_page(self.sundeas_page, self.superuser, self.LANGUAGE)
api.publish_page(self.flavors_page, self.superuser, self.LANGUAGE)
banana_split_of_interest = models.Sundea.objects.get(
name=self.BANANA_SPLIT,
placeholder__page__publisher_is_draft=False)
self.assertEqual(banana_split_of_interest.flavors.get().name,
self.BANANA)
def test_remove_plugin_page_under_moderation(self):
# login as slave and create page
page = create_page("page",
"nav_playground.html",
"en",
parent=self.slave_page)
self.assertEqual(page.get_moderator_queryset().count(), 1)
# add plugin
placeholder = page.placeholders.all()[0]
plugin = add_plugin(placeholder, "TextPlugin", "en", body="test")
self.assertEqual(page.moderator_state, Page.MODERATOR_CHANGED)
# publish page
page = self.reload(page)
page = publish_page(page, self.user_slave)
# only the draft plugin should exist
self.assertEqual(CMSPlugin.objects.all().count(), 1)
# page should require approval
self.assertEqual(page.moderator_state, Page.MODERATOR_NEED_APPROVEMENT)
# master approves and publishes the page
# first approve slave-home
slave_page = self.reload(self.slave_page)
publish_page(slave_page, self.user_master, approve=True)
page = self.reload(page)
page = publish_page(page, self.user_master, approve=True)
# draft and public plugins should now exist
self.assertEqual(CMSPlugin.objects.all().count(), 2)
# login as slave and delete the plugin - should require moderation
with self.login_user_context(self.user_slave):
plugin_data = {'plugin_id': plugin.pk}
remove_url = URL_CMS_PLUGIN_REMOVE
response = self.client.post(remove_url, plugin_data)
self.assertEquals(response.status_code, 200)
# there should only be a public plugin - since the draft has been deleted
self.assertEquals(CMSPlugin.objects.all().count(), 1)
# reload the page as it's moderator value should have been set in pageadmin.remove_plugin
self.assertEqual(page.moderator_state, Page.MODERATOR_APPROVED)
page = self.reload_page(page)
self.assertEqual(page.moderator_state,
Page.MODERATOR_NEED_APPROVEMENT)
# login as super user and approve/publish the page
page = publish_page(page, self.user_super, approve=True)
self.assertEqual(page.moderator_state, Page.MODERATOR_APPROVED)
# there should now be 0 plugins
self.assertEquals(CMSPlugin.objects.all().count(), 0)
def test_critical_created_after_page_publish(self, admin_user):
page = create_page('page', 'INHERIT', 'de')
publish_page(page, admin_user, 'de')
critical = Critical.objects.first()
assert Critical.objects.count() == 1
assert critical.url == page.get_absolute_url()
assert critical.path is None
assert critical.css is None
def test_plugins_get_published(self):
# create page under root
page = create_page("page", "nav_playground.html", "en")
placeholder = page.placeholders.all()[0]
add_plugin(placeholder, "TextPlugin", "en", body="test")
# public must not exist
self.assertEqual(CMSPlugin.objects.all().count(), 1)
publish_page(page, self.user_super, 'en')
self.assertEqual(CMSPlugin.objects.all().count(), 2)
def test_plugins_get_published(self):
# create page under root
page = create_page("page", "nav_playground.html", "en")
placeholder = page.placeholders.all()[0]
add_plugin(placeholder, "TextPlugin", "en", body="test")
# public must not exist
self.assertEqual(CMSPlugin.objects.all().count(), 1)
publish_page(page, self.user_super, 'en')
self.assertEqual(CMSPlugin.objects.all().count(), 2)
def test_remove_plugin_page_under_moderation(self):
# login as slave and create page
page = create_page("page", "nav_playground.html", "en", parent=self.slave_page)
self.assertEqual(page.get_moderator_queryset().count(), 1)
# add plugin
placeholder = page.placeholders.all()[0]
plugin = add_plugin(placeholder, "TextPlugin", "en", body="test")
self.assertEqual(page.moderator_state, Page.MODERATOR_CHANGED)
# publish page
page = self.reload(page)
page = publish_page(page, self.user_slave)
# only the draft plugin should exist
self.assertEqual(CMSPlugin.objects.all().count(), 1)
# page should require approval
self.assertEqual(page.moderator_state, Page.MODERATOR_NEED_APPROVEMENT)
# master approves and publishes the page
# first approve slave-home
slave_page = self.reload(self.slave_page)
publish_page(slave_page, self.user_master, approve=True)
page = self.reload(page)
page = publish_page(page, self.user_master, approve=True)
# draft and public plugins should now exist
self.assertEqual(CMSPlugin.objects.all().count(), 2)
# login as slave and delete the plugin - should require moderation
with self.login_user_context(self.user_slave):
plugin_data = {
'plugin_id': plugin.pk
}
remove_url = URL_CMS_PLUGIN_REMOVE
response = self.client.post(remove_url, plugin_data)
self.assertEquals(response.status_code, 200)
# there should only be a public plugin - since the draft has been deleted
self.assertEquals(CMSPlugin.objects.all().count(), 1)
# reload the page as it's moderator value should have been set in pageadmin.remove_plugin
self.assertEqual(page.moderator_state, Page.MODERATOR_APPROVED)
page = self.reload_page(page)
self.assertEqual(page.moderator_state, Page.MODERATOR_NEED_APPROVEMENT)
# login as super user and approve/publish the page
page = publish_page(page, self.user_super, approve=True)
self.assertEqual(page.moderator_state, Page.MODERATOR_APPROVED)
# there should now be 0 plugins
self.assertEquals(CMSPlugin.objects.all().count(), 0)
def create_pages():
from cms.api import add_plugin, create_page, publish_page
from cms.models import Placeholder
from django.conf import settings
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
placeholder = {}
with open("starting_page.json") as data_file:
content = json.load(data_file)
try:
# try to get a feature template with fallback
template = settings.CMS_TEMPLATES[1][0]
if template != "feature.html":
template = settings.CMS_TEMPLATES[0][0]
except IndexError:
template = settings.CMS_TEMPLATES[0][0]
lang = settings.LANGUAGES[0][0]
page = create_page(_("Home"), template, lang)
placeholder["main"] = page.placeholders.get(slot="content")
try:
# try to get a feature placeholder
placeholder_feature = page.placeholders.get(slot="feature")
add_plugin(placeholder_feature,
"TextPlugin",
lang,
body=content["feature"])
except Placeholder.DoesNotExist:
# fallback, add it to the
add_plugin(placeholder["main"],
"TextPlugin",
lang,
body=content["feature"])
# Add main content to a Bootstrap4GridRow
row_plugin = add_plugin(placeholder["main"], "Bootstrap4GridRowPlugin",
lang)
for column_content in content["main"]:
col = add_plugin(placeholder["main"],
"Bootstrap4GridColumnPlugin",
lang,
target=row_plugin)
add_plugin(placeholder["main"],
"TextPlugin",
lang,
body=column_content,
target=col)
# In order to publish the page there needs to be at least one user
if User.objects.count() > 0:
publish_page(page, User.objects.all()[0], lang)
def test_render_bootstrap3_boilerplate_templates(self):
"""
tests whether "bootstrap3" templates exist and don't cause import issues
"""
from aldryn_boilerplates import template_loaders
template_loaders.clear_cache()
self.test_add_gallery_plugin_api()
api.publish_page(self.page, self.superuser, self.language)
response = self.client.get(self.page.get_absolute_url())
# self.assertTrue('BOOTSTRAP3 GALLERY' in response.content)
# self.assertFalse('LEGACY GALLERY' in response.content)
template_loaders.clear_cache()
def test_render_bootstrap3_boilerplate_templates(self):
"""
tests whether "bootstrap3" templates exist and don't cause import issues
"""
from aldryn_boilerplates import template_loaders
template_loaders.clear_cache()
self.test_add_gallery_plugin_api()
api.publish_page(self.page, self.superuser, self.language)
response = self.client.get(self.page.get_absolute_url())
# self.assertTrue('BOOTSTRAP3 GALLERY' in response.content)
# self.assertFalse('LEGACY GALLERY' in response.content)
template_loaders.clear_cache()
def test_toolbar_switch_urls(self):
user = self.get_superuser()
user_settings = UserSettings(language="en", user=user)
placeholder = Placeholder(slot="clipboard")
placeholder.save()
user_settings.clipboard = placeholder
user_settings.save()
page = create_page("page", "nav_playground.html", "en", published=True)
create_title("fr", "french home", page)
publish_page(page, user, "fr")
page.set_as_homepage()
edit_on = get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
edit_off = get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF')
with self.login_user_context(user):
response = self.client.get("/fr/?{}".format(edit_on))
expected = """
<a href="?structure" class="cms-btn cms-btn-disabled" title="Toggle structure"
data-cms-structure-btn='{ "url": "/fr/?structure", "name": "Structure" }'
data-cms-content-btn='{ "url": "/fr/?edit", "name": "Content" }'>
<span class="cms-icon cms-icon-plugins"></span></a>
"""
self.assertContains(
response,
expected,
count=1,
html=True,
)
self.assertContains(
response,
'<a class="cms-btn cms-btn-switch-save" href="/fr/?preview&{}">'
'<span>View published</span></a>'.format(edit_off),
count=1,
html=True,
)
response = self.client.get("/fr/?preview&{}".format(edit_off))
self.assertContains(
response,
expected,
count=1,
html=True,
)
self.assertContains(
response,
'<a class="cms-btn cms-btn-action cms-btn-switch-edit" href="/fr/?{}">Edit</a>'
.format(edit_on),
count=1,
html=True,
)
def test_page_added_by_slave_can_be_published_by_user_master(self):
# add page
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page, created_by=self.user_slave)
# same as test_slave_can_add_page_under_slave_home
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertTrue(has_generic_permission(page.pk, self.user_master, "publish", page.site.pk))
# should be True user_master should have publish permissions for children as well
publish_page(page, self.user_master)
self.assertTrue(page.published)
def test_page_added_by_slave_can_be_published_by_user_master(self):
# add page
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page, created_by=self.user_slave)
# same as test_slave_can_add_page_under_slave_home
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertTrue(has_generic_permission(page.pk, self.user_master, "publish", page.site.pk))
# should be True user_master should have publish permissions for children as well
publish_page(page, self.user_master)
self.assertTrue(page.reload().published)
def test_extension_not_found(self, activate_cms, rf):
request = rf.get('/')
request.user = User.objects.create(username='******', is_superuser=True)
page = create_page('Test Page', 'INHERIT', 'en-us')
publish_page(page, request.user, 'en-us')
page.refresh_from_db()
template = Template((
'{%% load barbeque_tags %%}'
'{%% page_titleextension %s "extensionmodel" %%}'
) % page.pk)
context = Context({'request': request})
assert template.render(context) == 'None'
def test_critical_updated_after_page_publish(self, admin_user):
page = create_page('page', 'INHERIT', 'de')
publish_page(page, admin_user, 'de')
critical = Critical.objects.first()
critical.path = 'css/styles.css'
critical.css = 'test-critical-css'
critical.save()
publish_page(page, admin_user, 'de')
critical.refresh_from_db()
assert Critical.objects.count() == 1
assert critical.path == 'css/styles.css'
assert critical.css is None
def test_extension_not_found(self, rf):
request = rf.get('/')
request.user = User.objects.create(username='******', is_superuser=True)
page = create_page('Test Page', 'INHERIT', 'en-us')
publish_page(page, request.user, 'en-us')
page.refresh_from_db()
template = Template((
'{%% load cms_helpers %%}'
'{%% page_titleextension %s "extensionmodel" %%}'
) % page.pk)
context = Context({'request': request})
assert template.render(context) == 'None'
def test_page_added_by_slave_can_be_published_by_user_master(self):
# add page
page = create_page("page", "nav_playground.html", "en",
parent=self.slave_page, created_by=self.user_slave)
# same as test_slave_can_add_page_under_slave_home
# must not have public object yet
self.assertFalse(page.publisher_public)
self.assertTrue(user_can_publish_page(self.user_master, page))
# should be True user_master should have publish permissions for children as well
publish_page(self.slave_page, self.user_master, 'en')
page = publish_page(page, self.user_master, 'en')
self.assertTrue(page.publisher_public_id)
def _test_relation(self, publisher_is_draft):
placeholder = self.flavors_page.placeholders.get(slot='body')
chocolate_plugin = api.add_plugin(placeholder,
'FlavorPlugin',
self.LANGUAGE,
name=self.CHOCOLATE)
chocolate = chocolate_plugin.flavor
John = models.Photographer.objects.create(name=self.JOHN,
favorite=chocolate)
api.publish_page(self.flavors_page, self.superuser, self.LANGUAGE)
chocolate_of_interest = models.Flavor.objects.get(
name=self.CHOCOLATE,
placeholder__page__publisher_is_draft=publisher_is_draft)
self.assertEqual(chocolate_of_interest.fans.get().name, self.JOHN)
def test_relation_copied(self):
api.publish_page(
self.sundeas_page,
self.superuser,
self.LANGUAGE
)
banana_split_of_interest = models.Sundea.objects.get(
name=self.BANANA_SPLIT,
placeholder__page__publisher_is_draft=True
)
self.assertEqual(
banana_split_of_interest.pictures.get().name,
self.COVER_PICTURE
)
def test_relation_remains_when_origin_published(self):
api.publish_page(
self.sundeas_page,
self.superuser,
self.LANGUAGE
)
banana_split_of_interest = models.Sundea.objects.get(
name=self.BANANA_SPLIT,
placeholder__page__publisher_is_draft=True
)
self.assertEqual(
banana_split_of_interest.flavors.get().name,
self.BANANA
)
def test_relation_not_published_when_origin_not_public(self):
api.publish_page(
self.flavors_page,
self.superuser,
self.LANGUAGE
)
banana_of_interest = models.Flavor.objects.get(
name=self.BANANA,
placeholder__page__publisher_is_draft=False
)
self.assertRaises(
ObjectDoesNotExist,
banana_of_interest.sundeas.get
)
def create_plugin(self, language_code, plugin_parent, plugin_type,
post_data):
# placeholder_draft = self.placeholder_draft[language_code]
if plugin_parent is not None:
plugin_parent = plugin_parent.pk
url = (
"/{language_code}/admin/cms/page/add-plugin/"
"?placeholder_id={placeholder_id}"
"&plugin_type={plugin_type}"
"&cms_path=%2Fde%2Ffoo_bar%2F" # Not important
"&plugin_language={language_code}").format(
language_code=language_code,
placeholder_id=self.test_placeholder.pk,
plugin_type=plugin_type,
)
if plugin_parent is not None:
url += "&plugin_parent=%s" % plugin_parent
user = self.login(usertype='superuser')
print(url)
response = self.client.get(url, HTTP_ACCEPT_LANGUAGE=language_code)
if response.status_code == 302:
url = response.url
print("redirect url: %r" % url)
pprint(post_data)
response = self.client.post(url,
data=post_data,
HTTP_ACCEPT_LANGUAGE=language_code)
if response.status_code == 302:
self.assertRedirects(response, expected_url="FIXME")
else:
self.assertResponse(
response,
must_contain=('<div class="success"></div>', ),
must_not_contain=("Traceback", ),
status_code=200,
messages=[],
template_name="admin/cms/page/plugin/confirm_form.html",
html=False,
)
publish_page(self.test_page, user, language=language_code)
self.client = Client(
) # "log out the user" e.g.: run assert_plugin() with anonymous
def create_pages():
from cms.models import Placeholder
from cms.api import create_page, add_plugin, publish_page
from django.conf import settings
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
placeholder = {}
with open('starting_page.json') as data_file:
content = json.load(data_file)
try:
# try to get a feature template with fallback
template = settings.CMS_TEMPLATES[1][0]
if template != 'feature.html':
template = settings.CMS_TEMPLATES[0][0]
except IndexError:
template = settings.CMS_TEMPLATES[0][0]
lang = settings.LANGUAGES[0][0]
page = create_page(_('Home'), template, lang)
placeholder['main'] = page.placeholders.get(slot='content')
try:
# try to get a feature placeholder
placeholder_feature = page.placeholders.get(slot='feature')
add_plugin(placeholder_feature, 'TextPlugin', lang,
body=content['feature'])
except Placeholder.DoesNotExist:
# fallback, add it to the
add_plugin(placeholder['main'], 'TextPlugin', lang, body=content['feature'])
pass
# Add main content to a MultiColumnPlugin
multi_columns_plugin = add_plugin(placeholder['main'], 'MultiColumnPlugin', lang)
for column_content in content['main']:
col = add_plugin(placeholder['main'], 'ColumnPlugin', lang,
target=multi_columns_plugin, **{'width': '33%'})
add_plugin(placeholder['main'], 'TextPlugin', lang, body=column_content,
target=col)
# In order to publish the page there needs to be at least one user
if User.objects.count() > 0:
try:
publish_page(page, User.objects.all()[0], lang)
except TypeError:
# supporting old cms versions
publish_page(page, User.objects.all()[0])
def test_create_publish_copy(self):
# create new page to copy
page = create_page("page", "nav_playground.html", "en",
parent=self.home_page)
page = publish_page(page, self.user_master, 'en')
# copy it under master page...
# TODO: Use page.copy_page here
with self.login_user_context(self.user_master):
copied_page = self.copy_page(page, self.master_page)
self.check_published_page_attributes(page)
copied_page = publish_page(copied_page, self.user_master, 'en')
self.check_published_page_attributes(copied_page)
def handle(self, *args, **options):
try:
page_num = int(options['page-num'])
depth = int(options['depth'])
template = options['template']
plugin_num = int(options['plugin-num'])
self.create_page_descendant(template, depth,
page_num, plugin_num)
#Publish the pages
for page in Page.objects.drafts():
user = User.objects.get(id=1)
publish_page(page, user)
except Exception, e:
raise CommandError("There was an error running this command. ", e)
def create_page(self, language=None, site=None, published=True,
template='empty.html'):
if site is None:
site = Site.objects.get_current()
if language is None:
language = 'en'
page_data = self.get_new_page_data_dbfields(
site=site,
language=language,
template=template,
)
page = create_page(**page_data)
if published:
user = self.get_superuser()
publish_page(page, user, language)
return page
def test_absolute_url(self):
user = self.get_superuser()
page = create_page("page", "nav_playground.html", "en", published=True)
create_title("fr", "french home", page)
page_2 = create_page("inner", "nav_playground.html", "en", published=True, parent=page)
create_title("fr", "french inner", page_2)
publish_page(page_2, user, "fr")
self.assertEqual(page_2.get_absolute_url(), '/en/inner/')
self.assertEqual(page_2.get_absolute_url(language='en'), '/en/inner/')
self.assertEqual(page_2.get_absolute_url(language='fr'), '/fr/french-inner/')
with force_language('fr'):
self.assertEqual(page_2.get_absolute_url(), '/fr/french-inner/')
self.assertEqual(page_2.get_absolute_url(language='en'), '/en/inner/')
self.assertEqual(page_2.get_absolute_url(language='fr'), '/fr/french-inner/')
def test_user_globalpermission(self):
# Global user
with self.login_user_context(self.user_super):
user_global = User(username="******", is_active=True)
user_global.set_password("global")
user_global.save()
user_global = create_page_user(user_global, user_global)
user_global.is_staff = False
user_global.save() # Prevent is_staff permission
global_page = create_page("global", "nav_playground.html", "en",
published=True)
global_page = publish_page(global_page, user_global, approve=True)
# it's allowed for the normal user to view the page
assign_user_to_page(global_page, user_global,
global_permission=True, can_view=True)
url = global_page.get_absolute_url('en')
with self.login_user_context(user_global):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
with self.login_user_context(self.user_non_global):
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
