Merge pull request django-cms#2212 from czpython/fixes-2205

Fixes 2205

Author: digi604

cms/tests/views.py

@@ -1,13 +1,15 @@
 from __future__ import with_statement
 import re
 
-from django.contrib.auth.models import Permission
-from cms.api import create_page
+from cms.api import create_page, create_title
 from cms.apphook_pool import apphook_pool
 from cms.models import PagePermission
 from cms.test_utils.testcases import SettingsOverrideTestCase
 from cms.test_utils.util.context_managers import SettingsOverride
 from cms.views import _handle_no_page, details
+from cms.utils.i18n import force_language
+
+from django.contrib.auth.models import Permission
 from django.conf import settings
 from django.core.urlresolvers import clear_url_caches
 from django.http import Http404, HttpResponse
@@ -39,6 +41,20 @@ def test_handle_no_page(self):
             response = _handle_no_page(request, slug)
             self.assertEqual(response.status_code, 200)
 
+    def test_incorrect_slug_for_language(self):
+        """
+        Test details view when page slug and current language don't match.
+        In this case we refer to the user's current language and the page slug we have for that language.
+        """
+        create_page("home", "nav_playground.html", "en", published=True)
+        cms_page = create_page("stevejobs", "nav_playground.html", "en", published=True)
+        create_title("de", "jobs", cms_page)
+        cms_page.publish()
+        with force_language("de"):
+            response = self.client.get('/de/stevejobs/')
+            self.assertEqual(response.status_code, 302)
+            self.assertRedirects(response, '/de/jobs/')
+
     def test_apphook_not_hooked(self):
         """
         Test details view when apphook pool has apphooks, but they're not

cms/utils/i18n.py

@@ -33,6 +33,19 @@ def get_languages(site_id=None):
     return result
 
 
+def get_languages_for_user(user):
+    if user and user.is_staff:
+        languages = get_language_list()
+    else:
+        languages = get_public_languages()
+    return languages
+
+
+def get_languages_for_page_user(page, user=None):
+    page_languages = page.get_languages()
+    return [language for language in get_languages_for_user(user) if language in page_languages]
+
+
 def get_language_code(language_code):
     """
     Returns language code while making sure it's in LANGUAGES

cms/utils/page_resolver.py

@@ -13,6 +13,7 @@
 from cms.exceptions import NoHomeFound
 from cms.models.pagemodel import Page
 from cms.utils.urlutils import any_path_re
+from cms.utils.i18n import force_language, get_languages_for_page_user, get_fallback_languages
 
 ADMIN_PAGE_RE_PATTERN = ur'cms/page/(\d+)'
 ADMIN_PAGE_RE = re.compile(ADMIN_PAGE_RE_PATTERN)
@@ -36,6 +37,12 @@ def get_page_queryset(request=None):
     return Page.objects.public()
 
 
+def get_fallback_languages_for_page(page, current_language, current_user=None, allowed_languages=None):
+    if allowed_languages is None:
+        allowed_languages = get_languages_for_page_user(page=page, user=current_user)
+    return [language for language in get_fallback_languages(current_language) if language in allowed_languages]
+
+
 def get_page_queryset_from_path(path, preview=False, draft=False, site=None):
     """ Returns a queryset of pages corresponding to the path given
     In may returns None or a single page is no page is present or root path is given

cms/views.py

@@ -4,9 +4,17 @@
 from cms.appresolver import get_app_urls
 from cms.models import Title
 from cms.utils import get_template_from_request, get_language_from_request
-from cms.utils.i18n import get_fallback_languages, force_language, get_public_languages, get_redirect_on_fallback, get_language_list, is_language_prefix_patterns_used
-from cms.utils.page_resolver import get_page_from_request
+from cms.utils.i18n import (
+    force_language,
+    get_public_languages,
+    get_languages_for_page_user,
+    get_languages_for_user,
+    get_redirect_on_fallback,
+    is_language_prefix_patterns_used,
+)
+from cms.utils.page_resolver import get_fallback_languages_for_page, get_page_from_request
 from cms.test_utils.util.context_managers import SettingsOverride
+
 from django.conf import settings
 from django.conf.urls.defaults import patterns
 from django.core.urlresolvers import resolve, Resolver404, reverse
@@ -16,6 +24,7 @@
 from django.contrib.auth.views import redirect_to_login
 from django.utils.http import urlquote
 
+
 def _handle_no_page(request, slug):
     if not slug and settings.DEBUG:
         return render_to_response("cms/new.html", RequestContext(request))
@@ -31,64 +40,58 @@ def details(request, slug):
     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)
+
+    # 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 language is in FRONTEND_LANGUAGES:
-    if not current_language in user_languages:
+
+    # 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:
+        if not slug and available_languages:
             #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)
+            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:
-        # 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:
+        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
-            _handle_no_page(request, slug)
+            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
@@ -134,13 +137,15 @@ def details(request, slug):
         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 
+
+    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'] = page.has_view_permission(request)
+    context['has_view_permissions'] = has_view_permissions
 
-    if not context['has_view_permissions']:
+    if not has_view_permissions:
         return _handle_no_page(request, slug)
-
     return render_to_response(template_name, context_instance=context)