Synnefo

import logging

import calendar

from urllib import quote

from functools import wraps

from django.db.models import Q

from django.db.utils import IntegrityError

from django.forms.fields import URLField

from django.shortcuts import redirect

from django.template import RequestContext, loader as template_loader

from django.utils.http import urlencode

from django.http import HttpResponseBadRequest

from django.core.xheaders import populate_xheaders

from astakos.im.activation_backends import get_backend, SimpleBackend

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

from astakos.im.forms import (LoginForm, InvitationForm, ProfileForm,

                              AstakosGroupSortForm, MembersSortForm,

                              TimelineForm, PickResourceForm)

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

                                  activate as activate_func,

                                  switch_account_to_shibboleth,

                                  SendNotificationError)

from astakos.im.endpoints.quotaholder import timeline_charge

from astakos.im.tasks import request_billing

logger = logging.getLogger(__name__)

DB_REPLACE_GROUP_SCHEME = """REPLACE(REPLACE("auth_group".name, 'http://', ''),

                                     'https://', '')"""

def render_response(template, tab=None, status=200, reset_cookie=False,

                    context_instance=None, **kwargs):

    """

        if inviter.invitations > 0:

            if form.is_valid():

                try:

                    messages.success(request, message)

                except SendMailError, e:

                    message = e.message

        return response

    messages.success(request, _('You have successfully logged out.'))

    context = get_context(request, extra_context)

    return response

            pass

    if not term:

        return HttpResponseRedirect(reverse('index'))

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

    terms = f.read()

                           password_change_form=ExtendedPasswordChangeForm)

@signed_terms_required

@login_required

@transaction.commit_manually

            # send notification

            try:

                    template_name='im/group_creation_notification.txt',

                    dictionary={

                        'group': new_object,

                        'owner': request.user,

                        'policies': policies,

                )

            except SendNotificationError, e:

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

            d['own'].append(g)

        else:

            d['other'].append(g)

    # validate sorting

    fields = ('own', 'other')

    for f in fields:

            if not form.is_valid():

                globals()['%s_sorting' % f] = form.cleaned_data.get('sort_by')

    return object_list(request, queryset=none,

                                      'mine': d['own'],

                                      'other': d['other'],

                                      'own_sorting': own_sorting,

                        THEN 1 ELSE 0 END""" % request.user.id,

        'kindname': """SELECT name FROM im_groupkind

                       WHERE id = im_astakosgroup.kind_id"""})

    model = q.model

    context_processors = None

    mimetype = None

    except AstakosGroup.DoesNotExist:

        raise Http404("No %s found matching the query" % (

            model._meta.verbose_name))

    update_form = AstakosGroupUpdateForm(instance=obj)

    addmembers_form = AddGroupMembersForm()

    if request.method == 'POST':

        update_data = {}

        addmembers_data = {}

            if k in update_form.fields:

                update_data[k] = v

            if k in addmembers_form.fields:

        if addmembers_form.is_valid():

            map(obj.approve_member, addmembers_form.valid_users)

            addmembers_form = AddGroupMembersForm()

    t = template_loader.get_template(template_name)

    c = RequestContext(request, {

        'object': obj,

    }, context_processors)

    # validate sorting

    if sorting:

        form = MembersSortForm({'sort_by': sorting})

        if form.is_valid():

            sorting = form.cleaned_data.get('sort_by')

    extra_context = {'update_form': update_form,

                     'addmembers_form': addmembers_form,

                     'page': request.GET.get('page', 1),

        else:

            c[key] = value

    response = HttpResponse(t.render(c), mimetype=mimetype)

    return response

        queryset = queryset.filter(name__contains=q)

        queryset = queryset.filter(approval_date__isnull=False)

        queryset = queryset.extra(select={

                    SELECT COUNT(*) FROM im_membership

                    WHERE group_id = im_astakosgroup.group_ptr_id

                    AND date_joined IS NOT NULL""",

                    SELECT date_joined FROM im_membership

                    WHERE group_id = im_astakosgroup.group_ptr_id

                    AND person_id = %s""" % request.user.id,

                    SELECT CASE WHEN EXISTS(

                    SELECT date_joined FROM im_membership

                    WHERE group_id = im_astakosgroup.group_ptr_id

                    AND person_id = %s)

                    THEN 1 ELSE 0 END""" % request.user.id,

                    SELECT CASE WHEN EXISTS(

                    SELECT id FROM im_astakosuser_owner

                    WHERE astakosgroup_id = im_astakosgroup.group_ptr_id

                           q=q,

                           sorting=sorting))

@signed_terms_required

@login_required

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

        # TODO check sorting value

        q = q.order_by(sorting)

    return object_list(

@signed_terms_required

@signed_terms_required

@login_required

def resource_list(request):

    def with_class(entry):

        entry['load_class'] = 'red'

        max_value = float(entry['maxValue'])

        curr_value = float(entry['currValue'])

        if entry['ratio'] < 66:

        if entry['ratio'] < 33:

    def pluralize(entry):

        }

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

    today = datetime.today()

    start = request.POST.get('datefrom', None)

    if start:

        today = datetime.fromtimestamp(int(start))

    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=('pgerakios@grnet.gr',

                                    int(start) * 1000,

                                    int(end) * 1000))

    data = {}

    try:

        status, data = r.result

        if status != 200:

            messages.error(request, _('Service response status: %d' % status))

    except:

        messages.error(request, r.result)

    print type(start)

    return render_response(

        template='im/billing.html',

        context_instance=get_context(request),

        data=data,

        today=today,

        start=int(start),

def _clear_billing_data(data):

    # remove addcredits entries

    def isnotcredit(e):

        return e['serviceName'] != "addcredits"

    def servicefilter(service_name):

        service = service_name

        def fltr(e):

            return e['serviceName'] == service

        return fltr

    data['bill_nocredits'] = filter(isnotcredit, data['bill'])

    data['bill_vmtime'] = filter(servicefilter('vmtime'), data['bill'])

    data['bill_diskspace'] = filter(servicefilter('diskspace'), data['bill'])

    data['bill_addcredits'] = filter(servicefilter('addcredits'), data['bill'])

    return data

@signed_terms_required

                               'event name', 'event date',

                               'incremental cost', 'total cost')

            timeline_body = timeline_charge(

    return render_response(template='im/timeline.html',

                           context_instance=get_context(request),

                           form=form,