Synnefo

# Copyright (c) Django Software Foundation and individual contributors.

# All rights reserved.

# Redistribution and use in source and binary forms, with or without modification,

# are permitted provided that the following conditions are met:

#        this list of conditions and the following disclaimer.

#        notice, this list of conditions and the following disclaimer in the

#        documentation and/or other materials provided with the distribution.

#     3. Neither the name of Django nor the names of its contributors may be used

#        to endorse or promote products derived from this software without

#        specific prior written permission.

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

VERSION = (0, 3, 0, 'alpha', 0)

def get_version():

    version = '%s.%s' % (VERSION[0], VERSION[1])

    if VERSION[2]:

logger = logging.getLogger(__name__)

def get_backend(request):

    """

    Returns an instance of an activation backend,

    """

    module = 'astakos.im.activation_backends'

    prefix = 'Invitations' if INVITATIONS_ENABLED else 'Simple'

    try:

        mod = import_module(module)

    except ImportError, e:

    try:

        backend_class = getattr(mod, backend_class_name)

    except AttributeError:

        raise ImproperlyConfigured('Module "%s" does not define a activation backend named "%s"' % (module, backend_class_name))

    return backend_class(request)

class ActivationBackend(object):

    def __init__(self, request):

        self.request = request

    def _is_preaccepted(self, user):

        # return True if user email matches specific patterns

        for pattern in RE_USER_EMAIL_PATTERNS:

            if re.match(pattern, user.email):

                return True

        return False

    def get_signup_form(self, provider='local', instance=None):

        """

        Returns a form instance of the relevant class

        """

        main = provider.capitalize() if provider == 'local' else 'ThirdParty'

        formclass = '%s%s' % (main, suffix)

        request = self.request

        initial_data = None

            if provider == request.POST.get('provider', ''):

                initial_data = request.POST

        return globals()[formclass](initial_data, instance=instance, request=request)

                          switch_accounts_email_template_name='im/switch_accounts_email.txt'):

        """

        If the user is already active returns immediately.

            if user.conflicting_email():

                send_verification(user, switch_accounts_email_template_name)

                return SwitchAccountsVerificationSent(user.email)

            if self._is_preaccepted(user):

                if user.email_verified:

                    activate(user, greeting_template_name)

            else:

                send_admin_notification(

                    template_name=admin_email_template_name,

                    subject='%s alpha2 testing account notification' % SITENAME

                )

                return NotificationSent()

            logger.exception(e)

            raise e

class InvitationsBackend(ActivationBackend):

    """

    A activation backend which implements the following workflow: a user

    def get_signup_form(self, provider='local', instance=None):

        """

        Returns a form instance of the relevant class

        raises Invitation.DoesNotExist and ValueError if invitation is consumed

        or invitation username is reserved.

        """

        initial_data = self.get_signup_initial_data(provider)

        prefix = 'Invited' if invitation else ''

        main = provider.capitalize()

        formclass = '%s%s%s' % (prefix, main, suffix)

        return globals()[formclass](initial_data, instance=instance, request=self.request)

            if invitation:

                # create a tmp user with the invitation realname

                # to extract first and last name

        else:

            if provider == request.POST.get('provider', ''):

                initial_data = request.POST

            return True

        return False

