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_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 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_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_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_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)