Synnefo » astakos

from astakos.im.functions import (send_verification, send_activation,

                                  send_account_creation_notification,

                                  send_group_creation_notification, activate)

import logging

import re

class VerificationSent(ActivationResult):

    def __init__(self):

        super(VerificationSent, self).__init__(message)

class SwitchAccountsVerificationSent(ActivationResult):

    def __init__(self, email):

        super(SwitchAccountsVerificationSent, self).__init__(message)

class NotificationSent(ActivationResult):

    def __init__(self):

        super(NotificationSent, self).__init__(message)

class RegistationCompleted(ActivationResult):

    def __init__(self):

        super(RegistationCompleted, self).__init__(message)

logger = logging.getLogger(__name__)

def call(func_name):

    """Decorator function for QuotaholderHTTP client calls."""

from astakos.im.util import reserved_email, get_query

import logging

import hashlib

import recaptcha.client.captcha as captcha

    def clean_email(self):

        email = self.cleaned_data['email']

        if not email:

        if reserved_email(email):

        return email

    def clean_has_signed_terms(self):

        has_signed_terms = self.cleaned_data['has_signed_terms']

        if not has_signed_terms:

        return has_signed_terms

    def clean_recaptcha_response_field(self):

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

        """

    def clean_email(self):

        email = self.cleaned_data['email']

        if not email:

        return email

    def clean_has_signed_terms(self):

        has_signed_terms = self.cleaned_data['has_signed_terms']

        if not has_signed_terms:

        return has_signed_terms

    def save(self, commit=True):

        email = self.cleaned_data['email']

        for user in AstakosUser.objects.filter(email=email):

            if user.provider == 'shibboleth':

            elif not user.is_active:

        super(ShibbolethUserCreationForm, self).clean_email()

        return email

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

        return self.cleaned_data

        try:

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

            if not user.has_usable_password():

        except AstakosUser.DoesNotExist:

        return email

    def save(

    def clean_new_email_address(self):

        addr = self.cleaned_data['new_email_address']

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

        return addr

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

    def clean_has_signed_terms(self):

        has_signed_terms = self.cleaned_data['has_signed_terms']

        if not has_signed_terms:

        return has_signed_terms

        username = self.cleaned_data['username']

        try:

            Invitation.objects.get(username=username)

        except Invitation.DoesNotExist:

            pass

        return username

class AddGroupMembersForm(forms.Form):

    q = forms.CharField(

        max_length=800, widget=forms.Textarea, label=_('Add users'),

        required=True)

    def clean(self):

        db_entries = AstakosUser.objects.filter(email__in=users)

        unknown = list(set(users) - set(u.email for u in db_entries))

        if unknown:

        self.valid_users = db_entries

        return self.cleaned_data

                                 FEEDBACK_EMAIL_SUBJECT,

                                 EMAIL_CHANGE_EMAIL_SUBJECT)

import astakos.im.models

logger = logging.getLogger(__name__)

class SendAdminNotificationError(SendMailError):

    def __init__(self):

        super(SendAdminNotificationError, self).__init__()

class SendVerificationError(SendMailError):

    def __init__(self):

        super(SendVerificationError, self).__init__()

class SendInvitationError(SendMailError):

    def __init__(self):

        super(SendInvitationError, self).__init__()

class SendGreetingError(SendMailError):

    def __init__(self):

        super(SendGreetingError, self).__init__()

class SendFeedbackError(SendMailError):

    def __init__(self):

        super(SendFeedbackError, self).__init__()

class ChangeEmailError(SendMailError):

    def __init__(self):

        super(ChangeEmailError, self).__init__()

class SendNotificationError(SendMailError):

    def __init__(self):

        super(SendNotificationError, self).__init__()

from astakos.im.tasks import propagate_groupmembers_quota

from astakos.im.functions import send_invitation

logger = logging.getLogger(__name__)

DEFAULT_CONTENT_TYPE = None

    astakos_groups = models.ManyToManyField(

        AstakosGroup, verbose_name=_('agroups'), blank=True,

        through='Membership')

    __has_signed_terms = False

        q = q.filter(email=self.email)

        q = q.filter(is_active=self.is_active)

        if q.count() != 0:

    @property

    def signed_terms(self):

            except AstakosUser.DoesNotExist:

                pass

            else:

            # update user

            user = AstakosUser.objects.get(pk=email_change.user_id)

            user.email = email_change.new_email_address

            email_change.delete()

            return user

        except EmailChange.DoesNotExist:

class EmailChange(models.Model):

    new_email_address = models.EmailField(_(u'new e-mail address'),

    user = models.ForeignKey(

        AstakosUser, unique=True, related_name='emailchange_user')

    requested_at = models.DateTimeField(default=datetime.now())

post_save.connect(send_quota_disturbed, sender=AstakosUserQuota)

post_delete.connect(send_quota_disturbed, sender=AstakosUserQuota)

post_save.connect(send_quota_disturbed, sender=AstakosGroupQuota)

from astakos.im.forms import LoginForm

from astakos.im.settings import RATELIMIT_RETRIES_ALLOWED

from ratelimit.decorators import ratelimit

retries = RATELIMIT_RETRIES_ALLOWED - 1

    message = None

    if not user:

    elif not user.is_active:

    if message:

        messages.error(request, message)

        return render_to_response(on_failure,

from astakos.im.util import set_cookie

from astakos.im.functions import login as auth_login, logout

import logging

logger = logging.getLogger(__name__)

    """

    next = request.GET.get('next')

    if not next:

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

    response = HttpResponse()

    if force == '':

