LMS: Adds Language Selection Menu

cms/envs/common.py

@@ -456,8 +456,13 @@
 
     # Dark-launching languages
     'dark_lang',
+
     # Student identity reverification
     'reverification',
+
+    # User preferences
+    'user_api',
+    'django_openid_auth',
 )
 
 

cms/urls.py

@@ -36,6 +36,9 @@
 
     url(r'^xmodule/', include('pipeline_js.urls')),
     url(r'^heartbeat$', include('heartbeat.urls')),
+
+    url(r'^user_api/', include('user_api.urls')),
+    url(r'^lang_pref/', include('lang_pref.urls')),
 )
 
 # User creation and updating views

common/djangoapps/dark_lang/models.py

@@ -19,6 +19,8 @@ class DarkLangConfig(ConfigurationModel):
     def released_languages_list(self):
         """
         ``released_languages`` as a list of language codes.
+
+        Example: ['it', 'de-at', 'es', 'pt-br']
         """
         if not self.released_languages.strip():  # pylint: disable=no-member
             return []

common/djangoapps/lang_pref/__init__.py

@@ -0,0 +1,6 @@
+"""
+Useful information for setting the language preference
+"""
+
+# this is the UserPreference key for the user's preferred language
+LANGUAGE_KEY = 'pref-lang'

common/djangoapps/lang_pref/middleware.py

@@ -0,0 +1,25 @@
+"""
+Middleware for Language Preferences
+"""
+
+from user_api.models import UserPreference
+from lang_pref import LANGUAGE_KEY
+
+
+class LanguagePreferenceMiddleware(object):
+    """
+    Middleware for user preferences.
+
+    Ensures that, once set, a user's preferences are reflected in the page
+    whenever they are logged in.
+    """
+
+    def process_request(self, request):
+        """
+        If a user's UserPreference contains a language preference and there is
+        no language set on the session (i.e. from dark language overrides), use the user's preference.
+        """
+        if request.user.is_authenticated() and 'django_language' not in request.session:
+            user_pref = UserPreference.get_preference(request.user, LANGUAGE_KEY)
+            if user_pref:
+                request.session['django_language'] = user_pref

common/djangoapps/lang_pref/tests/test_middleware.py

@@ -0,0 +1,42 @@
+from django.test import TestCase
+from django.test.client import RequestFactory
+from django.contrib.sessions.middleware import SessionMiddleware
+
+from lang_pref.middleware import LanguagePreferenceMiddleware
+from user_api.models import UserPreference
+from lang_pref import LANGUAGE_KEY
+from student.tests.factories import UserFactory
+
+
+class TestUserPreferenceMiddleware(TestCase):
+    """
+    Tests to make sure user preferences are getting properly set in the middleware
+    """
+
+    def setUp(self):
+        self.middleware = LanguagePreferenceMiddleware()
+        self.session_middleware = SessionMiddleware()
+        self.user = UserFactory.create()
+        self.request = RequestFactory().get('/somewhere')
+        self.request.user = self.user
+        self.session_middleware.process_request(self.request)
+
+    def test_no_language_set_in_session_or_prefs(self):
+        # nothing set in the session or the prefs
+        self.middleware.process_request(self.request)
+        self.assertNotIn('django_language', self.request.session)
+
+    def test_language_in_user_prefs(self):
+        # language set in the user preferences and not the session
+        UserPreference.set_preference(self.user, LANGUAGE_KEY, 'eo')
+        self.middleware.process_request(self.request)
+        self.assertEquals(self.request.session['django_language'], 'eo')
+
+    def test_language_in_session(self):
+        # language set in both the user preferences and session,
+        # session should get precedence
+        self.request.session['django_language'] = 'en'
+        UserPreference.set_preference(self.user, LANGUAGE_KEY, 'eo')
+        self.middleware.process_request(self.request)
+
+        self.assertEquals(self.request.session['django_language'], 'en')

