def create_breadcrumb(self, page, glossary, slot='Breadcrumb'):
from cms.api import add_plugin
from cms.utils.i18n import get_public_languages
placeholder = page.placeholders.get(slot=slot)
language = get_public_languages()[0]
return add_plugin(placeholder, 'BreadcrumbPlugin', language, glossary=glossary)
def create_page_structure(self, page, slot='Main Content'):
from cms.api import add_plugin
from cms.utils.i18n import get_public_languages
placeholder = page.placeholders.get(slot=slot)
language = get_public_languages()[0]
glossary = {
'breakpoints': ['xs', 'sm', 'md', 'lg', 'xl'],
'fluid': None,
}
container = add_plugin(placeholder,
'BootstrapContainerPlugin',
language,
glossary=glossary)
row = add_plugin(placeholder,
'BootstrapRowPlugin',
language,
target=container)
glossary = {
'xs-column-width': 'col',
}
return add_plugin(placeholder,
'BootstrapColumnPlugin',
language,
target=row,
glossary=glossary)
def get_or_create_page(self, title, base_apphook_name, reverse_id=None, parent_page=None, in_navigation=False, soft_root=False):
from cms.api import create_page
from cms.models.pagemodel import Page
from cms.utils.i18n import get_public_languages
template = settings.CMS_TEMPLATES[0][0]
apphook = self.get_installed_apphook(base_apphook_name) if base_apphook_name else None
language = get_public_languages()[0]
try:
parent_node = parent_page.node if parent_page else None
page = Page.objects.drafts().get(
reverse_id=reverse_id,
node__parent=parent_node,
title_set__title=title,
title_set__language=language,
)
created = False
except Page.DoesNotExist:
page = create_page(
title,
template,
language,
apphook=apphook,
created_by="manage.py shop check-pages",
in_navigation=in_navigation,
soft_root=soft_root,
parent=parent_page,
reverse_id=reverse_id,
)
created = True
return page, created
def get_context(self, context, template, i18n_mode):
if template in MARKERS:
_tmp = template
if i18n_mode not in MARKERS:
template = i18n_mode
else:
template = NOT_PROVIDED
i18n_mode = _tmp
if template is NOT_PROVIDED:
template = "menu/language_chooser.html"
if not i18n_mode in MARKERS:
i18n_mode = 'raw'
if 'request' not in context:
# If there's an exception (500), default context_processors may not be called.
return {'template': 'cms/content.html'}
marker = MARKERS[i18n_mode]
current_lang = get_language()
site = Site.objects.get_current()
request = context['request']
if request.user.is_staff:
languages = get_language_list(site_id=site.pk)
else:
languages = get_public_languages(site_id=site.pk)
languages_info = []
for language in languages:
obj = get_language_object(language, site_id=site.pk)
languages_info.append((obj['code'], marker(obj['name'], obj['code'])))
context['languages'] = languages_info
context['current_language'] = current_lang
context['template'] = template
return context
def items(self):
alt_pages = []
site = Site.objects.get_current()
site_languages = get_public_languages(site.pk)
# Need this published filter due to a django-cms bug
page_queryset = Page.objects.on_site(site).public()\
.filter(login_required=False, published=True)
for page in page_queryset:
alt_links = get_alternate(page,
site=site,
site_languages=site_languages,
protocol=self.protocol)
# add alt ref to all pages
first = True
for lang, alt_link in alt_links.items():
# XXX maybe redirector link should be listed as a new url?
if alt_link['redirector']:
continue
if first:
alt_page = deepcopy(page)
first = False
else:
alt_page = page
# XXX maybe alt link should only be displayed if there is
# *more than one* alternative?
alt_page.alternate = alt_links.values()
# only path here: Sitemap class will add location and scheme
alt_page._cms_i18n_absolute_url_cached = \
alt_links[lang]['path']
alt_pages.append(alt_page)
return alt_pages
def items(self):
#
# It is counter-productive to provide entries for:
# > Pages which redirect:
# - If the page redirects to another page on this site, the
# destination page will already be in the sitemap, and
# - If the page redirects externally, then it shouldn't be
# part of our sitemap anyway.
# > Pages which cannot be accessed by anonymous users (like
# search engines are).
#
# It is noted here: http://www.sitemaps.org/protocol.html that
# "locations" that differ from the place where the sitemap is found,
# are considered invalid. E.g., if your sitemap is located here:
#
# http://example.com/sub/sitemap.xml
#
# valid locations *must* be rooted at http://example.com/sub/...
#
# This rules any redirected locations out.
#
# If, for some reason, you require redirecting pages (Titles) to be
# included, simply create a new class inheriting from this one, and
# supply a new items() method which doesn't filter out the redirects.
site = get_current_site()
languages = get_public_languages(site_id=site.pk)
all_titles = Title.objects.public().filter(
Q(redirect='') | Q(redirect__isnull=True),
language__in=languages,
page__login_required=False,
page__node__site=site,
).order_by('page__node__path')
return all_titles
def handle(self, verbosity, filename, *args, **options):
activate(settings.LANGUAGE_CODE)
path = self.find_fixture(filename)
if self.verbosity >= 2:
self.stdout.write("Importing products from: {}".format(path))
with open(path, 'r') as fh:
data = json.load(fh)
for number, product in enumerate(data, 1):
product_model = product.pop('product_model')
ProductModel = ContentType.objects.get(app_label='myshop',
model=product_model)
class_name = 'myshop.management.serializers.' + ProductModel.model_class(
).__name__ + 'Serializer'
serializer_class = import_string(class_name)
serializer = serializer_class(data=product)
assert serializer.is_valid(), serializer.errors
instance = serializer.save()
self.stdout.write("{}. {}".format(number, instance))
if product_model == 'commodity':
languages = get_public_languages()
try:
clipboard = CascadeClipboard.objects.get(
identifier=instance.slug)
except CascadeClipboard.DoesNotExist:
pass
else:
deserialize_to_placeholder(instance.placeholder,
clipboard.data, languages[0])
plugins = list(
instance.placeholder.get_plugins(
language=languages[0]).order_by('path'))
for language in languages[1:]:
copy_plugins_to(plugins, instance.placeholder,
language)
def publish_in_all_languages(self, page):
from cms.api import copy_plugins_to_language
from cms.utils.i18n import get_public_languages
languages = get_public_languages()
for language in languages[1:]:
copy_plugins_to_language(page, languages[0], language)
for language in languages:
page.publish(language)
def publish_in_all_languages(cls, page):
from cms.api import copy_plugins_to_language, create_title
from cms.utils.i18n import get_public_languages
languages = get_public_languages()
for language in languages[1:]:
create_title(language, page.get_title(), page, menu_title=None)
copy_plugins_to_language(page, languages[0], language)
for language in languages:
page.publish(language)
def get_alternate(page, site=None, site_languages=None, protocol=None,
enable_redirectors=None):
# Optimize for repeated calls within the same site
if site is None:
site = Site.objects.get_current()
if site_languages is None:
site_languages = get_public_languages(site.pk)
# TODO: build API for this default
if enable_redirectors is None:
enable_redirectors = get_config_redirectors()
protocol = protocol if protocol is not None else 'http'
# find all public translations for this page
available_languages = {l for l in page.get_languages()
if l in site_languages}
sitemap_languages = [l for l in site_languages
if l in available_languages]
# handle case when hide_untranslated = False
if len(sitemap_languages) < len(site_languages):
for lang in site_languages:
if (lang not in sitemap_languages
and not hide_untranslated(lang, site.pk)):
for fb_lang in sitemap_languages:
if fb_lang in get_fallback_languages(lang, site.pk):
sitemap_languages.append(lang)
break
# Append default redirector link
if sitemap_languages and enable_redirectors:
sitemap_languages.append(LANG_REDIRECTOR)
alt_links = OrderedDict()
for lang in sitemap_languages:
if lang == LANG_REDIRECTOR:
with override(sitemap_languages[0]):
url = page.get_absolute_url()
url = re.sub(r'^/{}'.format(sitemap_languages[0]), '', url)
assert sitemap_languages[0] != LANG_REDIRECTOR
else:
with override(lang):
url = page.get_absolute_url()
alt_links[lang] = {'language_code': lang,
'location': '%s://%s%s' % (protocol,
site.domain,
url),
'redirector': lang == LANG_REDIRECTOR,
'path': url}
return alt_links
def items(self):
site = get_current_site()
languages = get_public_languages(site_id=site.pk)
pages = Page.objects.public().filter(
Q(publication_date__lt=timezone.now())
| Q(publication_date__isnull=True),
Q(publication_end_date__gte=timezone.now())
| Q(publication_end_date__isnull=True),
login_required=False,
node__site=site
#Q(redirect__exact='') | Q(redirect__isnull=True),
#language__in=languages,
).exclude(sitemapextension__show_on_xml_sitemap=False).order_by(
'node__path').prefetch_related('title_set')
return pages
def create_social_icons(self):
from cms.utils.i18n import get_public_languages
default_language = get_public_languages()[0]
try:
clipboard = CascadeClipboard.objects.get(identifier='social-icons')
except CascadeClipboard.DoesNotExist:
self.stderr.write(
"No Persisted Clipboard named 'social-icons' found.")
else:
static_placeholder = StaticPlaceholder.objects.create(
code='Social Icons')
deserialize_to_placeholder(
static_placeholder.public, clipboard.data, default_language)
deserialize_to_placeholder(
static_placeholder.draft, clipboard.data, default_language)
self.stdout.write("Added Social Icons to Static Placeholder")
def items(self):
site = get_current_site()
languages = get_public_languages(site_id=site.pk)
#all_titles = Title.objects.public().filter(
#Q(redirect='') | Q(redirect__isnull=True),
#language__in=languages,
#page__login_required=False,
#page__node__site=site,
#).order_by('page__node__path')
all_titles = Title.objects.public().filter(
Q(page__publication_date__lt=timezone.now())
| Q(page__publication_date__isnull=True),
Q(page__publication_end_date__gte=timezone.now())
| Q(page__publication_end_date__isnull=True),
Q(redirect__exact='') | Q(redirect__isnull=True),
language__in=languages,
page__login_required=False,
page__node__site=site).exclude(
page__sitemapextension__show_on_xml_sitemap=False
).select_related('page').order_by('page__node__path')
return all_titles
def create_subcategory(self, apphook, parent_page, title, product_type):
from cms.api import create_page
from cms.constants import TEMPLATE_INHERITANCE_MAGIC
from cms.utils.i18n import get_public_languages
from shop.management.commands.shop import Command as ShopCommand
from shop.models.product import ProductModel
from shop.models.related import ProductPageModel
language = get_public_languages()[0]
page = create_page(
title,
TEMPLATE_INHERITANCE_MAGIC,
language,
apphook=apphook,
created_by="manage.py initialize_shop_demo",
in_navigation=True,
parent=parent_page,
)
ShopCommand.publish_in_all_languages(page)
page = page.get_public_object()
for product in ProductModel.objects.instance_of(product_type):
ProductPageModel.objects.create(page=page, product=product)
def get_public_page_with_fallbacks(page, request):
"""
the plugin should show the published page whenever it exists or the draft page otherwise.
On a public content, the draft page should not be shown at all but this is left to the
caller.
This is inspired by what DjangoCMS does in its main view:
https://github.com/django-cms/django-cms/blob/3.8.0/cms/views.py#L37
"""
page = page.get_public_object()
request_language = translation.get_language_from_request(request,
check_path=True)
if not page:
return None
# Check permissions
site = get_current_site()
if not page_permissions.user_can_view_page(request.user, page, site):
return None
if request.user.is_staff:
user_languages = i18n.get_language_list(site_id=site.pk)
else:
user_languages = i18n.get_public_languages(site_id=site.pk)
# These languages are then filtered out by the user allowed languages
available_languages = [
language for language in user_languages
if language in list(page.get_published_languages())
]
if request_language not in user_languages:
# Language is not allowed
# Use the default site language
default_language = i18n.get_default_language_for_site(site.pk)
fallbacks = i18n.get_fallback_languages(default_language,
site_id=site.pk)
fallbacks = [default_language] + fallbacks
else:
fallbacks = i18n.get_fallback_languages(request_language,
site_id=site.pk)
# Only fallback to languages the user is allowed to see
fallback_languages = [
language for language in fallbacks
if language != request_language and language in available_languages
]
if request_language not in available_languages:
if not fallback_languages:
# There is no page with the requested language
# and there's no configured fallbacks
return None
if request_language in page.get_languages():
# The page was already published and later unpublished in the current
# language. In this case we must not fallback to another language.
return None
return page
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
# get the right model
context = RequestContext(request)
subdomain=request.META['HTTP_HOST']
if subdomain[:4]=='www.':
subdomain=subdomain[4:]
if (subdomain[-6:]=='com.ua' and subdomain.count('.')>=3) or (subdomain[-6:]!='com.ua' and subdomain.count('.')>=2):
subdomain=subdomain[:subdomain.find('.')]
else:
subdomain=''
main_domain=request.META['HTTP_HOST']
if subdomain!='':
main_domain=main_domain[len(subdomain)+1:]
if subdomain and subdomain!='etalon' and not subdomain.endswith('dev'):
try:
obl=Site.objects.get_current().obl.get(subdomain=subdomain)
except:
return HttpResponseRedirect('http://'+main_domain+request.get_full_path())
else:
if request.location and request.location.custom_region:
try:
obl=Site.objects.get_current().obl.get(slug=request.location.custom_region.slug)
return HttpResponseRedirect('http://'+request.location.custom_region.subdomain+'.'+main_domain+request.get_full_path())
except:
pass
# import logging
# logging.info('dm='+request.META['HTTP_HOST'])
# logging.info('sbd='+subdomain)
# logging.info('mdm='+main_domain)
# logging.info('loc='+location(request)['loc'])
#
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = get_language_from_request(request)
# Check that the current page is available in the desired (current) language
available_languages = []
page_languages = page.get_languages()
user_languages = get_public_languages()
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
attrs = ''
if 'edit' in request.GET:
attrs = '?edit=1'
elif 'preview' in request.GET:
attrs = '?preview=1'
if 'draft' in request.GET:
attrs += '&draft=1'
# Check that the language is in FRONTEND_LANGUAGES:
if not current_language in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
with SettingsOverride(LANGUAGES=languages, LANGUAGE_CODE=languages[0][0]):
#get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
return HttpResponseRedirect(pages_root + attrs)
else:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language):
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang, fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
return HttpResponseRedirect(path + attrs)
else:
found = True
if not found:
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
try:
app_urls = page.get_application_urls(current_language, False)
except Title.DoesNotExist:
app_urls = []
if app_urls:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
context.current_app = page.reverse_id if page.reverse_id else app.app_name
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if redirect_url.startswith('reverse_id:'):
slug=cms_tags._get_page_by_untyped_arg(redirect_url.split(':')[1], request, Site.objects.get_current().id).get_absolute_url()
return HttpResponsePermanentRedirect(slug)
else:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if redirect_url not in own_urls:
return HttpResponsePermanentRedirect(redirect_url + attrs)
# permission checks
if page.login_required and not request.user.is_authenticated():
path = urlquote(request.get_full_path())
tup = settings.LOGIN_URL, "next", path
return HttpResponseRedirect('%s?%s=%s' % tup)
template_name = get_template_from_request(request, page, no_current_page=True)
# fill the context
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = page.has_view_permission(request)
if not context['has_view_permissions']:
return _handle_no_page(request, slug)
return render_to_response(template_name, context_instance=context)
def article(request, slug):
"""
The main view of the Django-CMS Articles! Takes a request and a slug,
renders the article.
"""
# Get current CMS Page as article tree
tree = request.current_page.get_public_object()
# Check whether it really is a tree.
# It could also be one of its sub-pages.
if tree.application_urls != 'CMSArticlesApp':
# In such case show regular CMS Page
return page(request, slug)
# Get an Article object from the request
draft = use_draft(request) and request.user.has_perm('cms_articles.change_article')
preview = 'preview' in request.GET and request.user.has_perm('cms_articles.change_article')
site = tree.node.site
article = get_article_from_slug(tree, slug, preview, draft)
if not article:
# raise 404
_handle_no_page(request)
request.current_article = article
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list(site_id=site.pk)
else:
user_languages = get_public_languages(site_id=site.pk)
request_language = get_language_from_request(request, check_path=True)
# get_published_languages will return all languages in draft mode
# and published only in live mode.
# These languages are then filtered out by the user allowed languages
available_languages = [
language for language in user_languages
if language in list(article.get_published_languages())
]
own_urls = [
request.build_absolute_uri(request.path),
'/%s' % request.path,
request.path,
]
try:
redirect_on_fallback = get_redirect_on_fallback(request_language, site_id=site.pk)
except LanguageError:
redirect_on_fallback = False
if request_language not in user_languages:
# Language is not allowed
# Use the default site language
default_language = get_default_language_for_site(site.pk)
fallbacks = get_fallback_languages(default_language, site_id=site.pk)
fallbacks = [default_language] + fallbacks
else:
fallbacks = get_fallback_languages(request_language, site_id=site.pk)
# Only fallback to languages the user is allowed to see
fallback_languages = [
language for language in fallbacks
if language != request_language and language in available_languages
]
language_is_unavailable = request_language not in available_languages
if language_is_unavailable and not fallback_languages:
# There is no page with the requested language
# and there's no configured fallbacks
return _handle_no_page(request)
elif language_is_unavailable and redirect_on_fallback:
# There is no page with the requested language and
# the user has explicitly requested to redirect on fallbacks,
# so redirect to the first configured / available fallback language
fallback = fallback_languages[0]
redirect_url = article.get_absolute_url(fallback, fallback=False)
else:
redirect_url = False
if redirect_url:
if request.user.is_staff and hasattr(request, 'toolbar') and request.toolbar.edit_mode_active:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
# prevent redirect to self
return HttpResponseRedirect(redirect_url)
# permission checks
if article.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.obj = article
structure_requested = get_cms_setting('CMS_TOOLBAR_URL__BUILD') in request.GET
if article.has_change_permission(request) and structure_requested:
return render_object_structure(request, article)
return render_article(request, article, current_language=request_language, slug=slug)
def create_recommended_pages(self):
from cms.models.pagemodel import Page
from cms.utils.i18n import get_public_languages
default_language = get_public_languages()[0]
# create the HOME page
if Page.objects.public().filter(is_home=True).exists():
yield "A home page exists already."
else:
page, created = self.get_or_create_page("Home", None, in_navigation=True)
assert created is True
try:
clipboard = CascadeClipboard.objects.get(identifier='home')
except CascadeClipboard.DoesNotExist:
pass
else:
self.deserialize_to_placeholder(page, clipboard.data)
try:
clipboard = CascadeClipboard.objects.get(identifier='footer')
except CascadeClipboard.DoesNotExist:
pass
else:
static_placeholder = StaticPlaceholder.objects.create(code='Static Footer')
deserialize_to_placeholder(static_placeholder.public, clipboard.data, default_language)
deserialize_to_placeholder(static_placeholder.draft, clipboard.data, default_language)
page.set_as_homepage()
self.publish_in_all_languages(page)
yield "Created recommended CMS home page."
parent_page, created = self.get_or_create_page("Legal", None, reverse_id='shop-legal-pages', soft_root=True)
if created:
self.publish_in_all_languages(parent_page)
yield "Created recommended CMS page 'Legal'."
else:
yield "Recommended CMS page 'Legal' exists already."
page, created = self.get_or_create_page("Imprint", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Imprint'."
else:
yield "Recommended CMS page 'Imprint' exists already."
page, created = self.get_or_create_page("Terms and Conditions", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Terms and Conditions'."
else:
yield "Recommended CMS page 'Terms and Conditions' exists already."
page, created = self.get_or_create_page("Privacy Protection", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Privacy Protection'."
else:
yield "Recommended CMS page 'Privacy Protection' exists already."
self.personal_pages, created = self.get_or_create_page("Personal Pages", None, reverse_id='shop-personal-pages', soft_root=True)
if created:
self.publish_in_all_languages(self.personal_pages)
yield "Created recommended CMS page 'Personal Pages'."
else:
yield "Recommended CMS page 'Personal Pages' exists already."
self.impersonal_pages, created = self.get_or_create_page("Join Us", None, reverse_id='shop-impersonal-pages', soft_root=True)
if created:
self.publish_in_all_languages(self.impersonal_pages)
yield "Created recommended CMS page 'Join Us'."
else:
yield "Recommended CMS page 'Join Us' exists already."
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
# get the right model
context = RequestContext(request)
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = get_language_from_request(request)
# Check that the current page is available in the desired (current) language
available_languages = []
page_languages = list(page.get_languages())
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
else:
user_languages = get_public_languages()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
attrs = ''
if 'edit' in request.GET:
attrs = '?edit=1'
elif 'preview' in request.GET:
attrs = '?preview=1'
if 'draft' in request.GET:
attrs += '&draft=1'
# Check that the language is in FRONTEND_LANGUAGES:
if not current_language in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
with SettingsOverride(LANGUAGES=languages, LANGUAGE_CODE=languages[0][0]):
#get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
return HttpResponseRedirect(pages_root + attrs)
else:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language):
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang, fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
return HttpResponseRedirect(path + attrs)
else:
found = True
if not found:
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
try:
app_urls = page.get_application_urls(current_language, False)
except Title.DoesNotExist:
app_urls = []
if app_urls:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url + attrs)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL)
template_name = get_template_from_request(request, page, no_current_page=True)
# fill the context
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = page.has_view_permission(request)
if not context['has_view_permissions']:
return _handle_no_page(request, slug)
return TemplateResponse(request, template_name, context)
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
from django.core.cache import cache
if get_cms_setting("PAGE_CACHE") and (
not hasattr(request, 'toolbar') or
(not request.toolbar.edit_mode and not request.toolbar.show_toolbar
and not request.user.is_authenticated())):
cache_content = cache.get(_get_cache_key(request),
version=_get_cache_version())
if not cache_content is None:
content, headers = cache_content
response = HttpResponse(content)
response._headers = headers
return response
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = request.REQUEST.get('language', None)
if current_language:
current_language = get_language_code(current_language)
if not current_language in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(
getattr(request, 'LANGUAGE_CODE', None))
if current_language:
current_language = get_language_code(current_language)
if not current_language in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(get_language())
# Check that the current page is available in the desired (current) language
available_languages = []
page_languages = list(page.get_languages())
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
else:
user_languages = get_public_languages()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
# Check that the language is in FRONTEND_LANGUAGES:
own_urls = [
'http%s://%s%s' %
('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if not current_language in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
with SettingsOverride(LANGUAGES=languages,
LANGUAGE_CODE=languages[0][0]):
#get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
if hasattr(
request, 'toolbar'
) and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = pages_root
elif pages_root not in own_urls:
return HttpResponseRedirect(pages_root)
elif not hasattr(request,
'toolbar') or not request.toolbar.redirect_url:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language) or slug == "":
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang,
fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
if hasattr(
request, 'toolbar'
) and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = path
elif path not in own_urls:
return HttpResponseRedirect(path)
else:
found = True
if not found and (not hasattr(request, 'toolbar')
or not request.toolbar.redirect_url):
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
app_urls = page.get_application_urls(current_language, False)
skip_app = False
if not page.is_published(current_language) and hasattr(
request, 'toolbar') and request.toolbar.edit_mode:
skip_app = True
if app_urls and not skip_app:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language,
redirect_url.lstrip("/"))
# prevent redirect to self
if hasattr(request, 'toolbar'
) and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()),
settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(page)
template_name = get_template_from_request(request,
page,
no_current_page=True)
# fill the context
context = RequestContext(request)
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = page.has_view_permission(request)
if not context['has_view_permissions']:
return _handle_no_page(request, slug)
response = TemplateResponse(request, template_name, context)
response.add_post_render_callback(_cache_page)
# Add headers for X Frame Options - this really should be changed upon moving to class based views
xframe_options = page.get_xframe_options()
if xframe_options == Page.X_FRAME_OPTIONS_INHERIT:
# This is when we defer to django's own clickjacking handling
return response
# We want to prevent django setting this in their middlewear
response.xframe_options_exempt = True
if xframe_options == Page.X_FRAME_OPTIONS_ALLOW:
# Do nothing, allowed is no header.
return response
elif xframe_options == Page.X_FRAME_OPTIONS_SAMEORIGIN:
response['X-Frame-Options'] = 'SAMEORIGIN'
elif xframe_options == Page.X_FRAME_OPTIONS_DENY:
response['X-Frame-Options'] = 'DENY'
return response
def get_nodes(self, request):
from cms.models import Title
site = self.renderer.site
lang = self.renderer.request_language
pages = get_page_queryset(
site,
draft=self.renderer.draft_mode_active,
published=not self.renderer.draft_mode_active,
)
if is_valid_site_language(lang, site_id=site.pk):
_valid_language = True
_hide_untranslated = hide_untranslated(lang, site.pk)
else:
_valid_language = False
_hide_untranslated = False
if _valid_language:
# The request language has been explicitly configured
# for the current site.
if _hide_untranslated:
fallbacks = []
else:
fallbacks = get_fallback_languages(lang, site_id=site.pk)
languages = [lang
] + [_lang for _lang in fallbacks if _lang != lang]
else:
# The request language is not configured for the current site.
# Fallback to all configured public languages for the current site.
languages = get_public_languages(site.pk)
fallbacks = languages
pages = (pages.filter(title_set__language__in=languages).
select_related('node').order_by('node__path').distinct())
if not self.renderer.draft_mode_active:
# we're dealing with public pages.
# prefetch the draft versions.
pages = pages.select_related('publisher_public__node')
pages = get_visible_nodes(request, pages, site)
if not pages:
return []
try:
homepage = [page for page in pages if page.is_home][0]
except IndexError:
homepage = None
titles = Title.objects.filter(
language__in=languages,
publisher_is_draft=self.renderer.draft_mode_active,
)
lookup = Prefetch(
'title_set',
to_attr='filtered_translations',
queryset=titles,
)
prefetch_related_objects(pages, lookup)
# Build the blank title instances only once
blank_title_cache = {
language: EmptyTitle(language=language)
for language in languages
}
if lang not in blank_title_cache:
blank_title_cache[lang] = EmptyTitle(language=lang)
# Maps a node id to its page id
node_id_to_page = {}
def _page_to_node(page):
# EmptyTitle is used to prevent the cms from trying
# to find a translation in the database
page.title_cache = blank_title_cache.copy()
for trans in page.filtered_translations:
page.title_cache[trans.language] = trans
menu_node = get_menu_node_for_page(
self.renderer,
page,
language=lang,
fallbacks=fallbacks,
)
return menu_node
menu_nodes = []
for page in pages:
node = page.node
parent_id = node_id_to_page.get(node.parent_id)
if node.parent_id and not parent_id:
# If the parent page is not available (unpublished, etc..)
# don't bother creating menu nodes for its descendants.
continue
menu_node = _page_to_node(page)
cut_homepage = homepage and not homepage.in_navigation
if cut_homepage and parent_id == homepage.pk:
# When the homepage is hidden from navigation,
# we need to cut all its direct children from it.
menu_node.parent_id = None
else:
menu_node.parent_id = parent_id
node_id_to_page[node.pk] = page.pk
menu_nodes.append(menu_node)
return menu_nodes
def create_recommended_pages(self):
from cms.models.pagemodel import Page
from cms.utils.i18n import get_public_languages
default_language = get_public_languages()[0]
# create the HOME page
if Page.objects.public().filter(is_home=True).exists():
yield "A home page exists already."
else:
page, created = self.get_or_create_page("Home", None, in_navigation=True)
assert created is True
try:
clipboard = CascadeClipboard.objects.get(identifier='home')
except CascadeClipboard.DoesNotExist:
pass
else:
self.deserialize_to_placeholder(page, clipboard.data)
try:
clipboard = CascadeClipboard.objects.get(identifier='footer')
except CascadeClipboard.DoesNotExist:
pass
else:
static_placeholder = StaticPlaceholder.objects.create(code='Static Footer')
deserialize_to_placeholder(static_placeholder.public, clipboard.data, default_language)
deserialize_to_placeholder(static_placeholder.draft, clipboard.data, default_language)
page.set_as_homepage()
self.publish_in_all_languages(page)
yield "Created recommended CMS home page."
parent_page, created = self.get_or_create_page("Legal", None, reverse_id='shop-legal-pages', soft_root=True)
if created:
self.publish_in_all_languages(parent_page)
yield "Created recommended CMS page 'Legal'."
else:
yield "Recommended CMS page 'Legal' exists already."
page, created = self.get_or_create_page("Imprint", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Imprint'."
else:
yield "Recommended CMS page 'Imprint' exists already."
page, created = self.get_or_create_page("Terms and Conditions", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Terms and Conditions'."
else:
yield "Recommended CMS page 'Terms and Conditions' exists already."
page, created = self.get_or_create_page("Privacy Protection", None, parent_page=parent_page, in_navigation=True)
if created:
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Privacy Protection'."
else:
yield "Recommended CMS page 'Privacy Protection' exists already."
self.personal_pages, created = self.get_or_create_page("Personal Pages", None, reverse_id='shop-personal-pages', soft_root=True)
if created:
self.publish_in_all_languages(self.personal_pages)
yield "Created recommended CMS page 'Personal Pages'."
else:
yield "Recommended CMS page 'Personal Pages' exists already."
self.impersonal_pages, created = self.get_or_create_page("Join Us", None, reverse_id='shop-impersonal-pages', soft_root=True)
if created:
self.publish_in_all_languages(self.impersonal_pages)
yield "Created recommended CMS page 'Join Us'."
else:
yield "Recommended CMS page 'Join Us' exists already."
try:
apphook = self.get_installed_apphook('CatalogSearchApp')
except MissingAppHook:
yield "Unable to create recommended CMS page 'Search', because django-elasticsearch-dsl is not installed."
else:
page, created = self.get_or_create_page("Search", apphook=apphook, reverse_id='shop-search-product')
if created:
try:
clipboard = CascadeClipboard.objects.get(identifier=page.get_slug(default_language))
except CascadeClipboard.DoesNotExist:
pass
else:
self.deserialize_to_placeholder(page, clipboard.data)
self.create_breadcrumb(page, {'render_type': 'catalog'})
self.publish_in_all_languages(page)
yield "Created recommended CMS page 'Search'."
else:
yield "Recommended CMS page 'Search' exists already."
def article(request, slug):
"""
The main view of the Django-CMS Articles! Takes a request and a slug,
renders the article.
"""
# Get current CMS Page as article tree
tree = request.current_page
# Check whether it really is a tree.
# It could also be one of its sub-pages.
if tree.application_urls != 'CMSArticlesApp':
# In such case show regular CMS Page
return page(request, slug)
# Get an Article object from the request
draft = use_draft(request) and request.user.has_perm(
'cms_articles.change_article')
preview = 'preview' in request.GET and request.user.has_perm(
'cms_articles.change_article')
site = tree.node.site
article = get_article_from_slug(tree, slug, preview, draft)
if not article:
# raise 404
_handle_no_page(request)
request.current_article = article
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list(site_id=site.pk)
else:
user_languages = get_public_languages(site_id=site.pk)
request_language = get_language_from_request(request, check_path=True)
# get_published_languages will return all languages in draft mode
# and published only in live mode.
# These languages are then filtered out by the user allowed languages
available_languages = [
language for language in user_languages
if language in list(article.get_published_languages())
]
own_urls = [
request.build_absolute_uri(request.path),
'/%s' % request.path,
request.path,
]
try:
redirect_on_fallback = get_redirect_on_fallback(request_language,
site_id=site.pk)
except LanguageError:
redirect_on_fallback = False
if request_language not in user_languages:
# Language is not allowed
# Use the default site language
default_language = get_default_language_for_site(site.pk)
fallbacks = get_fallback_languages(default_language, site_id=site.pk)
fallbacks = [default_language] + fallbacks
else:
fallbacks = get_fallback_languages(request_language, site_id=site.pk)
# Only fallback to languages the user is allowed to see
fallback_languages = [
language for language in fallbacks
if language != request_language and language in available_languages
]
language_is_unavailable = request_language not in available_languages
if language_is_unavailable and not fallback_languages:
# There is no page with the requested language
# and there's no configured fallbacks
return _handle_no_page(request)
elif language_is_unavailable and redirect_on_fallback:
# There is no page with the requested language and
# the user has explicitly requested to redirect on fallbacks,
# so redirect to the first configured / available fallback language
fallback = fallback_languages[0]
redirect_url = article.get_absolute_url(fallback, fallback=False)
else:
redirect_url = False
if redirect_url:
if request.user.is_staff and hasattr(
request, 'toolbar') and request.toolbar.edit_mode_active:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
# prevent redirect to self
return HttpResponseRedirect(redirect_url)
# permission checks
if article.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()),
settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.obj = article
structure_requested = get_cms_setting(
'CMS_TOOLBAR_URL__BUILD') in request.GET
if article.has_change_permission(request) and structure_requested:
return render_object_structure(request, article)
return render_article(request,
article,
current_language=request_language,
slug=slug)
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
# get the right model
context = RequestContext(request)
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = get_language_from_request(request)
# Languages specific to page that the current user can see.
available_languages = get_languages_for_page_user(page=page, user=request.user)
attrs = ''
if 'edit' in request.GET:
attrs = '?edit=1'
elif 'preview' in request.GET:
attrs = '?preview=1'
if 'draft' in request.GET:
attrs += '&draft=1'
# Check that the user has access to this language
# which is defined in FRONTEND_LANGUAGES:
if not current_language in get_languages_for_user(user=request.user):
#are we on root?
if not slug and available_languages:
#redirect to supported language
languages = [(language, language) for language in available_languages]
with SettingsOverride(LANGUAGES=languages, LANGUAGE_CODE=languages[0][0]):
# get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
return HttpResponseRedirect(pages_root + attrs)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
fallback_languages = get_fallback_languages_for_page(page, current_language, request.user)
if fallback_languages:
if get_redirect_on_fallback(current_language):
fallback_language = fallback_languages[0]
with force_language(fallback_language):
path = page.get_absolute_url(language=fallback_language, fallback=True) + attrs
return HttpResponseRedirect(path)
else:
# There is a page object we can't find a proper language to render it
return _handle_no_page(request, slug)
else:
page_path = page.get_absolute_url(language=current_language)
page_slug = page.get_path(language=current_language) or page.get_slug(language=current_language)
if slug and slug != page_slug and request.path[:len(page_path)] != page_path:
# The current language does not match it's slug.
# Redirect to the current language.
return HttpResponseRedirect(page_path + attrs)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
try:
app_urls = page.get_application_urls(current_language, False)
except Title.DoesNotExist:
app_urls = []
if app_urls:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
context.current_app = page.reverse_id if page.reverse_id else app.app_name
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url + attrs)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL)
template_name = get_template_from_request(request, page, no_current_page=True)
has_view_permissions = page.has_view_permission(request)
# fill the context
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = has_view_permissions
if not has_view_permissions:
return _handle_no_page(request, slug)
return render_to_response(template_name, context_instance=context)
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
from django.core.cache import cache
if get_cms_setting("PAGE_CACHE") and (
not hasattr(request, 'toolbar') or (
not request.toolbar.edit_mode and
not request.toolbar.show_toolbar and
not request.user.is_authenticated()
)
):
cache_content = cache.get(
_get_cache_key(request),
version=_get_cache_version()
)
if not cache_content is None:
content, headers = cache_content
response = HttpResponse(content)
response._headers = headers
return response
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = request.REQUEST.get('language', None)
if current_language:
current_language = get_language_code(current_language)
if not current_language in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(getattr(request, 'LANGUAGE_CODE', None))
if current_language:
current_language = get_language_code(current_language)
if not current_language in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(get_language())
# Check that the current page is available in the desired (current) language
available_languages = []
page_languages = list(page.get_languages())
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
else:
user_languages = get_public_languages()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
# Check that the language is in FRONTEND_LANGUAGES:
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if not current_language in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
with SettingsOverride(LANGUAGES=languages, LANGUAGE_CODE=languages[0][0]):
#get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = pages_root
elif pages_root not in own_urls:
return HttpResponseRedirect(pages_root)
elif not hasattr(request, 'toolbar') or not request.toolbar.redirect_url:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language) or slug == "":
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang, fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = path
elif path not in own_urls:
return HttpResponseRedirect(path)
else:
found = True
if not found and (not hasattr(request, 'toolbar') or not request.toolbar.redirect_url):
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
app_urls = page.get_application_urls(current_language, False)
skip_app = False
if not page.is_published(current_language) and hasattr(request, 'toolbar') and request.toolbar.edit_mode:
skip_app = True
if app_urls and not skip_app:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/" and not redirect_url.startswith(
'/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(page)
template_name = get_template_from_request(request, page, no_current_page=True)
# fill the context
context = RequestContext(request)
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = page.has_view_permission(request)
if not context['has_view_permissions']:
return _handle_no_page(request, slug)
response = TemplateResponse(request, template_name, context)
response.add_post_render_callback(_cache_page)
# Add headers for X Frame Options - this really should be changed upon moving to class based views
xframe_options = page.get_xframe_options()
if xframe_options == Page.X_FRAME_OPTIONS_INHERIT:
# This is when we defer to django's own clickjacking handling
return response
# We want to prevent django setting this in their middlewear
response.xframe_options_exempt = True
if xframe_options == Page.X_FRAME_OPTIONS_ALLOW:
# Do nothing, allowed is no header.
return response
elif xframe_options == Page.X_FRAME_OPTIONS_SAMEORIGIN:
response['X-Frame-Options'] = 'SAMEORIGIN'
elif xframe_options == Page.X_FRAME_OPTIONS_DENY:
response['X-Frame-Options'] = 'DENY'
return response
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
response_timestamp = now()
if get_cms_setting("PAGE_CACHE") and (
not hasattr(request, 'toolbar') or
(not request.toolbar.edit_mode_active
and not request.toolbar.show_toolbar
and not request.user.is_authenticated())):
cache_content = get_page_cache(request)
if cache_content is not None:
content, headers, expires_datetime = cache_content
response = HttpResponse(content)
response._headers = headers
# Recalculate the max-age header for this cached response
max_age = int((expires_datetime -
response_timestamp).total_seconds() + 0.5)
patch_cache_control(response, max_age=max_age)
return response
# Get a Page model object from the request
site = get_current_site()
page = get_page_from_request(request, use_path=slug)
toolbar = get_toolbar_from_request(request)
tree_nodes = TreeNode.objects.get_for_site(site)
if not page and not slug and not tree_nodes.exists():
# render the welcome page if the requested path is root "/"
# and there's no pages
return _render_welcome_page(request)
if not page:
# raise 404
_handle_no_page(request)
request.current_page = page
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list(site_id=site.pk)
else:
user_languages = get_public_languages(site_id=site.pk)
request_language = get_language_from_request(request, check_path=True)
if not page.is_home and request_language not in user_languages:
# The homepage is treated differently because
# when a request goes to the root of the site (/)
# without a language, Django will redirect to the user's
# browser language which might not be a valid cms language,
# this means we need to correctly redirect that request.
return _handle_no_page(request)
# get_published_languages will return all languages in draft mode
# and published only in live mode.
# These languages are then filtered out by the user allowed languages
available_languages = [
language for language in user_languages
if language in list(page.get_published_languages())
]
own_urls = [
request.build_absolute_uri(request.path),
'/%s' % request.path,
request.path,
]
try:
redirect_on_fallback = get_redirect_on_fallback(request_language,
site_id=site.pk)
except LanguageError:
redirect_on_fallback = False
if request_language not in user_languages:
# Language is not allowed
# Use the default site language
default_language = get_default_language_for_site(site.pk)
fallbacks = get_fallback_languages(default_language, site_id=site.pk)
fallbacks = [default_language] + fallbacks
else:
fallbacks = get_fallback_languages(request_language, site_id=site.pk)
# Only fallback to languages the user is allowed to see
fallback_languages = [
language for language in fallbacks
if language != request_language and language in available_languages
]
language_is_unavailable = request_language not in available_languages
if language_is_unavailable and not fallback_languages:
# There is no page with the requested language
# and there's no configured fallbacks
return _handle_no_page(request)
elif language_is_unavailable and (redirect_on_fallback or page.is_home):
# There is no page with the requested language and
# the user has explicitly requested to redirect on fallbacks,
# so redirect to the first configured / available fallback language
fallback = fallback_languages[0]
redirect_url = page.get_absolute_url(fallback, fallback=False)
else:
page_path = page.get_absolute_url(request_language)
page_slug = page.get_path(request_language) or page.get_slug(
request_language)
if slug and slug != page_slug and request.path[:len(page_path
)] != page_path:
# The current language does not match its slug.
# Redirect to the current language.
return HttpResponseRedirect(page_path)
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(request_language,
fallback=False) or ''
redirect_url = _clean_redirect_url(redirect_url, request_language)
if redirect_url:
if request.user.is_staff and toolbar.edit_mode_active:
toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
# prevent redirect to self
return HttpResponseRedirect(redirect_url)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()),
settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(page)
structure_requested = get_cms_setting(
'CMS_TOOLBAR_URL__BUILD') in request.GET
if user_can_change_page(request.user, page) and structure_requested:
return render_object_structure(request, page)
return render_page(request,
page,
current_language=request_language,
slug=slug)
def check_mandatory_pages(self):
"""
Entry point for subcommand ``./manage.py shop check-pages``.
"""
from cms.models.pagemodel import Page
from cms.models.pluginmodel import CMSPlugin
from cms.utils.i18n import get_public_languages
self._created_cms_pages = []
default_language = get_public_languages()[0]
# check for catalog pages
apphook = self.get_installed_apphook('CatalogListCMSApp')
catalog_pages = Page.objects.public().filter(application_urls=apphook.__class__.__name__)
if not catalog_pages.exists():
if self.add_mandatory:
page, created = self.get_or_create_page("Catalog", 'CatalogListCMSApp', in_navigation=True)
if created:
try:
clipboard = CascadeClipboard.objects.get(identifier='shop-list')
self.deserialize_to_placeholder(page, clipboard.data)
except CascadeClipboard.DoesNotExist:
leaf_plugin = self.create_page_structure(page)
self.add_plugin(leaf_plugin, 'ShopCatalogPlugin', {})
self.create_breadcrumb(page, {'render_type': 'catalog'})
self.publish_in_all_languages(page)
self.assign_all_products_to_page(page)
yield "Created CMS page titled 'Catalog'."
else:
yield "CMS page 'Catalog' exists already."
else:
yield "There should be at least one published CMS page configured to use an Application inheriting from 'CatalogListCMSApp'."
page_attributes = [
# Menu Title, CMS-App-Hook or None, kwargs, Main Plugin, Plugin Context,
(("Search", 'CatalogSearchApp', {'reverse_id': 'shop-search-product'}),
('ShopSearchResultsPlugin', {}), {'render_type': 'catalog'}),
(("Cart", None, {'reverse_id': 'shop-cart'}),
('ShopCartPlugin', {'render_type': 'editable'}), {'render_type': 'soft-root'}),
(("Watch-List", None, {'reverse_id': 'shop-watch-list'}),
('ShopCartPlugin', {'render_type': 'watch'}), {'render_type': 'soft-root'}),
(("Your Orders", 'OrderApp', {'reverse_id': 'shop-order', 'parent_page': self.personal_pages, 'in_navigation': True}),
('ShopOrderViewsPlugin', {}), {'render_type': 'default'}),
(("Personal Details", None, {'reverse_id': 'shop-customer-details', 'parent_page': self.personal_pages, 'in_navigation': True}),
('CustomerFormPlugin', {}), {'render_type': 'default'}),
(("Change Password", None, {'reverse_id': 'shop-password-change', 'parent_page': self.personal_pages, 'in_navigation': True}),
('ShopAuthenticationPlugin', {'form_type': 'password-change'}), {'render_type': 'default'}),
(("Login", None, {'reverse_id': 'shop-login', 'parent_page': self.impersonal_pages, 'in_navigation': True}),
('ShopAuthenticationPlugin', {'form_type': 'login'}), {'render_type': 'default'}),
(("Register Customer", None, {'reverse_id': 'shop-register-customer', 'parent_page': self.impersonal_pages, 'in_navigation': True}),
('ShopAuthenticationPlugin', {'form_type': 'register-user'}), {'render_type': 'default'}),
(("Request Password Reset", None, {'reverse_id': 'password-reset-request', 'parent_page': self.impersonal_pages, 'in_navigation': True}),
('ShopAuthenticationPlugin', {'form_type': 'password-reset-request'}), {'render_type': 'default'}),
(("Confirm Password Reset", 'PasswordResetApp', {'reverse_id': 'password-reset-confirm'}),
('ShopAuthenticationPlugin', {'form_type': 'password-reset-confirm'}), {'render_type': 'default'}),
(("Payment Canceled", None, {'reverse_id': 'shop-cancel-payment'}),
('HeadingPlugin', {'tag_type': "h2", 'content': "Your payment has been canceled"}), {'render_type': 'default'}),
]
for page_attrs, content_attrs, breadcrumb_glossary in page_attributes:
try:
page = self.check_page(*page_attrs[:2], **page_attrs[2])
self.check_page_content(page, *content_attrs)
except MissingPage as exc:
if self.add_mandatory:
page, created = self.get_or_create_page(*page_attrs[:2], **page_attrs[2])
if created:
try:
clipboard = CascadeClipboard.objects.get(identifier=page.get_slug(default_language))
self.deserialize_to_placeholder(page, clipboard.data)
except CascadeClipboard.DoesNotExist:
leaf_plugin = self.create_page_structure(page)
self.add_plugin(leaf_plugin, *content_attrs)
if breadcrumb_glossary:
self.create_breadcrumb(page, breadcrumb_glossary)
self.publish_in_all_languages(page)
yield "Created mandatory CMS page titled '{0}'.".format(page.get_title(default_language))
else:
yield "Mandatory CMS page '{0}' exists already.".format(page.get_title(default_language))
else:
yield str(exc)
except CommandError as exc:
yield str(exc)
# the checkout page must be found through the purchase button
for plugin in CMSPlugin.objects.filter(plugin_type='ShopProceedButton', language=default_language, placeholder__page__publisher_is_draft=False):
link = plugin.get_bound_plugin().glossary.get('link')
if isinstance(link, dict) and link.get('type') == 'PURCHASE_NOW':
break
else:
if self.add_mandatory:
page, created = self.get_or_create_page("Checkout", None)
if created:
try:
clipboard = CascadeClipboard.objects.get(identifier='checkout')
self.deserialize_to_placeholder(page, clipboard.data)
except CascadeClipboard.DoesNotExist:
column_plugin = self.create_page_structure(page)
forms_plugin = self.add_plugin(column_plugin, 'ValidateSetOfFormsPlugin', {})
glossary = {'button_type': 'btn-success', 'link': {'type': 'PURCHASE_NOW'}, 'link_content': "Purchase Now"}
self.add_plugin(forms_plugin, 'ShopProceedButton', glossary)
self.publish_in_all_languages(page)
yield "Created CMS page titled 'Checkout'"
else:
yield "CMS page titled 'Checkout' exists already."
else:
yield "There should be at least one published CMS page containing a 'Proceed Button Plugin' for purchasing the cart's content."
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
response_timestamp = now()
if get_cms_setting("PAGE_CACHE") and (
not hasattr(request, 'toolbar') or
(not request.toolbar.edit_mode and not request.toolbar.show_toolbar
and not request.user.is_authenticated())):
cache_content = get_page_cache(request)
if cache_content is not None:
content, headers, expires_datetime = cache_content
response = HttpResponse(content)
response._headers = headers
# Recalculate the max-age header for this cached response
max_age = int((expires_datetime -
response_timestamp).total_seconds() + 0.5)
patch_cache_control(response, max_age=max_age)
return response
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = request.GET.get('language', None)
if not current_language:
current_language = request.POST.get('language', None)
if current_language:
current_language = get_language_code(current_language)
if current_language not in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(
getattr(request, 'LANGUAGE_CODE', None))
if current_language:
current_language = get_language_code(current_language)
if current_language not in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(get_language())
# Check that the current page is available in the desired (current) language
available_languages = []
# this will return all languages in draft mode, and published only in live mode
page_languages = list(page.get_published_languages())
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
else:
user_languages = get_public_languages()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
# Check that the language is in FRONTEND_LANGUAGES:
own_urls = [
'http%s://%s%s' %
('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if current_language not in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
# get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
if (hasattr(request, 'toolbar')
and request.user.is_staff
and request.toolbar.edit_mode):
request.toolbar.redirect_url = pages_root
elif pages_root not in own_urls:
return HttpResponseRedirect(pages_root)
elif not hasattr(request,
'toolbar') or not request.toolbar.redirect_url:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language) or slug == "":
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang,
fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
if (hasattr(request, 'toolbar') and request.user.is_staff
and request.toolbar.edit_mode):
request.toolbar.redirect_url = path
elif path not in own_urls:
return HttpResponseRedirect(path)
else:
found = True
if not found and (not hasattr(request, 'toolbar')
or not request.toolbar.redirect_url):
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
else:
page_path = page.get_absolute_url(language=current_language)
page_slug = page.get_path(language=current_language) or page.get_slug(
language=current_language)
if slug and slug != page_slug and request.path[:len(page_path
)] != page_path:
# The current language does not match it's slug.
# Redirect to the current language.
if hasattr(
request, 'toolbar'
) and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = page_path
else:
return HttpResponseRedirect(page_path)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
app_urls = page.get_application_urls(current_language, False)
skip_app = False
if (not page.is_published(current_language)
and hasattr(request, 'toolbar') and request.toolbar.edit_mode):
skip_app = True
if app_urls and not skip_app:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
if app:
for urlpatterns in get_app_urls(
app.get_urls(page, current_language)):
pattern_list += urlpatterns
try:
view, args, kwargs = resolve('/', tuple(pattern_list))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language,
redirect_url.lstrip("/"))
# prevent redirect to self
if hasattr(request, 'toolbar'
) and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()),
settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(page)
response = render_page(request,
page,
current_language=current_language,
slug=slug)
return response
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
# get the right model
context = RequestContext(request)
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = get_language_from_request(request)
# Check that the current page is available in the desired (current) language
available_languages = []
page_languages = page.get_languages()
user_languages = get_public_languages()
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
attrs = ''
if 'edit' in request.GET:
attrs = '?edit=1'
elif 'preview' in request.GET:
attrs = '?preview=1'
if 'draft' in request.GET:
attrs += '&draft=1'
# Check that the language is in FRONTEND_LANGUAGES:
if not current_language in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
with SettingsOverride(LANGUAGES=languages, LANGUAGE_CODE=languages[0][0]):
#get supported language
new_language = translation.get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
return HttpResponseRedirect(pages_root + attrs)
else:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language):
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang, fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
return HttpResponseRedirect(path + attrs)
else:
found = True
if not found:
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
try:
app_urls = page.get_application_urls(current_language, False)
except Title.DoesNotExist:
app_urls = []
if app_urls:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
for urlpatterns in get_app_urls(app.urls):
pattern_list += urlpatterns
urlpatterns = patterns('', *pattern_list)
try:
context.current_app = page.reverse_id if page.reverse_id else app.app_name
view, args, kwargs = resolve('/', tuple(urlpatterns))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (settings.USE_I18N and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url + attrs)
# permission checks
if page.login_required and not request.user.is_authenticated():
path = urlquote(request.get_full_path())
tup = settings.LOGIN_URL, "next", path
return HttpResponseRedirect('%s?%s=%s' % tup)
template_name = get_template_from_request(request, page, no_current_page=True)
# fill the context
context['lang'] = current_language
context['current_page'] = page
context['has_change_permissions'] = page.has_change_permission(request)
context['has_view_permissions'] = page.has_view_permission(request)
if not context['has_view_permissions']:
return _handle_no_page(request, slug)
return render_to_response(template_name, context_instance=context)
def get_relevant_page_with_fallbacks(context, instance):
"""
The plugin should show the published page whenever it exists or the draft page
otherwise but only in edit mode.
This is inspired by what DjangoCMS does in its main view:
https://github.com/django-cms/django-cms/blob/3.8.0/cms/views.py#L37
"""
request = context["request"]
site = get_current_site()
# Check permissions
if not page_permissions.user_can_view_page(request.user, instance.page,
site):
return None
relevant_page = instance.page.get_public_object()
if not relevant_page:
if context.get(
"current_page") and context["current_page"].publisher_is_draft:
return instance.page
return None
if request.user.is_staff:
user_languages = i18n.get_language_list(site_id=site.pk)
else:
user_languages = i18n.get_public_languages(site_id=site.pk)
# These languages are then filtered out by the user allowed languages
available_languages = [
language for language in user_languages
if language in list(relevant_page.get_published_languages())
]
request_language = translation.get_language_from_request(request,
check_path=True)
if request_language not in user_languages:
# Language is not allowed
# Use the default site language
default_language = i18n.get_default_language_for_site(site.pk)
fallbacks = i18n.get_fallback_languages(default_language,
site_id=site.pk)
fallbacks = [default_language] + fallbacks
else:
fallbacks = i18n.get_fallback_languages(request_language,
site_id=site.pk)
# Only fallback to languages the user is allowed to see
fallback_languages = [
language for language in fallbacks
if language != request_language and language in available_languages
]
if request_language not in available_languages:
if not fallback_languages:
# There is no page with the requested language
# and there's no configured fallbacks
return None
if request_language in relevant_page.get_languages():
# The page was already published and later unpublished in the current
# language. In this case we must not fallback to another language.
return None
return relevant_page
def deserialize_to_placeholder(self, page, data, slot='Main Content'):
from cms.utils.i18n import get_public_languages
language = get_public_languages()[0]
placeholder = page.placeholders.get(slot=slot)
deserialize_to_placeholder(placeholder, data, language)
def languages(self, obj):
site = get_current_site()
return get_public_languages(site_id=site.pk)
{%- if cookiecutter.products_model != 'polymorphic' %}
if product_model != '{{ cookiecutter.products_model }}':
continue
{%- endif %}
if product.get('product_code'){% if cookiecutter.products_model == 'commodity' %} != {% else %} == {% endif %}"parklake-springfield":
continue
ProductModel = ContentType.objects.get(app_label='{{ cookiecutter.app_name }}_shop', model=product_model)
class_name = '{{ cookiecutter.app_name }}.base_shop.management.serializers.' + ProductModel.model_class().__name__ + 'Serializer'
serializer_class = import_string(class_name)
serializer = serializer_class(data=product)
assert serializer.is_valid(), serializer.errors
instance = serializer.save()
self.assign_product_to_catalog(instance)
self.stdout.write("{}. {}".format(number, instance))
if product_model == 'commodity':
languages = get_public_languages()
try:
clipboard = CascadeClipboard.objects.get(identifier=instance.slug)
except CascadeClipboard.DoesNotExist:
pass
else:
deserialize_to_placeholder(instance.placeholder, clipboard.data, languages[0])
plugins = list(instance.placeholder.get_plugins(language=languages[0]).order_by('path'))
for language in languages[1:]:
copy_plugins_to(plugins, instance.placeholder, language)
def find_fixture(self, filename):
if os.path.isabs(filename):
fixture_dirs = [os.path.dirname(filename)]
fixture_name = os.path.basename(filename)
else:
def details(request, slug):
"""
The main view of the Django-CMS! Takes a request and a slug, renders the
page.
"""
response_timestamp = now()
if get_cms_setting("PAGE_CACHE") and (
not hasattr(request, 'toolbar') or (
not request.toolbar.edit_mode and
not request.toolbar.show_toolbar and
not request.user.is_authenticated()
)
):
cache_content = get_page_cache(request)
if cache_content is not None:
content, headers, expires_datetime = cache_content
response = HttpResponse(content)
response._headers = headers
# Recalculate the max-age header for this cached response
max_age = int(
(expires_datetime - response_timestamp).total_seconds() + 0.5)
patch_cache_control(response, max_age=max_age)
return response
# Get a Page model object from the request
page = get_page_from_request(request, use_path=slug)
if not page:
return _handle_no_page(request, slug)
current_language = request.GET.get('language', None)
if not current_language:
current_language = request.POST.get('language', None)
if current_language:
current_language = get_language_code(current_language)
if current_language not in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(getattr(request, 'LANGUAGE_CODE', None))
if current_language:
current_language = get_language_code(current_language)
if current_language not in get_language_list(page.site_id):
current_language = None
if current_language is None:
current_language = get_language_code(get_language())
# Check that the current page is available in the desired (current) language
available_languages = []
# this will return all languages in draft mode, and published only in live mode
page_languages = list(page.get_published_languages())
if hasattr(request, 'user') and request.user.is_staff:
user_languages = get_language_list()
else:
user_languages = get_public_languages()
for frontend_lang in user_languages:
if frontend_lang in page_languages:
available_languages.append(frontend_lang)
# Check that the language is in FRONTEND_LANGUAGES:
own_urls = [
'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path),
'/%s' % request.path,
request.path,
]
if current_language not in user_languages:
#are we on root?
if not slug:
#redirect to supported language
languages = []
for language in available_languages:
languages.append((language, language))
if languages:
# get supported language
new_language = get_language_from_request(request)
if new_language in get_public_languages():
with force_language(new_language):
pages_root = reverse('pages-root')
if (hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode):
request.toolbar.redirect_url = pages_root
elif pages_root not in own_urls:
return HttpResponseRedirect(pages_root)
elif not hasattr(request, 'toolbar') or not request.toolbar.redirect_url:
_handle_no_page(request, slug)
else:
return _handle_no_page(request, slug)
if current_language not in available_languages:
# If we didn't find the required page in the requested (current)
# language, let's try to find a fallback
found = False
for alt_lang in get_fallback_languages(current_language):
if alt_lang in available_languages:
if get_redirect_on_fallback(current_language) or slug == "":
with force_language(alt_lang):
path = page.get_absolute_url(language=alt_lang, fallback=True)
# In the case where the page is not available in the
# preferred language, *redirect* to the fallback page. This
# is a design decision (instead of rendering in place)).
if (hasattr(request, 'toolbar') and request.user.is_staff
and request.toolbar.edit_mode):
request.toolbar.redirect_url = path
elif path not in own_urls:
return HttpResponseRedirect(path)
else:
found = True
if not found and (not hasattr(request, 'toolbar') or not request.toolbar.redirect_url):
# There is a page object we can't find a proper language to render it
_handle_no_page(request, slug)
if apphook_pool.get_apphooks():
# There are apphooks in the pool. Let's see if there is one for the
# current page
# since we always have a page at this point, applications_page_check is
# pointless
# page = applications_page_check(request, page, slug)
# Check for apphooks! This time for real!
app_urls = page.get_application_urls(current_language, False)
skip_app = False
if (not page.is_published(current_language) and hasattr(request, 'toolbar')
and request.toolbar.edit_mode):
skip_app = True
if app_urls and not skip_app:
app = apphook_pool.get_apphook(app_urls)
pattern_list = []
if app:
for urlpatterns in get_app_urls(app.get_urls(page, current_language)):
pattern_list += urlpatterns
try:
view, args, kwargs = resolve('/', tuple(pattern_list))
return view(request, *args, **kwargs)
except Resolver404:
pass
# Check if the page has a redirect url defined for this language.
redirect_url = page.get_redirect(language=current_language)
if redirect_url:
if (is_language_prefix_patterns_used() and redirect_url[0] == "/"
and not redirect_url.startswith('/%s/' % current_language)):
# add language prefix to url
redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/"))
# prevent redirect to self
if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode:
request.toolbar.redirect_url = redirect_url
elif redirect_url not in own_urls:
return HttpResponseRedirect(redirect_url)
# permission checks
if page.login_required and not request.user.is_authenticated():
return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(page)
response = render_page(request, page, current_language=current_language, slug=slug)
return response
