def render(self, context, instance, placeholder):
template_vars = {
'placeholder': placeholder,
}
template_vars['object'] = instance
lang = instance.from_language
request = None
if not lang:
if context.has_key('request'):
request = context['request']
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGE_CODE
if instance.from_page:
page = instance.from_page
else:
page = instance.page
if not instance.page.publisher_is_draft and page.publisher_is_draft:
page = page.publisher_public
plugins = get_cmsplugin_queryset(request).filter(page=page, language=lang, placeholder__iexact=placeholder, parent__isnull=True).order_by('position').select_related()
plugin_output = []
template_vars['parent_plugins'] = plugins
for plg in plugins:
tmpctx = copy.copy(context)
tmpctx.update(template_vars)
inst, name = plg.get_plugin_instance()
outstr = inst.render_plugin(tmpctx, placeholder)
plugin_output.append(outstr)
template_vars['parent_output'] = plugin_output
context.update(template_vars)
return context
def get_admin_menu_item_context(request, page, filtered=False, language=None):
"""
Used for rendering the page tree, inserts into context everything what
we need for single item
"""
has_add_page_permission = page.has_add_permission(request)
has_move_page_permission = page.has_move_page_permission(request)
site = Site.objects.get_current()
lang = get_language_from_request(request)
metadata = ""
if get_cms_setting('PERMISSION'):
# jstree metadata generator
md = []
if not has_move_page_permission:
md.append(('valid_children', False))
md.append(('draggable', False))
if md:
# just turn it into simple javascript object
metadata = "{" + ", ".join(
map(
lambda e: "%s: %s" %
(e[0], isinstance(e[1], bool) and str(e[1]) or e[1].lower(
)), md)) + "}"
has_add_on_same_level_permission = False
opts = Page._meta
if get_cms_setting('PERMISSION'):
if hasattr(request.user, '_global_add_perm_cache'):
global_add_perm = request.user._global_add_perm_cache
else:
global_add_perm = GlobalPagePermission.objects.user_has_add_permission(
request.user, page.site_id).exists()
request.user._global_add_perm_cache = global_add_perm
if request.user.has_perm(
opts.app_label + '.' +
get_permission_codename('add', opts)) and global_add_perm:
has_add_on_same_level_permission = True
from cms.utils import permissions
if not has_add_on_same_level_permission and page.parent_id:
has_add_on_same_level_permission = permissions.has_generic_permission(
page.parent_id, request.user, "add", page.site_id)
context = {
'request': request,
'page': page,
'site': site,
'lang': lang,
'filtered': filtered,
'metadata': metadata,
'preview_language': language,
'has_change_permission': page.has_change_permission(request),
'has_publish_permission': page.has_publish_permission(request),
'has_delete_permission': page.has_delete_permission(request),
'has_move_page_permission': has_move_page_permission,
'has_add_page_permission': has_add_page_permission,
'has_add_on_same_level_permission': has_add_on_same_level_permission,
'CMS_PERMISSION': get_cms_setting('PERMISSION'),
}
return context
def get_admin_menu_item_context(request, page, filtered=False):
"""
Used for rendering the page tree, inserts into context everything what
we need for single item
"""
has_add_page_permission = page.has_add_permission(request)
has_move_page_permission = page.has_move_page_permission(request)
site = Site.objects.get_current()
lang = get_language_from_request(request)
#slug = page.get_slug(language=lang, fallback=True) # why was this here ??
metadata = ""
if get_cms_setting('PERMISSION'):
# jstree metadata generator
md = []
#if not has_add_page_permission:
if not has_move_page_permission:
md.append(('valid_children', False))
md.append(('draggable', False))
if md:
# just turn it into simple javascript object
metadata = "{" + ", ".join(map(lambda e: "%s: %s" %(e[0],
isinstance(e[1], bool) and str(e[1]) or e[1].lower() ), md)) + "}"
has_add_on_same_level_permission = False
opts = Page._meta
if get_cms_setting('PERMISSION'):
perms = has_global_page_permission(request, page.site_id, can_add=True)
if (request.user.has_perm(opts.app_label + '.' + opts.get_add_permission()) and perms):
has_add_on_same_level_permission = True
if page.delete_requested():
css_class = "publisher_delete_requested"
elif not page.published:
css_class = "publisher_draft"
else:
css_class = publisher_classes.get(page.publisher_state, "")
if not has_add_on_same_level_permission and page.parent_id:
has_add_on_same_level_permission = permissions.has_generic_permission(page.parent_id, request.user, "add", page.site)
#has_add_on_same_level_permission = has_add_page_on_same_level_permission(request, page)
context = {
'page': page,
'site': site,
'lang': lang,
'filtered': filtered,
'metadata': metadata,
'css_class': css_class,
'has_change_permission': page.has_change_permission(request),
'has_publish_permission': page.has_publish_permission(request),
'has_delete_permission': page.has_delete_permission(request),
'has_move_page_permission': has_move_page_permission,
'has_add_page_permission': has_add_page_permission,
'has_add_on_same_level_permission': has_add_on_same_level_permission,
'CMS_PERMISSION': get_cms_setting('PERMISSION'),
'CMS_SHOW_END_DATE': get_cms_setting('SHOW_END_DATE'),
}
return context
def render_tag_links(context):
request = context["request"]
language = get_language_from_request(request)
filters = dict(is_published=True, pub_date__lte=datetime.datetime.now(), entrytitle__language=language)
return {
'tags': Tag.objects.usage_for_model(Entry, filters=filters)
}
def get_plugins(request, placeholder, lang=None):
if not placeholder:
return []
lang = lang or get_language_from_request(request)
if not hasattr(placeholder, '_%s_plugins_cache' % lang):
assign_plugins(request, [placeholder], lang)
return getattr(placeholder, '_%s_plugins_cache' % lang)
def copy_plugins(self, request):
if 'history' in request.path or 'recover' in request.path:
return HttpResponse(str("error"))
if request.method == "POST":
copy_from = request.POST['copy_from']
placeholder_id = request.POST['placeholder']
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
page = get_item_from_placeholder_if_exists(placeholder)
language = request.POST['language'] or get_language_from_request(request)
if not page.has_change_permission(request):
return HttpResponseForbidden(_("You do not have permission to change this page"))
if not language or not language in [ l[0] for l in settings.CMS_LANGUAGES ]:
return HttpResponseBadRequest(_("Language must be set to a supported language!"))
if language == copy_from:
return HttpResponseBadRequest(_("Language must be different than the copied language!"))
plugins = list(placeholder.cmsplugin_set.filter(language=copy_from).order_by('tree_id', '-rght'))
copy_plugins_to(plugins, placeholder, language)
if page and "reversion" in settings.INSTALLED_APPS:
make_revision_with_plugins(page)
reversion.revision.user = request.user
reversion.revision.comment = _(u"Copied %(language)s plugins to %(placeholder)s") % {'language':dict(settings.LANGUAGES)[language], 'placeholder':placeholder}
plugin_list = CMSPlugin.objects.filter(language=language, placeholder=placeholder, parent=None).order_by('position')
return render_to_response('admin/cms/page/widgets/plugin_item.html', {'plugin_list':plugin_list}, RequestContext(request))
raise Http404
def render(self, context, instance, placeholder):
template_vars = {
'placeholder': placeholder,
}
template_vars['object'] = instance
lang = instance.from_language
request = context.get('request', None)
if not lang:
if context.has_key('request'):
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGE_CODE
if instance.from_page:
page = instance.from_page
else:
page = instance.page
if not instance.page.publisher_is_draft and page.publisher_is_draft:
page = page.publisher_public
plugins = get_cmsplugin_queryset(request).filter(
placeholder__page=page,
language=lang,
placeholder__slot__iexact=placeholder,
parent__isnull=True).order_by('position').select_related()
plugin_output = []
template_vars['parent_plugins'] = plugins
for plg in plugins:
tmpctx = copy.copy(context)
tmpctx.update(template_vars)
inst, name = plg.get_plugin_instance()
outstr = inst.render_plugin(tmpctx, placeholder)
plugin_output.append(outstr)
template_vars['parent_output'] = plugin_output
context.update(template_vars)
return context
def page_id_url(context, reverse_id, lang=None):
"""
Show the url of a page with a reverse id in the right language
This is mostly used if you want to have a static link in a template to a page
"""
request = context.get('request', False)
if not request:
return {'content':''}
if lang is None:
lang = get_language_from_request(request)
if hasattr(settings, 'CMS_CONTENT_CACHE_DURATION'):
key = 'page_url_pid:'+reverse_id+'_l:'+str(lang)+'_type:absolute_url'
url = cache.get(key)
if not url:
try:
page = Page.objects.get(reverse_id=reverse_id)
except:
if settings.DEBUG:
raise
else:
site = request.site
send_mail(_('Reverse ID not found on %(domain)s') % {'domain':site.domain},
_("A page_url template tag didn't found a page with the reverse_id %(reverse_id)s\nThe url of the page was: http://%(host)s%(path)s")%{'reverse_id':reverse_id, 'host':request.host, 'path':request.path},
settings.DEFAULT_FROM_EMAIL,
settings.MANAGERS,
fail_silently=True)
url = page.get_absolute_url(language=lang)
cache.set(key, url, settings.CMS_CONTENT_CACHE_DURATION)
else:
url = page.get_absolute_url(language=lang)
if url:
return {'content':url}
return {'content':''}
def render_tag(self, context, static_code, extra_bits, nodelist=None):
request = context.get('request')
if not static_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 ''
validate_placeholder_name(static_code)
toolbar = get_toolbar_from_request(request)
renderer = toolbar.get_content_renderer()
alias = self._get_alias(request, static_code, extra_bits)
if not alias:
return ''
# Get draft contents in edit or preview mode?
get_draft_content = False
if toolbar.edit_mode_active or toolbar.preview_mode_active:
get_draft_content = True
language = get_language_from_request(request)
placeholder = alias.get_placeholder(language=language, show_draft_content=get_draft_content)
if placeholder:
content = renderer.render_placeholder(
placeholder=placeholder,
context=context,
nodelist=nodelist,
)
return content
return ''
def assign_plugins(request, placeholders, lang=None):
"""
Fetch all plugins for the given ``placeholders`` and
cast them down to the concrete instances in one query
per type.
"""
placeholders = list(placeholders)
if not placeholders:
return
lang = lang or get_language_from_request(request)
request_lang = lang
if hasattr(request, "current_page") and request.current_page is not None:
languages = request.current_page.get_languages()
if not lang in languages and not get_redirect_on_fallback(lang):
fallbacks = get_fallback_languages(lang)
for fallback in fallbacks:
if fallback in languages:
request_lang = fallback
break
# get all plugins for the given placeholders
qs = get_cmsplugin_queryset(request).filter(
placeholder__in=placeholders,
language=request_lang).order_by('placeholder', 'tree_id', 'lft')
plugin_list = downcast_plugins(qs)
# split the plugins up by placeholder
groups = dict((key, list(plugins)) for key, plugins in groupby(
plugin_list, operator.attrgetter('placeholder_id')))
for group in groups:
groups[group] = build_plugin_tree(groups[group])
for placeholder in placeholders:
setattr(placeholder, '_%s_plugins_cache' % lang,
list(groups.get(placeholder.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 get_form_kwargs(self, step=None):
"""This is called by self.get_form()"""
kwargs = super(WizardCreateView, self).get_form_kwargs()
kwargs['wizard_user'] = self.request.user
if self.is_second_step(step):
kwargs['wizard_page'] = self.get_origin_page()
kwargs['wizard_language'] = get_language_from_request(self.request)
else:
page_pk = self.page_pk or self.request.GET.get('page', None)
if page_pk and page_pk != 'None':
kwargs['wizard_page'] = Page.objects.filter(pk=page_pk).first()
else:
kwargs['wizard_page'] = None
kwargs['wizard_language'] = self.request.GET.get(
'language', get_language_from_request(self.request))
return kwargs
def get_form_initial(self, step):
"""This is called by self.get_form()"""
initial = super(WizardCreateView, self).get_form_initial(step)
if self.is_first_step(step):
initial['page'] = self.request.GET.get('page')
initial['language'] = get_language_from_request(self.request)
return initial
def render_placeholder_toolbar(placeholder,
context,
content,
name_fallback=None):
from cms.plugin_pool import plugin_pool
request = context['request']
page = placeholder.page if placeholder else None
if not page:
page = getattr(request, 'current_page', None)
if page:
template = page.template
if name_fallback and not placeholder:
placeholder = Placeholder.objects.create(slot=name_fallback)
page.placeholders.add(placeholder)
placeholder.page = page
else:
template = None
if placeholder:
slot = placeholder.slot
else:
slot = None
installed_plugins = plugin_pool.get_all_plugins(slot, page)
name = get_placeholder_conf("name", slot, template, title(slot))
name = _(name)
context.push()
context['installed_plugins'] = installed_plugins
context['language'] = get_language_from_request(request)
context['placeholder_label'] = name
context['placeholder'] = placeholder
context['page'] = page
toolbar = render_to_string("cms/toolbar/placeholder.html", context)
context.pop()
return "".join([toolbar, content])
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 init_toolbar(self, request):
self.request = request
self.is_staff = self.request.user.is_staff
self.edit_mode = self.is_staff and self.request.session.get("cms_edit", False)
self.build_mode = self.is_staff and self.request.session.get("cms_build", False)
self.use_draft = self.is_staff and self.edit_mode or self.build_mode
self.show_toolbar = self.is_staff or self.request.session.get("cms_edit", False)
self.login_form = CMSToolbarLoginForm(request=request)
if self.request.session.get("cms_toolbar_disabled", False):
self.show_toolbar = False
if settings.USE_I18N:
self.language = get_language_from_request(request)
else:
self.language = settings.LANGUAGE_CODE
# We need to store the current language in case the user's preferred language is different.
self.toolbar_language = self.language
user_settings = self.get_user_settings()
if user_settings:
if (settings.USE_I18N and user_settings.language in dict(settings.LANGUAGES)) or (
not settings.USE_I18N and user_settings.language == settings.LANGUAGE_CODE
):
self.toolbar_language = user_settings.language
else:
user_settings.language = self.language
user_settings.save()
self.clipboard = user_settings.clipboard
if hasattr(self, "toolbars"):
for key, toolbar in self.toolbars.items():
self.toolbars[key].request = self.request
def __call__(self, lang):
page_language = get_language_from_request(self.request)
with force_language(page_language):
try:
view = resolve(self.request.path_info)
except Resolver404:
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: # noqa: E722
pass
elif view and view.url_name not 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):
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 page_id_url(context, reverse_id, lang=None, site=None):
"""
Show the url of a page with a reverse id in the right language
This is mostly used if you want to have a static link in a template to a page
"""
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return {'content': ''}
if request.current_page == "dummy":
return {'content': ''}
if lang is None:
lang = get_language_from_request(request)
key = 'page_id_url_pid:' + str(reverse_id) + '_l:' + str(
lang) + '_site:' + str(site_id) + '_type:absolute_url'
url = cache.get(key)
if not url:
try:
page = get_page_queryset(request).get(reverse_id=reverse_id,
site=site_id)
url = page.get_absolute_url(language=lang)
cache.set(key, url, settings.CMS_CONTENT_CACHE_DURATION)
except:
send_missing_mail(reverse_id, request)
if url:
return {'content': url}
return {'content': ''}
def init_toolbar(self, request):
self.request = request
self.is_staff = self.request.user.is_staff
self.edit_mode = self.is_staff and self.request.session.get('cms_edit', False)
self.build_mode = self.is_staff and self.request.session.get('cms_build', False)
self.use_draft = self.is_staff and self.edit_mode or self.build_mode
self.show_toolbar = self.is_staff or self.request.session.get('cms_edit', False)
self.login_form = CMSToolbarLoginForm(request=request)
if self.request.session.get('cms_toolbar_disabled', False):
self.show_toolbar = False
if settings.USE_I18N:
self.language = get_language_from_request(request)
else:
self.language = settings.LANGUAGE_CODE
# We need to store the current language in case the user's preferred language is different.
self.toolbar_language = self.language
user_settings = self.get_user_settings()
if user_settings:
if (settings.USE_I18N and user_settings.language in dict(settings.LANGUAGES)) or (
not settings.USE_I18N and user_settings.language == settings.LANGUAGE_CODE):
self.toolbar_language = user_settings.language
else:
user_settings.language = self.language
user_settings.save()
self.clipboard = user_settings.clipboard
if hasattr(self, 'toolbars'):
for key, toolbar in self.toolbars.items():
self.toolbars[key].request = self.request
def language_chooser(context, template=NOT_PROVIDED, i18n_mode="raw"):
"""
Displays a language chooser
- template: template used to render the language chooser
"""
if template in MARKERS:
i18n_mode = template
template = NOT_PROVIDED
if template is NOT_PROVIDED:
template = "menu/language_chooser.html"
if not i18n_mode in MARKERS:
i18n_mode = "raw"
try:
# If there's an exception (500), default context_processors may not be called.
request = context["request"]
except KeyError:
return {"template": "cms/content.html"}
marker = MARKERS[i18n_mode]
cms_languages = dict(settings.CMS_LANGUAGES)
current_lang = get_language()
site = Site.objects.get_current()
cache_key = "%s-language-chooser-%s-%s-%s" % (settings.CMS_CACHE_PREFIX, site.pk, current_lang, i18n_mode)
languages = cache.get(cache_key, [])
if not languages:
for lang in settings.CMS_FRONTEND_LANGUAGES:
if lang in cms_languages:
languages.append((lang, marker(cms_languages[lang], lang)))
if current_lang != get_language():
activate(current_lang)
cache.set(cache_key, languages)
lang = get_language_from_request(request, request.current_page)
context.update({"languages": languages, "current_language": lang, "template": template})
return context
def render(self, context, instance, placeholder):
context['object'] = instance
context['placeholder'] = placeholder
lang = instance.from_language
request = context.get('request', None)
if not lang:
if 'request' in context:
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGE_CODE
page = instance.placeholder.page
from_page = instance.from_page
if page.publisher_is_draft:
# If the plugin is being rendered in draft
# then show only the draft content of the linked page
from_page = from_page.get_draft_object()
else:
# Otherwise show the live content
from_page = from_page.get_public_object()
plugins = get_cmsplugin_queryset(request).filter(
placeholder__page=from_page,
language=lang,
placeholder__slot__iexact=placeholder,
parent__isnull=True
).order_by('position').select_related()
context['parent_plugins'] = plugins
context['parent_output'] = self._render_plugins(plugins, context)
return context
def page_url(context, page_lookup, lang=None, site=None):
"""
Show the url of a page with a reverse id in the right language
This is mostly used if you want to have a static link in a template to a page
"""
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return {'content': ''}
if request.current_page == "dummy":
return {'content': ''}
if lang is None:
lang = get_language_from_request(request)
cache_key = _get_cache_key('page_url', page_lookup, lang, site_id)+'_type:absolute_url'
url = cache.get(cache_key)
if not url:
page = _get_page_by_untyped_arg(page_lookup, request, site_id)
if page:
url = page.get_absolute_url(language=lang)
cache.set(cache_key, url, settings.CMS_CONTENT_CACHE_DURATION)
if url:
return {'content': url}
return {'content': ''}
def _show_placeholder_for_page(context,
placeholder_name,
page_lookup,
lang=None,
site=None,
cache_result=True):
"""
Shows the content of a page with a placeholder name and given lookup
arguments in the given language.
This is useful if you want to have some more or less static content that is
shared among many pages, such as a footer.
See _get_page_by_untyped_arg() for detailed information on the allowed types
and their interpretation for the page_lookup argument.
"""
from django.core.cache import cache
validate_placeholder_name(placeholder_name)
request = context.get('request', False)
site_id = get_site_id(site)
if not request:
return {'content': ''}
if lang is None:
lang = get_language_from_request(request)
if cache_result:
base_key = _get_cache_key('_show_placeholder_for_page', page_lookup,
lang, site_id)
cache_key = _clean_key('%s_placeholder:%s' %
(base_key, placeholder_name))
cached_value = cache.get(cache_key)
if cached_value:
restore_sekizai_context(context, cached_value['sekizai'])
return {'content': mark_safe(cached_value['content'])}
page = _get_page_by_untyped_arg(page_lookup, request, site_id)
if not page:
return {'content': ''}
try:
placeholder = page.placeholders.get(slot=placeholder_name)
except PlaceholderModel.DoesNotExist:
if settings.DEBUG:
raise
return {'content': ''}
watcher = Watcher(context)
content = render_placeholder(placeholder,
context,
placeholder_name,
use_cache=cache_result)
changes = watcher.get_changes()
if cache_result:
cache.set(cache_key, {
'content': content,
'sekizai': changes
},
get_cms_setting('CACHE_DURATIONS')['content'])
if content:
return {'content': mark_safe(content)}
return {'content': ''}
def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
field = super(SelectedCategoryInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
if db_field.name == "category":
language = get_language_from_request(request)
field.queryset = models.Category.objects.language(language)
return field
def get_form(self, request, obj=None, **kwargs):
"""
Get PageForm for the Page model and modify its fields depending on
the request.
"""
if obj:
if not obj.has_publish_permission(request):
self.exclude.append('status')
else:
if 'status' in self.exclude:
self.exclude.remove('status')
if not obj.has_softroot_permission(request):
self.exclude.append('soft_root')
else:
if 'soft_root' in self.exclude:
self.exclude.remove('soft_root')
version_id = None
versioned = False
if "history" in request.path or 'recover' in request.path:
versioned = True
version_id = request.path.split("/")[-2]
form = super(PageAdmin, self).get_form(request, obj, **kwargs)
language = get_language_from_request(request, obj)
form.base_fields['language'].initial = force_unicode(language)
if obj:
initial_slug = obj.get_slug(language=language, fallback=False, version_id=version_id, force_reload=True)
initial_title = obj.get_title(language=language, fallback=False, version_id=version_id)
form.base_fields['slug'].initial = initial_slug
form.base_fields['title'].initial = initial_title
else:
# Clear out the customisations made above
# TODO - remove this hack, this is v ugly
form.base_fields['slug'].initial = u''
form.base_fields['title'].initial = u''
template = get_template_from_request(request, obj)
if settings.CMS_TEMPLATES:
template_choices = list(settings.CMS_TEMPLATES)
form.base_fields['template'].choices = template_choices
form.base_fields['template'].initial = force_unicode(template)
for placeholder in get_placeholders(request, template):
if placeholder.name not in self.mandatory_placeholders:
installed_plugins = plugin_pool.get_all_plugins(placeholder.name)
plugin_list = []
if obj:
if versioned:
from reversion.models import Version
version = get_object_or_404(Version, pk=version_id)
revs = [related_version.object_version for related_version in version.revision.version_set.all()]
plugin_list = []
for rev in revs:
obj = rev.object
if obj.__class__ == CMSPlugin:
if obj.language == language and obj.placeholder == placeholder.name:
plugin_list.append(rev.object)
else:
plugin_list = CMSPlugin.objects.filter(page=obj, language=language, placeholder=placeholder.name).order_by('position')
widget = PluginEditor(attrs={'installed':installed_plugins, 'list':plugin_list})
form.base_fields[placeholder.name] = CharField(widget=widget, required=False)
return form
def render_placeholder_toolbar(placeholder, context, content, name_fallback=None):
from cms.plugin_pool import plugin_pool
request = context['request']
page = get_page_from_placeholder_if_exists(placeholder)
if not page:
page = getattr(request, 'current_page', None)
if page:
template = page.template
if name_fallback and not placeholder:
placeholder = Placeholder.objects.create(slot=name_fallback)
page.placeholders.add(placeholder)
else:
template = None
if placeholder:
slot = placeholder.slot
else:
slot = None
installed_plugins = plugin_pool.get_all_plugins(slot, page)
mixed_key = "%s %s" % (template, slot)
name = settings.CMS_PLACEHOLDER_CONF.get(mixed_key, {}).get("name", None)
if not name:
name = settings.CMS_PLACEHOLDER_CONF.get(slot, {}).get("name", None)
if not name:
name = slot
if not name:
name = name_fallback
name = title(name)
toolbar = render_to_string("cms/toolbar/add_plugins.html", {
'installed_plugins': installed_plugins,
'language': get_language_from_request(request),
'placeholder_label': name,
'placeholder': placeholder,
'page': page,
})
return "".join([toolbar, content])
def get_extra_placeholder_menu_items(cls, request, placeholder):
data = urlencode({
'placeholder': placeholder.pk,
'language': get_language_from_request(request),
})
return [
PluginMenuItem(
_("Export to Clipboard"),
reverse('admin:export_clipboard_plugins') + '?' + data,
data={},
action='modal',
attributes={
'icon': 'export',
},
),
PluginMenuItem(
_("Import from Clipboard"),
reverse('admin:import_clipboard_plugins') + '?' + data,
data={},
action='modal',
attributes={
'icon': 'import',
},
)
]
def render_placeholder_toolbar(placeholder, context, content, name_fallback=None):
from cms.plugin_pool import plugin_pool
request = context['request']
page = get_page_from_placeholder_if_exists(placeholder)
if not page:
page = getattr(request, 'current_page', None)
if page:
template = page.template
if name_fallback and not placeholder:
placeholder = Placeholder.objects.create(slot=name_fallback)
page.placeholders.add(placeholder)
else:
template = None
if placeholder:
slot = placeholder.slot
else:
slot = None
installed_plugins = plugin_pool.get_all_plugins(slot, page)
name = get_placeholder_conf(slot, template, "name", title(slot))
name = _(name)
context.push()
context.update({
'installed_plugins': installed_plugins,
'language': get_language_from_request(request),
'placeholder_label': name,
'placeholder': placeholder,
'page': page,
})
toolbar = render_to_string("cms/toolbar/placeholder.html", context)
context.pop()
return "".join([toolbar, content])
def copy_plugins(self, request):
# only allow POST
if request.method != "POST":
raise Http404
placeholder_id = request.POST['placeholder']
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
# check permissions
if not placeholder.has_add_permission(request):
raise Http404
# the placeholder actions are responsible for copying, they should return
# a list of plugins if successful.
plugins = placeholder.actions.copy(
target_placeholder=placeholder,
source_language=request.POST['copy_from'],
target_language=get_language_from_request(request),
fieldname=placeholder._get_attached_field_name(),
model=placeholder._get_attached_model(),
)
if plugins:
return render_to_response('admin/cms/page/widgets/plugin_item.html',
{'plugin_list': list(plugins)}, RequestContext(request))
else:
return HttpResponseBadRequest("Error during copy")
def render(self, context, instance, placeholder):
request = context.get("request", None)
if context.has_key("request"):
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGE_CODE
# Get all FaqEntryPlugins on this page and in this language
plugins = get_cmsplugin_queryset(request).filter(
plugin_type="CMSFaqEntryPlugin",
placeholder__page=instance.page,
language=lang,
placeholder__slot__iexact=placeholder,
parent__isnull=True).order_by("position").select_related()
faqentry_plugins = []
# Make a list of the FaqEntry plugin objects
for plugin in plugins:
# Truncate the entry's body
if instance.truncate_body:
plugin.faqentry.body = truncate_words(plugin.faqentry.body,
instance.truncate_body)
# Show the entry's body or not
if not instance.show_body:
plugin.faqentry.body = ''
faqentry_plugins.append(plugin.faqentry)
context.update({
"faq_list": faqentry_plugins,
"css": instance.get_css_display(),
"placeholder": placeholder,
})
return context
def page_url(context, page_lookup, lang=None, site=None):
"""
Show the url of a page with a reverse id in the right language
This is mostly used if you want to have a static link in a template to a page
"""
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return {'content': ''}
if request.current_page == "dummy":
return {'content': ''}
if lang is None:
lang = get_language_from_request(request)
cache_key = _get_cache_key('page_url', page_lookup, lang,
site_id) + '_type:absolute_url'
url = cache.get(cache_key)
if not url:
page = _get_page_by_untyped_arg(page_lookup, request, site_id)
if page:
url = page.get_absolute_url(language=lang)
cache.set(cache_key, url, settings.CMS_CONTENT_CACHE_DURATION)
if url:
return {'content': url}
return {'content': ''}
def get_operations_from_request(request, path=None, language=None):
from .models import PlaceholderOperation
if not language:
language = get_language_from_request(language)
origin = path or request.path
# This is controversial :/
# By design, we don't let undo/redo span longer than a day.
# To be decided if/how this should be configurable.
date = timezone.now() - timedelta(days=1)
site = Site.objects.get_current(request)
queryset = PlaceholderOperation.objects.filter(
site=site,
origin=origin,
language=language,
user=request.user,
user_session_key=request.session.session_key,
date_created__gt=date,
is_archived=False,
)
return queryset
def get_extra_plugin_menu_items(cls, request, plugin):
if plugin.plugin_type == cls.__name__:
return
data = urlencode({
'language': get_language_from_request(request),
'plugin': plugin.pk,
})
return [
PluginMenuItem(
_('Export plugins'),
admin_reverse('cms_export_plugins') + '?' + data,
data={},
action='none',
attributes={
'icon': 'export',
},
),
PluginMenuItem(
_('Import plugins'),
admin_reverse('cms_import_plugins') + '?' + data,
data={},
action='modal',
attributes={
'icon': 'import',
},
),
]
def render_month_links(context):
request = context["request"]
language = get_language_from_request(request)
kw = get_translation_filter_language(Entry, language)
return {
'dates': Entry.published.filter(**kw).dates('pub_date', 'month'),
}
def get_extra_placeholder_menu_items(cls, request, placeholder): # noqa
data = urlencode({
'language': get_language_from_request(request),
'placeholder': placeholder.pk,
})
return [
PluginMenuItem(
_('Export plugins'),
admin_reverse('cms_export_plugins') + '?' + data,
data={},
action='none',
attributes={
'icon': 'export',
},
),
PluginMenuItem(
_('Import plugins'),
admin_reverse('cms_import_plugins') + '?' + data,
data={},
action='modal',
attributes={
'icon': 'import',
},
)
]
def render(self, context):
if not 'request' in context:
return ''
l = get_language_from_request(context['request'])
request = context['request']
page = request.current_page
c = None
t = None
if self.name == "title":
t = Title.objects.get_title(page, l, True)
if t:
c = t.title
elif self.name == "slug":
t = Title.objects.get_title(page, l, True)
if t:
c = t.slug
else:
plugins = CMSPlugin.objects.filter(page=page, language=l, placeholder__iexact=self.name).order_by('position').select_related()
c = ""
for plugin in plugins:
c += plugin.render_plugin(context, self.name)
if not c:
return ''
if not t:
return '<div id="%s" class="placeholder">%s</div>' % (self.name, c)
return c
def render(self, context, instance, placeholder):
context['object'] = instance
context['placeholder'] = placeholder
lang = instance.from_language
request = context.get('request', None)
if not lang:
if 'request' in context:
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGE_CODE
page = instance.placeholder.page
from_page = instance.from_page
if page.publisher_is_draft:
# If the plugin is being rendered in draft
# then show only the draft content of the linked page
from_page = from_page.get_draft_object()
else:
# Otherwise show the live content
from_page = from_page.get_public_object()
plugins = get_cmsplugin_queryset(request).filter(
placeholder__page=from_page,
language=lang,
placeholder__slot__iexact=placeholder,
parent__isnull=True
).order_by('position').select_related()
context['parent_plugins'] = plugins
context['parent_output'] = self._render_plugins(plugins, context)
return context
def render(self, context):
if context.get('display_placeholder_names_only'):
return "<!-- PlaceholderNode: %s -->" % self.name
if not 'request' in context:
return ''
l = get_language_from_request(context['request'])
request = context['request']
page = request.current_page
if page == "dummy":
return ""
plugins = get_cmsplugin_queryset(request).filter(
page=page,
language=l,
placeholder__iexact=self.name,
parent__isnull=True).order_by('position').select_related()
if settings.CMS_PLACEHOLDER_CONF and self.name in settings.CMS_PLACEHOLDER_CONF:
if "extra_context" in settings.CMS_PLACEHOLDER_CONF[self.name]:
context.update(
settings.CMS_PLACEHOLDER_CONF[self.name]["extra_context"])
if self.theme:
# this may overwrite previously defined key [theme] from settings.CMS_PLACEHOLDER_CONF
context.update({
'theme': self.theme,
})
c = []
for index, plugin in enumerate(plugins):
context['plugin_index'] = index
c.append(plugin.render_plugin(context, self.name))
return "".join(c)
def get_admin_menu_item_context(request, page, filtered=False):
"""
Used for rendering the page tree, inserts into context everything what
we need for single item
"""
has_add_page_permission = page.has_add_permission(request)
has_move_page_permission = page.has_move_page_permission(request)
site = Site.objects.get_current()
lang = get_language_from_request(request)
# slug = page.get_slug(language=lang, fallback=True) # why was this here ??
metadata = ""
if settings.CMS_PERMISSION:
# jstree metadata generator
md = []
# if not has_add_page_permission:
if not has_move_page_permission:
md.append(("valid_children", False))
md.append(("draggable", False))
if md:
# just turn it into simple javasript object
metadata = (
"{"
+ ", ".join(map(lambda e: "%s: %s" % (e[0], isinstance(e[1], bool) and str(e[1]) or e[1].lower()), md))
+ "}"
)
moderator_state = moderator.page_moderator_state(request, page)
has_add_on_same_level_permission = False
opts = Page._meta
if request.user.has_perm(
opts.app_label + "." + opts.get_add_permission()
) and GlobalPagePermission.objects.with_user(request.user).filter(can_add=True, sites__in=[page.site_id]):
has_add_on_same_level_permission = True
if not has_add_on_same_level_permission and page.parent_id:
has_add_on_same_level_permission = permissions.has_generic_permission(
page.parent_id, request.user, "add", page.site
)
# has_add_on_same_level_permission = has_add_page_on_same_level_permission(request, page)
context = {
"page": page,
"site": site,
"lang": lang,
"filtered": filtered,
"metadata": metadata,
"has_change_permission": page.has_change_permission(request),
"has_publish_permission": page.has_publish_permission(request),
"has_delete_permission": page.has_delete_permission(request),
"has_move_page_permission": has_move_page_permission,
"has_add_page_permission": has_add_page_permission,
"has_moderate_permission": page.has_moderate_permission(request),
"page_moderator_state": moderator_state,
"moderator_should_approve": moderator_state["state"] >= moderator.I_APPROVE,
"has_add_on_same_level_permission": has_add_on_same_level_permission,
"CMS_PERMISSION": settings.CMS_PERMISSION,
"CMS_MODERATOR": settings.CMS_MODERATOR,
}
return context
def add_plugin(self, request):
# only allow POST
if request.method != "POST":
raise Http404
plugin_type = request.POST['plugin_type']
if not has_plugin_permission(request.user, plugin_type, "add"):
return HttpResponseForbidden(
"You don't have permission to add plugins")
placeholder_id = request.POST.get('placeholder', None)
position = None
language = get_language_from_request(request)
parent = None
# check if we got a placeholder (id)
if placeholder_id:
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
else: # else get the parent_id
parent_id = request.POST.get('parent_id', None)
if not parent_id: # if we get neither a placeholder nor a parent, bail out
raise Http404
parent = get_object_or_404(CMSPlugin, pk=parent_id)
placeholder = parent.placeholder
# check add permissions on placeholder
if not placeholder.has_add_permission(request):
return HttpResponseForbidden(
_("You don't have permission to add content here."))
# check the limits defined in CMS_PLACEHOLDER_CONF for this placeholder
limits = settings.CMS_PLACEHOLDER_CONF.get(placeholder.slot,
{}).get('limits', None)
if limits:
count = placeholder.cmsplugin_set.count()
global_limit = limits.get("global", None)
type_limit = limits.get(plugin_type, None)
# check the global limit first
if global_limit and count >= global_limit:
return HttpResponseBadRequest(
"This placeholder already has the maximum number of plugins."
)
elif type_limit: # then check the type specific limit
type_count = CMSPlugin.objects.filter(
language=language,
placeholder=placeholder,
plugin_type=plugin_type).count()
if type_count >= type_limit:
return HttpResponseBadRequest(
"This placeholder already has the maximum number (%s) "
"of %s plugins." % (type_limit, plugin_type))
# actually add the plugin
plugin = CMSPlugin(language=language,
plugin_type=plugin_type,
position=position,
placeholder=placeholder,
parent=parent)
plugin.save()
# returns it's ID as response
return HttpResponse(str(plugin.pk))
def get_nodes(self, request):
page_queryset = get_page_queryset(request)
site = Site.objects.get_current()
lang = get_language_from_request(request)
filters = {
'site': site,
}
if hide_untranslated(lang, site.pk):
filters['title_set__language'] = lang
if not use_draft(request):
page_queryset = page_queryset.published(lang)
pages = page_queryset.filter(**filters).order_by("tree_id", "lft")
ids = {}
nodes = []
first = True
home_cut = False
home_children = []
home = None
actual_pages = []
# cache view perms
visible_pages = get_visible_pages(request, pages, site)
for page in pages:
# Pages are ordered by tree_id, therefore the first page is the root
# of the page tree (a.k.a "home")
if page.pk not in visible_pages:
# Don't include pages the user doesn't have access to
continue
if not home:
home = page
if first and page.pk != home.pk:
home_cut = True
if (page.parent_id == home.pk
or page.parent_id in home_children) and home_cut:
home_children.append(page.pk)
if (page.pk == home.pk
and home.in_navigation) or page.pk != home.pk:
first = False
ids[page.id] = page
actual_pages.append(page)
page.title_cache = {}
langs = [lang]
if not hide_untranslated(lang):
langs.extend(get_fallback_languages(lang))
titles = list(
get_title_queryset(request).filter(page__in=ids,
language__in=langs))
for title in titles: # add the title and slugs and some meta data
page = ids[title.page_id]
page.title_cache[title.language] = title
for page in actual_pages:
if page.title_cache:
nodes.append(page_to_node(page, home, home_cut))
return nodes
def show_placeholder_by_id(context, placeholder_name, reverse_id, lang=None, site=None):
"""
Show the content of a page with a placeholder name and a reverse id in the right language
This is mostly used if you want to have static content in a template of a page (like a footer)
"""
request = context.get('request', False)
site_id = get_site_id(site)
if not request:
return {'content':''}
if lang is None:
lang = get_language_from_request(request)
key = 'show_placeholder_by_id_pid:'+reverse_id+'_placeholder:'+placeholder_name+'_site:'+str(site_id)+'_l:'+str(lang)
content = cache.get(key)
if not content:
try:
page = get_page_queryset(request).get(reverse_id=reverse_id, site=site_id)
except:
send_missing_mail(reverse_id, request)
return {'content':''}
plugins = get_cmsplugin_queryset(request).filter(page=page, language=lang, placeholder__iexact=placeholder_name, parent__isnull=True).order_by('position').select_related()
content = ""
for plugin in plugins:
content += plugin.render_plugin(context, placeholder_name)
cache.set(key, content, settings.CMS_CONTENT_CACHE_DURATION)
if content:
return {'content':mark_safe(content)}
return {'content':''}
def render(self, name, value, attrs=None):
try:
ph = Placeholder.objects.get(pk=value)
except Placeholder.DoesNotExist:
ph = None
context = {'add': True}
if ph:
plugin_list = ph.cmsplugin_set.filter(
parent=None).order_by('position')
plugin_list = self.filter_func(self.request, plugin_list)
language = get_language_from_request(self.request)
copy_languages = []
if ph.actions.can_copy:
copy_languages = ph.actions.get_copy_languages(
placeholder=ph,
model=ph._get_attached_model(),
fieldname=ph._get_attached_field_name())
context = {
'plugin_list': plugin_list,
'installed_plugins': plugin_pool.get_all_plugins(ph.slot),
'copy_languages': copy_languages,
'language': language,
'show_copy': bool(copy_languages) and ph.actions.can_copy,
'urloverride': True,
'placeholder': ph,
}
#return mark_safe(render_to_string(
# 'admin/cms/page/widgets/plugin_editor.html', context))
return mark_safe(
render_to_string('admin/cms/page/widgets/placeholder_editor.html',
context))
def save_model(self, request, obj, form, change):
"""
Given a model instance save it to the database.
"""
super(EntryAdmin, self).save_model(request, obj, form, change)
language = get_language_from_request(request)
EntryTitle.objects.filter(entry=obj, language=language, author=None).update(author=request.user)
def get_plugins(request, placeholder, lang=None):
if not placeholder:
return []
lang = lang or get_language_from_request(request)
if not hasattr(placeholder, '_%s_plugins_cache' % lang):
assign_plugins(request, [placeholder], lang)
return getattr(placeholder, '_%s_plugins_cache' % lang)
def category(self):
if not self._category:
language = get_language_from_request(self.request)
self._category = BlogCategory._default_manager.language(language).get(
translations__language_code=language,
translations__slug=self.kwargs['category'])
return self._category
def assign_plugins(request, placeholders, lang=None):
"""
Fetch all plugins for the given ``placeholders`` and
cast them down to the concrete instances in one query
per type.
"""
placeholders = list(placeholders)
if not placeholders:
return
lang = lang or get_language_from_request(request)
request_lang = lang
if hasattr(request, "current_page") and request.current_page is not None:
languages = request.current_page.get_languages()
if not lang in languages and not get_redirect_on_fallback(lang):
fallbacks = get_fallback_languages(lang)
for fallback in fallbacks:
if fallback in languages:
request_lang = fallback
break
# get all plugins for the given placeholders
qs = get_cmsplugin_queryset(request).filter(placeholder__in=placeholders, language=request_lang).order_by(
'placeholder', 'tree_id', 'lft')
plugin_list = downcast_plugins(qs)
# split the plugins up by placeholder
groups = dict((key, list(plugins)) for key, plugins in groupby(plugin_list, operator.attrgetter('placeholder_id')))
for group in groups:
groups[group] = build_plugin_tree(groups[group])
for placeholder in placeholders:
setattr(placeholder, '_%s_plugins_cache' % lang, list(groups.get(placeholder.pk, [])))
def get_value(self, context, page_lookup, lang, site):
from django.core.cache import cache
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return ''
if lang is None:
lang = get_language_from_request(request)
cache_key = _get_cache_key('page_url', page_lookup, lang, site_id) + \
'_type:absolute_url'
url = cache.get(cache_key)
if not url:
page = _get_page_by_untyped_arg(page_lookup, request, site_id)
if page:
url = page.get_absolute_url(language=lang)
cache.set(cache_key, url,
get_cms_setting('CACHE_DURATIONS')['content'])
if url:
return url
return ''
def get_value(self, context, page_lookup, lang, site):
from django.core.cache import cache
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return ''
if lang is None:
lang = get_language_from_request(request)
cache_key = _get_cache_key('page_url', page_lookup, lang, site_id) + \
'_type:absolute_url'
url = cache.get(cache_key)
if not url:
page = _get_page_by_untyped_arg(page_lookup, request, site_id)
if page:
url = page.get_absolute_url(language=lang)
cache.set(cache_key, url,
get_cms_setting('CACHE_DURATIONS')['content'])
if url:
return url
return ''
def get_language_from_context(context):
if 'LANGUAGE_CODE' in context:
return context['LANGUAGE_CODE']
elif 'request' in context:
return get_language_from_request(context['request'])
else:
return get_language() or settings.LANGUAGE_CODE
def add_wizard_button(self):
from cms.wizards.wizard_pool import entry_choices
title = _("Create")
try:
page_pk = self.page.pk
except AttributeError:
page_pk = ''
user = getattr(self.request, "user", None)
disabled = user and hasattr(self, "page") and len(
list(entry_choices(user, self.page))) == 0
lang = get_language_from_request(
self.request, current_page=self.page) or get_default_language()
url = '{url}?page={page}&language={lang}&edit'.format(
url=reverse("cms_wizard_create"),
page=page_pk,
lang=lang,
)
self.toolbar.add_modal_button(title,
url,
side=self.toolbar.RIGHT,
disabled=disabled,
on_close=REFRESH_PAGE)
def get_resource_url(self, res, href, **kwargs):
if res.id is None or not res.realm:
raise resource.ResourceNotFound()
elif res.realm == 'filer':
try:
link = self._get_file(res).url
except filer_models.File.DoesNotExist as e:
raise resource.ResourceNotFound(e)
elif res.realm == 'blog':
try:
link = self._get_blog(res).get_absolute_url()
except blog_models.EntryTitle.DoesNotExist as e:
raise resource.ResourceNotFound(e)
elif res.realm == 'cms':
try:
request = _get_django_request(res=res)
lang = cms_utils.get_language_from_request(request)
link = self._get_page(res).get_absolute_url(language=lang)
except cms_models.Page.DoesNotExist as e:
# Test again as maybe we got [cms: this page] link but we could not get current page
if not res.id:
raise resource.ResourceNotFound(e)
try:
link = urlresolvers.reverse(res.id)
except urlresolvers.NoReverseMatch as e:
raise resource.ResourceNotFound(e)
else:
raise RuntimeError("This should be impossible")
args = [link]
if link.endswith('/') and not link.strip('/') == '':
# We add an empty link component at the end to force trailing slash
args.append('')
return href(*args, **kwargs)
def render_month_links(context):
request = context["request"]
language = get_language_from_request(request)
kw = get_translation_filter_language(Entry, language)
return {
'dates': Entry.published.filter(**kw).dates('pub_date', 'month'),
}
def render(self, name, value, attrs=None):
try:
ph = Placeholder.objects.get(pk=value)
except Placeholder.DoesNotExist:
ph = None
context = {'add':True}
if ph:
plugin_list = ph.cmsplugin_set.filter(parent=None).order_by('position')
plugin_list = self.filter_func(self.request, plugin_list)
language = get_language_from_request(self.request)
copy_languages = []
if ph.actions.can_copy:
copy_languages = ph.actions.get_copy_languages(
placeholder=ph,
model=ph._get_attached_model(),
fieldname=ph._get_attached_field_name()
)
context = {
'plugin_list': plugin_list,
'installed_plugins': plugin_pool.get_all_plugins(ph.slot),
'copy_languages': copy_languages,
'language': language,
'show_copy': bool(copy_languages) and ph.actions.can_copy,
'urloverride': True,
'placeholder': ph,
}
#return mark_safe(render_to_string(
# 'admin/cms/page/widgets/plugin_editor.html', context))
return mark_safe(render_to_string(
'admin/cms/page/widgets/placeholder_editor.html', context, RequestContext(self.request)))
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 page_id_url(context, reverse_id, lang=None, site=None):
"""
Show the url of a page with a reverse id in the right language
This is mostly used if you want to have a static link in a template to a page
"""
site_id = get_site_id(site)
request = context.get('request', False)
if not request:
return {'content':''}
if request.current_page == "dummy":
return {'content': ''}
if lang is None:
lang = get_language_from_request(request)
key = 'page_id_url_pid:'+str(reverse_id)+'_l:'+str(lang)+'_site:'+str(site_id)+'_type:absolute_url'
url = cache.get(key)
if not url:
try:
page = get_page_queryset(request).get(reverse_id=reverse_id,site=site_id)
url = page.get_absolute_url(language=lang)
cache.set(key, url, settings.CMS_CONTENT_CACHE_DURATION)
except:
send_missing_mail(reverse_id, request)
if url:
return {'content':url}
return {'content':''}
def get_context(self, context, lang):
try:
# If there's an exception (500), default context_processors may not be called.
request = context['request']
except KeyError:
return {'template': 'cms/content.html'}
if hasattr(request, "_language_changer"):
try:
setattr(request._language_changer, 'request', request)
except AttributeError:
pass
url = "/%s" % lang + request._language_changer(lang)
else:
page = request.current_page
if page == "dummy":
return {'content': ''}
try:
url = page.get_absolute_url(language=lang, fallback=False)
url = "/" + lang + url
except:
# no localized path/slug.
url = ''
if page.get_application_urls():
# determine which part of the current url belongs to the app
curLang = get_language_from_request(request)
curPageUrl = page.get_absolute_url(language=curLang, fallback=False)
curPath = request.path_info
appPath = curPath[ len(curPageUrl) :]
url += appPath
return {'content':url}
def copy_plugins(self, request):
# only allow POST
if request.method != "POST":
raise Http404
placeholder_id = request.POST['placeholder']
placeholder = get_object_or_404(Placeholder, pk=placeholder_id)
# check permissions
if not placeholder.has_add_permission(request):
raise Http404
# the placeholder actions are responsible for copying, they should return
# a list of plugins if successful.
plugins = placeholder.actions.copy(
target_placeholder=placeholder,
source_language=request.POST['copy_from'],
target_language=get_language_from_request(request),
fieldname=placeholder._get_attached_field_name(),
model=placeholder._get_attached_model(),
)
if plugins:
return render_to_response('admin/cms/page/widgets/plugin_item.html',
{'plugin_list': list(plugins)}, RequestContext(request))
else:
return HttpResponseBadRequest("Error during copy")
def render_placeholder_toolbar(placeholder, context, content):
from cms.plugin_pool import plugin_pool
request = context['request']
page = get_page_from_placeholder_if_exists(placeholder)
if page:
template = page.template
else:
template = None
installed_plugins = plugin_pool.get_all_plugins(placeholder.slot, page)
name = settings.CMS_PLACEHOLDER_CONF.get(
"%s %s" % (template, placeholder.slot), {}).get("name", None)
if not name:
name = settings.CMS_PLACEHOLDER_CONF.get(placeholder.slot,
{}).get("name", None)
if not name:
name = placeholder.slot
name = title(name)
toolbar = render_to_string(
"cms/toolbar/add_plugins.html", {
'installed_plugins': installed_plugins,
'language': get_language_from_request(request),
'placeholder_label': name,
'placeholder': placeholder,
'page': page,
})
return "".join([toolbar, content])