common/djangoapps/lang_pref/tests/test_views.py

@@ -0,0 +1,34 @@
+"""
+Tests for the language setting view
+"""
+from django.core.urlresolvers import reverse
+from django.test import TestCase
+from student.tests.factories import UserFactory
+from user_api.models import UserPreference
+from lang_pref import LANGUAGE_KEY
+
+
+class TestLanguageSetting(TestCase):
+    """
+    Test setting languages
+    """
+    def test_set_preference_happy(self):
+        user = UserFactory.create()
+        self.client.login(username=user.username, password='test')
+
+        lang = 'en'
+        response = self.client.post(reverse('lang_pref_set_language'), {'language': lang})
+
+        self.assertEquals(response.status_code, 200)
+        user_pref = UserPreference.get_preference(user, LANGUAGE_KEY)
+        self.assertEqual(user_pref, lang)
+
+    def test_set_preference_missing_lang(self):
+        user = UserFactory.create()
+        self.client.login(username=user.username, password='test')
+
+        response = self.client.post(reverse('lang_pref_set_language'))
+
+        self.assertEquals(response.status_code, 400)
+
+        self.assertIsNone(UserPreference.get_preference(user, LANGUAGE_KEY))

common/djangoapps/lang_pref/urls.py

@@ -0,0 +1,10 @@
+"""
+Urls for managing language preferences
+"""
+
+from django.conf.urls import patterns, url
+
+urlpatterns = patterns(
+    '',
+    url(r'^setlang/', 'lang_pref.views.set_language', name='lang_pref_set_language')
+)

common/djangoapps/lang_pref/views.py

@@ -0,0 +1,23 @@
+"""
+Views for accessing language preferences
+"""
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse, HttpResponseBadRequest
+
+from user_api.models import UserPreference
+from lang_pref import LANGUAGE_KEY
+
+
+@login_required
+def set_language(request):
+    """
+    This view is called when the user would like to set a language preference
+    """
+    user = request.user
+    lang_pref = request.POST.get('language', None)
+
+    if lang_pref:
+        UserPreference.set_preference(user, LANGUAGE_KEY, lang_pref)
+        return HttpResponse('{"success": true}')
+
+    return HttpResponseBadRequest('no language provided')

common/djangoapps/student/views.py

@@ -45,6 +45,7 @@
 
 from verify_student.models import SoftwareSecurePhotoVerification, MidcourseReverificationWindow
 from certificates.models import CertificateStatuses, certificate_status_for_student
+from dark_lang.models import DarkLangConfig
 
 from xmodule.course_module import CourseDescriptor
 from xmodule.modulestore.exceptions import ItemNotFoundError
@@ -61,6 +62,8 @@
 
 from bulk_email.models import Optout, CourseAuthorization
 import shoppingcart
+from user_api.models import UserPreference
+from lang_pref import LANGUAGE_KEY
 
 import track.views
 
@@ -468,23 +471,42 @@ def dashboard(request):
     # we'll display the banner
     denied_banner = any(item.display for item in reverifications["denied"])
 
