Synnefo

from django.contrib.auth import (

    login as auth_login,

    logout as auth_logout)

from django.contrib.auth.models import AnonymousUser

from django.core.exceptions import PermissionDenied

from django.db import IntegrityError

from datetime import datetime

from functools import wraps

from astakos.im.settings import (

    CONTACT_EMAIL, SITENAME, BASEURL, LOGGING_LEVEL,

    VERIFICATION_EMAIL_SUBJECT, ACCOUNT_CREATION_SUBJECT,

    PROJECT_CREATION_SUBJECT, PROJECT_APPROVED_SUBJECT,

    PROJECT_TERMINATION_SUBJECT, PROJECT_SUSPENSION_SUBJECT,

    PROJECT_MEMBERSHIP_CHANGE_SUBJECT,

from astakos.im.notifications import build_notification, NotificationError

from astakos.im.models import (

    AstakosUser, Invitation, ProjectMembership, ProjectApplication, Project,

    application_submit_notify, application_approve_notify,

    application_deny_notify,

    project_termination_notify, project_suspension_notify)

import astakos.im.messages as astakos_messages

from astakos.quotaholder.exception import NoCapacityError

    dictionary = dictionary or {}

    message = render_to_string(template_name, dictionary)

    sender = settings.SERVER_EMAIL

    try:

        send_mail(subject, message, sender, recipient_list,

                  connection=get_connection())

        {'user': user}

    )

    sender = settings.SERVER_EMAIL

    try:

        send_mail(_(HELPDESK_NOTIFICATION_EMAIL_SUBJECT) % {'user': user.email},

                  message, sender, recipient_list, connection=get_connection())

def send_feedback(msg, data, user, email_template_name='im/feedback_mail.txt'):

    subject = _(FEEDBACK_EMAIL_SUBJECT)

    from_email = settings.SERVER_EMAIL

    content = render_to_string(email_template_name, {

        'message': msg,

        'data': data,

            user=user_id, setting=key)

        return setting.value

    except UserSetting.DoesNotExist:

def set_user_setting(user_id, key, value):

IM_MODULES = getattr(settings, 'ASTAKOS_IM_MODULES', ['local'])

# Force user profile verification

#Enable invitations

INVITATIONS_ENABLED = getattr(settings, 'ASTAKOS_INVITATIONS_ENABLED', False)

settings.LOGGING_SETUP['disable_existing_loggers'] = False

im_settings = functools.partial(with_settings, astakos_settings)

shibboleth_settings = functools.partial(with_settings,

                                        prefix=prefixes['shibboleth'])

                                       prefix=prefixes['local'])

class AstakosTestClient(Client):

    pass

class ShibbolethClient(AstakosTestClient):

    """

    A shibboleth agnostic client.

        astakos_settings.IM_MODULES = ['local', 'shibboleth']

        astakos_settings.MODERATION_ENABLED = True

    def test_create_account(self):

        client = ShibbolethClient()

                     'last_name': 'Mitroglou',

                     'provider': 'shibboleth'}

        # invlid email

        post_data['email'] = 'kpap'

        self.assertContains(r, token)

        # existing email

        existing_user = get_local_user('test@test.com')

        post_data['email'] = 'test@test.com'

        self.assertContains(r, messages.EMAIL_USED)

        existing_user.delete()

        # and finally a valid signup

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

        self.assertContains(r, messages.NOTIFICATION_SENT)

        # everything is ok in our db

                          cn="Kostas Papadimitriou", )

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

        self.assertContains(r, 'is pending moderation')

        # admin activates our user

        u = AstakosUser.objects.get(username="kpap@grnet.gr")

        # we can reenable the local provider by setting a password

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

                                                'new_password2': '111'},

                        follow=True)

        user = r.context['request'].user

        form = forms.LocalUserCreationForm(data)

        self.assertFalse(form.is_valid())

    def test_local_provider(self):

        self.helpdesk_email = astakos_settings.HELPDESK[0][1]

        # enable moderation

        self.assertFalse(user.activation_sent)  # activation automatically sent

        # admin gets notified and activates the user from the command line

        self.assertEqual(len(get_mailbox(self.helpdesk_email)), 1)

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

                                           'password': 'password'})

    @shibboleth_settings(AUTOMODERATE_POLICY=True)

    @im_settings(IM_MODULES=['shibboleth', 'local'])

    @im_settings(MODERATION_ENABLED=True)

    def test_user(self):

        Profile = AuthProviderPolicyProfile

        Pending = PendingThirdPartyUser

        User = AstakosUser

        cl_olduser = ShibbolethClient()

        cl_newuser = ShibbolethClient()

        cl_newuser2 = Client()

        academic_group, created = Group.objects.get_or_create(

            name='academic-login')

        academic_users = academic_group.user_set

        self.service = Service.objects.create(name="service1",

                                              api_url="http://service.api")

        self.resource = Resource.objects.create(name="service1.resource",

        self.admin = get_local_user("projects-admin@synnefo.org")

        self.admin.uuid = 'uuid1'

        self.admin.save()

    ExtendedPasswordResetForm,

    ExtendedPasswordChangeForm,

    ExtendedSetPasswordForm, LoginForm)

urlpatterns = patterns(

    'astakos.im.views',

)

    urlpatterns += patterns(

        'astakos.im.views',

        url(r'^email_change/?$', 'change_email', {}, name='email_change'),

        url(r'^email_change/confirm/(?P<activation_key>\w+)/?$', 'change_email', {},

            name='email_change_confirm'))

    urlpatterns += patterns(

        'astakos.im.target',

        url(r'^local/?$', 'local.login'),

        url(r'^local/password/reset/complete/?$', 'password_reset_complete')

    )

    urlpatterns += patterns(

        'astakos.im.views',

        url(r'^invite/?$', 'invite', {}, name='invite'))

    urlpatterns += patterns(

        'astakos.im.target',

        url(r'^login/shibboleth/?$', 'shibboleth.login'),

    )

    urlpatterns += patterns(

        'astakos.im.target',

        url(r'^login/twitter/?$', 'twitter.login'),

        url(r'^login/twitter/authenticated/?$',

            'twitter.authenticated'))

    urlpatterns += patterns(

        'astakos.im.target',

        url(r'^login/google/?$', 'google.login'),

        url(r'^login/google/authenticated/?$',

            'google.authenticated'))

    urlpatterns += patterns(

        'astakos.im.target',

        url(r'^login/linkedin/?$', 'linkedin.login'),

from django.utils.translation import ugettext as _

from astakos.im.models import AstakosUser, Invitation

from astakos.im.functions import login

import astakos.im.messages as astakos_messages

        except ValidationError, e:

            return HttpResponseBadRequest(e)

        params = ''

        if next:

            params = '?' + urlencode({'next': next})

    request.session.set_expiry(user.auth_token_expires)

    if not next:

    response['Location'] = next

    response.status_code = 302