def test_create_alias_wizard_form(self): wizard = self._get_wizard_instance('CreateAliasWizard') data = { 'name': 'Content #1', 'category': self.category.pk, 'site': get_current_site().pk } form_class = step2_form_factory( mixin_cls=WizardStep2BaseForm, entry_form_class=wizard.form, ) form = form_class(**self._get_form_kwargs(data)) self.assertTrue(form.is_valid()) alias = form.save() self.assertEqual(form.fields['site'].initial, get_current_site()) with self.login_user_context(self.superuser): response = self.client.get(alias.get_absolute_url()) self.assertContains(response, data['name']) if is_versioning_enabled(): from djangocms_versioning.models import Version self.assertEqual(Version.objects.filter_by_grouper(alias).count(), 1)
def get_site(self, request): site_id = request.session.get('cms_admin_site') if not site_id: return get_current_site() try: site = Site.objects._get_site_by_id(site_id) except Site.DoesNotExist: site = get_current_site() return site
def __init__(self, data=None, *args, **kwargs): instance = kwargs.get('instance') default_link_type = {'type': self.LINK_TYPE_CHOICES[0][0]} initial = dict(instance.glossary) if instance else { 'link': default_link_type } initial.update(kwargs.pop('initial', {})) initial.setdefault('link', {'type': default_link_type}) link_type = initial['link']['type'] self.base_fields['link_type'].choices = self.LINK_TYPE_CHOICES self.base_fields['link_type'].initial = link_type if data and data.get('shared_glossary'): # convert this into an optional field since it is disabled with ``shared_glossary`` set self.base_fields['link_type'].required = False set_initial_linktype = getattr(self, 'set_initial_{}'.format(link_type), None) if 'django_select2' not in settings.INSTALLED_APPS: # populate classic Select field for choosing a CMS page site = get_current_site() choices = [(p.pk, format_page_link(p.get_page_title(), p.get_absolute_url())) for p in Page.objects.drafts().on_site(site)] self.base_fields['cms_page'].choices = choices if callable(set_initial_linktype): set_initial_linktype(initial) self._preset_section(data, initial) self.base_fields['download_file'].widget = AdminFileWidget( ManyToOneRel(FilerFileField, FilerFileModel, 'id'), admin_site) super(LinkForm, self).__init__(data, initial=initial, *args, **kwargs)
def __init__(self, data=None, *args, **kwargs): instance = kwargs.get('instance') default_link_type = {'type': self.LINK_TYPE_CHOICES[0][0]} initial = dict(instance.glossary) if instance else {'link': default_link_type} initial.update(kwargs.pop('initial', {})) initial.setdefault('link', {'type': default_link_type}) link_type = initial['link']['type'] self.base_fields['link_type'].choices = self.LINK_TYPE_CHOICES self.base_fields['link_type'].initial = link_type if data and data.get('shared_glossary'): # convert this into an optional field since it is disabled with ``shared_glossary`` set self.base_fields['link_type'].required = False set_initial_linktype = getattr(self, 'set_initial_{}'.format(link_type), None) if 'django_select2' not in settings.INSTALLED_APPS: # populate classic Select field for choosing a CMS page site = get_current_site() choices = [(p.pk, format_page_link(p.get_page_title(), p.get_absolute_url())) for p in Page.objects.drafts().on_site(site)] self.base_fields['cms_page'].choices = choices if callable(set_initial_linktype): set_initial_linktype(initial) self._preset_section(data, initial) self.base_fields['download_file'].widget = AdminFileWidget(ManyToOneRel(FilerFileField, FilerFileModel, 'id'), admin_site) super(LinkForm, self).__init__(data, initial=initial, *args, **kwargs)
def test_notify_version_author_version_unlocked_email_sent_for_different_user( self): """ The user unlocking a version that is authored buy a different user should be sent a notification email """ draft_version = factories.PageVersionFactory( content__template="", created_by=self.user_author) draft_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', draft_version.pk) # Check that no emails exist self.assertEqual(len(mail.outbox), 0) # Unlock the version with a different user with unlock permissions with self.login_user_context(self.user_has_unlock_perms): self.client.post(draft_unlock_url, follow=True) site = get_current_site() expected_subject = "[Django CMS] ({site_name}) {title} - {description}".format( site_name=site.name, title=draft_version.content, description=_("Unlocked"), ) expected_body = "The following draft version has been unlocked by {by_user} for their use.".format( by_user=self.user_has_unlock_perms) expected_version_url = get_absolute_url( get_object_preview_url(draft_version.content)) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, expected_subject) self.assertEqual(mail.outbox[0].to[0], self.user_author.email) self.assertTrue(expected_body in mail.outbox[0].body) self.assertTrue(expected_version_url in mail.outbox[0].body)
def test_get_page_choices_with_multiple_translations(self): site = get_current_site() pages = [ create_page("0001", "nav_playground.html", "en"), create_page("0002", "nav_playground.html", "en"), create_page("0003", "nav_playground.html", "en"), create_page("0004", "nav_playground.html", "en"), ] languages = ['de', 'fr'] for page in pages: for language in languages: title = page.get_title('en') create_title(language, title, page=page) for language in ['en'] + languages: expected = [ ('', '----'), (site.name, [ (page.pk, page.get_title(language, fallback=False)) for page in pages ]) ] with force_language(language): self.assertSequenceEqual(get_page_choices(), expected)
def render_tag(self, context, code, extra_bits, nodelist=None): request = context.get('request') if not code or not request: # an empty string was passed in or the variable is not available in the context if nodelist: return nodelist.render(context) return '' toolbar = get_toolbar_from_request(request) renderer = toolbar.get_content_renderer() if isinstance(code, StaticPlaceholder): static_placeholder = code else: kwargs = { 'code': code, 'defaults': { 'creation_method': StaticPlaceholder.CREATION_BY_TEMPLATE } } if 'site' in extra_bits: kwargs['site'] = get_current_site() else: kwargs['site_id__isnull'] = True static_placeholder = StaticPlaceholder.objects.get_or_create( **kwargs)[0] content = renderer.render_static_placeholder( static_placeholder, context=context, nodelist=nodelist, ) return content
def items(self): # # It is counter-productive to provide entries for: # > Pages which redirect: # - If the page redirects to another page on this site, the # destination page will already be in the sitemap, and # - If the page redirects externally, then it shouldn't be # part of our sitemap anyway. # > Pages which cannot be accessed by anonymous users (like # search engines are). # # It is noted here: http://www.sitemaps.org/protocol.html that # "locations" that differ from the place where the sitemap is found, # are considered invalid. E.g., if your sitemap is located here: # # http://example.com/sub/sitemap.xml # # valid locations *must* be rooted at http://example.com/sub/... # # This rules any redirected locations out. # # If, for some reason, you require redirecting pages (Titles) to be # included, simply create a new class inheriting from this one, and # supply a new items() method which doesn't filter out the redirects. site = get_current_site() languages = get_public_languages(site_id=site.pk) all_titles = Title.objects.public().filter( Q(redirect='') | Q(redirect__isnull=True), language__in=languages, page__login_required=False, page__node__site=site, ).order_by('page__node__path') return all_titles
def dispatch(self, *args, **kwargs): user = self.request.user if not user.is_active or not user.is_staff: raise PermissionDenied self.site = get_current_site() return super(WizardCreateView, self).dispatch(*args, **kwargs)
def notify_version_author_version_unlocked(version, unlocking_user): # If the unlocking user is the current author, don't send a notification email if version.created_by == unlocking_user: return # If the users name is available use it, otherwise use their username username = unlocking_user.get_full_name() or unlocking_user.username site = get_current_site() recipients = [version.created_by.email] subject = "[Django CMS] ({site_name}) {title} - {description}".format( site_name=site.name, title=version.content, description=_("Unlocked"), ) version_url = get_absolute_url(get_object_preview_url(version.content)) # Prepare and send the email template_context = { 'version_link': version_url, 'by_user': username, } status = send_email( recipients=recipients, subject=subject, template='unlock-notification.txt', template_context=template_context, ) return status
def assign_user_to_page(page, user, grant_on=ACCESS_PAGE_AND_DESCENDANTS, can_add=False, can_change=False, can_delete=False, can_change_advanced_settings=False, can_publish=False, can_change_permissions=False, can_move_page=False, can_recover_page=True, can_view=False, grant_all=False, global_permission=False): """ Assigns given user to page, and gives him requested permissions. See docs/extending_cms/api_reference.rst for more info """ grant_all = grant_all and not global_permission data = { 'can_add': can_add or grant_all, 'can_change': can_change or grant_all, 'can_delete': can_delete or grant_all, 'can_change_advanced_settings': can_change_advanced_settings or grant_all, 'can_publish': can_publish or grant_all, 'can_change_permissions': can_change_permissions or grant_all, 'can_move_page': can_move_page or grant_all, 'can_view': can_view or grant_all, } page_permission = PagePermission(page=page, user=user, grant_on=grant_on, **data) page_permission.save() if global_permission: page_permission = GlobalPagePermission( user=user, can_recover_page=can_recover_page, **data) page_permission.save() page_permission.sites.add(get_current_site()) return page_permission
def test_create_alias_wizard_form_with_no_category_fallback_language(self): """When creating an Alias via the Wizard an error can occur if the category doesn't have a valid translation """ translation.activate('en') # A japanese translation that does not have any fallback settings! Category.objects.language('ja').create(name='Japanese category') wizard = self._get_wizard_instance('CreateAliasWizard') data = { 'name': 'Content #1', 'category': None, } form_class = step2_form_factory( mixin_cls=WizardStep2BaseForm, entry_form_class=wizard.form, ) form = form_class(**self._get_form_kwargs(data)) category_form_queryset = form.declared_fields['category'].queryset self.assertEqual(form.fields['site'].initial, get_current_site()) # Be sure that we have untranslated categories that enforces a fair test self.assertNotEqual( category_form_queryset.all().count(), category_form_queryset.active_translations().count() ) for category in category_form_queryset.all(): # Each category string representation can be accessed without an error category_name = str(category) self.assertTrue(category_name)
def get_page_from_request(request, use_path=None, clean_path=None): """ Gets the current page from a request object. URLs can be of the following form (this should help understand the code): http://server.whatever.com/<some_path>/"pages-root"/some/page/slug <some_path>: This can be anything, and should be stripped when resolving pages names. This means the CMS is not installed at the root of the server's URLs. "pages-root" This is the root of Django urls for the CMS. It is, in essence an empty page slug (slug == '') The page slug can then be resolved to a Page model object """ from cms.utils.page_permissions import user_can_view_page_draft if hasattr(request, '_current_page_cache'): # The following is set by CurrentPageMiddleware return request._current_page_cache if clean_path is None: clean_path = not bool(use_path) draft = use_draft(request) preview = 'preview' in request.GET path = request.path_info if use_path is None else use_path if clean_path: pages_root = reverse("pages-root") if path.startswith(pages_root): path = path[len(pages_root):] # strip any final slash if path.endswith("/"): path = path[:-1] site = get_current_site() page = get_page_from_path(site, path, preview, draft) if draft and page and not user_can_view_page_draft(request.user, page): page = get_page_from_path(site, path, preview, draft=False) # For public pages, check if any parent is hidden due to published dates # In this case the selected page is not reachable if page and not draft: now = timezone.now() unpublished_ancestors = ( page .get_ancestor_pages() .filter( Q(publication_date__gt=now) | Q(publication_end_date__lt=now), ) ) if unpublished_ancestors.exists(): page = None return page
def node(self): """Create a node for the page (under its parent if applicable).""" site = get_current_site() new_node = cms_models.TreeNode(site=site) if self.parent: return self.parent.node.add_child(instance=new_node) return cms_models.TreeNode.add_root(instance=new_node)
def __init__(self, *args, **kwargs): queryset = Page.objects.public() try: queryset = queryset.on_site(get_current_site()) except: pass # can happen if database is not ready yet kwargs.setdefault('queryset', queryset) super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): queryset = Page.objects.public() try: queryset = queryset.published().on_site(get_current_site()).distinct() except: pass kwargs.setdefault('queryset', queryset) super().__init__(*args, **kwargs)
def test_switch_moderator_off(self): site = get_current_site() with force_language("en"): pages_root = unquote(reverse("pages-root")) page1 = create_page('page', 'nav_playground.html', 'en', published=True) path = page1.get_absolute_url()[len(pages_root):].strip('/') page2 = get_page_from_path(site, path) self.assertIsNotNone(page2) self.assertEqual(page1.get_absolute_url(), page2.get_absolute_url())
def get_app_patterns(): try: site = get_current_site() return _get_app_patterns(site) except (OperationalError, ProgrammingError): # ignore if DB is not ready # Starting with Django 1.9 this code gets called even when creating # or running migrations. So in many cases the DB will not be ready yet. return []
def __init__(self, *args, **kwargs): self.user = kwargs.pop('user') super().__init__(*args, **kwargs) if not has_plugin_permission(self.user, 'Alias', 'add'): self.fields['replace'].widget = forms.HiddenInput() self.set_category_widget(self.user) self.fields["site"].initial = get_current_site()
def inner(request, *args, **kwargs): page = request.current_page if page: if page.login_required and not request.user.is_authenticated(): return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL) site = get_current_site() if not user_can_view_page(request.user, page, site): return _handle_no_page(request) return func(request, *args, **kwargs)
def __init__(self, *args, **kwargs): self._site = get_current_site() self._user = self.user self._language = self.language_code super().__init__(*args, **kwargs) self.fields['title'].help_text = _("Provide a title for the new page.") self.fields['slug'].required = False self.fields['slug'].widget = SlugWidget() self.fields['slug'].help_text = _( "Leave empty for automatic slug, or override as required.")
def get_roots(self, request): queryset = MenuItem.get_root_nodes().filter( menucontent__menu__site=get_current_site()) versionable = get_versionable_for_content(MenuContent) if versionable: inner_filter = {"versions__state__in": [PUBLISHED]} if self.renderer.draft_mode_active: inner_filter["versions__state__in"] += [DRAFT] menucontents = versionable.distinct_groupers(**inner_filter) queryset = queryset.filter(menucontent__in=menucontents) return queryset
def test_switch_moderator_on(self): site = get_current_site() with force_language("en"): pages_root = unquote(reverse("pages-root")) page1 = create_page('page', 'nav_playground.html', 'en', published=True) with disable_logger(log): call_command('cms', 'moderator', 'on') with force_language("en"): path = page1.get_absolute_url()[len(pages_root):].strip('/') page2 = get_page_from_path(site, path) self.assertEqual(page1.get_absolute_url(), page2.get_absolute_url())
def __init__(self, request, toolbar, is_current_app, app_path): self.request = request self.toolbar = toolbar self.is_current_app = is_current_app self.app_path = app_path self.current_site = get_current_site() try: self.current_lang = get_language_object( get_language_from_request(self.request), self.current_site.pk)['code'] except LanguageError: self.current_lang = None
def __init__(self, *args, **kwargs): queryset = Page.objects.public() try: queryset = queryset.published().on_site(get_current_site()) except: choices = [] # can happen if database is not ready yet else: # set a minimal set of choices, otherwise django-select2 builds them for every published page choices = [(index, str(page)) for index, page in enumerate(queryset[:15])] kwargs.setdefault('queryset', queryset.distinct()) super().__init__(*args, **kwargs) self.choices = choices
def _get_operation_language(self, request): # Unfortunately the ?language GET query # has a special meaning on the CMS. # It allows users to see another language while maintaining # the same url. This complicates language detection. site = get_current_site() parsed_url = urlparse(request.GET['cms_path']) queries = dict(parse_qsl(parsed_url.query)) language = queries.get('language') if not language: language = translation.get_language_from_path(parsed_url.path) return get_language_code(language, site_id=site.pk)
def to_internal_value(self, data): site = get_current_site() pages_root = reverse('pages-root') ret = [] for path in data: if path.startswith(pages_root): path = path[len(pages_root):] # strip any final slash if path.endswith('/'): path = path[:-1] page = get_page_from_path(site, path) if page: ret.append(page) return ret
def to_internal_value(self, data): site = get_current_site() pages_root = reverse('pages-root') ret = [] for path in data: if path.startswith(pages_root): path = path[len(pages_root):] # strip any final slash if path.endswith('/'): path = path[:-1] page = get_page_from_path(site, path) if page: ret.append(page) return ret
def test_wizard_create_child_page_under_page_type(self): """ When a user creates a child page through the wizard, if the parent page is a page-type, the child page should also be a page-type. """ site = get_current_site() superuser = self.get_superuser() source_page = create_page( title="Source", template=TEMPLATE_INHERITANCE_MAGIC, language="en", ) with self.login_user_context(superuser): self.client.post( self.get_admin_url(PageType, 'add'), data={ 'source': source_page.pk, 'title': 'type1', 'slug': 'type1', '_save': 1 }, ) types_root = PageType.get_root_page(site) parent_page = types_root.get_child_pages()[0] data = { 'title': 'page-type-child', 'slug': 'page-type-child', 'page_type': None, } form = CreateCMSSubPageForm( data=data, wizard_page=parent_page, wizard_user=superuser, wizard_language='en', ) self.assertTrue(form.is_valid()) child_page = form.save() self.assertTrue(child_page.is_page_type) self.assertFalse(child_page.in_navigation) self.assertEqual(child_page.node.depth, 3) self.assertEqual(child_page.parent_page, parent_page) self.assertEqual(child_page.get_title('en'), 'page-type-child') self.assertEqual(child_page.get_path('en'), 'page_types/type1/page-type-child')
def items(self): site = get_current_site() languages = get_public_languages(site_id=site.pk) pages = Page.objects.public().filter( Q(publication_date__lt=timezone.now()) | Q(publication_date__isnull=True), Q(publication_end_date__gte=timezone.now()) | Q(publication_end_date__isnull=True), login_required=False, node__site=site #Q(redirect__exact='') | Q(redirect__isnull=True), #language__in=languages, ).exclude(sitemapextension__show_on_xml_sitemap=False).order_by( 'node__path').prefetch_related('title_set') return pages
def __init__(self, pool, request): self.pool = pool # It's important this happens on init # because we need to make sure that a menu renderer # points to the same registered menus as long as the # instance lives. self.menus = pool.get_registered_menus(for_rendering=True) self.request = request if is_language_prefix_patterns_used(): self.request_language = get_language_from_request(request, check_path=True) else: self.request_language = get_default_language_for_site( get_current_site().pk) self.site = Site.objects.get_current(request)
def get_content_parameters(self, edit=False): """ Convenient wrapper to authorize and return required parameters for LTI content consumption """ role = INSTRUCTOR if edit else STUDENT site = get_current_site() lti_parameters = { "lti_message_type": "basic-lti-launch-request", "lti_version": "LTI-1p0", "resource_link_id": self.get_resource_link_id(), "context_id": site.domain, "user_id": "richie", "lis_person_contact_email_primary": "", "roles": role, } # Get credentials from the predefined LTI provider if any, or from the model otherwise oauth_consumer_key = ( self.lti_provider.get("oauth_consumer_key", "") if self.lti_provider_id else self.oauth_consumer_key ) shared_secret = ( self.lti_provider.get("shared_secret", "") if self.lti_provider_id else self.shared_secret ) client = oauth1.Client( client_key=oauth_consumer_key, client_secret=shared_secret ) _uri, headers, _body = client.sign( self.url, http_method="POST", body=lti_parameters, headers={"Content-Type": "application/x-www-form-urlencoded"}, ) oauth_dict = dict( param.strip().replace('"', "").split("=") for param in headers["Authorization"].split(",") ) oauth_dict["oauth_signature"] = unquote(oauth_dict["oauth_signature"]) oauth_dict["oauth_nonce"] = oauth_dict.pop("OAuth oauth_nonce") oauth_dict.update(lti_parameters) return oauth_dict