-    context = {'course_enrollment_pairs': course_enrollment_pairs,
-               'course_optouts': course_optouts,
-               'message': message,
-               'external_auth_map': external_auth_map,
-               'staff_access': staff_access,
-               'errored_courses': errored_courses,
-               'show_courseware_links_for': show_courseware_links_for,
-               'all_course_modes': course_modes,
-               'cert_statuses': cert_statuses,
-               'show_email_settings_for': show_email_settings_for,
-               'reverifications': reverifications,
-               'verification_status': verification_status,
-               'verification_msg': verification_msg,
-               'show_refund_option_for': show_refund_option_for,
-               'denied_banner': denied_banner,
-               'billing_email': settings.PAYMENT_SUPPORT_EMAIL,
-               }
+    language_options = DarkLangConfig.current().released_languages_list
+
+    # add in the default language if it's not in the list of released languages
+    if settings.LANGUAGE_CODE not in language_options:
+        language_options.append(settings.LANGUAGE_CODE)
+
+    # try to get the prefered language for the user
+    cur_lang_code = UserPreference.get_preference(request.user, LANGUAGE_KEY)
+    if cur_lang_code:
+        # if the user has a preference, get the name from the code
+        current_language = settings.LANGUAGE_DICT[cur_lang_code]
+    else:
+        # if the user doesn't have a preference, use the default language
+        current_language = settings.LANGUAGE_DICT[settings.LANGUAGE_CODE]
+
+    context = {
+        'course_enrollment_pairs': course_enrollment_pairs,
+        'course_optouts': course_optouts,
+        'message': message,
+        'external_auth_map': external_auth_map,
+        'staff_access': staff_access,
+        'errored_courses': errored_courses,
+        'show_courseware_links_for': show_courseware_links_for,
+        'all_course_modes': course_modes,
+        'cert_statuses': cert_statuses,
+        'show_email_settings_for': show_email_settings_for,
+        'reverifications': reverifications,
+        'verification_status': verification_status,
+        'verification_msg': verification_msg,
+        'show_refund_option_for': show_refund_option_for,
+        'denied_banner': denied_banner,
+        'billing_email': settings.PAYMENT_SUPPORT_EMAIL,
+        'language_options': language_options,
+        'current_language': current_language,
+        'current_language_code': cur_lang_code,
+    }
 
     return render_to_response('dashboard.html', context)
 

common/djangoapps/user_api/models.py

@@ -0,0 +1,35 @@
+from django.contrib.auth.models import User
+from django.db import models
+
+
+class UserPreference(models.Model):
+    """A user's preference, stored as generic text to be processed by client"""
+    user = models.ForeignKey(User, db_index=True, related_name="+")
+    key = models.CharField(max_length=255, db_index=True)
+    value = models.TextField()
+
+    class Meta:
+        unique_together = ("user", "key")
+
+    @classmethod
+    def set_preference(cls, user, preference_key, preference_value):
+        """
+        Sets the user preference for a given key
+        """
+        user_pref, _ = cls.objects.get_or_create(user=user, key=preference_key)
+        user_pref.value = preference_value
+        user_pref.save()
+
+    @classmethod
+    def get_preference(cls, user, preference_key, default=None):
+        """
+        Gets the user preference value for a given key
+
+        Returns the given default if there isn't a preference for the given key
+        """
+
+        try:
+            user_pref = cls.objects.get(user=user, key=preference_key)
+            return user_pref.value
+        except cls.DoesNotExist:
+            return default

lms/djangoapps/user_api/tests/test_models.py → common/djangoapps/user_api/tests/test_models.py

@@ -2,6 +2,7 @@
 from django.test import TestCase
 from student.tests.factories import UserFactory
 from user_api.tests.factories import UserPreferenceFactory
+from user_api.models import UserPreference
 
 
 class UserPreferenceModelTest(TestCase):
@@ -26,3 +27,21 @@ def test_arbitrary_values(self):
             key="testkey3",
             value="\xe8\xbf\x99\xe6\x98\xaf\xe4\xb8\xad\xe5\x9b\xbd\xe6\x96\x87\xe5\xad\x97'"
         )
+
+    def test_get_set_preference(self):
+        # Checks that you can set a preference and get that preference later
+        # Also, tests that no preference is returned for keys that are not set
+
+        user = UserFactory.create()
+        key = 'testkey'
+        value = 'testvalue'
+
+        # does a round trip
+        UserPreference.set_preference(user, key, value)
+        pref = UserPreference.get_preference(user, key)
+
+        self.assertEqual(pref, value)
+
+        # get preference for key that doesn't exist for user
+        pref = UserPreference.get_preference(user, 'testkey_none')
+        self.assertIsNone(pref)