class SimpleBackend(ActivationBackend):

    """

    A activation backend which implements the following workflow: a user

            return False

        return True

class ActivationResult(object):

    def __init__(self, message):

        self.message = message

class VerificationSent(ActivationResult):

    def __init__(self):

        message = _('Verification sent.')

        super(VerificationSent, self).__init__(message)

class SwitchAccountsVerificationSent(ActivationResult):

    def __init__(self, email):

        message = _('This email is already associated with another \

                    to %s. Otherwise just ignore it.' % email)

        super(SwitchAccountsVerificationSent, self).__init__(message)

class NotificationSent(ActivationResult):

    def __init__(self):

        message = _('Your request for an account was successfully received and is now pending \

                    your interest in ~okeanos! The GRNET team.')

        super(NotificationSent, self).__init__(message)

class RegistationCompleted(ActivationResult):

    def __init__(self):

        message = _('Registration completed. You can now login.')

absolute = lambda request, url: request.build_absolute_uri(url)

def render_fault(request, fault):

    if isinstance(fault, InternalServerError) and settings.DEBUG:

        fault.details = format_exc(fault)

    response['Content-Length'] = len(response.content)

    return response

def api_method(http_method=None):

    """Decorator function for views that implement an API method."""

    def decorator(func):

        return wrapper

    return decorator

def _get_user_by_username(user_id):

    try:

    except AstakosUser.DoesNotExist:

        raise ItemNotFound('Invalid userid')

    else:

        response = HttpResponse()

        response.content = json.dumps(user_info)

        response['Content-Type'] = 'application/json; charset=UTF-8'

        response['Content-Length'] = len(response.content)

        return response

def _get_user_by_email(email):

    if not email:

        raise BadRequest('Email missing')

    try:

    except AstakosUser.DoesNotExist:

        raise ItemNotFound('Invalid email')

    if not user.is_active:

        raise ItemNotFound('Inactive user')

    else:

        response = HttpResponse()

        response.content = json.dumps(user_info)

        response['Content-Type'] = 'application/json; charset=UTF-8'

        response['Content-Length'] = len(response.content)

        return response

@api_method(http_method='GET')

def get_services(request):

    callback = request.GET.get('callback', None)

    services = Service.objects.all()

    data = json.dumps(data)

    mimetype = 'application/json'

    return HttpResponse(content=data, mimetype=mimetype)

@api_method()

def get_menu(request, with_extra_links=False, with_signout=True):

    user = request.user

            pass

    if not isinstance(user, AstakosUser):

        index_url = reverse('index')

    else:

        l = []

        append = l.append

                        ),

                        item(

                            url=absolute(request,

                            name="Create"

                        ),

                        item(

                    name="Sign out"

                )

            )

    callback = request.GET.get('callback', None)

    data = json.dumps(tuple(l))

    mimetype = 'application/json'

    return HttpResponse(content=data, mimetype=mimetype)

class MenuItem(dict):

    current_path = ''

    def __init__(self, *args, **kwargs):

        super(MenuItem, self).__init__(*args, **kwargs)

        if kwargs.get('url') or kwargs.get('submenu'):

            self.__set_is_active__()

    def __setitem__(self, key, value):

        super(MenuItem, self).__setitem__(key, value)

        if key in ('url', 'submenu'):

            self.__set_is_active__()

    def __set_is_active__(self):

        if self.get('is_active'):

            return

                self.__setitem__('is_active', True)

            except StopIteration:

                return

    def __setattribute__(self, name, value):

        super(MenuItem, self).__setattribute__(name, value)

        if name == 'current_path':

from django.http import HttpResponse

from django.utils import simplejson as json

    Forbidden)

from astakos.im.api import render_fault, _get_user_by_email, _get_user_by_username

from astakos.im.models import AstakosUser

logger = logging.getLogger(__name__)

format = ('%a, %d %b %Y %H:%M:%S GMT')

def api_method(http_method=None, token_required=False, perms=None):

    """Decorator function for views that implement an API method."""

    if not perms:

        return wrapper

    return decorator

@api_method(http_method='GET', token_required=True)

def authenticate_old(request, user=None):

    # Normal Response Codes: 204

        raise Unauthorized('Pending approval terms')

    response = HttpResponse()

    response.content = json.dumps(user_info)

    response['Content-Type'] = 'application/json; charset=UTF-8'

    response['Content-Length'] = len(response.content)

    return response

@api_method(http_method='GET', token_required=True)

def authenticate(request, user=None):

    # Normal Response Codes: 204

        raise Unauthorized('Pending approval terms')

    response = HttpResponse()

    response.content = json.dumps(user_info)

    response['Content-Type'] = 'application/json; charset=UTF-8'

    response['Content-Length'] = len(response.content)

    return response

@api_method(http_method='GET', token_required=True, perms=['im.can_access_userinfo'])

def get_user_by_email(request, user=None):

    # Normal Response Codes: 200

    email = request.GET.get('name')

    return _get_user_by_email(email)

@api_method(http_method='GET', token_required=True, perms=['im.can_access_userinfo'])

def get_user_by_username(request, user_id, user=None):

    # Normal Response Codes: 200

# Copyright 2011-2012 GRNET S.A. All rights reserved.

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

def camelCase(s):

    return s[0].lower() + s[1:]

class Fault(Exception):

    def __init__(self, message='', details='', name=''):

        Exception.__init__(self, message, details, name)

        self.details = details

        self.name = name or camelCase(self.__class__.__name__)

class BadRequest(Fault):

    code = 400

class Unauthorized(Fault):

    code = 401

class InternalServerError(Fault):

    code = 500

class Forbidden(Fault):

    code = 403

class ItemNotFound(Fault):

logger = logging.getLogger(__name__)

def api_method(http_method=None, token_required=False):

    """Decorator function for views that implement an API method."""

    def decorator(func):

                        raise Unauthorized('Access denied')

                    try:

                        service = Service.objects.get(auth_token=x_auth_token)

                        # Check if the token has expired.

                        if (time() - mktime(service.auth_token_expires.timetuple())) > 0:

                            raise Unauthorized('Authentication expired')

        return wrapper

    return decorator

@api_method(http_method='GET', token_required=True)

def get_user_by_email(request, user=None):

    # Normal Response Codes: 200

    email = request.GET.get('name')

    return _get_user_by_email(email)

@api_method(http_method='GET', token_required=True)

def get_user_by_username(request, user_id, user=None):

    # Normal Response Codes: 200

    #                       itemNotFound (404)

    return _get_user_by_username(user_id)

@csrf_exempt

@api_method(http_method='POST', token_required=True)

def send_feedback(request, email_template_name='im/feedback_mail.txt'):

    auth_token = request.POST.get('auth', '')

    if not auth_token:

        raise BadRequest('Missing user authentication')

    try:

        user = AstakosUser.objects.get(auth_token=auth_token)

    except:

        pass

    if not user:

        raise BadRequest('Invalid user authentication')

    form = FeedbackForm(request.POST)

    if not form.is_valid():

        raise BadRequest('Invalid data')

    msg = form.cleaned_data['feedback_msg']

    data = form.cleaned_data['feedback_data']

    send_feedback_func(msg, data, user, email_template_name)

    response = HttpResponse(status=200)

    response['Content-Length'] = len(response.content)

from astakos.im.models import AstakosUser

class TokenBackend(ModelBackend):

    """

    AuthenticationBackend used to authenticate using token instead

        except AstakosUser.DoesNotExist:

            return None

