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