from astakos.im.forms import LoginForm

from astakos.im.activation_backends import get_backend, SimpleBackend

class Tokens:

    # these are mapped by the Shibboleth SP software

                                    request.GET.get('next'),

                                    'renew' in request.GET)

        else:

            messages.error(request, message)

            return render_response(on_login_template,

                                   login_form=LoginForm(request=request),

from django.core.urlresolvers import reverse

from django.core.exceptions import ValidationError, ObjectDoesNotExist

from django.db.models.fields import Field

from astakos.im.models import AstakosUser, Invitation

from astakos.im.settings import COOKIE_NAME, \

    COOKIE_DOMAIN, COOKIE_SECURE, FORCE_PROFILE_UPDATE, LOGGING_LEVEL

from astakos.im.functions import login

logger = logging.getLogger(__name__)

        return

    invitation = Invitation.objects.get(code=code)

    if invitation.is_consumed:

    if reserved_email(invitation.username):

    return invitation

from astakos.im.tasks import request_billing

from astakos.im.api.callpoint import AstakosCallpoint

logger = logging.getLogger(__name__)

                    email = form.cleaned_data.get('username')

                    realname = form.cleaned_data.get('realname')

                    inviter.invite(email, realname)

                    messages.success(request, message)

                except SendMailError, e:

                    message = e.message

                    messages.error(request, message)

                    transaction.rollback()

                except BaseException, e:

                    messages.error(request, message)

                    logger.exception(e)

                    transaction.rollback()

                else:

                    transaction.commit()

        else:

            messages.error(request, message)

    sent = [{'email': inv.username,

                next = request.POST.get('next')

                if next:

                    return redirect(next)

                messages.success(request, msg)

            except ValueError, ve:

                messages.success(request, ve)

                messages.error(request, message)

                transaction.rollback()

            except BaseException, e:

                messages.error(request, message)

                logger.exception(e)

                transaction.rollback()

            except SendMailError, e:

                messages.error(request, message)

            else:

                messages.success(request, message)

    return render_response(template_name,

                           feedback_form=form,

        response['Location'] = LOGOUT_NEXT

        response.status_code = 301

        return response

    context = get_context(request, extra_context)

    response.write(

        template_loader.render_to_string(template, context_instance=context))

    try:

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

    except AstakosUser.DoesNotExist:

    if user.is_active:

        messages.error(request, message)

        return index(request)

            transaction.rollback()

            return index(request)

        except BaseException, e:

            messages.error(request, message)

            logger.exception(e)

            transaction.rollback()

            transaction.rollback()

            return index(request)

        except BaseException, e:

            messages.error(request, message)

            logger.exception(e)

            transaction.rollback()

            pass

    if not term:

        return HttpResponseRedirect(reverse('index'))

    f = open(term.location, 'r')

    terms = f.read()

        try:

            user = EmailChange.objects.change_email(activation_key)

            if request.user.is_authenticated() and request.user == user:

                messages.success(request, msg)

                auth_logout(request)

                response = prepare_response(request, user)

            messages.error(request, msg)

            transaction.rollback()

        except IntegrityError, e:

            messages.error(request, msg)

        else:

            messages.success(request, msg)

            transaction.commit()

    return render_response(form_template_name,

    try:

        kind = GroupKind.objects.get(name=kind_name)

    except:

        result = callpoint.create_groups((d,)).next()

        if result.is_success:

            new_object = result.data[0]

                {"verbose_name": model._meta.verbose_name}

            messages.success(request, msg, fail_silently=True)

            post_save_redirect = '/im/group/%(id)s/'

            return HttpResponseRedirect(post_save_redirect % new_object)

        else:

                {"verbose_name": model._meta.verbose_name,

                 "reason":result.reason}

            messages.error(request, msg, fail_silently=True)

        return HttpResponseRedirect(post_save_redirect)

    except IntegrityError, e:

        logger.exception(e)

        messages.error(request, msg)

        return group_search(request)

            group__id=group_id,

            person=request.user)

    except Membership.DoesNotExist:

    if request.user in m.group.owner.all():

    return delete_object(

        request,

        model=Membership,

                group__id=group_id,

                person__id=user_id)

        except Membership.DoesNotExist:

        else:

            if request.user not in m.group.owner.all():

            func(request, m)

            return group_detail(request, group_id)

    return wrapper

    try:

        membership.approve()

        realname = membership.person.realname

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        realname = membership.person.realname

        messages.error(request, msg)

    try:

        membership.disapprove()

        realname = membership.person.realname

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        messages.error(request, msg)

        status, data = r.result

        data = _clear_billing_data(data)

        if status != 200:

    except:

        messages.error(request, r.result)