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