def __init__(self, *args, **kwargs): super(AdvancedSettingsForm, self).__init__(*args, **kwargs) self.fields['language'].widget = HiddenInput() self.fields['site'].widget = HiddenInput() site_id = self.fields['site'].initial languages = get_language_tuple(site_id) self.fields['language'].choices = languages if not self.fields['language'].initial: self.fields['language'].initial = get_language() if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select({}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: # Prepare a dict mapping the apps by class name ('PollApp') to # their app_name attribute ('polls'), if any. app_namespaces = {} for hook in apphook_pool.get_apphooks(): app = apphook_pool.get_apphook(hook[0]) if app.app_name: app_namespaces[hook[0]] = app.app_name self.fields['application_urls'].widget = AppHookSelect( attrs={'id':'application_urls'}, app_namespaces=app_namespaces, ) self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks() if 'redirect' in self.fields: self.fields['redirect'].widget.language = self.fields['language'].initial
def __init__(self, *args, **kwargs): super(AdvancedSettingsForm, self).__init__(*args, **kwargs) self.fields['language'].widget = HiddenInput() self.fields['site'].widget = HiddenInput() site_id = self.fields['site'].initial languages = get_language_tuple(site_id) self.fields['language'].choices = languages if not self.fields['language'].initial: self.fields['language'].initial = get_language() if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select( {}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: # Prepare a dict mapping the apps by class name ('PollApp') to # their app_name attribute ('polls'), if any. app_namespaces = {} app_configs = {} for hook in apphook_pool.get_apphooks(): app = apphook_pool.get_apphook(hook[0]) if app.app_name: app_namespaces[hook[0]] = app.app_name if app.app_config: app_configs[hook[0]] = app self.fields['application_urls'].widget = AppHookSelect( attrs={'id': 'application_urls'}, app_namespaces=app_namespaces ) self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks() page_data = self.data if self.data else self.initial if app_configs: self.fields['application_configs'].widget = ApplicationConfigSelect( attrs={'id': 'application_configs'}, app_configs=app_configs) if page_data.get('application_urls', False) and page_data['application_urls'] in app_configs: self.fields['application_configs'].choices = [(config.pk, force_text(config)) for config in app_configs[page_data['application_urls']].get_configs()] apphook = page_data.get('application_urls', False) try: config = apphook_pool.get_apphook(apphook).get_configs().get(namespace=self.initial['application_namespace']) self.fields['application_configs'].initial = config.pk except ObjectDoesNotExist: # Provided apphook configuration doesn't exist (anymore), # just skip it # The user will choose another value anyway pass else: # If app_config apphook is not selected, drop any value # for application_configs to avoid the field data from # being validated by the field itself try: del self.data['application_configs'] except KeyError: pass if 'redirect' in self.fields: self.fields['redirect'].widget.language = self.fields['language'].initial
def __init__(self, *args, **kwargs): super(AdvancedSettingsForm, self).__init__(*args, **kwargs) self.title_obj = self.instance.get_title_obj( language=self._language, fallback=False, force_reload=True, ) if 'navigation_extenders' in self.fields: navigation_extenders = self.get_navigation_extenders() self.fields['navigation_extenders'].widget = forms.Select( {}, [('', "---------")] + navigation_extenders) if 'application_urls' in self.fields: # Prepare a dict mapping the apps by class name ('PollApp') to # their app_name attribute ('polls'), if any. app_namespaces = {} app_configs = {} for hook in apphook_pool.get_apphooks(): app = apphook_pool.get_apphook(hook[0]) if app.app_name: app_namespaces[hook[0]] = app.app_name if app.app_config: app_configs[hook[0]] = app self.fields['application_urls'].widget = AppHookSelect( attrs={'id': 'application_urls'}, app_namespaces=app_namespaces ) self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks() page_data = self.data if self.data else self.initial if app_configs: self.fields['application_configs'].widget = ApplicationConfigSelect( attrs={'id': 'application_configs'}, app_configs=app_configs, ) if page_data.get('application_urls', False) and page_data['application_urls'] in app_configs: configs = app_configs[page_data['application_urls']].get_configs() self.fields['application_configs'].widget.choices = [(config.pk, force_text(config)) for config in configs] try: config = configs.get(namespace=self.initial['application_namespace']) self.fields['application_configs'].initial = config.pk except ObjectDoesNotExist: # Provided apphook configuration doesn't exist (anymore), # just skip it # The user will choose another value anyway pass if 'redirect' in self.fields: self.fields['redirect'].widget.language = self._language self.fields['redirect'].initial = self.title_obj.redirect if 'overwrite_url' in self.fields and self.title_obj.has_url_overwrite: self.fields['overwrite_url'].initial = self.title_obj.path
def __init__(self, *args, **kwargs): super(PageForm, self).__init__(*args, **kwargs) if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select({}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks()
def apphook_clear(self): from cms.apphook_pool import apphook_pool for name, label in list(apphook_pool.get_apphooks()): if apphook_pool.apps[name].__class__.__module__ in sys.modules: del sys.modules[apphook_pool.apps[name].__class__.__module__] apphook_pool.clear()
def __init__(self, *args, **kwargs): super(PageForm, self).__init__(*args, **kwargs) if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select({}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks() if 'redirect_to_page' in self.fields: self.fields['redirect_to_page'].choices = [('', "---------")] + [(page.id, "%s %s" % (u" "*page.level, page.get_menu_title())) for page in Page.objects.all()]
def apphook_clear(self): """ Clean up apphook_pool and sys.modules. Taken from cms with slight adjustments and fixes. :return: None """ try: apphooks = apphook_pool.get_apphooks() except AppAlreadyRegistered: # there is an issue with discover apps, or i'm using it wrong. # setting discovered to True solves it. Maybe that is due to import # from aldryn_events.cms_app which registers EventListAppHook apphook_pool.discovered = True apphooks = apphook_pool.get_apphooks() for name, label in list(apphooks): if apphook_pool.apps[name].__class__.__module__ in sys.modules: del sys.modules[apphook_pool.apps[name].__class__.__module__] apphook_pool.clear()
def apphook_clear(self): """ Clean up apphook_pool and sys.modules. Taken from cms with slight adjustments and fixes. :return: None """ try: apphooks = apphook_pool.get_apphooks() except AppAlreadyRegistered: # there is an issue with discover apps, or i'm using it wrong. # setting discovered to True solves it. Maybe that is due to import # from aldryn_events.cms_apps which registers EventListAppHook apphook_pool.discovered = True apphooks = apphook_pool.get_apphooks() for name, label in list(apphooks): if apphook_pool.apps[name].__class__.__module__ in sys.modules: del sys.modules[apphook_pool.apps[name].__class__.__module__] apphook_pool.clear()
def test_explicit_apphooks(self): """ Test explicit apphook loading with the CMS_APPHOOKS setting. """ self.apphook_clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) self.apphook_clear()
def __init__(self, *args, **kwargs): super(PageForm, self).__init__(*args, **kwargs) if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select( {}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: self.fields['application_urls'].choices = [ ('', "---------") ] + apphook_pool.get_apphooks()
def test_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS cms_apps.py """ self.apphook_clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 7) self.assertIn(NS_APP_NAME, app_names) self.assertIn(APP_NAME, app_names) self.apphook_clear()
def get_installed_apphook(cls, base_apphook_name): from cms.apphook_pool import apphook_pool base_apphook = import_string('shop.cms_apphooks.' + base_apphook_name) for apphook, _ in apphook_pool.get_apphooks(): apphook = apphook_pool.get_apphook(apphook) if isinstance(apphook, base_apphook): return apphook else: msg = "The project must register an AppHook inheriting from '{apphook_name}'" raise MissingAppHook(msg.format(apphook_name=base_apphook_name))
def test_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS cms_apps.py """ self.apphook_clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 8) self.assertIn(NS_APP_NAME, app_names) self.assertIn(APP_NAME, app_names) self.apphook_clear()
def test_explicit_apphooks(self): """ Test explicit apphook loading with the CMS_APPHOOKS setting. """ apphooks = ("%s.%s" % (APP_MODULE, APP_NAME),) with SettingsOverride(CMS_APPHOOKS=apphooks): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) apphook_pool.clear()
def get_apphooks(cls): """ Returns a list of apphooks to which this CMSAttachMenu is attached. Calling this does NOT produce DB queries. """ apps = [] for key, _ in apphook_pool.get_apphooks(): app = apphook_pool.get_apphook(key) if cls in app.menus: apps.append(app) return apps
def test_explicit_apphooks(self): """ Test explicit apphook loading with the CMS_APPHOOKS setting. """ apphooks = ('%s.%s' % (APP_MODULE, APP_NAME), ) with SettingsOverride(CMS_APPHOOKS=apphooks): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) apphook_pool.clear()
def test_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS + cms_app.py """ apps = ['cms.test_utils.project.sampleapp'] with SettingsOverride(INSTALLED_APPS=apps, ROOT_URLCONF='cms.test_utils.project.urls_for_apphook_tests'): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) apphook_pool.clear()
def test_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS cms_app.py """ apps = ["cms.test_utils.project.sampleapp"] with SettingsOverride(INSTALLED_APPS=apps, ROOT_URLCONF="cms.test_utils.project.urls_for_apphook_tests"): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 3) self.assertIn(NS_APP_NAME, app_names) self.assertIn(APP_NAME, app_names) apphook_pool.clear()
def test_02_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS + cms_app.py """ if APP_MODULE in sys.modules: del sys.modules[APP_MODULE] apps = ['testapp.sampleapp'] with SettingsOverride(INSTALLED_APPS=apps): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) apphook_pool.clear()
def __init__(self, *args, **kwargs): super(AdvancedSettingsForm, self).__init__(*args, **kwargs) self.fields['language'].widget = HiddenInput() self.fields['site'].widget = HiddenInput() site_id = self.fields['site'].initial languages = get_language_tuple(site_id) self.fields['language'].choices = languages if not self.fields['language'].initial: self.fields['language'].initial = get_language() if 'navigation_extenders' in self.fields: self.fields['navigation_extenders'].widget = forms.Select({}, [('', "---------")] + menu_pool.get_menus_by_attribute("cms_enabled", True)) if 'application_urls' in self.fields: self.fields['application_urls'].choices = [('', "---------")] + apphook_pool.get_apphooks()
def get_queryset(self): # qs = super(ApphooksList, self).get_queryset() qs = [] apphook_tuples = apphook_pool.get_apphooks() for apphook_tuple in apphook_tuples: apphook_info = {} apphook_info['name'] = unicode(apphook_tuple[1]) apphook_info['class'] = unicode(apphook_tuple[0]) apphook_info['amount'] = Page.objects.filter(application_urls=apphook_tuple[0], publisher_is_draft=False).count() apphook_info['url'] = reverse('apphook_detail', kwargs={'apphook_class': apphook_info['class']}) qs.append(apphook_info) return qs
def test_02_implicit_apphooks(self): """ Test implicit apphook loading with INSTALLED_APPS + cms_app.py """ if APP_MODULE in sys.modules: del sys.modules[APP_MODULE] apps = ['testapp.sampleapp'] with SettingsOverride(INSTALLED_APPS=apps, ROOT_URLCONF='testapp.urls_for_apphook_tests'): apphook_pool.clear() hooks = apphook_pool.get_apphooks() app_names = [hook[0] for hook in hooks] self.assertEqual(len(hooks), 1) self.assertEqual(app_names, [APP_NAME]) apphook_pool.clear()
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.get_languages() # We resolve an alternate language for the page if it's not available. # Since the "old" details view had an exception for the root page, it is # ported here. So no resolution if the slug is ''. if (current_language not in available_languages): if settings.CMS_LANGUAGE_FALLBACK: # If we didn't find the required page in the requested (current) # language, let's try to find a suitable fallback in the list of # fallback languages (CMS_LANGUAGE_CONF) for alt_lang in get_fallback_languages(current_language): if alt_lang in available_languages: alt_url = page.get_absolute_url(language=alt_lang, fallback=True) path = '/%s%s' % (alt_lang, alt_url) # 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) # 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) 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 (settings.i18n_installed and redirect_url[0] == "/" and not redirect_url.startswith('/%s/' % current_language)): redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/")) # add language prefix to url return HttpResponseRedirect(redirect_url) # permission checks if page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote("/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: 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)
def details(request, page_id=None, slug=None, template_name=settings.CMS_TEMPLATES[0][0], no404=False): # get the right model page_queryset = get_page_queryset(request) lang = get_language_from_request(request) site = Site.objects.get_current() if 'preview' in request.GET.keys() and request.user.has_perm(Page._meta.app_label + ' ' + Page._meta.get_change_permission()): pages = page_queryset.filter(site=site) else: pages = page_queryset.published().filter(site=site) current_page, response = None, None if pages.all_root(): if page_id: current_page = get_object_or_404(pages, pk=page_id) elif slug != None: if slug == "": current_page = pages.get_home() else: pages_root = reverse('pages-root') path = slug.startswith(pages_root) and slug[len(pages_root):] or slug try: home = pages.get_home() current_page, alternative = get_current_page(path, lang, pages, home.get_slug(language=lang), home.tree_id) except NoHomeFound: current_page, alternative = get_current_page(path, lang, pages) if apphook_pool.get_apphooks(): # check if it shouldn't point to some application, if yes, # change current page if required current_page = applications_page_check(request, current_page, path) if not current_page: if alternative and settings.CMS_LANGUAGE_FALLBACK: return HttpResponseRedirect(alternative) if no404:# used for placeholder finder current_page = None else: if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL return "cms/new.html", locals() raise Http404('CMS: Page not found for "%s"' % slug) else: current_page = applications_page_check(request) #current_page = None template_name = get_template_from_request(request, current_page, no_current_page=True) elif not no404: if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL return "cms/new.html", locals() raise Http404("CMS: No page found for site %s" % unicode(site.name)) if current_page: has_change_permissions = current_page.has_change_permission(request) request._current_page_cache = current_page redirect_url = current_page.get_redirect(language=lang) if redirect_url: if settings.i18n_installed and redirect_url[0] == "/": redirect_url = "/%s/%s" % (lang, redirect_url.lstrip("/")) # add language prefix to url return HttpResponseRedirect(redirect_url) if current_page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote("/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: path = urlquote(request.get_full_path()) tup = django_settings.LOGIN_URL , "next", path return HttpResponseRedirect('%s?%s=%s' % tup) else: has_change_permissions = False return template_name, locals()
def details(request, page_id=None, slug=None, template_name=settings.CMS_TEMPLATES[0][0], no404=False): ''' This is the bitch of the CMS. Basically, she does it all. For instance, this is called by a util function to retrieve Models (!), hence the no404 argument. BADLY NEEDS REFACTORING, BITCH ''' # get the right model page_queryset = get_page_queryset(request) lang = get_language_from_request(request) site = Site.objects.get_current() if 'preview' in request.GET.keys(): pages = page_queryset.filter(site=site) else: pages = page_queryset.published(site=site) current_page, response = None, None if pages.all_root(): # QUERY! # If there is at least one root page (no parent) if page_id: current_page = get_object_or_404(pages, pk=page_id)# QUERY! elif slug != None: if slug == "": # Gets the first root page (no parent) in the page's tree, # ordered by tree ID current_page = pages.get_home()# QUERY! else: # We have a slug, we get the root using reverse (see ./urls.py) pages_root = reverse('pages-root') # If the CMS urls are not the actual root of the url path # (http://bullshit.com/blablabla/some/page/slug) # Remove the prefix # (some/page/slug) if slug.startswith(pages_root): path = slug[len(pages_root):] else: path = slug try: home = pages.get_home() # QUERY! current_page, alternative = get_current_page(path, lang, pages, home.get_slug(language=lang), home.tree_id) except NoHomeFound: current_page, alternative = get_current_page(path, lang, pages)# QUERY! if apphook_pool.get_apphooks(): # check if it shouldn't point to some application, if yes, # change current page if required current_page = applications_page_check(request, current_page, path) if not current_page: # We still don't have a current page... probably because it # doesn't exist in the current language, let's lookup for # the current language's fallback if alternative and settings.CMS_LANGUAGE_FALLBACK: return HttpResponseRedirect(alternative) if no404:# used for placeholder finder current_page = None else: # "Normal case" - we're being a view if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL # Classic case of "I didn't read the Zen of Python". # This is line 2: "Explicit is better than implicit" return "cms/new.html", locals() # Come on, use a dict!. raise Http404('CMS: Page not found for "%s"' % slug) else: # We have an apphook on the root page current_page = applications_page_check(request) #current_page = None template_name = get_template_from_request(request, current_page, no_current_page=True) elif not no404: # Double negation: no404 = True # If we're not being a view if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL return "cms/new.html", locals() # damn, it should be a dict! raise Http404("CMS: No page found for site %s" % unicode(site.name)) if current_page: has_change_permissions = current_page.has_change_permission(request) request._current_page_cache = current_page redirect_url = current_page.get_redirect(language=lang) if redirect_url: if settings.i18n_installed and redirect_url[0] == "/": redirect_url = "/%s/%s" % (lang, redirect_url.lstrip("/")) # add language prefix to url return HttpResponseRedirect(redirect_url) if current_page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote("/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: path = urlquote(request.get_full_path()) tup = django_settings.LOGIN_URL , "next", path return HttpResponseRedirect('%s?%s=%s' % tup) else: has_change_permissions = False return template_name, locals() # Ah well, passing the whole context again
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. """ # 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
# -*- coding: utf-8 -*- from django.conf import settings from django.conf.urls import url from cms.apphook_pool import apphook_pool from cms.appresolver import get_app_patterns from cms.views import details if settings.APPEND_SLASH: regex = r'^(?P<slug>[0-9A-Za-z-_.//]+)/$' else: regex = r'^(?P<slug>[0-9A-Za-z-_.//]+)$' if apphook_pool.get_apphooks(): # If there are some application urls, use special resolver, # so we will have standard reverse support. urlpatterns = get_app_patterns() else: urlpatterns = [] urlpatterns.extend([ url(regex, details, name='pages-details-by-slug'), url(r'^$', details, {'slug': ''}, name='pages-root'), ])
def get_apphooks(self): for hook in apphook_pool.get_apphooks(): yield (hook[0], apphook_pool.get_apphook(hook[0]))
# -*- coding: utf-8 -*- from cms.apphook_pool import apphook_pool from cms.views import details from django.conf import settings from django.conf.urls import url, patterns if settings.APPEND_SLASH: reg = url(r'^(?P<slug>[0-9A-Za-z-_.//]+)/$', details, name='pages-details-by-slug') else: reg = url(r'^(?P<slug>[0-9A-Za-z-_.//]+)$', details, name='pages-details-by-slug') urlpatterns = [ # Public pages url(r'^$', details, {'slug':''}, name='pages-root'), reg, ] if apphook_pool.get_apphooks(): """If there are some application urls, add special resolver, so we will have standard reverse support. """ from cms.appresolver import get_app_patterns urlpatterns = get_app_patterns() + urlpatterns urlpatterns = patterns('', *urlpatterns)
def __init__(self, *args, **kwargs): super(AdvancedSettingsForm, self).__init__(*args, **kwargs) self.fields['language'].widget = HiddenInput() self.fields['site'].widget = HiddenInput() site_id = self.fields['site'].initial languages = get_language_tuple(site_id) self.fields['language'].choices = languages if not self.fields['language'].initial: self.fields['language'].initial = get_language() if 'navigation_extenders' in self.fields: navigation_extenders = self.get_navigation_extenders() self.fields['navigation_extenders'].widget = forms.Select( {}, [('', "---------")] + navigation_extenders) if 'application_urls' in self.fields: # Prepare a dict mapping the apps by class name ('PollApp') to # their app_name attribute ('polls'), if any. app_namespaces = {} app_configs = {} for hook in apphook_pool.get_apphooks(): app = apphook_pool.get_apphook(hook[0]) if app.app_name: app_namespaces[hook[0]] = app.app_name if app.app_config: app_configs[hook[0]] = app self.fields['application_urls'].widget = AppHookSelect( attrs={'id': 'application_urls'}, app_namespaces=app_namespaces) self.fields['application_urls'].choices = [ ('', "---------") ] + apphook_pool.get_apphooks() page_data = self.data if self.data else self.initial if app_configs: self.fields[ 'application_configs'].widget = ApplicationConfigSelect( attrs={'id': 'application_configs'}, app_configs=app_configs) if page_data.get( 'application_urls', False ) and page_data['application_urls'] in app_configs: self.fields['application_configs'].choices = [ (config.pk, force_text(config)) for config in app_configs[ page_data['application_urls']].get_configs() ] apphook = page_data.get('application_urls', False) try: config = apphook_pool.get_apphook(apphook).get_configs( ).get(namespace=self.initial['application_namespace']) self.fields['application_configs'].initial = config.pk except ObjectDoesNotExist: # Provided apphook configuration doesn't exist (anymore), # just skip it # The user will choose another value anyway pass else: # If app_config apphook is not selected, drop any value # for application_configs to avoid the field data from # being validated by the field itself try: del self.data['application_configs'] except KeyError: pass if 'redirect' in self.fields: self.fields['redirect'].widget.language = self.fields[ 'language'].initial
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
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.get_languages() # We resolve an alternate language for the page if it's not available. # Since the "old" details view had an exception for the root page, it is # ported here. So no resolution if the slug is ''. if (current_language not in available_languages) and (slug != ''): if settings.CMS_LANGUAGE_FALLBACK: # If we didn't find the required page in the requested (current) # language, let's try to find a suitable fallback in the list of # fallback languages (CMS_LANGUAGE_CONF) for alt_lang in get_fallback_languages(current_language): if alt_lang in available_languages: alt_url = page.get_absolute_url(language=alt_lang, fallback=True) path = '/%s%s' % (alt_lang, alt_url) # 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) # 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) 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 settings.i18n_installed and redirect_url[0] == "/": redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/")) # add language prefix to url return HttpResponseRedirect(redirect_url) # permission checks if page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote("/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: path = urlquote(request.get_full_path()) tup = django_settings.LOGIN_URL , "next", path return HttpResponseRedirect('%s?%s=%s' % tup) if page.login_required and not page.has_view_permission(request): return HttpResponseForbidden("You don't have the rights to access this resource") 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) return render_to_response(template_name, context)
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 details(request, slug): """ The main view of the Django-CMS! Takes a request and a slug, renders the page. """ from cms.apphook_pool import apphook_pool from cms.appresolver import get_app_urls from cms.utils import get_template_from_request, get_language_from_request from cms.utils.i18n import get_fallback_languages from cms.utils.django_load import load_object from cms.utils.page_resolver import get_page_from_request from cms.views import _handle_no_page from django.conf import settings from django.conf.urls import patterns from django.core.urlresolvers import resolve, Resolver404 from django.http import Http404, HttpResponseRedirect from django.shortcuts import render_to_response from django.template.context import RequestContext from django.utils.http import urlquote # 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.get_languages() # We resolve an alternate language for the page if it's not available. # Since the "old" details view had an exception for the root page, it is # ported here. So no resolution if the slug is ''. if (current_language not in available_languages): if settings.CMS_LANGUAGE_FALLBACK: # If we didn't find the required page in the requested (current) # language, let's try to find a suitable fallback in the list of # fallback languages (CMS_LANGUAGE_CONF) for alt_lang in get_fallback_languages(current_language): if alt_lang in available_languages: alt_url = page.get_absolute_url(language=alt_lang, fallback=True) path = '/%s%s' % (alt_lang, alt_url) # 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) # 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) 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 if page.view_path: view = load_object(page.view_path) args, kwargs = view.extract_args_kwargs(slug) return view(request, *args, **kwargs) # 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.i18n_installed 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%s' % (current_language, request.path), request.path, ] if redirect_url not in own_urls: return HttpResponseRedirect(redirect_url) # permission checks if page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote("/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: 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)
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 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, page_id=None, slug=None, template_name=settings.CMS_TEMPLATES[0][0], no404=False): # get the right model page_queryset = get_page_queryset(request) lang = get_language_from_request(request) site = Site.objects.get_current() if 'preview' in request.GET.keys(): pages = page_queryset.filter(site=site) else: pages = page_queryset.published().filter(site=site) current_page, response = None, None if pages.all_root(): if page_id: current_page = get_object_or_404(pages, pk=page_id) elif slug != None: if slug == "": current_page = pages.get_home() else: pages_root = reverse('pages-root') path = slug.startswith( pages_root) and slug[len(pages_root):] or slug try: home = pages.get_home() current_page, alternative = get_current_page( path, lang, pages, home.get_slug(language=lang), home.tree_id) except NoHomeFound: current_page, alternative = get_current_page( path, lang, pages) if apphook_pool.get_apphooks(): # check if it shouldn't point to some application, if yes, # change current page if required current_page = applications_page_check( request, current_page, path) if not current_page: if alternative and settings.CMS_LANGUAGE_FALLBACK: return HttpResponseRedirect(alternative) if no404: # used for placeholder finder current_page = None else: if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL return "cms/new.html", locals() raise Http404('CMS: Page not found for "%s"' % slug) else: current_page = applications_page_check(request) #current_page = None template_name = get_template_from_request(request, current_page, no_current_page=True) elif not no404: if not slug and settings.DEBUG: CMS_MEDIA_URL = settings.CMS_MEDIA_URL return "cms/new.html", locals() raise Http404("CMS: No page found for site %s" % unicode(site.name)) if current_page: has_change_permissions = current_page.has_change_permission(request) request._current_page_cache = current_page redirect_url = current_page.get_redirect(language=lang) if redirect_url: if settings.i18n_installed and redirect_url[0] == "/": redirect_url = "/%s/%s" % (lang, redirect_url.lstrip("/")) # add language prefix to url return HttpResponseRedirect(redirect_url) if current_page.login_required and not request.user.is_authenticated(): if settings.i18n_installed: path = urlquote( "/%s%s" % (request.LANGUAGE_CODE, request.get_full_path())) else: path = urlquote(request.get_full_path()) tup = django_settings.LOGIN_URL, "next", path return HttpResponseRedirect('%s?%s=%s' % tup) else: has_change_permissions = False return template_name, locals()