def set_blog_page_cache(response): from django.core.cache import cache if not get_cms_setting('PAGE_CACHE'): return response request = response._request save_cache = True for placeholder in getattr(request, 'placeholders', []): if not placeholder.cache_placeholder: save_cache = False break if hasattr(request, 'toolbar'): if request.toolbar.edit_mode or request.toolbar.show_toolbar: save_cache = False if request.user.is_authenticated(): save_cache = False if not save_cache: add_never_cache_headers(response) return response else: version = _get_cache_version() ttl = get_cms_setting('CACHE_DURATIONS')['content'] cache.set( _blog_page_cache_key(request), (response.content, response._headers), ttl, version=version ) # See note in invalidate_cms_page_cache() _set_cache_version(version)
def add_structure_mode(self): switcher = self.toolbar.add_button_list('Mode Switcher', side=self.toolbar.RIGHT, extra_classes=['cms_toolbar-item-cms-mode-switcher']) switcher.add_button(_("Structure"), '?%s' % get_cms_setting('CMS_TOOLBAR_URL__BUILD'), active=self.toolbar.build_mode, disabled=not self.toolbar.build_mode) switcher.add_button(_("Content"), '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'), active=not self.toolbar.build_mode, disabled=self.toolbar.build_mode)
def test_get_placeholder_cache_key(self): version, vary_on_list = _get_placeholder_cache_version(self.placeholder, 'en', 1) desired_key = '{prefix}|render_placeholder|id:{id}|lang:{lang}|site:{site}|tz:{tz}|v:{version}|country-code:{cc}'.format( # noqa prefix=get_cms_setting('CACHE_PREFIX'), id=self.placeholder.pk, lang='en', site=1, tz=get_timezone_name(), version=version, cc='_', ) _set_placeholder_cache_version(self.placeholder, 'en', 1, version, vary_on_list=vary_on_list, duration=1) actual_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_request) self.assertEqual(actual_key, desired_key) en_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_request) de_key = _get_placeholder_cache_key(self.placeholder, 'de', 1, self.de_request) self.assertNotEqual(en_key, de_key) en_us_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_us_request) self.assertNotEqual(en_key, en_us_key) desired_key = '{prefix}|render_placeholder|id:{id}|lang:{lang}|site:{site}|tz:{tz}|v:{version}|country-code:{cc}'.format( # noqa prefix=get_cms_setting('CACHE_PREFIX'), id=self.placeholder.pk, lang='en', site=1, tz=get_timezone_name(), version=version, cc='US', ) self.assertEqual(en_us_key, desired_key)
def add_structure_mode_item(self, extra_classes=('cms_toolbar-item-cms-mode-switcher',)): build_mode = self.toolbar.build_mode build_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__BUILD') edit_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON') switcher = self.toolbar.add_button_list('Mode Switcher', side=self.toolbar.RIGHT, extra_classes=extra_classes) switcher.add_button(_('Structure'), build_url, active=build_mode, disabled=not build_mode) switcher.add_button(_('Content'), edit_url, active=not build_mode, disabled=build_mode)
def test_templates(self): """ Test the inheritance magic for templates """ parent = create_page("parent", "nav_playground.html", "en") child = create_page("child", "nav_playground.html", "en", parent=parent) grand_child = create_page("child", "nav_playground.html", "en", parent=child) child.template = constants.TEMPLATE_INHERITANCE_MAGIC grand_child.template = constants.TEMPLATE_INHERITANCE_MAGIC child.save() grand_child.save() # kill template cache delattr(grand_child, '_template_cache') with self.assertNumQueries(1): self.assertEqual(child.template, constants.TEMPLATE_INHERITANCE_MAGIC) self.assertEqual(parent.get_template_name(), grand_child.get_template_name()) # test template cache with self.assertNumQueries(0): grand_child.get_template() parent.template = constants.TEMPLATE_INHERITANCE_MAGIC parent.save() self.assertEqual(parent.template, constants.TEMPLATE_INHERITANCE_MAGIC) self.assertEqual(parent.get_template(), get_cms_setting('TEMPLATES')[0][0]) self.assertEqual(parent.get_template_name(), get_cms_setting('TEMPLATES')[0][1])
def add_admin_menu(self): if not self._admin_menu: self._admin_menu = self.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER, self.current_site.name) # Users button self.add_users_button(self._admin_menu) # sites menu if get_cms_setting('PERMISSION'): sites_queryset = get_user_sites_queryset(self.request.user) else: sites_queryset = Site.objects.all() if len(sites_queryset) > 1: sites_menu = self._admin_menu.get_or_create_menu('sites', _('Sites')) sites_menu.add_sideframe_item(_('Admin Sites'), url=admin_reverse('sites_site_changelist')) sites_menu.add_break(ADMIN_SITES_BREAK) for site in sites_queryset: sites_menu.add_link_item(site.name, url='http://%s' % site.domain, active=site.pk == self.current_site.pk) # admin self._admin_menu.add_sideframe_item(_('Administration'), url=admin_reverse('index')) self._admin_menu.add_break(ADMINISTRATION_BREAK) # cms users self._admin_menu.add_sideframe_item(_('User settings'), url=admin_reverse('cms_usersettings_change')) self._admin_menu.add_break(USER_SETTINGS_BREAK) # Disable toolbar self._admin_menu.add_link_item(_('Disable toolbar'), url='?%s' % get_cms_setting('CMS_TOOLBAR_URL__DISABLE')) self._admin_menu.add_break(TOOLBAR_DISABLE_BREAK) # logout self.add_logout_button(self._admin_menu)
def get_admin_menu_item_context(request, page, filtered=False): """ Used for rendering the page tree, inserts into context everything what we need for single item """ has_add_page_permission = page.has_add_permission(request) has_move_page_permission = page.has_move_page_permission(request) site = Site.objects.get_current() lang = get_language_from_request(request) #slug = page.get_slug(language=lang, fallback=True) # why was this here ?? metadata = "" if get_cms_setting('PERMISSION'): # jstree metadata generator md = [] #if not has_add_page_permission: if not has_move_page_permission: md.append(('valid_children', False)) md.append(('draggable', False)) if md: # just turn it into simple javascript object metadata = "{" + ", ".join(map(lambda e: "%s: %s" %(e[0], isinstance(e[1], bool) and str(e[1]) or e[1].lower() ), md)) + "}" has_add_on_same_level_permission = False opts = Page._meta if get_cms_setting('PERMISSION'): perms = has_global_page_permission(request, page.site_id, can_add=True) if (request.user.has_perm(opts.app_label + '.' + opts.get_add_permission()) and perms): has_add_on_same_level_permission = True if page.delete_requested(): css_class = "publisher_delete_requested" elif not page.published: css_class = "publisher_draft" else: css_class = publisher_classes.get(page.publisher_state, "") if not has_add_on_same_level_permission and page.parent_id: has_add_on_same_level_permission = permissions.has_generic_permission(page.parent_id, request.user, "add", page.site) #has_add_on_same_level_permission = has_add_page_on_same_level_permission(request, page) context = { 'page': page, 'site': site, 'lang': lang, 'filtered': filtered, 'metadata': metadata, 'css_class': css_class, 'has_change_permission': page.has_change_permission(request), 'has_publish_permission': page.has_publish_permission(request), 'has_delete_permission': page.has_delete_permission(request), 'has_move_page_permission': has_move_page_permission, 'has_add_page_permission': has_add_page_permission, 'has_add_on_same_level_permission': has_add_on_same_level_permission, 'CMS_PERMISSION': get_cms_setting('PERMISSION'), 'CMS_SHOW_END_DATE': get_cms_setting('SHOW_END_DATE'), } return context
def get_admin_menu_item_context(request, page, filtered=False, language=None): """ Used for rendering the page tree, inserts into context everything what we need for single item """ has_add_page_permission = page.has_add_permission(request) has_move_page_permission = page.has_move_page_permission(request) site = Site.objects.get_current() lang = get_language_from_request(request) metadata = "" if get_cms_setting("PERMISSION"): # jstree metadata generator md = [] if not has_move_page_permission: md.append(("valid_children", False)) md.append(("draggable", False)) if md: # just turn it into simple javascript object metadata = ( "{" + ", ".join(map(lambda e: "%s: %s" % (e[0], isinstance(e[1], bool) and str(e[1]) or e[1].lower()), md)) + "}" ) has_add_on_same_level_permission = False opts = Page._meta if get_cms_setting("PERMISSION"): if hasattr(request.user, "_global_add_perm_cache"): global_add_perm = request.user._global_add_perm_cache else: global_add_perm = GlobalPagePermission.objects.user_has_add_permission(request.user, page.site_id).exists() request.user._global_add_perm_cache = global_add_perm if request.user.has_perm(opts.app_label + "." + get_permission_codename("add", opts)) and global_add_perm: has_add_on_same_level_permission = True from cms.utils import permissions if not has_add_on_same_level_permission and page.parent_id: has_add_on_same_level_permission = permissions.has_generic_permission( page.parent_id, request.user, "add", page.site_id ) context = { "page": page, "site": site, "lang": lang, "filtered": filtered, "metadata": metadata, "preview_language": language, "has_change_permission": page.has_change_permission(request), "has_publish_permission": page.has_publish_permission(request), "has_delete_permission": page.has_delete_permission(request), "has_move_page_permission": has_move_page_permission, "has_add_page_permission": has_add_page_permission, "has_add_on_same_level_permission": has_add_on_same_level_permission, "CMS_PERMISSION": get_cms_setting("PERMISSION"), } return context
def get_admin_menu_item_context(request, page, filtered=False, language=None): """ Used for rendering the page tree, inserts into context everything what we need for single item """ has_add_page_permission = page.has_add_permission(request) has_move_page_permission = page.has_move_page_permission(request) site = Site.objects.get_current() lang = get_language_from_request(request) #slug = page.get_slug(language=lang, fallback=True) # why was this here ?? metadata = "" if get_cms_setting('PERMISSION'): # jstree metadata generator md = [] #if not has_add_page_permission: if not has_move_page_permission: md.append(('valid_children', False)) md.append(('draggable', False)) if md: # just turn it into simple javascript object metadata = "{" + ", ".join(map(lambda e: "%s: %s" % (e[0], isinstance(e[1], bool) and str(e[1]) or e[1].lower() ), md)) + "}" has_add_on_same_level_permission = False opts = Page._meta if get_cms_setting('PERMISSION'): if hasattr(request.user, '_global_add_perm_cache'): global_add_perm = request.user._global_add_perm_cache else: global_add_perm = GlobalPagePermission.objects.user_has_add_permission( request.user, page.site_id).exists() request.user._global_add_perm_cache = global_add_perm if request.user.has_perm(opts.app_label + '.' + opts.get_add_permission()) and global_add_perm: has_add_on_same_level_permission = True from cms.utils import permissions if not has_add_on_same_level_permission and page.parent_id: has_add_on_same_level_permission = permissions.has_generic_permission(page.parent_id, request.user, "add", page.site_id) #has_add_on_same_level_permission = has_add_page_on_same_level_permission(request, page) context = { 'page': page, 'site': site, 'lang': lang, 'filtered': filtered, 'metadata': metadata, 'preview_language': language, 'has_change_permission': page.has_change_permission(request), 'has_publish_permission': page.has_publish_permission(request), 'has_delete_permission': page.has_delete_permission(request), 'has_move_page_permission': has_move_page_permission, 'has_add_page_permission': has_add_page_permission, 'has_add_on_same_level_permission': has_add_on_same_level_permission, 'CMS_PERMISSION': get_cms_setting('PERMISSION'), } return context
def test_templates(self): """ Tests that the plain CMS_TEMPLATES works as usual """ original_files = [template[0] for template in settings.CMS_TEMPLATES] files = [template[0] for template in get_cms_setting('TEMPLATES')] if get_cms_setting('TEMPLATE_INHERITANCE'): original_files.append(constants.TEMPLATE_INHERITANCE_MAGIC) self.assertEqual(len(files), 6) self.assertEqual(set(files), set(original_files))
def test_toolbar_staff(self): page = create_page('test', 'nav_playground.html', 'en', published=True) request = self.get_page_request(page, self.get_superuser()) toolbar = CMSToolbar(request) items = toolbar.get_items({}) # Logo + edit-mode + templates + page-menu + admin-menu + logout self.assertEqual(len(items), 6) # check the logo is there logo = items[0] self.assertIsInstance(logo, Anchor) # check the edit-mode switcher is there and the switcher is turned off edit = items[1] self.assertIsInstance(edit, Switcher) self.assertFalse(toolbar.edit_mode) # check templates templates = items[2] self.assertIsInstance(templates, List) self.assertEqual(len(templates.raw_items), len(get_cms_setting('TEMPLATES'))) base = reverse('admin:cms_page_change_template', args=(page.pk,)) for item, template in zip(templates.raw_items, get_cms_setting('TEMPLATES')): self.assertEqual(item.url, '%s?template=%s' % (base, template[0])) # check page menu pagemenu = items[3] self.assertIsInstance(pagemenu, List) self.assertEqual(len(pagemenu.raw_items), 4) overview, addchild, addsibling, delete = pagemenu.raw_items self.assertEqual(overview.url, reverse('admin:cms_page_changelist')) self.assertEqual(addchild.serialize_url({}, toolbar), reverse('admin:cms_page_add') + '?position=last-child&target=%s' % page.pk) self.assertEqual(addsibling.serialize_url({}, toolbar), reverse('admin:cms_page_add') + '?position=last-child') self.assertEqual(delete.serialize_url({}, toolbar), reverse('admin:cms_page_delete', args=(page.pk,))) # check the admin-menu admin = items[4] self.assertIsInstance(admin, List) self.assertEqual(len(admin.raw_items), 3) # page settings, history and admin self.assertIsInstance(admin.raw_items[0], ListItem) self.assertIsInstance(admin.raw_items[1], ListItem) self.assertIsInstance(admin.raw_items[2], ListItem) # check the logout button logout = items[-1] self.assertIsInstance(logout, GetButton) self.assertEqual(logout.url, '?cms-toolbar-logout')
def test_multisite(self): """ Checking that templates can be loaded by the template loader """ templates = get_cms_setting('TEMPLATES') for template in templates: if template[0] != constants.TEMPLATE_INHERITANCE_MAGIC: self.assertTrue(template[0].find('%s/' % SITE_PATH[1]) >= -1) with self.settings(SITE_ID=2): templates = get_cms_setting('TEMPLATES') for template in templates: if template[0] != constants.TEMPLATE_INHERITANCE_MAGIC: self.assertTrue(template[0].find('%s/' % SITE_PATH[2]) >= -1)
def get_absolute_url(self, link): cache_key = '{0}anylink-page-url:{1}:{2}'.format( get_cms_setting('CACHE_PREFIX'), str(link.page_id), get_language()) url = cache.get(cache_key) if url is None: url = link.page.get_absolute_url() cache.set(cache_key, url, get_cms_setting('CACHE_DURATIONS')['content']) if link.anchor: parsed = urlparse.urlparse(url) parsed = parsed._replace(fragment=link.anchor) url = parsed.geturl() return url
def populate(self): # always use draft if we have a page self.page = get_page_draft(self.request.current_page) if not self.page: # Nothing to do return # check global permissions if CMS_PERMISSIONS is active if get_cms_setting('PERMISSION'): has_global_current_page_change_permission = has_page_change_permission(self.request) else: has_global_current_page_change_permission = False # check if user has page edit permission can_change = self.request.current_page and self.request.current_page.has_change_permission(self.request) if has_global_current_page_change_permission or can_change: try: icon_extension = MenuExtension.objects.get(extended_object_id=self.page.id) except MenuExtension.DoesNotExist: icon_extension = None try: if icon_extension: url = reverse('admin:app_menuextension_change', args=(icon_extension.pk,)) else: url = reverse('admin:app_menuextension_add') + '?extended_object=%s' % self.page.pk except NoReverseMatch: pass else: not_edit_mode = not self.toolbar.edit_mode current_page_menu = self.toolbar.get_or_create_menu('page') current_page_menu.add_modal_item(_('Menu Settings'), url=url, disabled=not_edit_mode)
def get_placeholder_conf(setting, placeholder, template=None, default=None): """ Returns the placeholder configuration for a given setting. The key would for example be 'plugins' or 'name'. If a template is given, it will try CMS_PLACEHOLDER_CONF['template placeholder'] and CMS_PLACEHOLDER_CONF['placeholder'], if no template is given only the latter is checked. """ if placeholder: keys = [] if template: keys.append("%s %s" % (template, placeholder)) keys.append(placeholder) for key in keys: conf = get_cms_setting('PLACEHOLDER_CONF').get(key) if not conf: continue value = conf.get(setting) if value is not None: return value inherit = conf.get('inherit') if inherit: if ' ' in inherit: inherit = inherit.split(' ') else: inherit = (None, inherit,) value = get_placeholder_conf(setting, inherit[1], inherit[0], default) if value is not None: return value return default
def _setup_extension_toolbar(self): """ Does all the sanity check for the current environment: * that a page exists * permissions check on the current page It returns the page menu or None if the above conditions are not met """ page = self._get_page() if not page: # Nothing to do return # check global permissions if CMS_PERMISSIONS is active if get_cms_setting('PERMISSION'): has_global_current_page_change_permission = has_page_change_permission(self.request) else: has_global_current_page_change_permission = True # check if user has page edit permission can_change = (self.request.current_page and self.request.current_page.has_change_permission(self.request)) current_page_menu = self.toolbar.get_or_create_menu('page') if can_change and has_global_current_page_change_permission: return current_page_menu else: return
def test_cache_invalidation(self): # Ensure that we're testing in an environment WITHOUT the MW cache... exclude = [ 'django.middleware.cache.UpdateCacheMiddleware', 'django.middleware.cache.FetchFromCacheMiddleware' ] overrides = dict() if getattr(settings, 'MIDDLEWARE', None): overrides['MIDDLEWARE'] = [mw for mw in settings.MIDDLEWARE if mw not in exclude] else: overrides['MIDDLEWARE_CLASSES'] = [mw for mw in settings.MIDDLEWARE_CLASSES if mw not in exclude] with self.settings(**overrides): # Silly to do these tests if this setting isn't True page_cache_setting = get_cms_setting('PAGE_CACHE') self.assertTrue(page_cache_setting) page1 = create_page('test page 1', 'nav_playground.html', 'en', published=True) placeholder = page1.placeholders.get(slot="body") add_plugin(placeholder, "TextPlugin", 'en', body="First content") page1.publish('en') response = self.client.get('/en/') self.assertContains(response, 'First content') response = self.client.get('/en/') self.assertContains(response, 'First content') add_plugin(placeholder, "TextPlugin", 'en', body="Second content") page1.publish('en') response = self.client.get('/en/') self.assertContains(response, 'Second content')
def test_clean_overwrite_url(self): user = AnonymousUser() user.is_superuser = True user.pk = 1 request = type('Request', (object,), {'user': user}) with SettingsOverride(): data = { 'title': 'TestPage', 'slug': 'test-page', 'language': 'en', 'overwrite_url': '/overwrite/url/', 'site': Site.objects.get_current().pk, 'template': get_cms_setting('TEMPLATES')[0][0], 'published': True } form = PageForm(data) self.assertTrue(form.is_valid(), form.errors.as_text()) # WTF? WHY DOES form.save() not handle this stuff??? instance = form.save() instance.permission_user_cache = user instance.permission_advanced_settings_cache = True Title.objects.set_or_create(request, instance, form, 'en') form = PageForm(data, instance=instance) self.assertTrue(form.is_valid(), form.errors.as_text())
def get_value(self, context, page_lookup, lang, site): from django.core.cache import cache site_id = get_site_id(site) request = context.get('request', False) if not request: return '' if lang is None: lang = get_language_from_request(request) cache_key = _get_cache_key('page_url', page_lookup, lang, site_id) + \ '_type:absolute_url' url = cache.get(cache_key) if not url: page = _get_page_by_untyped_arg(page_lookup, request, site_id) if page: url = page.get_absolute_url(language=lang) cache.set(cache_key, url, get_cms_setting('CACHE_DURATIONS')['content']) if url: return url return ''
def setUp(self): super(CMSRequestBasedTest, self).setUp() self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.root_page = api.create_page( 'root page', self.template, self.language, published=True ) self.app_config = FaqConfig.objects.create(namespace='aldryn_faq', permalink_type='Bp', non_permalink_handling=301) self.page = api.create_page( 'faq', self.template, self.language, published=True, parent=self.root_page, apphook='FaqApp', apphook_namespace=self.app_config.namespace ) self.placeholder = self.page.placeholders.all()[0] for page in [self.root_page, self.page]: for language, _ in settings.LANGUAGES[1:]: api.create_title(language, page.get_slug(), page) page.publish(language)
def test_hide_untranslated(self): TESTLANG = get_primary_lanaguage() TESTLANG2 = get_secondary_lanaguage() page = create_page("mlpage-%s" % TESTLANG, "nav_playground.html", TESTLANG) create_title(TESTLANG2, "mlpage-%s" % TESTLANG2, page, slug=page.get_slug()) page2 = create_page("mlpage-2-%s" % TESTLANG, "nav_playground.html", TESTLANG, parent=page) page.publish(TESTLANG) page.publish(TESTLANG2) page2.publish(TESTLANG) menu = CMSMenu() lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) request_1 = self.get_request('/%s/' % TESTLANG, TESTLANG) request_2 = self.get_request('/%s/' % TESTLANG2, TESTLANG2) lang_settings[1][1]['hide_untranslated'] = False with SettingsOverride(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertEqual(list_1, list_2) self.assertEqual(len(list_1), 2) lang_settings[1][1]['hide_untranslated'] = True with SettingsOverride(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertNotEqual(list_1, list_2) self.assertEqual(len(list_2), 1) self.assertEqual(len(list_1), 2)
def clear_permission_cache(): version = get_cache_version() if version > 1: cache.incr(get_cache_version_key()) else: cache.set(get_cache_version_key(), 2, get_cms_setting('CACHE_DURATIONS')['permissions'])
def _build_nodes(self, request, site_id): """ This is slow. Caching must be used. One menu is built per language and per site. Namespaces: they are ID prefixes to avoid node ID clashes when plugging multiple trees together. - We iterate on the list of nodes. - We store encountered nodes in a dict (with namespaces): done_nodes[<namespace>][<node's id>] = node - When a node has a parent defined, we lookup that parent in done_nodes if it's found: set the node as the node's parent's child (re-read this) else: the node is put at the bottom of the list """ # Before we do anything, make sure that the menus are expanded. self._expand_menus() # Cache key management lang = get_language() prefix = getattr(settings, "CMS_CACHE_PREFIX", "menu_cache_") key = "%smenu_nodes_%s_%s" % (prefix, lang, site_id) if request.user.is_authenticated(): key += "_%s_user" % request.user.pk cached_nodes = cache.get(key, None) if cached_nodes: return cached_nodes final_nodes = [] for menu_class_name in self.menus: menu = self.menus[menu_class_name] try: if isinstance(menu, type): menu = menu() nodes = menu.get_nodes(request) except NoReverseMatch: # Apps might raise NoReverseMatch if an apphook does not yet # exist, skip them instead of crashing nodes = [] toolbar = getattr(request, 'toolbar', None) if toolbar and toolbar.is_staff: messages.error(request, _('Menu %s cannot be loaded. Please, make sure all ' 'its urls exist and can be resolved.') % menu_class_name) logger.error("Menu %s could not be loaded." % menu_class_name, exc_info=True) # nodes is a list of navigation nodes (page tree in cms + others) final_nodes += _build_nodes_inner_for_one_menu( nodes, menu_class_name) cache.set(key, final_nodes, get_cms_setting('CACHE_DURATIONS')['menus']) # We need to have a list of the cache keys for languages and sites that # span several processes - so we follow the Django way and share through # the database. It's still cheaper than recomputing every time! # This way we can selectively invalidate per-site and per-language, # since the cache shared but the keys aren't CacheKey.objects.get_or_create(key=key, language=lang, site=site_id) return final_nodes
def check_sekizai(output): with output.section("Sekizai") as section: if is_installed('sekizai'): section.success("Sekizai is installed") else: section.error("Sekizai is not installed, could not find 'sekizai' in INSTALLED_APPS") if DJANGO_1_7: if 'sekizai.context_processors.sekizai' in settings.TEMPLATE_CONTEXT_PROCESSORS: section.success("Sekizai template context processor is installed") else: section.error("Sekizai template context processor is not installed, could not find 'sekizai.context_processors.sekizai' in TEMPLATE_CONTEXT_PROCESSORS") else: processors = list(chain(*[template['OPTIONS'].get('context_processors', []) for template in settings.TEMPLATES])) if 'sekizai.context_processors.sekizai' in processors: section.success("Sekizai template context processor is installed") else: section.error("Sekizai template context processor is not installed, could not find 'sekizai.context_processors.sekizai' in TEMPLATES option context_processors") for template, _ in get_cms_setting('TEMPLATES'): if template == constants.TEMPLATE_INHERITANCE_MAGIC: continue if validate_template(template, ['js', 'css']): section.success("Sekizai namespaces 'js' and 'css' found in %r" % template) else: section.error("Sekizai namespaces 'js' and 'css' not found in %r" % template) if section.successful: section.finish_success("Sekizai configuration okay") else: section.finish_error("Sekizai configuration has errors")
def check_sekizai(output): with output.section("Sekizai") as section: sekizai_installed = is_installed('sekizai') if sekizai_installed: section.success("Sekizai is installed") else: section.error("Sekizai is not installed, could not find 'sekizai' in INSTALLED_APPS") processors = list( chain(*[template['OPTIONS'].get('context_processors', []) for template in settings.TEMPLATES])) if 'sekizai.context_processors.sekizai' in processors: section.success("Sekizai template context processor is installed") else: section.error("Sekizai template context processor is not installed, could not find " "'sekizai.context_processors.sekizai' in TEMPLATES option context_processors") if not sekizai_installed: # sekizai is not installed. # we can't reliable check templates # because template loading won't work return for template, _ in get_cms_setting('TEMPLATES'): if template == constants.TEMPLATE_INHERITANCE_MAGIC: continue if validate_template(template, ['js', 'css']): section.success("Sekizai namespaces 'js' and 'css' found in %r" % template) else: section.error("Sekizai namespaces 'js' and 'css' not found in %r" % template) if section.successful: section.finish_success("Sekizai configuration okay") else: section.finish_error("Sekizai configuration has errors")
def _get_placeholder(current_page, page, context, name): from django.core.cache import cache placeholder_cache = getattr(current_page, '_tmp_placeholders_cache', {}) if page.pk in placeholder_cache: placeholder = placeholder_cache[page.pk].get(name, None) if placeholder: return placeholder placeholder_cache[page.pk] = {} placeholders = page.rescan_placeholders().values() fetch_placeholders = [] request = context['request'] if not get_cms_setting('PLACEHOLDER_CACHE') or (hasattr(request, 'toolbar') and request.toolbar.edit_mode): fetch_placeholders = placeholders else: for placeholder in placeholders: cache_key = placeholder.get_cache_key(get_language()) cached_value = cache.get(cache_key) if not cached_value is None: restore_sekizai_context(context, cached_value['sekizai']) placeholder.content_cache = cached_value['content'] else: fetch_placeholders.append(placeholder) placeholder.cache_checked = True if fetch_placeholders: assign_plugins(context['request'], fetch_placeholders, page.get_template(), get_language()) for placeholder in placeholders: placeholder_cache[page.pk][placeholder.slot] = placeholder placeholder.page = page current_page._tmp_placeholders_cache = placeholder_cache placeholder = placeholder_cache[page.pk].get(name, None) if page.application_urls and not placeholder: raise PlaceholderNotFound( '"%s" placeholder not found in an apphook application. Please use a static placeholder instead.' % name) return placeholder
def check_i18n(output): with output.section("Internationalization") as section: if isinstance(getattr(settings, 'CMS_LANGUAGES', {}), dict): section.success("New style CMS_LANGUAGES") else: section.warn("Old style (tuple based) CMS_LANGUAGES, please switch to the new (dictionary based) style") if getattr(settings, 'LANGUAGE_CODE', '').find('_') > -1: section.warn("LANGUAGE_CODE must contain a valid language code, not a locale (e.g.: 'en-us' instead of " "'en_US'): '%s' provided" % getattr(settings, 'LANGUAGE_CODE', '')) for lang in getattr(settings, 'LANGUAGES', ()): if lang[0].find('_') > -1: section.warn("LANGUAGES must contain valid language codes, not locales (e.g.: 'en-us' instead of " "'en_US'): '%s' provided" % lang[0]) if settings.SITE_ID == hash(settings.SITE_ID): for site, items in get_cms_setting('LANGUAGES').items(): if type(site) == int: for lang in items: if lang['code'].find('_') > -1: section.warn("CMS_LANGUAGES entries must contain valid language codes, not locales (e.g.: " "'en-us' instead of 'en_US'): '%s' provided" % lang['code']) else: section.error("SITE_ID must be an integer, not %r" % settings.SITE_ID) for deprecated in ['CMS_HIDE_UNTRANSLATED', 'CMS_LANGUAGE_FALLBACK', 'CMS_LANGUAGE_CONF', 'CMS_SITE_LANGUAGES', 'CMS_FRONTEND_LANGUAGES']: if hasattr(settings, deprecated): section.warn("Deprecated setting %s found. This setting is now handled in the new style " "CMS_LANGUAGES and can be removed" % deprecated)
def get_placeholder_content(context, request, current_page, name, inherit, default): from django.core.cache import cache edit_mode = getattr(request, 'toolbar', None) and getattr(request.toolbar, 'edit_mode') pages = [current_page] # don't display inherited plugins in edit mode, so that the user doesn't # mistakenly edit/delete them. This is a fix for issue #1303. See the discussion # there for possible enhancements if inherit and not edit_mode: pages = chain([current_page], current_page.get_cached_ancestors(ascending=True)) for page in pages: placeholder = _get_placeholder(current_page, page, context, name) if placeholder is None: continue if not edit_mode and get_cms_setting('PLACEHOLDER_CACHE'): if hasattr(placeholder, 'content_cache'): return mark_safe(placeholder.content_cache) if not hasattr(placeholder, 'cache_checked'): cache_key = placeholder.get_cache_key(get_language()) cached_value = cache.get(cache_key) if not cached_value is None: restore_sekizai_context(context, cached_value['sekizai']) return mark_safe(cached_value['content']) if not get_plugins(request, placeholder, page.get_template()): continue content = render_placeholder(placeholder, context, name) if content: return content # if we reach this point, we have an empty or non-existant placeholder # call _get_placeholder again to get the placeholder properly rendered # in frontend editing placeholder = _get_placeholder(current_page, current_page, context, name) return render_placeholder(placeholder, context, name, default=default)
def setUp(self): self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.page = api.create_page('page', self.template, self.language, published=True) self.placeholder = self.page.placeholders.all()[0] self.superuser = self.create_superuser() self.random = Randomness()
def _get_cache_key(name, page_lookup, lang, site_id): if isinstance(page_lookup, Page): page_key = str(page_lookup.pk) else: page_key = str(page_lookup) page_key = _clean_key(page_key) return get_cms_setting('CACHE_PREFIX') + name + '__page_lookup:' + page_key + '_site:' + str(site_id) + '_lang:' + str(lang)
def add_structure_mode_item( self, extra_classes=('cms-toolbar-item-cms-mode-switcher', )): build_mode = self.toolbar.build_mode build_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__BUILD') edit_url = '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON') if self.request.user.has_perm("cms.use_structure"): switcher = self.toolbar.add_button_list( 'Mode Switcher', side=self.toolbar.RIGHT, extra_classes=extra_classes) switcher.add_button(_('Structure'), build_url, active=build_mode, disabled=False) switcher.add_button(_('Content'), edit_url, active=not build_mode, disabled=False)
def test_get_placeholder_cache_version_key(self): cache_version_key = '{prefix}|placeholder_cache_version|id:{id}|lang:{lang}|site:{site}'.format( prefix=get_cms_setting('CACHE_PREFIX'), id=self.placeholder.pk, lang='en', site=1, ) self.assertEqual( _get_placeholder_cache_version_key(self.placeholder, 'en', 1), cache_version_key)
def set_placeholder_cache(placeholder, lang, content): """ Caches the rendering of a placeholder """ from django.core.cache import cache cache.set(_placeholder_cache_key(placeholder, lang), content, get_cms_setting('CACHE_DURATIONS')['content'], version=_get_cache_version()) _set_cache_version(_get_cache_version())
def is_restricted(page, request): if get_cms_setting('PERMISSION'): if hasattr(page, 'permission_restricted'): text = bool(page.permission_restricted) else: all_perms = list(get_any_page_view_permissions(request, page)) text = bool(all_perms) return text else: return boolean_icon(None)
def test_invalidate_restart(self): # Clear the entire cache for a clean slate cache.clear() # Ensure that we're testing in an environment WITHOUT the MW cache... exclude = [ 'django.middleware.cache.UpdateCacheMiddleware', 'django.middleware.cache.FetchFromCacheMiddleware' ] mw_classes = [ mw for mw in settings.MIDDLEWARE_CLASSES if mw not in exclude ] with self.settings(MIDDLEWARE_CLASSES=mw_classes): # Silly to do these tests if this setting isn't True page_cache_setting = get_cms_setting('PAGE_CACHE') self.assertTrue(page_cache_setting) # Create a test page page1 = create_page('test page 1', 'nav_playground.html', 'en', published=True) # Add some content placeholder = page1.placeholders.filter(slot="body")[0] add_plugin(placeholder, "TextPlugin", 'en', body="English") add_plugin(placeholder, "TextPlugin", 'de', body="Deutsch") # Create a request object request = self.get_request(page1.get_path(), 'en') # Ensure that user is NOT authenticated self.assertFalse(request.user.is_authenticated()) # Test that the page is initially uncached with self.assertNumQueries(FuzzyInt(1, 20)): response = self.client.get('/en/') self.assertEqual(response.status_code, 200) # # Test that subsequent requests of the same page are cached by # asserting that they require fewer queries. # with self.assertNumQueries(0): response = self.client.get('/en/') self.assertEqual(response.status_code, 200) old_plugins = plugin_pool.plugins plugin_pool.clear() plugin_pool.discover_plugins() plugin_pool.plugins = old_plugins with self.assertNumQueries(FuzzyInt(1, 20)): response = self.client.get('/en/') self.assertEqual(response.status_code, 200)
def test_get_placeholder_cache_key(self): version, vary_on_list = _get_placeholder_cache_version( self.placeholder, 'en', 1) desired_key = '{prefix}|render_placeholder|id:{id}|lang:{lang}|site:{site}|tz:{tz}|v:{version}|country-code:{cc}'.format( # noqa prefix=get_cms_setting('CACHE_PREFIX'), id=self.placeholder.pk, lang='en', site=1, tz=get_timezone_name(), version=version, cc='_', ) _set_placeholder_cache_version(self.placeholder, 'en', 1, version, vary_on_list=vary_on_list, duration=1) actual_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_request) self.assertEqual(actual_key, desired_key) en_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_request) de_key = _get_placeholder_cache_key(self.placeholder, 'de', 1, self.de_request) self.assertNotEqual(en_key, de_key) en_us_key = _get_placeholder_cache_key(self.placeholder, 'en', 1, self.en_us_request) self.assertNotEqual(en_key, en_us_key) desired_key = '{prefix}|render_placeholder|id:{id}|lang:{lang}|site:{site}|tz:{tz}|v:{version}|country-code:{cc}'.format( # noqa prefix=get_cms_setting('CACHE_PREFIX'), id=self.placeholder.pk, lang='en', site=1, tz=get_timezone_name(), version=version, cc='US', ) self.assertEqual(en_us_key, desired_key)
def add_admin_menu(self): admin_menu = self.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER, self.current_site.name) # Users button self.add_users_button(admin_menu) # sites menu if get_cms_setting('PERMISSION'): sites_queryset = get_user_sites_queryset(self.request.user) else: sites_queryset = Site.objects.all() if len(sites_queryset) > 1: sites_menu = admin_menu.get_or_create_menu('sites', _('Sites')) sites_menu.add_sideframe_item( _('Admin Sites'), url=admin_reverse('sites_site_changelist')) sites_menu.add_break(ADMIN_SITES_BREAK) for site in sites_queryset: sites_menu.add_link_item( site.name, url='http://%s' % site.domain, active=site.pk == self.current_site.pk) # admin admin_menu.add_sideframe_item(_('Administration'), url=admin_reverse('index')) admin_menu.add_break(ADMINISTRATION_BREAK) # cms users admin_menu.add_sideframe_item( _('User settings'), url=admin_reverse('cms_usersettings_change')) admin_menu.add_break(USER_SETTINGS_BREAK) # Disable toolbar admin_menu.add_link_item(_('Disable toolbar'), url='?%s' % get_cms_setting('CMS_TOOLBAR_URL__DISABLE')) admin_menu.add_break(TOOLBAR_DISABLE_BREAK) # logout self.add_logout_button(admin_menu)
def set_permission_cache(user, key, value): """ Helper method for storing values in cache. Stores used keys so all of them can be cleaned when clean_permission_cache gets called. """ from django.core.cache import cache # store this key, so we can clean it when required cache_key = get_cache_key(user, key) cache.set(cache_key, value, get_cms_setting('CACHE_DURATIONS')['permissions'], version=get_cache_permission_version())
def test_templates(self): """ Test the inheritance magic for templates """ parent = create_page("parent", "nav_playground.html", "en") child = create_page("child", "nav_playground.html", "en", parent=parent) grand_child = create_page("grand child", "nav_playground.html", "en", parent=child) child2 = create_page("child2", "col_two.html", "en", parent=parent) grand_child2 = create_page("grand child2", "nav_playground.html", "en", parent=child2) child.template = constants.TEMPLATE_INHERITANCE_MAGIC grand_child.template = constants.TEMPLATE_INHERITANCE_MAGIC child.save() grand_child.save() grand_child2.template = constants.TEMPLATE_INHERITANCE_MAGIC grand_child2.save() # kill template cache delattr(grand_child, '_template_cache') with self.assertNumQueries(1): self.assertEqual(child.template, constants.TEMPLATE_INHERITANCE_MAGIC) self.assertEqual(parent.get_template_name(), grand_child.get_template_name()) # test template cache with self.assertNumQueries(0): grand_child.get_template() # kill template cache delattr(grand_child2, '_template_cache') with self.assertNumQueries(1): self.assertEqual(child2.template, 'col_two.html') self.assertEqual(child2.get_template_name(), grand_child2.get_template_name()) # test template cache with self.assertNumQueries(0): grand_child2.get_template() parent.template = constants.TEMPLATE_INHERITANCE_MAGIC parent.save() self.assertEqual(parent.template, constants.TEMPLATE_INHERITANCE_MAGIC) self.assertEqual(parent.get_template(), get_cms_setting('TEMPLATES')[0][0]) self.assertEqual(parent.get_template_name(), get_cms_setting('TEMPLATES')[0][1])
def setUp(self): # prepare root page self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.root_page = api.create_page( 'root page', self.template, self.language, published=True) # create translations for all languages for language, _ in settings.LANGUAGES[1:]: api.create_title( language, self.root_page.get_slug(), self.root_page) self.root_page.publish(language)
def setUp(self): self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.page = api.create_page('page', self.template, self.language, published=True) api.create_title('de', 'page de', self.page) self.page.publish('de') self.placeholder = self.page.placeholders.all()[0] self.superuser = self.create_superuser() super(DefaultSetupMixin, self).setUp()
def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None): """ We just need the popup interface here """ context.update({ 'preview': not "no_preview" in request.GET, 'is_popup': True, 'plugin': self.cms_plugin_instance, 'CMS_MEDIA_URL': get_cms_setting('MEDIA_URL'), }) return super(CMSPluginBase, self).render_change_form(request, context, add, change, form_url, obj)
def add_admin_menu(self): if not self._admin_menu: self._admin_menu = self.toolbar.get_or_create_menu( ADMIN_MENU_IDENTIFIER, self.current_site.name) # Users button self.add_users_button(self._admin_menu) # sites menu sites_queryset = get_user_sites_queryset(self.request.user) if len(sites_queryset) > 1: sites_menu = self._admin_menu.get_or_create_menu( 'sites', _('Sites')) sites_menu.add_sideframe_item( _('Admin Sites'), url=admin_reverse('sites_site_changelist')) sites_menu.add_break(ADMIN_SITES_BREAK) for site in sites_queryset: sites_menu.add_link_item( site.name, url='http://%s' % site.domain, active=site.pk == self.current_site.pk) # admin self._admin_menu.add_sideframe_item(_('Administration'), url=admin_reverse('index')) self._admin_menu.add_break(ADMINISTRATION_BREAK) # clipboard if self.toolbar.edit_mode or self.toolbar.build_mode: # True if the clipboard exists and there's plugins in it. clipboard_is_bound = self.get_clipboard_plugins().exists() self._admin_menu.add_link_item( _('Clipboard...'), url='#', extra_classes=['cms-clipboard-trigger'], disabled=not clipboard_is_bound) self._admin_menu.add_link_item( _('Clear clipboard'), url='#', extra_classes=['cms-clipboard-empty'], disabled=not clipboard_is_bound) self._admin_menu.add_break(CLIPBOARD_BREAK) # Disable toolbar self._admin_menu.add_link_item( _('Disable toolbar'), url='?%s' % get_cms_setting('CMS_TOOLBAR_URL__DISABLE')) self._admin_menu.add_break(TOOLBAR_DISABLE_BREAK) # logout self.add_logout_button(self._admin_menu)
def _set_cache_version(version): ''' Set the cache version to the specified value. ''' from django.core.cache import cache cache.set( CMS_PAGE_CACHE_VERSION_KEY, version, get_cms_setting('CACHE_DURATIONS')['content'] )
def _get_placeholder_cache_key(placeholder, lang, site_id, request, soft=False): """ Returns the fully-addressed cache key for the given placeholder and the request. The kwarg «soft» should be set to True if getting the cache key to then read from the cache. If instead the key retrieval is to support a cache write, let «soft» be False. """ prefix = get_cms_setting('CACHE_PREFIX') version, vary_on_list = _get_placeholder_cache_version( placeholder, lang, site_id) main_key = '{prefix}|render_placeholder|id:{id}|lang:{lang}|site:{site}|tz:{tz}|v:{version}'.format( prefix=prefix, id=placeholder.pk, lang=lang, site=site_id, tz=get_timezone_name(), version=version, ) if not soft: # We are about to write to the cache, so we want to get the latest # vary_cache_on headers and the correct cache expiration, ignoring any # we already have. If the placeholder has already been rendered, this # will be very efficient (zero-additional queries) due to the caching # of all its plugins during the rendering process anyway. vary_on_list = placeholder.get_vary_cache_on(request) duration = placeholder.get_cache_expiration(request, now()) # Update the main placeholder cache version _set_placeholder_cache_version(placeholder, lang, site_id, version, vary_on_list, duration) sub_key_list = [] for key in vary_on_list: value = request.META.get(get_header_name(key)) or '_' sub_key_list.append(key + ':' + value) cache_key = main_key if sub_key_list: cache_key += '|' + '|'.join(sub_key_list) if len(cache_key) > 250: cache_key = '{prefix}|{hash}'.format( prefix=prefix, hash=hashlib.sha1(cache_key.encode('utf-8')).hexdigest(), ) return cache_key
def test_site_publish(self): self._login_context.__exit__(None, None, None) pages = {"2": list(range(0, 5)), "3": list(range(0, 5))} lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) lang_settings[3][1]['public'] = True with self.settings(CMS_LANGUAGES=lang_settings, LANGUAGE_CODE="de"): with self.settings(SITE_ID=self.site2.pk): pages["2"][0] = create_page("page_2", "nav_playground.html", "de", site=self.site2) pages["2"][0].publish('de') pages["2"][1] = create_page("page_2_1", "nav_playground.html", "de", parent=pages["2"][0], site=self.site2) pages["2"][2] = create_page("page_2_2", "nav_playground.html", "de", parent=pages["2"][0], site=self.site2) pages["2"][3] = create_page("page_2_1_1", "nav_playground.html", "de", parent=pages["2"][1], site=self.site2) pages["2"][4] = create_page("page_2_1_2", "nav_playground.html", "de", parent=pages["2"][1], site=self.site2) for page in pages["2"]: page.publish('de') for page in pages["2"]: if page.is_home: page_url = "/de/" else: page_url = page.get_absolute_url(language='de') response = self.client.get(page_url) self.assertEqual(response.status_code, 200) with self.settings(SITE_ID=self.site3.pk): pages["3"][0] = create_page("page_3", "nav_playground.html", "de", site=self.site3) pages["3"][0].publish('de') pages["3"][1] = create_page("page_3_1", "nav_playground.html", "de", parent=pages["3"][0], site=self.site3) pages["3"][2] = create_page("page_3_2", "nav_playground.html", "de", parent=pages["3"][0], site=self.site3) pages["3"][3] = create_page("page_3_1_1", "nav_playground.html", "de", parent=pages["3"][1], site=self.site3) pages["3"][4] = create_page("page_3_1_2", "nav_playground.html", "de", parent=pages["3"][1], site=self.site3) for page in pages["3"]: page.publish('de') for page in pages["3"]: if page.is_home: page_url = "/de/" else: page_url = page.get_absolute_url(language='de') response = self.client.get(page_url) self.assertEqual(response.status_code, 200)
def test_wrong_plugin_language(self): page = create_page("page", "nav_playground.html", "en", published=True) ph_en = page.placeholders.get(slot="body") add_plugin(ph_en, "TextPlugin", "en", body="I'm the first") title = Title(title="page", slug="page", language="ru", page=page) title.save() # add wrong plugin language add_plugin(ph_en, "TextPlugin", "ru", body="I'm the second") page.publish('en') superuser = self.get_superuser() with self.login_user_context(superuser): response = self.client.get('/en/?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')) self.assertEqual(response.status_code, 200)
def has_page_change_permission(self): if not hasattr(self, 'page_change_permission'): if not self.page and not get_cms_setting('PERMISSION'): # We can't check permissions for an individual page # and can't check global cms permissions because # user opted out of them. # So just check django auth permissions. user = self.request.user can_change = has_auth_page_permission(user, action='change') else: can_change = can_change_page(self.request) self.page_change_permission = can_change return self.page_change_permission
def setUp(self): self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.page = api.create_page('page', self.template, self.language, published=True, apphook='BlogApp', apphook_namespace='Blog') api.create_title('fr', 'french page', self.page) self.page.publish('fr') self.placeholder = self.page.placeholders.all()[0] self.user = User.objects.create(first_name='Peter', last_name='Muster')
def test_language_fallback(self): """ Test language fallbacks in details view """ from cms.views import details p1 = create_page("page", "nav_playground.html", "en", published=True) request = self.get_request('/de/', 'de') response = details(request, p1.get_path()) self.assertEqual(response.status_code, 302) self.assertEqual(response['Location'], '/en/') lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) lang_settings[1][0]['fallbacks'] = [] lang_settings[1][1]['fallbacks'] = [] with self.settings(CMS_LANGUAGES=lang_settings): response = self.client.get("/de/") self.assertEqual(response.status_code, 404) lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) lang_settings[1][0]['redirect_on_fallback'] = False lang_settings[1][1]['redirect_on_fallback'] = False with self.settings(CMS_LANGUAGES=lang_settings): response = self.client.get("/de/") self.assertEqual(response.status_code, 302)
def populate(self): # always use draft if we have a page self.page = get_page_draft(self.request.current_page) if not self.page: # Nothing to do return # check global permissions if CMS_PERMISSIONS is active if get_cms_setting('PERMISSION'): if not has_page_change_permission: has_global_current_page_change_permission = has_page_permission( self.request.user, self.request.current_page, 'change' ) else: has_global_current_page_change_permission = has_page_change_permission( self.request ) else: has_global_current_page_change_permission = False # check if user has page edit permission if not has_page_change_permission: can_change = (self.request.current_page and self.request.current_page.has_change_permission(self.request.user)) else: can_change = (self.request.current_page and self.request.current_page.has_change_permission(self.request)) if has_global_current_page_change_permission or can_change: not_edit_mode = not self.toolbar.edit_mode current_page_menu = self.toolbar.get_or_create_menu('page') position = current_page_menu.find_first( Break, identifier=PAGE_MENU_THIRD_BREAK) - 1 # Page tags try: page_extension = PageSitemapProperties.objects.get(extended_object_id=self.page.pk) except PageSitemapProperties.DoesNotExist: page_extension = None try: if page_extension: url = reverse('admin:djangocms_page_sitemap_pagesitemapproperties_change', args=(page_extension.pk,)) else: url = "%s?extended_object=%s" % ( reverse('admin:djangocms_page_sitemap_pagesitemapproperties_add'), self.page.pk) except NoReverseMatch: # pragma: no cover # not in urls pass else: current_page_menu.add_modal_item(PAGE_SITEMAP_MENU_TITLE, url=url, disabled=not_edit_mode, position=position)
def test_untranslated_language_url(self): """ Tests page_language_url templatetag behavior when used on a page without the requested translation, both when CMS_HIDE_UNTRANSLATED is True and False. When True it should return the root page URL if the current page is untranslated (PR #1125) """ page_1 = create_page('Page 1', 'nav_playground.html', 'en', published=True, in_navigation=True, reverse_id='page1') create_title("de", "Seite 1", page_1, slug="seite-1") page_1.publish('en') page_1.publish('de') page_2 = create_page('Page 2', 'nav_playground.html', 'en', page_1, published=True, in_navigation=True, reverse_id='page2') create_title("de", "Seite 2", page_2, slug="seite-2") page_2.publish('en') page_2.publish('de') page_3 = create_page('Page 3', 'nav_playground.html', 'en', page_2, published=True, in_navigation=True, reverse_id='page3') tpl = "{% load menu_tags %}{% page_language_url 'de' %}" lang_settings = deepcopy(get_cms_setting('LANGUAGES')) lang_settings[1][1]['hide_untranslated'] = False with self.settings(CMS_LANGUAGES=lang_settings): context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2 res = self.render_template_obj(tpl, context.__dict__, context['request']) self.assertEqual(res, "/de/seite-2/") # Default configuration has CMS_HIDE_UNTRANSLATED=False context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2.publisher_public res = self.render_template_obj(tpl, context.__dict__, context['request']) self.assertEqual(res, "/de/seite-2/") context = self.get_context(page_3.get_absolute_url()) context['request'].current_page = page_3.publisher_public res = self.render_template_obj(tpl, context.__dict__, context['request']) self.assertEqual(res, "/de/page-3/") lang_settings[1][1]['hide_untranslated'] = True with self.settings(CMS_LANGUAGES=lang_settings): context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2.publisher_public res = self.render_template_obj(tpl, context.__dict__, context['request']) self.assertEqual(res, "/de/seite-2/") context = self.get_context(page_3.get_absolute_url()) context['request'].current_page = page_3.publisher_public res = self.render_template_obj(tpl, context.__dict__, context['request']) self.assertEqual(res, "/de/")
def setUp(self): self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.page = api.create_page('page', self.template, self.language, published=True) self.placeholder = self.page.placeholders.all()[0] self.superuser = self.create_superuser() self.img = create_image() self.image_name = 'test_file.jpg' self.filename = os.path.join(settings.MEDIA_ROOT, self.image_name) self.img.save(self.filename, 'JPEG')
def test_site_preview(self): page = create_page("page", "nav_playground.html", "de", site=self.site2, published=True) with self.login_user_context(self.get_superuser()): response = self.client.get( admin_reverse('cms_page_preview_page', args=[page.pk, 'de'])) self.assertEqual(response.status_code, 302) self.assertEqual( response._headers['location'][1], 'http://sample2.com/de/?%s&language=de' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
def get_page_request(self, page, user, path=None, edit=False, lang_code='en', disable=False): path = path or page and page.get_absolute_url() if edit: path += '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON') request = RequestFactory().get(path) request.session = {} request.user = user request.LANGUAGE_CODE = lang_code request.GET = request.GET.copy() if edit: request.GET['edit'] = None else: request.GET['edit_off'] = None if disable: request.GET[get_cms_setting('CMS_TOOLBAR_URL__DISABLE')] = None request.current_page = page mid = ToolbarMiddleware() mid.process_request(request) if hasattr(request, 'toolbar'): request.toolbar.populate() return request
def _show_placeholder_for_page(context, placeholder_name, page_lookup, lang=None, site=None, cache_result=True): """ Shows the content of a page with a placeholder name and given lookup arguments in the given language. This is useful if you want to have some more or less static content that is shared among many pages, such as a footer. See _get_page_by_untyped_arg() for detailed information on the allowed types and their interpretation for the page_lookup argument. """ validate_placeholder_name(placeholder_name) request = context.get('request', False) site_id = get_site_id(site) if not request: return {'content': ''} if lang is None: lang = get_language_from_request(request) if cache_result: base_key = _get_cache_key('_show_placeholder_for_page', page_lookup, lang, site_id) cache_key = _clean_key('%s_placeholder:%s' % (base_key, placeholder_name)) cached_value = cache.get(cache_key) if isinstance(cached_value, dict): # new style _restore_sekizai(context, cached_value['sekizai']) return {'content': mark_safe(cached_value['content'])} elif isinstance(cached_value, basestring): # old style return {'content': mark_safe(cached_value)} page = _get_page_by_untyped_arg(page_lookup, request, site_id) if not page: return {'content': ''} try: placeholder = page.placeholders.get(slot=placeholder_name) except PlaceholderModel.DoesNotExist: if settings.DEBUG: raise return {'content': ''} watcher = Watcher(context) content = render_placeholder(placeholder, context, placeholder_name) changes = watcher.get_changes() if cache_result: cache.set(cache_key, {'content': content, 'sekizai': changes}, get_cms_setting('CACHE_DURATIONS')['content']) if content: return {'content': mark_safe(content)} return {'content': ''}
def _get_cache_key(request): #md5 key of current path cache_key = "%s:%d:%s" % ( get_cms_setting("CACHE_PREFIX"), settings.SITE_ID, hashlib.md5(iri_to_uri( request.get_full_path()).encode('utf-8')).hexdigest()) if settings.USE_TZ: # The datetime module doesn't restrict the output of tzname(). # Windows is known to use non-standard, locale-dependant names. # User-defined tzinfo classes may return absolutely anything. # Hence this paranoid conversion to create a valid cache key. tz_name = force_text(get_current_timezone_name(), errors='ignore') cache_key += '.%s' % tz_name.encode( 'ascii', 'ignore').decode('ascii').replace(' ', '_') return cache_key
def test_custom_templates_loading(self): """ Checking that templates can be loaded by the template loader """ templates = get_cms_setting('TEMPLATES') for template in templates: if template[0] != constants.TEMPLATE_INHERITANCE_MAGIC: tpl = loader.get_template(template[0]) if DJANGO_1_7: tpl_name = tpl.name else: tpl_name = tpl.template.name self.assertEqual(tpl_name, template[0])
def has_page_change_permission(request): """ Return true if the current user has permission to change this page. To be granted this permission, you need the cms.change_page permission. In addition, if CMS_PERMISSION is enabled you also need to either have global can_change permission or just on this page. """ from cms.utils.plugins import current_site opts = Page._meta return request.user.is_superuser or ( request.user.has_perm(opts.app_label + '.' + opts.get_change_permission()) and (not get_cms_setting('PERMISSION') or has_global_page_permission( request, current_site(request), can_change=True) or has_any_page_change_permissions(request)))
def is_restricted(page, request): if get_cms_setting('PERMISSION'): if hasattr(page, 'permission_restricted'): icon = boolean_icon(bool(page.permission_restricted)) else: all_perms = list(get_any_page_view_permissions(request, page)) icon = boolean_icon(bool(all_perms)) return mark_safe(ugettext('<span>%(icon)s</span>') % { 'icon': icon, }) else: icon = boolean_icon(None) return mark_safe(ugettext('<span>%(icon)s</span>') % { 'icon': icon, })