Python models.UserPreference类代码示例

    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')

    def test_user_with_locale_claim(self):
        language = "en"
        UserPreference.set_preference(self.user, LANGUAGE_KEY, language)
        scopes, claims = self.get_id_token_values("openid profile")

        self.assertIn("profile", scopes)

        locale = claims["locale"]
        self.assertEqual(language, locale)

    def setUp(self):
        # Platform language is English, instructor's language is Chinese,
        # student's language is French, so the emails should all be sent in
        # French.
        self.course = CourseFactory.create()
        self.instructor = InstructorFactory(course_key=self.course.id)
        UserPreference.set_preference(self.instructor, LANGUAGE_KEY, 'zh-cn')
        self.client.login(username=self.instructor.username, password='test')

        self.student = UserFactory.create()
        UserPreference.set_preference(self.student, LANGUAGE_KEY, 'fr')

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')

    def test_custom_visibility_over_age(self, api_client, requesting_username):
        self.create_mock_profile(self.user)
        # set user's custom visibility preferences
        set_user_preference(self.user, ACCOUNT_VISIBILITY_PREF_KEY, CUSTOM_VISIBILITY)
        shared_fields = ("bio", "language_proficiencies", "name")
        for field_name in shared_fields:
            set_user_preference(self.user, "visibility.{}".format(field_name), ALL_USERS_VISIBILITY)

        # make API request
        client = self.login_client(api_client, requesting_username)
        response = self.send_get(client)

        # verify response
        if requesting_username == "different_user":
            data = response.data
            self.assertEqual(6, len(data))

            # public fields
            self.assertEqual(self.user.username, data["username"])
            self.assertEqual(UserPreference.get_value(self.user, 'account_privacy'), data["account_privacy"])
            self._verify_profile_image_data(data, has_profile_image=True)

            # custom shared fields
            self.assertEqual(TEST_BIO_VALUE, data["bio"])
            self.assertEqual([{"code": TEST_LANGUAGE_PROFICIENCY_CODE}], data["language_proficiencies"])
            self.assertEqual(self.user.first_name + " " + self.user.last_name, data["name"])
        else:
            self._verify_full_account_response(response)

def get_user_email_language(user):
    """
    Return the language most appropriate for writing emails to user. Returns
    None if the preference has not been set, or if the user does not exist.
    """
    # Calling UserPreference directly instead of get_user_preference because the user requesting the
    # information is not "user" and also may not have is_staff access.
    return UserPreference.get_value(user, LANGUAGE_KEY)

    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))

 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

 def test_discussions_email_digest_pref(self, digest_enabled):
     with mock.patch.dict("student.models.settings.FEATURES", {"ENABLE_DISCUSSION_EMAIL_DIGEST": digest_enabled}):
         response = self.client.post(self.url, self.params)
         self.assertEqual(response.status_code, 200)
         user = User.objects.get(username=self.username)
         preference = UserPreference.get_preference(user, NOTIFICATION_PREF_KEY)
         if digest_enabled:
             self.assertIsNotNone(preference)
         else:
             self.assertIsNone(preference)

    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 _visible_fields_from_custom_preferences(user, configuration):
    """
    Returns all fields that are marked to be shared with other users in the
    given user's preferences. Includes fields that are always public.
    """
    preferences = UserPreference.get_all_preferences(user)
    fields_shared_with_all_users = [
        field_name for field_name in configuration.get('custom_shareable_fields')
        if preferences.get('{}{}'.format(VISIBILITY_PREFIX, field_name)) == 'all_users'
    ]
    return set(fields_shared_with_all_users + configuration.get('public_fields'))

def share_with_facebook_friends(friend):
    """
    Return true if the user's share_with_facebook_friends preference is set to true.
    """

    # Calling UserPreference directly because the requesting user may be different (and not is_staff).
    try:
        existing_user = User.objects.get(username=friend['edX_username'])
    except ObjectDoesNotExist:
        return False

    return UserPreference.get_value(existing_user, 'share_with_facebook_friends') == 'True'

def get_profile_visibility(user_profile, user, configuration=None):
    """Returns the visibility level for the specified user profile."""
    if user_profile.requires_parental_consent():
        return PRIVATE_VISIBILITY

    if not configuration:
        configuration = settings.ACCOUNT_VISIBILITY_CONFIGURATION

    # Calling UserPreference directly because the requesting user may be different from existing_user
    # (and does not have to be is_staff).
    profile_privacy = UserPreference.get_value(user, ACCOUNT_VISIBILITY_PREF_KEY)
    return profile_privacy if profile_privacy else configuration.get('default_visibility')

    def claim_locale(self, data):
        """
        Return the locale for the users based on their preferences.
        Does not return a value if the users have not set their locale preferences.

        """

        language = UserPreference.get_preference(data['user'], LANGUAGE_KEY)

        # If the user has no language specified, return the default one.
        if not language:
            language = getattr(settings, 'LANGUAGE_CODE')

        return language

    def claim_locale(self, data):
        """
        Return the locale for the users based on their preferences.
        Does not return a value if the users have not set their locale preferences.
        """

        # Calling UserPreference directly because it is not clear which user made the request.
        language = UserPreference.get_value(data['user'], LANGUAGE_KEY)

        # If the user has no language specified, return the default one.
        if not language:
            language = settings.LANGUAGE_CODE

        return language