Synnefo

from django.utils.http import urlencode

from django.utils.translation import ugettext as _

from django.views.generic.create_update import (create_object, delete_object,

from django.views.generic.list_detail import object_list, object_detail

    EmailChange, GroupKind, Membership)

from astakos.im.activation_backends import get_backend, SimpleBackend

from astakos.im.util import get_context, prepare_response, set_cookie, get_query

    SignApprovalTermsForm, ExtendedPasswordChangeForm, EmailChangeForm,

    AstakosGroupCreationForm, AstakosGroupSearchForm

)

from astakos.im.functions import (send_feedback, SendMailError,

    LOGGING_LEVEL

)

from astakos.im.tasks import request_billing

logger = logging.getLogger(__name__)

def render_response(template, tab=None, status=200, reset_cookie=False, context_instance=None, **kwargs):

    """

    Calls ``django.template.loader.render_to_string`` with an additional ``tab``

    if tab is None:

        tab = template.partition('_')[0].partition('.html')[0]

    kwargs.setdefault('tab', tab)

    response = HttpResponse(html, status=status)

    if reset_cookie:

        set_cookie(response, context_instance['request'].user)

        return func(request, *args)

    return wrapper

def signed_terms_required(func):

    """

    Decorator checkes whether the request.user is Anonymous and in that case

    def wrapper(request, *args, **kwargs):

        if request.user.is_authenticated() and not request.user.signed_terms:

            params = urlencode({'next': request.build_absolute_uri(),

            terms_uri = reverse('latest_terms') + '?' + params

            return HttpResponseRedirect(terms_uri)

        return func(request, *args, **kwargs)

    return wrapper

@signed_terms_required

def index(request, login_template_name='im/login.html', extra_context=None):

    """

    if request.user.is_authenticated():

        return HttpResponseRedirect(reverse('edit_profile'))

    return render_response(template_name,

@login_required

@signed_terms_required

    status = None

    message = None

    form = InvitationForm()

    inviter = request.user

    if request.method == 'POST':

        form = InvitationForm(request.POST)

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

             'realname': inv.realname,

             'is_consumed': inv.is_consumed}

    kwargs = {'inviter': inviter,

    context = get_context(request, extra_context, **kwargs)

    return render_response(template_name,

@login_required

@signed_terms_required

            request.user.is_verified = True

            request.user.save()

    return render_response(template_name,

def signup(request, template_name='im/signup.html', on_success='im/signup_complete.html', extra_context=None, backend=None):

    """

    if present, otherwise to the ``astakos.im.activation_backends.InvitationBackend``

    if settings.ASTAKOS_INVITATIONS_ENABLED is True or ``astakos.im.activation_backends.SimpleBackend`` if not

    (see activation_backends);

    Upon successful user creation, if ``next`` url parameter is present the user is redirected there

    otherwise renders the same page with a success message.

    On unsuccessful creation, renders ``template_name`` with an error message.

    **Arguments**

    ``template_name``

        A custom template to render. This is optional;

        if not specified, this will default to ``im/signup.html``.

        An dictionary of variables to add to the template context.

    **Template:**

    im/signup.html or ``template_name`` keyword argument.

    """

    if request.user.is_authenticated():

        return HttpResponseRedirect(reverse('edit_profile'))

    provider = get_query(request).get('provider', 'local')

    try:

        if not backend:

                    additional_email = form.cleaned_data['additional_email']

                    if additional_email != user.email:

                        user.additionalmail_set.create(email=additional_email)

                        logger.log(LOGGING_LEVEL, msg)

                if user and user.is_active:

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

                messages.error(request, message)

                logger.exception(e)

    return render_response(template_name,

                           context_instance=get_context(request, extra_context))

@login_required

@signed_terms_required

def feedback(request, template_name='im/feedback.html', email_template_name='im/feedback_mail.txt', extra_context=None):

                message = _('Feedback successfully sent')

                messages.success(request, message)

    return render_response(template_name,

@signed_terms_required

def logout(request, template='registration/logged_out.html', extra_context=None):

    response.write(loader.render_to_string(template, context_instance=context))

    return response

@transaction.commit_manually

def activate(request, greeting_email_template_name='im/welcome_email.txt', helpdesk_email_template_name='im/helpdesk_notification.txt'):

    """

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

    except AstakosUser.DoesNotExist:

        return HttpResponseBadRequest(_('No such user'))

    if user.is_active:

        message = _('Account already active.')

        messages.error(request, message)

        return index(request)

    try:

        local_user = AstakosUser.objects.get(

            email=user.email,

            is_active=True

        )

            transaction.rollback()

            return index(request)

def approval_terms(request, term_id=None, template_name='im/approval_terms.html', extra_context=None):

    term = None

    terms = None

        form = SignApprovalTermsForm(request.POST, instance=request.user)

        if not form.is_valid():

            return render_response(template_name,

        user = form.save()

        return HttpResponseRedirect(next)

    else:

        if request.user.is_authenticated() and not request.user.signed_terms:

            form = SignApprovalTermsForm(instance=request.user)

        return render_response(template_name,

@signed_terms_required

def change_password(request):

    return password_change(request,

@signed_terms_required

@login_required

        except ValueError, e:

            messages.error(request, e)

        return render_response(confirm_template_name,

    if not request.user.is_authenticated():

        path = quote(request.get_full_path())

        url = request.build_absolute_uri(reverse('index'))

            messages.success(request, msg)

            transaction.commit()

    return render_response(form_template_name,

@signed_terms_required

@login_required

def group_add(request, kind_name='default'):

    try:

    except:

        return HttpResponseBadRequest(_('No such group kind'))

    model, form_class = get_model_and_form_class(

        model=None,

        form_class=AstakosGroupCreationForm

    )

    policies = []

    if request.method == 'POST':

        form = form_class(request.POST, request.FILES, resources=resources)

        if form.is_valid():

            new_object = form.save()

            # save owner

            new_object.owners = [request.user]

            # save quota policies

            for (rid, limit) in form.resources():

                try:

                    continue

                else:

                    new_object.astakosgroupquota_set.create(

                    )

                policies.append('%s %d' % (r, limit))

            msg = _("The %(verbose_name)s was created successfully.") %\

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

            # send notification

            try:

                send_admin_notification(

                    template_name='im/group_creation_notification.txt',

                    dictionary={

                    },

                    subject='%s alpha2 testing group creation notification' % SITENAME

                )

    else:

        now = datetime.now()

        data = {

        }

        form = form_class(data, resources=resources)

    }, context_processors)

    return HttpResponse(t.render(c))

@signed_terms_required

@login_required

def group_list(request):

    list = request.user.astakos_groups.select_related().all()

    return object_list(request, queryset=list,

@signed_terms_required

@login_required

    except AstakosGroup.DoesNotExist:

        return HttpResponseBadRequest(_('Invalid group.'))

    return object_detail(request,

@signed_terms_required

@login_required

def group_approval_request(request, group_id):

    return HttpResponse()

@signed_terms_required

@login_required

def group_search(request, extra_context=None, **kwargs):

        form = AstakosGroupSearchForm(get_query(request))

        if form.is_valid():

            q = form.cleaned_data['q'].strip()

            return object_list(

                request,

                queryset,

            )

    return render_response(

        template='im/astakosgroup_list.html',

        context_instance=get_context(request, extra_context),

        is_search=False

@signed_terms_required

@login_required

def group_join(request, group_id):

    m = Membership(group_id=group_id,

    try:

        m.save()

        post_save_redirect = reverse(

        messages.error(request, msg)

        return group_search(request)

@signed_terms_required

@login_required

def group_leave(request, group_id):

    return delete_object(

        request,

        model=Membership,

        template_name='im/astakosgroup_list.html',

            'group_detail',

            kwargs=dict(group_id=group_id)

        )

    )

def handle_membership():

    def decorator(func):

        @wraps(func)

        return wrapper

    return decorator

@signed_terms_required

@login_required

@handle_membership()

        logger.exception(e)

        msg = _('Something went wrong during %s\'s approval.' % realname)

        messages.error(request, msg)

@signed_terms_required

@login_required

@handle_membership()

        msg = _('Something went wrong during %s\'s disapproval.' % realname)

        messages.error(request, msg)

@signed_terms_required

@login_required

def resource_list(request):

        context_instance=get_context(request),

        quota=request.user.quota

    )

def group_create_list(request):

    return render_response(

        template='im/astakosgroup_create_list.html',

        context_instance=get_context(request),

    )

@signed_terms_required

@login_required

def billing(request):

    start = datetime(today.year, today.month, 1).strftime("%s")

    end = datetime(today.year, today.month, month_last_day).strftime("%s")

    r = request_billing.apply(args=(request.user.email,

    data = None

    try:

        status, data = r.result

    return render_response(

        template='im/billing.html',

        context_instance=get_context(request),