class EmailBackend(ModelBackend):

    """

    If the ``username`` parameter is actually an email uses email to authenticate

    the user else tries the username.

    Used from ``astakos.im.forms.LoginForm`` to authenticate.

    """

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

                return None

        if user.check_password(password):

            return user

    def get_user(self, user_id):

        try:

            return AstakosUser.objects.get(pk=user_id)

        except AstakosUser.DoesNotExist:

# or implied, of GRNET S.A.

from astakos.im.settings import IM_MODULES, INVITATIONS_ENABLED, IM_STATIC_URL, \

from astakos.im.api import get_menu

from astakos.im.util import get_query

from astakos.im.models import GroupKind

from django.utils import simplejson as json

def im_modules(request):

    return {'im_modules': IM_MODULES}

def next(request):

def code(request):

def invitations(request):

def media(request):

def custom_messages(request):

    return {

def menu(request):

    try:

    except Exception, e:

        return {}

    else:

def group_kinds(request):

            name='default'

from astakos.im.settings import AQUARIUM_URL

class AquariumClient():

    def get_billing(self, user, start, end):

        if not AQUARIUM_URL:

            return

        url = AQUARIUM_URL.rstrip('/')

        url = '%s/%s/bill/%d/%d' % (url, user, start, end)

        r = requests.get(url)

            return r.status_code, json.loads(r.text)

        except ValueError:

            pass

from astakos.im.models import AstakosUser

def on_creditevent(msg):

    """

    Queue handler for updating AstakosUser has_credits

        user.has_credits = has_credits

        user.save()

    except BaseException, e:

if QUEUE_CONNECTION:

    from synnefo.lib.queue import (exchange_connect, exchange_send,

INSTANCE_ID = '1'

RESOURCE = 'addcredits'

DEFAULT_CREDITS = 1000

logging.basicConfig(format='%(asctime)s [%(levelname)s] %(name)s %(message)s',

logger = logging.getLogger('endpoint.aquarium')

def wrapper(func):

    @wraps(func)

    def wrapper(*args, **kwargs):

        if not QUEUE_CONNECTION:

            return

        try:

            body, key = func(*args, **kwargs)

            conn = exchange_connect(QUEUE_CONNECTION)

            logger.exception(e)

    return wrapper

@wrapper

def report_user_event(user, create=False):

    eventType = 'create' if not create else 'modify'

    body = UserEvent(QUEUE_CLIENT_ID, user.email, user.is_active, eventType, {}

    routing_key = '%s.user'

    return body, routing_key

@wrapper

def report_user_credits_event(user):

    body = Receipt(QUEUE_CLIENT_ID, user.email, INSTANCE_ID, RESOURCE,

    routing_key = '%s.resource'

    return body, routing_key

def report_credits_event():

    # better approach?

    from astakos.im.models import AstakosUser

# Copyright 2011-2012 GRNET S.A. All rights reserved.

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

logger = logging.getLogger(__name__)

def register_users(users, client=None):

    if not users:

        return

    if not QUOTA_HOLDER_URL:

        return

    c = client or QuotaholderHTTP(QUOTA_HOLDER_URL)

    data = []

    append = data.append

            entity = user.email

        except AttributeError:

            continue

            args = entity, owner, key, ownerkey = (

                entity, 'system', ENTITY_KEY, ''

            )

            append(args)

    if not data:

        return

    rejected = c.create_entity(

        context={},

        create_entity=data,

    )

    msg = _('Create entities: %s - Rejected: %s' % (data, rejected,))

    logger.log(LOGGING_LEVEL, msg)

    created = filter(lambda u: unicode(u.email) not in rejected, users)

    send_quota(created, c)

    return rejected

def send_quota(users, client=None):

    if not users:

        return

    if not QUOTA_HOLDER_URL:

        return

    c = client or QuotaholderHTTP(QUOTA_HOLDER_URL)

    data = []

    append = data.append

            continue

        else:

            for resource, limit in user.quota.iteritems():

                        entity, resource, ENTITY_KEY, '0', str(limit), 0, 0, 0

                append(args)

    if not data:

        return

    rejected = c.set_quota(context={}, set_quota=data)

    msg = _('Set quota: %s - Rejected: %s' % (data, rejected,))

    logger.log(LOGGING_LEVEL, msg)

    return rejected

def get_quota(users, client=None):

    if not users:

        return

    if not QUOTA_HOLDER_URL:

        return

    c = client or QuotaholderHTTP(QUOTA_HOLDER_URL)

    data = []

    append = data.append

            for r in user.quota.keys():

                args = entity, resource, key = entity, r, ENTITY_KEY

                append(args)

    if not data:

        return

    r = c.get_quota(context={}, get_quota=data)

    msg = _('Get quota: %s' % data)

    logger.log(LOGGING_LEVEL, msg)

from django import forms

from django.utils.translation import ugettext as _

from django.contrib.auth.forms import (UserCreationForm, AuthenticationForm,

from django.core.mail import send_mail

from django.contrib.auth.tokens import default_token_generator

from django.template import Context, loader

from django.forms.extras.widgets import SelectDateWidget

from django.conf import settings

    Membership, GroupKind, get_latest_terms

)

from astakos.im.settings import (INVITATIONS_PER_LEVEL, BASEURL, SITENAME,

from astakos.im.widgets import DummyWidget, RecaptchaWidget

from astakos.im.functions import send_change_email

logger = logging.getLogger(__name__)

class LocalUserCreationForm(UserCreationForm):

    """

    Extends the built in UserCreationForm in several ways:

    * User created is not active.

    """

    recaptcha_challenge_field = forms.CharField(widget=DummyWidget)

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        """

            kwargs.pop('request')

            self.ip = request.META.get('REMOTE_ADDR',

                                       request.META.get('HTTP_X_REAL_IP', None))

        super(LocalUserCreationForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder = ['email', 'first_name', 'last_name',

                                'password1', 'password2']

        if RECAPTCHA_ENABLED:

            self.fields.keyOrder.extend(['recaptcha_challenge_field',

        if get_latest_terms():

            self.fields.keyOrder.append('has_signed_terms')

        if 'has_signed_terms' in self.fields:

            # Overriding field label since we need to apply a link

            # to the terms within the label

            terms_link_html = '<a href="%s" target="_blank">%s</a>' \

            self.fields['has_signed_terms'].label = \

    def clean_email(self):

        email = self.cleaned_data['email']

        rrf = self.cleaned_data['recaptcha_response_field']

        check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)

        if not check.is_valid:

    def save(self, commit=True):

        """

            logger.log(LOGGING_LEVEL, 'Created user %s' % user.email)

        return user

class InvitedLocalUserCreationForm(LocalUserCreationForm):

    """

    Extends the LocalUserCreationForm: email is readonly.

        ro = ('email', 'username',)

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

    def save(self, commit=True):

        user = super(InvitedLocalUserCreationForm, self).save(commit=False)

            user.save()

        return user

class ThirdPartyUserCreationForm(forms.ModelForm):

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        """

        Changes the order of fields, and removes the username field.

        if self.request:

            kwargs.pop('request')

        super(ThirdPartyUserCreationForm, self).__init__(*args, **kwargs)

        if get_latest_terms():

            self.fields.keyOrder.append('has_signed_terms')

        #set readonly form fields

        ro = ["third_party_identifier"]

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

        if 'has_signed_terms' in self.fields:

            # Overriding field label since we need to apply a link

            # to the terms within the label

            terms_link_html = '<a href="%s" target="_blank">%s</a>' \

            self.fields['has_signed_terms'].label = \

    def clean_email(self):

        email = self.cleaned_data['email']

        if not email:

            raise forms.ValidationError(_("This field is required"))

        return email

    def clean_has_signed_terms(self):

        has_signed_terms = self.cleaned_data['has_signed_terms']

        if not has_signed_terms:

            raise forms.ValidationError(_('You have to agree with the terms'))

        return has_signed_terms

    def save(self, commit=True):

        user = super(ThirdPartyUserCreationForm, self).save(commit=False)

        user.set_unusable_password()

            logger.log(LOGGING_LEVEL, 'Created user %s' % user.email)

        return user

class InvitedThirdPartyUserCreationForm(ThirdPartyUserCreationForm):

    """

    Extends the ThirdPartyUserCreationForm: email is readonly.

        """

        Changes the order of fields, and removes the username field.

        """

        #set readonly form fields

        ro = ('email',)

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

    def save(self, commit=True):

        level = user.invitation.inviter.level + 1

        user.level = level

        user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)

            user.save()

        return user

class ShibbolethUserCreationForm(ThirdPartyUserCreationForm):

    def __init__(self, *args, **kwargs):

        super(ShibbolethUserCreationForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder.append('additional_email')

        # copy email value to additional_mail in case user will change it

        name = 'email'

        field = self.fields[name]

    def clean_email(self):

        email = self.cleaned_data['email']

            if user.provider == 'shibboleth':

                raise forms.ValidationError(_("This email is already associated with another shibboleth account."))

            elif not user.is_active:

        super(ShibbolethUserCreationForm, self).clean_email()

        return email

class InvitedShibbolethUserCreationForm(ShibbolethUserCreationForm, InvitedThirdPartyUserCreationForm):

    pass

class LoginForm(AuthenticationForm):

    username = forms.EmailField(label=_("Email"))

    recaptcha_challenge_field = forms.CharField(widget=DummyWidget)

    def __init__(self, *args, **kwargs):

        was_limited = kwargs.get('was_limited', False)

        request = kwargs.get('request', None)

        if request:

            self.ip = request.META.get('REMOTE_ADDR',

                                       request.META.get('HTTP_X_REAL_IP', None))

        t = ('request', 'was_limited')

        for elem in t:

            if elem in kwargs.keys():

                kwargs.pop(elem)

        super(LoginForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder = ['username', 'password']

        if was_limited and RECAPTCHA_ENABLED:

            self.fields.keyOrder.extend(['recaptcha_challenge_field',

    def clean_recaptcha_response_field(self):

        if 'recaptcha_challenge_field' in self.cleaned_data:

            self.validate_captcha()

        rrf = self.cleaned_data['recaptcha_response_field']

        check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)

        if not check.is_valid:

    def clean(self):

        super(LoginForm, self).clean()

        if self.user_cache and self.user_cache.provider not in ('local', ''):

            raise forms.ValidationError(_('Local login is not the current authentication method for this account.'))

        return self.cleaned_data

class ProfileForm(forms.ModelForm):

    """

    Subclass of ``ModelForm`` for permiting user to edit his/her profile.

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        super(ProfileForm, self).__init__(*args, **kwargs)

            user.save()

        return user

class FeedbackForm(forms.Form):

    """

    Form for writing feedback.

    feedback_data = forms.CharField(widget=forms.HiddenInput(), label='',

                                    required=False)

class SendInvitationForm(forms.Form):

    """

    Form for sending an invitations

    """

class ExtendedPasswordResetForm(PasswordResetForm):

    """

        try:

            user = AstakosUser.objects.get(email=email, is_active=True)

            if not user.has_usable_password():

        except AstakosUser.DoesNotExist:

            raise forms.ValidationError(_('That e-mail address doesn\'t have an associated user account. Are you sure you\'ve registered?'))

        return email

        """

        Generates a one-use only link for resetting password and sends to the user.

        """

        for user in self.users_cache:

            url = reverse('django.contrib.auth.views.password_reset_confirm',

            url = urljoin(BASEURL, url)

            t = loader.get_template(email_template_name)

            c = {

            }

            from_email = settings.SERVER_EMAIL

            send_mail(_("Password reset on %s alpha2 testing") % SITENAME,

class EmailChangeForm(forms.ModelForm):

    class Meta:

        model = EmailChange

        fields = ('new_email_address',)

    def clean_new_email_address(self):

        addr = self.cleaned_data['new_email_address']

        if AstakosUser.objects.filter(email__iexact=addr):

            raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))

        return addr

    def save(self, email_template_name, request, commit=True):

        ec = super(EmailChangeForm, self).save(commit=False)

        ec.user = request.user

        if commit:

            ec.save()

        send_change_email(ec, request, email_template_name=email_template_name)

class SignApprovalTermsForm(forms.ModelForm):

    class Meta:

        model = AstakosUser

            raise forms.ValidationError(_('You have to agree with the terms'))

        return has_signed_terms

class InvitationForm(forms.ModelForm):

    username = forms.EmailField(label=_("Email"))

    def __init__(self, *args, **kwargs):

        super(InvitationForm, self).__init__(*args, **kwargs)

    class Meta:

        model = Invitation

        fields = ('username', 'realname')

    def clean_username(self):

        username = self.cleaned_data['username']

        try:

        except Invitation.DoesNotExist:

            pass

        return username

class ExtendedPasswordChangeForm(PasswordChangeForm):

    """

    Extends PasswordChangeForm by enabling user

    to optionally renew also the token.

    """

    renew = forms.BooleanField(label='Renew token', required=False)

    def __init__(self, user, *args, **kwargs):

        super(ExtendedPasswordChangeForm, self).__init__(user, *args, **kwargs)

    def save(self, commit=True):

        user = super(ExtendedPasswordChangeForm, self).save(commit=False)

        if self.cleaned_data.get('renew'):

            user.save()

        return user

class AstakosGroupCreationForm(forms.ModelForm):

#     issue_date = forms.DateField(widget=SelectDateWidget())

#     expiration_date = forms.DateField(widget=SelectDateWidget())

    class Meta:

        model = AstakosGroup

    def __init__(self, *args, **kwargs):

        try: