Synnefo » astakos

    """

    def authenticate(self, email=None, auth_token=None):

        try:

        except AstakosUser.DoesNotExist:

            return None

        else:

    """

    def authenticate(self, username=None, password=None):

        # First check whether a user having this email exists

            if  user.check_password(password):

                return user

        except AstakosUser.DoesNotExist:

            return None

        if user.check_password(password):

            return user

        else:

)

class StoreUserMixin(object):

    @transaction.commit_on_success

    def store_user(self, user, request):

        user.save()

                mark_safe("I agree with %s" % terms_link_html)

    def clean_email(self):

        if not email:

            raise forms.ValidationError(_(astakos_messages.REQUIRED_FIELD))

        if reserved_email(email):

                    mark_safe("I agree with %s" % terms_link_html)

    def clean_email(self):

        if not email:

            raise forms.ValidationError(_(astakos_messages.REQUIRED_FIELD))

        if reserved_email(email):

        username = self.cleaned_data.get('username')

        try:

            if not user.has_auth_provider('local'):

                provider = auth_providers.get_provider('local')

                raise forms.ValidationError(

    def get_by_email(self, email):

        return self.get(email=email)

class AstakosUser(User):

    """

    Extends ``django.contrib.auth.models.User`` by defining additional fields.

        if not self.id:

            # set username

        self.validate_unique_email_isactive()

from astakos.im.models import *

from astakos.im import functions

from astakos.im import settings as astakos_settings

from urllib import quote

        astakos_settings.SHIBBOLETH_REQUIRE_NAME_INFO = False

        # shibboleth logged us in

                          ep_affiliation="Test Affiliation")

        r = client.get('/im/login/shibboleth?')

        self.assertEqual(r.status_code, 200)

        # and finally a valid signup

        post_data['email'] = 'kpap@grnet.gr'

        # everything is ok in our db

        self.assertEqual(AstakosUser.objects.count(), 1)

        provider = AstakosUserAuthProvider.objects.get(module="shibboleth")

        self.assertEqual(provider.affiliation, 'Test Affiliation')

        self.assertEqual(provider.info, {u'email': u'kpap@grnet.gr',

        # lets login (not activated yet)

        r = client.get("/im/login/shibboleth?", follow=True)

        self.assertContains(r, messages.ACCOUNT_PENDING_MODERATION)

        r = client.get("/im/profile", follow=True)

        client = ShibbolethClient()

        # shibboleth logged us in, notice that we use different email

        r = client.get("/im/login/shibboleth?")

        # astakos asks if we want to switch a local account to shibboleth

                     'key': pending_key}

        r = client.post('/im/local', post_data, follow=True)

        self.assertRedirects(r, "/im/profile")

        self.assertTrue(existing_user.has_auth_provider('shibboleth'))

        self.assertTrue(existing_user.has_auth_provider('local',

        client.logout()

        # look Ma, i can login with both my shibboleth and local account

        r = client.get("/im/login/shibboleth?", follow=True)

        self.assertTrue(r.context['request'].user.is_authenticated())

        self.assertTrue(r.context['request'].user.email == "kpap@grnet.gr")

        self.assertEqual(r.status_code, 200)

        # cannot add the same eppn

        r = client.get("/im/login/shibboleth?", follow=True)

        self.assertRedirects(r, '/im/profile')

        self.assertTrue(r.status_code, 200)

        # but can add additional eppn

        client.set_tokens(mail="secondary@shibboleth.gr", eppn="kpapeppn2",

        r = client.get("/im/login/shibboleth?", follow=True)

        new_provider = existing_user.auth_providers.get(identifier="kpapeppn2")

        self.assertRedirects(r, '/im/profile')

        client.reset_tokens()

        # cannot login with another eppn

        r = client.get("/im/login/shibboleth?", follow=True)

        self.assertFalse(r.context['request'].user.is_authenticated())

                                                         identifier='kpapeppn')

        remove_shibbo2_url = user.get_provider_remove_url('shibboleth',

                                                         identifier='kpapeppn2')

        r = client.get("/im/login/shibboleth?", follow=True)

        client.reset_tokens()

        user2 = get_local_user('another@grnet.gr')

        user2.add_auth_provider('shibboleth', identifier='existingeppn')

        # login

        r = client.get("/im/login/shibboleth?", follow=True)

        # try to assign existing shibboleth identifier of another user

        r = client.get("/im/login/shibboleth?", follow=True)

class LocalUserTests(TestCase):

        self.assertEqual(len(get_mailbox('kpap@grnet.gr')), 1)

        astakos_settings.MODERATION_ENABLED = True

    def test_local_provider(self):

        # enable moderation

        astakos_settings.MODERATION_ENABLED = True

        self.assertContains(r, "doesn't have an associated user account")

        r = self.client.post('/im/local', {'username': 'kpap@grnet.gr',

                                                 'password': 'password'})

        self.assertContains(r, messages.ACCOUNT_PENDING_ACTIVATION)

        self.assertContains(r, 'Resend activation')

        self.assertFalse(r.context['request'].user.is_authenticated())

    """

    Return url if having the supplied ``domain`` (if present) or one of the ``allowed_schemes``.

    Otherwise return None.

    >>> print restrict_next('/im/feedback', '.okeanos.grnet.gr')

    /im/feedback

    >>> print restrict_next('pithos.okeanos.grnet.gr/im/feedback', '.okeanos.grnet.gr')

        try:

            user.save()

        except ValidationError, e:

    next = restrict_next(next, domain=COOKIE_DOMAIN)

    if FORCE_PROFILE_UPDATE and not user.is_verified and not user.is_superuser:

        params = ''

        if next:

    if not next:

        next = reverse('astakos.im.views.index')

    response['Location'] = next

    response.status_code = 302

    return response

def reserved_email(email):

def get_query(request):