def __call__(self, lang):
page_language = get_language_from_request(self.request)
with force_language(page_language):
try:
view = resolve(self.request.path)
except:
view = None
if hasattr(self.request, "toolbar") and self.request.toolbar.obj:
with force_language(lang):
try:
return self.request.toolbar.obj.get_absolute_url()
except:
pass
elif view and not view.url_name in ("pages-details-by-slug", "pages-root"):
view_name = view.url_name
if view.namespace:
"%s:%s" % (view.namespace, view_name)
url = None
with force_language(lang):
try:
url = reverse(view_name, args=view.args, kwargs=view.kwargs, current_app=view.app_name)
except NoReverseMatch:
pass
if url:
return url
return "%s%s" % (self.get_page_path(lang), self.app_path)
def test_get_i18n_apphook_with_explicit_current_app(self):
self.apphook_clear()
titles = self.create_base_structure(NS_APP_NAME, ['en', 'de'], 'instance_1')
public_de_title = titles[1]
de_title = Title.objects.get(page=public_de_title.page.publisher_draft, language="de")
de_title.slug = "de"
de_title.save()
de_title.page.publish('de')
self.reload_urls()
self.apphook_clear()
page2 = create_page("page2", "nav_playground.html",
"en", created_by=self.superuser, published=True, parent=de_title.page.parent,
apphook=NS_APP_NAME,
apphook_namespace="instance_2")
create_title("de", "de_title", page2, slug="slug")
page2.publish('de')
clear_app_resolvers()
clear_url_caches()
if APP_MODULE in sys.modules:
del sys.modules[APP_MODULE]
self.reload_urls()
with force_language("de"):
reverse('namespaced_app_ns:current-app', current_app="instance_1")
reverse('namespaced_app_ns:current-app', current_app="instance_2")
reverse('namespaced_app_ns:current-app')
with force_language("en"):
reverse('namespaced_app_ns:current-app', current_app="instance_1")
reverse('namespaced_app_ns:current-app', current_app="instance_2")
reverse('namespaced_app_ns:current-app')
self.apphook_clear()
def test_get_apps(self):
"""
Check that urlconf are dynamically loaded according to the different page the apphook is
attached to
"""
titles = self.create_base_structure('VariableUrlsApp', ['en', 'de'])
titles[0].page.reverse_id = 'page1'
titles[0].page.save()
self.reload_urls()
# only one urlconf is configured given that only one page is created
with force_language('de'):
reverse('extra_first')
with self.assertRaises(NoReverseMatch):
reverse('sample2-root')
self.reload_urls()
self.apphook_clear()
page2 = create_page('page2', 'nav_playground.html',
'en', created_by=self.superuser, published=True,
parent=titles[0].page.parent,
apphook='VariableUrlsApp', reverse_id='page2')
create_title('de', 'de_title', page2, slug='slug')
page2.publish('de')
self.reload_urls()
with force_language('de'):
reverse('sample2-root')
reverse('extra_first')
self.apphook_clear()
def test_include_urlconf(self):
with SettingsOverride(ROOT_URLCONF='cms.test_utils.project.second_urls_for_apphook_tests'):
self.create_base_structure(APP_NAME, 'en')
path = reverse('extra_second')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test included urlconf")
path = reverse('extra_first')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test urlconf")
with force_language("de"):
path = reverse('extra_first')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test urlconf")
with force_language("de"):
path = reverse('extra_second')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test included urlconf")
apphook_pool.clear()
def render_tag(self, context, name, nodelist):
# render JS
request = context.get('request', None)
toolbar = getattr(request, 'toolbar', None)
if toolbar:
toolbar.init_toolbar(request)
toolbar.populate()
if request and 'cms-toolbar-login-error' in request.GET:
context['cms_toolbar_login_error'] = request.GET['cms-toolbar-login-error'] == '1'
context['cms_version'] = __version__
if toolbar and toolbar.show_toolbar:
language = toolbar.toolbar_language
with force_language(language):
# needed to populate the context with sekizai content
render_to_string('cms/toolbar/toolbar_javascript.html', context)
context['addons'] = mark_safe(toolbar.render_addons(context))
else:
language = None
# render everything below the tag
rendered_contents = nodelist.render(context)
# sanity checks
if not request:
return rendered_contents
if not toolbar:
return rendered_contents
if not toolbar.show_toolbar:
return rendered_contents
# render the toolbar content
request.toolbar.post_template_populate()
with force_language(language):
addons = mark_safe(toolbar.post_template_render_addons(context))
toolbar = render_to_string('cms/toolbar/toolbar.html', context)
# return the toolbar content and the content below
return '%s\n%s\n%s' % (toolbar, addons, rendered_contents)
def render_tag(self, context, name, nodelist):
# render JS
request = context.get('request', None)
toolbar = getattr(request, 'toolbar', None)
if toolbar:
toolbar.populate()
context['cms_version'] = __version__
if toolbar and toolbar.show_toolbar:
language = toolbar.toolbar_language
with force_language(language):
# needed to populate the context with sekizai content
render_to_string('cms/toolbar/toolbar_javascript.html', context)
clipboard = mark_safe(render_to_string('cms/toolbar/clipboard.html', context))
else:
language = None
clipboard = ''
# render everything below the tag
rendered_contents = nodelist.render(context)
# sanity checks
if not request:
return rendered_contents
if not toolbar:
return rendered_contents
if not toolbar.show_toolbar:
return rendered_contents
# render the toolbar content
request.toolbar.post_template_populate()
with force_language(language):
context['clipboard'] = clipboard
content = render_to_string('cms/toolbar/toolbar.html', context)
# return the toolbar content and the content below
return '%s\n%s' % (content, rendered_contents)
def test_get_absolute_url(self):
category = self.question1.category
with force_language('en'):
question_1_url_en = reverse(
'aldryn_faq:faq-answer',
kwargs={
'category_pk': category.pk,
'pk': self.question1.pk,
'category_slug': get_slug_in_language(category, 'en'),
}
)
with force_language('de'):
question_1_url_de = reverse(
'aldryn_faq:faq-answer',
kwargs={
'category_pk': category.pk,
'pk': self.question1.pk,
'category_slug': get_slug_in_language(category, 'de'),
}
)
self.assertEqual(self.question1.get_absolute_url("en"), question_1_url_en)
self.assertEqual(self.question1.get_absolute_url("de"), question_1_url_de)
def test_get_page_for_apphook(self):
en_title, de_title = self.create_base_structure(APP_NAME, ['en', 'de'])
with force_language("en"):
path = reverse('sample-settings')
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, en_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/home.html')
self.assertContains(response, en_title.title)
with force_language("de"):
path = reverse('sample-settings')
request = self.get_request(path)
request.LANGUAGE_CODE = 'de'
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash and language prefix
self.assertEqual(attached_to_page.pk, de_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/home.html')
self.assertContains(response, de_title.title)
self.apphook_clear()
def test_get_absolute_url_pk_slug(self):
question_1 = self.question1
category_1 = self.category1
old = self.app_config.permalink_type
self.app_config.permalink_type = "Ps"
self.app_config.save()
with force_language('en'):
question_1_url_en = reverse(
'aldryn_faq:faq-answer',
kwargs={
'category_pk': category_1.pk,
'slug': get_slug_in_language(question_1, 'en'),
}
)
with force_language('de'):
question_1_url_de = reverse(
'aldryn_faq:faq-answer',
kwargs={
'category_pk': category_1.pk,
'slug': get_slug_in_language(question_1, 'de'),
}
)
self.assertEqual(question_1.get_absolute_url("en"), question_1_url_en)
self.assertEqual(question_1.get_absolute_url("de"), question_1_url_de)
self.app_config.permalink_type = old
self.app_config.save()
def populate(self):
"""
Get the CMS items on the toolbar
"""
if self.right_items is not None and self.left_items is not None:
return
self.right_items = []
self.left_items = []
# never populate the toolbar on is_staff=False
if not self.is_staff:
return
with force_language(self.language):
try:
self.view_name = resolve(self.request.path).func.__module__
except Resolver404:
self.view_name = ""
with force_language(self.toolbar_language):
toolbars = toolbar_pool.get_toolbars()
app_key = ""
for key in toolbars:
app_name = ".".join(key.split(".")[:-2])
if app_name in self.view_name and len(key) > len(app_key):
app_key = key
# if the cms_toolbar is in use, ensure it's first
first = ('cms.cms_toolbar.BasicToolbar', 'cms.cms_toolbar.PlaceholderToolbar')
for key in first:
toolbar = toolbars[key](self.request, self, key == app_key, app_key)
toolbar.populate()
for key in toolbars:
if key in first:
continue
toolbar = toolbars[key](self.request, self, key == app_key, app_key)
toolbar.populate()
def __call__(self, lang):
page_language = get_language_from_request(self.request)
with force_language(page_language):
try:
view = resolve(self.request.path)
except:
view = None
if hasattr(self.request, 'toolbar') and self.request.toolbar.obj:
with force_language(lang):
try:
return self.request.toolbar.obj.get_absolute_url()
except:
pass
elif view and not view.url_name in ('pages-details-by-slug', 'pages-root'):
view_name = view.url_name
if view.namespace:
view_name = "%s:%s" % (view.namespace, view_name)
url = None
with force_language(lang):
with static_stringifier(view): # This is a fix for Django < 1.7
try:
url = reverse(view_name, args=view.args, kwargs=view.kwargs, current_app=view.app_name)
except NoReverseMatch:
pass
if url:
return url
return '%s%s' % (self.get_page_path(lang), self.app_path)
def test_get_page_for_apphook(self):
with SettingsOverride(ROOT_URLCONF="cms.test_utils.project.second_urls_for_apphook_tests"):
en_title, de_title = self.create_base_structure(APP_NAME, ["en", "de"])
with force_language("en"):
path = reverse("sample-settings")
request = self.get_request(path)
request.LANGUAGE_CODE = "en"
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, en_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "sampleapp/home.html")
self.assertContains(response, en_title.title)
with force_language("de"):
path = reverse("sample-settings")
request = self.get_request(path)
request.LANGUAGE_CODE = "de"
attached_to_page = applications_page_check(
request, path=path[1:]
) # strip leading slash and language prefix
self.assertEqual(attached_to_page.pk, de_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "sampleapp/home.html")
self.assertContains(response, de_title.title)
apphook_pool.clear()
def test_get_page_for_apphook_on_preview_or_edit(self):
if get_user_model().USERNAME_FIELD == "email":
superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "*****@*****.**")
else:
superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "admin")
page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True, apphook=APP_NAME)
create_title("de", page.get_title(), page)
page.publish("en")
page.publish("de")
public_page = page.get_public_object()
with self.login_user_context(superuser):
with force_language("en"):
path = reverse("sample-settings")
request = self.get_request(path + "?edit")
request.LANGUAGE_CODE = "en"
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, public_page.pk)
with force_language("de"):
path = reverse("sample-settings")
request = self.get_request(path + "?edit")
request.LANGUAGE_CODE = "de"
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, public_page.pk)
def test_get_page_for_apphook_on_preview_or_edit(self):
if get_user_model().USERNAME_FIELD == 'email':
superuser = get_user_model().objects.create_superuser('admin', '*****@*****.**', '*****@*****.**')
else:
superuser = get_user_model().objects.create_superuser('admin', '*****@*****.**', 'admin')
page = create_page("home", "nav_playground.html", "en",
created_by=superuser, published=True, apphook=APP_NAME)
create_title('de', page.get_title(), page)
page.publish('en')
page.publish('de')
page.save()
public_page = page.get_public_object()
with self.login_user_context(superuser):
with force_language("en"):
path = reverse('sample-settings')
request = self.get_request(path + '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
response = self.client.get(path+"?edit")
self.assertContains(response, '?redirect=')
with force_language("de"):
path = reverse('sample-settings')
request = self.get_request(path + '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
request.LANGUAGE_CODE = 'de'
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, public_page.pk)
def __call__(self, lang):
page_language = get_language_from_request(self.request)
with force_language(page_language):
try:
view = resolve(self.request.path)
except:
view = None
if hasattr(self.request, 'toolbar') and self.request.toolbar.obj:
with force_language(lang):
try:
return self.request.toolbar.obj.get_absolute_url()
except:
pass
elif view and not view.url_name in ('pages-details-by-slug', 'pages-root'):
view_name = view.url_name
if view.namespace:
"%s:%s" % (view.namespace, view_name)
url = None
# every class-level argument is instantiated
# before reversing as reverse does not support
# classes as arguments
for idx, arg in enumerate(view.args):
if isinstance(arg, type):
view.args[idx] = arg()
for key, arg in view.kwargs.items():
if isinstance(arg, type):
view.kwargs[key] = arg()
with force_language(lang):
try:
url = reverse(view_name, args=view.args, kwargs=view.kwargs, current_app=view.app_name)
except NoReverseMatch:
pass
if url:
return url
return '%s%s' % (self.get_page_path(lang), self.app_path)
def test_include_urlconf(self):
self.create_base_structure(APP_NAME, 'en')
path = reverse('extra_second')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test included urlconf")
path = reverse('extra_first')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test urlconf")
with force_language("de"):
path = reverse('extra_first')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test urlconf")
with force_language("de"):
path = reverse('extra_second')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/extra.html')
self.assertContains(response, "test included urlconf")
self.apphook_clear()
def test_event_list_plugin(self, timezone_mock):
"""
We add an event to the Event Plugin and look it up
"""
timezone_mock.now.return_value = tz_datetime(2014, 1, 2, 12)
# default event start_date='2014-09-10' publish_at='2014-01-01 12:00'
event1 = self.create_event(
title='Event2014',
slug='open-air',
start_date=tz_datetime(2014, 9, 10),
publish_at=tz_datetime(2014, 1, 1, 9),
de={'title': 'Ereignis', 'slug': 'im-freien'}
)
event2 = self.create_event(
title='Event2014 only english',
start_date=tz_datetime(2014, 1, 29),
publish_at=tz_datetime(2014, 1, 1, 12)
)
root_page = self.create_root_page()
page = api.create_page(
'Events en', self.template, 'en', published=True, parent=root_page,
apphook='EventListAppHook',
apphook_namespace=self.app_config.namespace,
publication_date=tz_datetime(2014, 1, 8)
)
api.create_title('de', 'Events de', page)
ph = page.placeholders.get(slot='content')
plugin_en = api.add_plugin(
ph, 'EventListCMSPlugin', 'en', app_config=self.app_config,
)
plugin_de = api.add_plugin(
ph, 'EventListCMSPlugin', 'de', app_config=self.app_config,
)
plugin_en.events = [event1, event2]
plugin_en.save()
plugin_de.events = [event1]
plugin_de.save()
page.publish('en')
page.publish('de')
# EN: test plugin rendering
with force_language('en'):
response = self.client.get(reverse('aldryn_events:events_list'))
event1.set_current_language('en')
self.assertContains(response, event1.title)
self.assertContains(response, event1.get_absolute_url())
event2.set_current_language('en')
self.assertContains(response, event2.title)
self.assertContains(response, event2.get_absolute_url())
# DE: test plugin rendering
with force_language('de'):
response = self.client.get(reverse('aldryn_events:events_list'))
event1.set_current_language('de')
self.assertContains(response, event1.title)
self.assertContains(response, event1.get_absolute_url())
self.assertContains(response, event2.title)
self.assertContains(response, event2.get_absolute_url())
def test_switch_moderator_on(self):
with force_language("en"):
pages_root = urllib.unquote(reverse("pages-root"))
page1 = create_page('page', 'nav_playground.html', 'en', published=True)
call_command('cms', 'moderator', 'on')
with force_language("en"):
path = page1.get_absolute_url()[len(pages_root):].strip('/')
page2 = get_page_from_path(path)
self.assertEqual(page1.get_absolute_url(), page2.get_absolute_url())
def test_add_event_app_to_page(self, manager_timezone_mock,
tag_timezone_mock):
"""
When we link event app to any page it should list events
"""
manager_timezone_mock.now.return_value = tz_datetime(2014, 6, 8)
tag_timezone_mock.now.return_value = tz_datetime(2014, 6, 8)
root_page = self.create_root_page(
publication_date=tz_datetime(2014, 6, 8)
)
page = api.create_page(
title='Events en', template=self.template, language='en',
published=True,
parent=root_page,
apphook='EventListAppHook',
apphook_namespace=self.app_config.namespace,
publication_date=tz_datetime(2014, 6, 8)
)
api.create_title('de', 'Events de', page)
page.publish('en')
page.publish('de')
# create events
event1 = Event.objects.language('en').create(
title='Event2014',
start_date=tz_datetime(2014, 9, 10),
publish_at=tz_datetime(2014, 6, 5, 12),
app_config=self.app_config
)
event1.create_translation('de', title='Ereignis', slug='im-freien')
event2 = Event.objects.language('en').create(
title='Event2015 only english',
start_date=tz_datetime(2014, 9, 10),
publish_at=tz_datetime(2014, 1, 1),
app_config=self.app_config
)
# test english, have 2 events
with force_language('en'):
response = self.client.get(page.get_absolute_url('en'))
self.assertContains(response, event1.title)
self.assertContains(response, event1.get_absolute_url())
self.assertContains(response, event2.title)
self.assertContains(response, event2.get_absolute_url())
# test german, have 1 event, event 2 is only english
event1.set_current_language('de')
with force_language('de'):
response = self.client.get(page.get_absolute_url('de'))
self.assertContains(response, event1.title)
self.assertContains(response, event1.get_absolute_url())
self.assertContains(response, event2.title)
self.assertContains(response, event2.get_absolute_url())
def __init__(self, request):
super(CMSToolbar, self).__init__()
self.right_items = []
self.left_items = []
self.populated = False
self.post_template_populated = False
self.menus = {}
self.obj = None
self.redirect_url = None
self.request = None
self.is_staff = None
self.edit_mode = None
self.edit_mode_url_on = get_cms_setting("CMS_TOOLBAR_URL__EDIT_ON")
self.edit_mode_url_off = get_cms_setting("CMS_TOOLBAR_URL__EDIT_OFF")
self.disable_url = get_cms_setting("CMS_TOOLBAR_URL__DISABLE")
self.build_mode = None
self.use_draft = None
self.show_toolbar = None
self.login_form = None
self.clipboard = None
self.language = None
self.toolbar_language = None
self.simple_structure_mode = get_cms_setting("TOOLBAR_SIMPLE_STRUCTURE_MODE")
self.show_toolbar = True
self.init_toolbar(request)
with force_language(self.language):
try:
decorator = resolve(self.request.path_info).func
try:
# If the original view is decorated we try to extract the real function
# module instead of the decorator's one
if decorator and getattr(decorator, "func_closure", False):
# python 2
self.app_name = decorator.func_closure[0].cell_contents.__module__
elif decorator and getattr(decorator, "__closure__", False):
# python 3
self.app_name = decorator.__closure__[0].cell_contents.__module__
else:
raise AttributeError()
except (TypeError, AttributeError):
# no decorator
self.app_name = decorator.__module__
except Resolver404:
self.app_name = ""
toolbars = toolbar_pool.get_toolbars()
parts = self.app_name.split(".")
while parts:
path = ".".join(parts)
if path in installed_apps():
self.app_name = path
break
parts.pop()
self.toolbars = OrderedDict()
for key in toolbars:
toolbar = toolbars[key](
self.request, self, toolbars[key].check_current_app(key, self.app_name), self.app_name
)
self.toolbars[key] = toolbar
def toolbar_plugin_processor(instance, placeholder, rendered_content, original_context):
from cms.plugin_pool import plugin_pool
original_context.push()
child_plugin_classes = []
plugin_class = instance.get_plugin_class()
if plugin_class.allow_children:
inst, plugin = instance.get_plugin_instance()
page = original_context['request'].current_page
plugin.cms_plugin_instance = inst
children = [plugin_pool.get_plugin(cls) for cls in plugin.get_child_classes(placeholder, page)]
# Builds the list of dictionaries containing module, name and value for the plugin dropdowns
child_plugin_classes = get_toolbar_plugin_struct(children, placeholder.slot, placeholder.page,
parent=plugin_class)
instance.placeholder = placeholder
request = original_context['request']
with force_language(request.toolbar.toolbar_language):
data = {
'instance': instance,
'rendered_content': rendered_content,
'child_plugin_classes': child_plugin_classes,
}
# TODO: Remove js_compat once get_action_urls is refactored.
data.update(instance.get_action_urls(js_compat=False))
original_context.update(data)
plugin_class = instance.get_plugin_class()
template = plugin_class.frontend_edit_template
output = render_to_string(template, flatten_context(original_context)).strip()
original_context.pop()
return output
def is_valid_namespace_for_language(namespace, language_code):
"""
Check if provided namespace has an app-hooked page for given language_code.
Returns True or False.
"""
with force_language(language_code):
return is_valid_namespace(namespace)
def _test_plugin_languages(self, plugin_type, populate_func):
"""Test plugins for rendering objects in unpublished app language"""
app_page = self.create_base_pages(multilang=True)
# 'en' is the default language for our tests
language_code = 'en'
plugin_page = api.create_page(
'Events plugins page {0}'.format(language_code), self.template,
language_code, parent=self.root_page,
)
ph = plugin_page.placeholders.get(slot='content')
plugin = api.add_plugin(
ph, plugin_type, language_code, app_config=self.app_config,
)
populate_func(plugin)
plugin_page.publish(language_code)
# Unpublish page with the apphook
app_page.unpublish(language_code)
cache.clear()
try:
with force_language(language_code):
response = self.client.get(plugin_page.get_absolute_url())
# check we've received non-empty response
self.assertTrue(response.status_code, 200)
except NoReverseMatch:
self.fail("NoReverseMatch was raised during plugin page rendering")
def add_publish_button(self, classes=('cms_btn-action', 'cms_btn-publish',)):
# only do dirty lookups if publish permission is granted else button isn't added anyway
if self.toolbar.edit_mode and self.has_publish_permission():
classes = list(classes or [])
pk = self.page.pk if self.page else 0
dirty = (bool(self.dirty_statics) or
(self.page and (self.page.is_dirty(self.current_lang) or
self.page_is_pending(self.page, self.current_lang))))
if dirty:
classes.append('cms_btn-publish-active')
if self.dirty_statics or (self.page and self.page.is_published(self.current_lang)):
title = _('Publish changes')
else:
title = _('Publish page now')
classes.append('cms_publish-page')
params = {}
if self.dirty_statics:
params['statics'] = ','.join(str(sp.pk) for sp in self.dirty_statics)
if self.in_apphook():
params['redirect'] = self.request.path_info
with force_language(self.current_lang):
url = admin_reverse('cms_page_publish_page', args=(pk, self.current_lang))
url = add_url_parameters(url, params)
self.toolbar.add_button(title, url=url, extra_classes=classes,
side=self.toolbar.RIGHT, disabled=not dirty)
def test_apphook_on_root(self):
with SettingsOverride(ROOT_URLCONF="cms.test_utils.project.urls_for_apphook_tests"):
apphook_pool.clear()
superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "admin")
page = create_page(
"apphooked-page", "nav_playground.html", "en", created_by=superuser, published=True, apphook="SampleApp"
)
blank_page = create_page(
"not-apphooked-page",
"nav_playground.html",
"en",
created_by=superuser,
published=True,
apphook="",
slug="blankapp",
)
english_title = page.title_set.all()[0]
self.assertEqual(english_title.language, "en")
create_title("de", "aphooked-page-de", page)
self.assertTrue(page.publish("en"))
self.assertTrue(page.publish("de"))
self.assertTrue(blank_page.publish("en"))
with force_language("en"):
response = self.client.get(self.get_pages_root())
self.assertTemplateUsed(response, "sampleapp/home.html")
response = self.client.get("/en/blankapp/")
self.assertTemplateUsed(response, "nav_playground.html")
apphook_pool.clear()
def calendar_url(year, month, language, namespace):
with force_language(language):
url = reverse(
'{0}:get-calendar-dates'.format(namespace),
kwargs={'year': year, 'month': month}
)
return url
def test_calendar_plugin_with_not_existing_ns(self, timezone_mock):
timezone_mock.now.return_value = tz_datetime(2014, 1, 2)
self.create_base_pages()
new_config = EventsConfig.objects.create(namespace='new_namespace')
page = api.create_page('Plugin test en', self.template, 'en',
published=True, slug='plugin-test-en')
api.create_title('de', 'Plugin test de', page)
ph = page.placeholders.get(slot='content')
api.add_plugin(ph, 'CalendarPlugin', 'en', app_config=new_config)
api.add_plugin(ph, 'CalendarPlugin', 'de', app_config=new_config)
page.publish('en')
page.publish('de')
with force_language('en'):
event = Event.objects.create(
title='Test event namespace',
slug='test-event-namespace',
start_date=tz_datetime(2014, 1, 10),
publish_at=tz_datetime(2014, 1, 1),
app_config=new_config
)
event.create_translation(
'de',
title='Test event namespace de',
slug='test-event-namespace-de')
for language in ('en', 'de'):
page_url = page.get_absolute_url(language)
response = self.client.get(page_url)
self.assertEqual(response.status_code, 200)
def get_absolute_url(self, language=None):
language = language or self.get_current_language()
slug = self.safe_translation_getter('slug', language_code=language)
category_slug = self.category.safe_translation_getter(
'slug', language_code=language
)
namespace = getattr(
self.category.app_config, "namespace", "aldryn_jobs")
with force_language(language):
try:
# FIXME: does not looks correct return category url here
if not slug:
return self.category.get_absolute_url(language=language)
kwargs = {
'category_slug': category_slug,
'job_opening_slug': slug,
}
return reverse(
'{0}:job-opening-detail'.format(namespace),
kwargs=kwargs,
current_app=self.category.app_config.namespace
)
except NoReverseMatch:
# FIXME: this is wrong, if have some problem in reverse
# we should know
return "/%s/" % language
def toolbar_plugin_processor(instance, placeholder, rendered_content, original_context):
from cms.plugin_pool import plugin_pool
original_context.push()
child_plugin_classes = []
plugin_class = instance.get_plugin_class()
if plugin_class.allow_children:
inst, plugin = instance.get_plugin_instance()
page = original_context['request'].current_page
children = [plugin_pool.get_plugin(cls) for cls in plugin.get_child_classes(placeholder, page)]
# Builds the list of dictionaries containing module, name and value for the plugin dropdowns
child_plugin_classes = get_toolbar_plugin_struct(children, placeholder.slot, placeholder.page,
parent=plugin_class)
instance.placeholder = placeholder
request = original_context['request']
with force_language(request.toolbar.toolbar_language):
data = {
'instance': instance,
'rendered_content': rendered_content,
'child_plugin_classes': child_plugin_classes,
'edit_url': placeholder.get_edit_url(instance.pk),
'add_url': placeholder.get_add_url(),
'delete_url': placeholder.get_delete_url(instance.pk),
'move_url': placeholder.get_move_url(),
}
original_context.update(data)
output = render_to_string(instance.get_plugin_class().frontend_edit_template, original_context)
original_context.pop()
return output
def get_on_delete_redirect_url(self, event):
language = getattr(
self, 'current_lang', get_language_from_request(
self.request, check_path=True))
with force_language(language):
return reverse('{0}:events_list'.format(
event.app_config.namespace))
def _call_toolbar(self, func_name):
with force_language(self.toolbar_language):
first = ('cms.cms_toolbar.BasicToolbar',
'cms.cms_toolbar.PlaceholderToolbar')
for key in first:
toolbar = self.toolbars.get(key)
if not toolbar:
continue
result = getattr(toolbar, func_name)()
if isinstance(result, HttpResponse):
return result
for key in self.toolbars:
if key in first:
continue
toolbar = self.toolbars[key]
result = getattr(toolbar, func_name)()
if isinstance(result, HttpResponse):
return result
def test_apphooks_with_excluded_permissions(self):
en_title = self.create_base_structure(
'SampleAppWithExcludedPermissions', 'en')
with force_language("en"):
excluded_path = reverse('excluded:example')
not_excluded_path = reverse('not_excluded:example')
page = en_title.page.publisher_public
page.login_required = True
page.save()
page.publish('en')
excluded_response = self.client.get(excluded_path)
not_excluded_response = self.client.get(not_excluded_path)
self.assertEqual(excluded_response.status_code, 200)
self.assertEqual(not_excluded_response.status_code, 302)
self.apphook_clear()
def test_get_sub_page_for_apphook_with_implicit_current_app(self):
en_title = self.create_base_structure(NS_APP_NAME, 'en',
'namespaced_app_ns')
with force_language("en"):
path = reverse('namespaced_app_ns:current-app')
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(
request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, en_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/app.html')
self.assertContains(response, 'namespaced_app_ns')
self.assertContains(response, path)
self.apphook_clear()
def get_apphook_url(self, namespace=None, language=None):
"""
Returns url for default view with pattern '^$' which is a
base url for our application. Right now 'events_list' is
considered as default view.
"""
DEFAULT_VIEW = 'events_list'
if namespace is None:
namespace = self.app_config.namespace
# if language is not provided then leave control over language to
# caller
if language is None:
return reverse('{0}:{1}'.format(namespace, DEFAULT_VIEW))
# otherwise force it for cases with parler switch_language which
# seems to affect only parler internals
with force_language(language):
return reverse('{0}:{1}'.format(namespace, DEFAULT_VIEW))
def test_get_root_page_for_apphook_with_instance_namespace(self):
en_title = self.create_base_structure(NS_APP_NAME, 'en', 'instance_ns')
self.reload_urls()
with force_language("en"):
reverse("example_app:example")
reverse("example1:example")
reverse("example2:example")
path = reverse('namespaced_app_ns:sample-root')
path_instance = reverse('instance_ns:sample-root')
self.assertEqual(path, path_instance)
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(
request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, en_title.page.pk)
self.apphook_clear()
def test_a0_en_only(self):
namespace = self.app_config.namespace
self.page.unpublish('de')
author, owner = self.create_authors()
author.translations.create(slug='{0}-de'.format(author.slug),
language_code='de')
de_dashboard = self.create_de_dashboard(
author=author,
owner=owner,
categories=[self.category1],
)
dashboards = self.create_en_dashboards(categories=[self.category1])
with force_language('en'):
response = self.client.get(
reverse('{0}:{1}'.format(namespace, self.view_name),
kwargs=self.get_view_kwargs()))
for dashboard in dashboards:
self.assertContains(response, dashboard.title)
self.assertNotContains(response, de_dashboard.title)
def test_event_list_by_year_past_event_1_day_long(self):
"""
Regression test case for checking that if event was created
today but for past date it is still displayed on month list view
"""
# make it previous year or so
start_date = end_date = self.get_past_date(366)
event_data, kwargs = self.get_new_past_event_data(start_date,
end_date,
arg_list=('year', ))
with force_language('en'):
event = self.create_event(**event_data)
event_url = event.get_absolute_url()
view_url = reverse('{0}:events_list-by-year'.format(
self.app_config.namespace),
kwargs=kwargs)
response = self.client.get(view_url)
self.assertContains(response, event.get_title())
self.assertContains(response, event_url)
def test_apphook_permissions(self):
with SettingsOverride(
ROOT_URLCONF=
'cms.test_utils.project.second_urls_for_apphook_tests'):
en_title, de_title = self.create_base_structure(
APP_NAME, ['en', 'de'])
with force_language("en"):
path = reverse('sample-settings')
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
page = en_title.page.publisher_public
page.login_required = True
page.save()
page.publish('en')
response = self.client.get(path)
self.assertEqual(response.status_code, 302)
apphook_pool.clear()
def test_publish_wrong_lang(self):
page = self.create_page("test_admin", published=False)
superuser = self.get_superuser()
with SettingsOverride(LANGUAGES=(('de', 'de'), ('en', 'en')),
CMS_LANGUAGES={
1: [{
'code': 'en',
'name': 'en',
'fallbacks': ['fr', 'de'],
'public': True
}]
}):
with self.login_user_context(superuser):
with force_language('de'):
response = self.client.get(
reverse("admin:cms_page_publish_page",
args=[page.pk, 'en']))
self.assertEqual(response.status_code, 302)
page = Page.objects.get(pk=page.pk)
def test_apphooks_with_excluded_permissions(self):
with SettingsOverride(ROOT_URLCONF='cms.test_utils.project.second_urls_for_apphook_tests'):
en_title = self.create_base_structure('SampleAppWithExcludedPermissions', 'en')
with force_language("en"):
excluded_path = reverse('excluded:example')
not_excluded_path = reverse('not_excluded:example')
page = en_title.page.publisher_public
page.login_required = True
page.save()
page.publish('en')
excluded_response = self.client.get(excluded_path)
not_excluded_response = self.client.get(not_excluded_path)
self.assertEqual(excluded_response.status_code, 200)
self.assertEqual(not_excluded_response.status_code, 302)
apphook_pool.clear()
def test_event_list_page_by_month(self):
self.create_base_pages()
ev1, ev2, ev3, ev4, ev5, ev6, ev7 = self.setUpForEventListPages()
url = reverse("aldryn_events:events_list-by-month",
kwargs={
'year': 2014,
'month': 3
})
with force_language('en'):
response = self.client.get(url)
self.assertQuerysetEqual(
response.context_data['object_list'],
map(repr, [ev5, ev2, ev3, ev1, ev6]),
)
self.assertContains(response, ev5.get_absolute_url())
self.assertContains(response, ev2.get_absolute_url())
self.assertContains(response, ev3.get_absolute_url())
self.assertContains(response, ev1.get_absolute_url())
self.assertContains(response, ev6.get_absolute_url())
def get_absolute_url(self, language=None):
language = language or self.get_current_language()
slug = self.safe_translation_getter('slug', language_code=language)
if self.app_config_id:
namespace = self.app_config.namespace
else:
namespace = 'aldryn_jobs'
with force_language(language):
try:
if not slug:
return reverse('{0}:job-opening-list'.format(namespace))
kwargs = {'category_slug': slug}
return reverse(
'{0}:category-job-opening-list'.format(namespace),
kwargs=kwargs,
current_app=self.app_config.namespace
)
except NoReverseMatch:
return "/%s/" % language
def test_b_event_upcoming_past_plugin_with_en_and_de(self, timezone_mock):
timezone_mock.now.return_value = tz_datetime(2014, 2, 6, 12)
root_page, app_page = self.setup_pages(multilang=True)
self.create_de_only_event()
ph = root_page.placeholders.get(slot='content')
plugin_en = api.add_plugin(
ph,
'UpcomingPlugin',
'en',
app_config=self.app_config,
)
plugin_en.past_events = True
plugin_en.save()
root_page.publish('en')
with force_language('en'):
response = self.client.get(root_page.get_absolute_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'German event only')
def test_plugin_with_vcard_enabled_with_apphook(self):
vcard_kwargs = {'slug': self.person1.slug}
with force_language('en'):
self.create_apphook_page()
person_vcard_url = reverse('{0}:download_vcard'.format(
self.namespace),
kwargs=vcard_kwargs)
plugin = self.create_plugin(plugin_params={'show_vcard': True})
url = self.page.get_absolute_url()
response = self.client.get(url, follow=True)
self.assertContains(response, self.person1.name)
self.assertContains(response, person_vcard_url)
# test that vcard download link is not shown if disabled
plugin.show_vcard = False
plugin.save()
self.page.publish('en')
response = self.client.get(url, follow=True)
self.assertContains(response, self.person1.name)
self.assertNotContains(response, person_vcard_url)
def test_get_sub_page_for_apphook_with_explicit_current_app(self):
with SettingsOverride(ROOT_URLCONF='cms.test_utils.project.second_urls_for_apphook_tests'):
en_title = self.create_base_structure(NS_APP_NAME, 'en', 'instance_ns')
with force_language("en"):
path = reverse('namespaced_app_ns:current-app')
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash
self.assertEqual(attached_to_page.pk, en_title.page.pk)
response = self.client.get(path)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'sampleapp/app.html')
self.assertContains(response, 'instance_ns')
self.assertContains(response, path)
apphook_pool.clear()
def test_toolbar_current_app_apphook_with_implicit_current_app(self):
self.create_base_structure(NS_APP_NAME, 'en', 'namespaced_app_ns')
with force_language("en"):
path = reverse('namespaced_app_ns:current-app')
request = self.get_request(path)
toolbar = CMSToolbar(request)
self.assertEqual(
toolbar.toolbars[
'cms.test_utils.project.sampleapp.cms_toolbars.CategoryToolbar']
.app_path, 'cms.test_utils.project.sampleapp')
self.assertTrue(toolbar.toolbars[
'cms.test_utils.project.sampleapp.cms_toolbars.CategoryToolbar'].
is_current_app)
self.assertEqual(
toolbar.toolbars[
'cms.test_utils.project.extensionapp.cms_toolbars.MyTitleExtensionToolbar']
.app_path, 'cms.test_utils.project.sampleapp')
self.assertFalse(toolbar.toolbars[
'cms.test_utils.project.extensionapp.cms_toolbars.MyTitleExtensionToolbar']
.is_current_app)
def test_default_language_changer_with_implicit_current_app(self):
with SettingsOverride(
ROOT_URLCONF=
'cms.test_utils.project.second_urls_for_apphook_tests'):
titles = self.create_base_structure(
NS_APP_NAME, ['en', 'de'], 'namespaced_app_ns') # nopyflakes
self.reload_urls()
with force_language("en"):
path = reverse('namespaced_app_ns:translated-url')
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
url = DefaultLanguageChanger(request)('en')
self.assertEqual(url, path)
url = DefaultLanguageChanger(request)('de')
self.assertEqual(url,
'/de%s' % path[3:].replace('/page', '/Seite'))
apphook_pool.clear()
def test_get_child_page_for_apphook_with_instance_namespace(self):
with SettingsOverride(
ROOT_URLCONF=
'cms.test_utils.project.second_urls_for_apphook_tests'):
en_title = self.create_base_structure(NS_APP_NAME, 'en',
'instance_ns')
with force_language("en"):
path = reverse('namespaced_app_ns:sample-settings')
path_instance1 = reverse('instance_ns:sample-settings')
path_instance2 = reverse('namespaced_app_ns:sample-settings',
current_app='instance_ns')
self.assertEquals(path, path_instance1)
self.assertEquals(path, path_instance2)
request = self.get_request(path)
request.LANGUAGE_CODE = 'en'
attached_to_page = applications_page_check(
request, path=path[1:]) # strip leading slash
self.assertEquals(attached_to_page.pk, en_title.page_id)
apphook_pool.clear()
def toolbar_plugin_processor(instance, placeholder, rendered_content,
original_context):
toolbar = original_context['request'].toolbar
instance.placeholder = placeholder
with force_language(toolbar.toolbar_language):
data = {
'instance': instance,
'rendered_content': rendered_content,
}
# TODO: Remove js_compat once get_action_urls is refactored.
data.update(instance.get_action_urls(js_compat=False))
original_context.update(data)
template = toolbar.get_cached_template(
template=instance.get_plugin_class().frontend_edit_template)
output = template.render(original_context).strip()
original_context.pop()
return output
def test_apphook_on_root(self):
self.apphook_clear()
superuser = get_user_model().objects.create_superuser('admin', '*****@*****.**', 'admin')
page = create_page("apphooked-page", "nav_playground.html", "en",
created_by=superuser, published=True, apphook="SampleApp")
blank_page = create_page("not-apphooked-page", "nav_playground.html", "en",
created_by=superuser, published=True, apphook="", slug='blankapp')
english_title = page.title_set.all()[0]
self.assertEqual(english_title.language, 'en')
create_title("de", "aphooked-page-de", page)
self.assertTrue(page.publish('en'))
self.assertTrue(page.publish('de'))
self.assertTrue(blank_page.publish('en'))
with force_language("en"):
response = self.client.get(self.get_pages_root())
self.assertTemplateUsed(response, 'sampleapp/home.html')
self.assertContains(response, '<--noplaceholder-->')
response = self.client.get('/en/blankapp/')
self.assertTemplateUsed(response, 'nav_playground.html')
self.apphook_clear()
def override_language_switcher(self):
language_menu = self.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER,
_('Language'))
# Remove all existing language links
# remove_item uses `items` attribute so we have to copy object
for _item in copy(language_menu.items):
language_menu.remove_item(item=_item)
for code, name in get_language_tuple(self.current_site.pk):
# Showing only existing translation. For versioning it will be the
# latest translation i.e. draft or published
alias_content = self.toolbar.obj.alias.get_content(
language=code,
show_draft_content=True,
)
if alias_content:
with force_language(code):
url = alias_content.get_absolute_url()
language_menu.add_link_item(name,
url=url,
active=self.current_lang == code)
def create_en_articles(self, author=None, owner=None, app_config=None,
amount=3, categories=None):
if author is None:
author = self.author
if owner is None:
owner = self.owner
if app_config is None:
app_config = self.app_config
with force_language('en'):
articles = []
for _ in range(amount):
article = self.create_article(author=author,
owner=owner,
app_config=app_config)
if categories:
article.categories = categories
article.tags.add('tag1')
article.save()
articles.append(article)
return articles
def test_apphook_on_root(self):
with SettingsOverride(ROOT_URLCONF='cms.test_utils.project.urls_for_apphook_tests'):
apphook_pool.clear()
superuser = User.objects.create_superuser('admin', '*****@*****.**', 'admin')
page = create_page("apphooked-page", "nav_playground.html", "en",
created_by=superuser, published=True, apphook="SampleApp")
blank_page = create_page("not-apphooked-page", "nav_playground.html", "en",
created_by=superuser, published=True, apphook="", slug='blankapp')
english_title = page.title_set.all()[0]
self.assertEquals(english_title.language, 'en')
create_title("de", "aphooked-page-de", page, apphook="SampleApp")
self.assertTrue(page.publish())
self.assertTrue(blank_page.publish())
with force_language("en"):
response = self.client.get(self.get_pages_root())
self.assertTemplateUsed(response, 'sampleapp/home.html')
response = self.client.get('/en/blankapp/')
self.assertTemplateUsed(response, 'nav_playground.html')
apphook_pool.clear()
def test_a_calendar_plugin_with_en(self):
root_page, app_page = self.setup_pages(multilang=False)
now = datetime.date.today()
today = tz_datetime(year=now.year, month=now.month, day=now.day)
tomorrow = today + datetime.timedelta(days=1)
event_de = self.create_de_only_event(date_start=today,
date_end=tomorrow)
ph = root_page.placeholders.get(slot='content')
plugin_en = api.add_plugin(
ph,
'CalendarPlugin',
'en',
app_config=self.app_config,
)
plugin_en.save()
root_page.publish('en')
with force_language('en'):
date_view_url = self.get_list_by_day_url(event_de.app_config,
event_de.start_date)
response = self.client.get(root_page.get_absolute_url())
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, date_view_url)
def test_move_plugin(self):
static_placeholder_source = StaticPlaceholder.objects.create(
name='foobar', code='foobar', site_id=1)
static_placeholder_target = StaticPlaceholder.objects.create(
name='foofoo', code='foofoo', site_id=1)
sourceplugin = add_plugin(static_placeholder_source.draft,
'TextPlugin',
'en',
body='test')
plugin_class = sourceplugin.get_plugin_class_instance()
with force_language('en'):
action_urls = sourceplugin.get_action_urls()
expected = {
'reload': plugin_class.requires_reload(PLUGIN_MOVE_ACTION),
'urls': action_urls,
}
admin = self.get_admin()
with self.login_user_context(admin):
endpoint = self.get_move_plugin_uri(sourceplugin,
container=StaticPlaceholder)
data = {
'plugin_id': sourceplugin.pk,
'placeholder_id': static_placeholder_target.draft.id,
'plugin_parent': '',
'plugin_language': 'en',
}
response = self.client.post(endpoint, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content.decode('utf8')),
expected)
source = StaticPlaceholder.objects.get(
pk=static_placeholder_source.pk)
target = StaticPlaceholder.objects.get(
pk=static_placeholder_target.pk)
self.assertTrue(source.dirty)
self.assertTrue(target.dirty)
def test_alias_change_category_button_is_visible_on_alias_edit_view(self):
button_label = 'Change category...'
alias_change_viewname = 'djangocms_alias_alias_change'
alias = self._create_alias()
with force_language('en'):
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
self.assertIsNotNone(search_result)
button = search_result.item
self.assertEqual(button.on_close, 'REFRESH_PAGE')
self.assertEqual(
button.url,
admin_reverse(
alias_change_viewname,
args=[alias.pk],
),
)
def fallback_aware_namespace_url(context, view_name, namespace, **kwargs):
"""
Resolve namespaced url with respect to language fallback settings.
:param context: template context
:param view_name: view name
:param namespace: namespace string
:param kwargs: view kwargs
:return: first resolved url string
"""
language = get_language_from_request(context['request'], check_path=True)
valid_languages = get_valid_languages(namespace, language)
url = ''
for lang in valid_languages:
with force_language(lang):
try:
url = reverse('{0}:{1}'.format(namespace, view_name),
kwargs=kwargs)
except NoReverseMatch:
pass
else:
break
return url
def test_a1_en_de(self):
namespace = self.app_config.namespace
author, owner = self.create_authors()
author.translations.create(
slug='{0}-de'.format(author.slug),
language_code='de')
de_article = self.create_de_article(
author=author,
owner=owner,
categories=[self.category1]
)
articles = self.create_en_articles(categories=[self.category1])
with force_language('en'):
response = self.client.get(
reverse(
'{0}:{1}'.format(namespace, self.view_name),
kwargs=self.get_view_kwargs()
)
)
for article in articles:
self.assertContains(response, article.title)
self.assertContains(response, de_article.title)
def toolbar_plugin_processor(instance, placeholder, rendered_content,
original_context):
from cms.plugin_pool import plugin_pool
original_context.push()
child_plugin_classes = []
plugin_class = instance.get_plugin_class()
if plugin_class.allow_children:
inst, plugin = instance.get_plugin_instance()
page = original_context['request'].current_page
plugin.cms_plugin_instance = inst
children = [
plugin_pool.get_plugin(cls)
for cls in plugin.get_child_classes(placeholder, page)
]
# Builds the list of dictionaries containing module, name and value for the plugin dropdowns
child_plugin_classes = get_toolbar_plugin_struct(children,
placeholder.slot,
placeholder.page,
parent=plugin_class)
instance.placeholder = placeholder
request = original_context['request']
with force_language(request.toolbar.toolbar_language):
data = {
'instance': instance,
'rendered_content': rendered_content,
'child_plugin_classes': child_plugin_classes,
'edit_url': placeholder.get_edit_url(instance.pk),
'add_url': placeholder.get_add_url(),
'delete_url': placeholder.get_delete_url(instance.pk),
'move_url': placeholder.get_move_url(),
}
original_context.update(data)
plugin_class = instance.get_plugin_class()
template = plugin_class.frontend_edit_template
output = render_to_string(template, original_context).strip()
original_context.pop()
return output
def get_absolute_url(self, language=None):
language = language or self.get_current_language()
slug = self.safe_translation_getter('slug', language_code=language)
category_slug = self.category.safe_translation_getter(
'slug', language_code=language)
namespace = getattr(self.category.app_config, "namespace",
"aldryn_jobs")
with force_language(language):
try:
# FIXME: does not looks correct return category url here
if not slug:
return self.category.get_absolute_url(language=language)
kwargs = {
'category_slug': category_slug,
'job_opening_slug': slug,
}
return reverse('{0}:job-opening-detail'.format(namespace),
kwargs=kwargs,
current_app=self.category.app_config.namespace)
except NoReverseMatch:
# FIXME: this is wrong, if have some problem in reverse
# we should know
return "/%s/" % language
