Synnefo » astakos

                                                get_model_and_form_class)

from django.views.generic.list_detail import object_list

from django.core.xheaders import populate_xheaders

from django.template.loader import render_to_string

from django.views.decorators.http import require_http_methods

from astakos.im.models import (AstakosUser, ApprovalTerms, AstakosGroup,

                               EmailChange, GroupKind, Membership,

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

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

                              FeedbackForm, SignApprovalTermsForm,

from astakos.im.api.callpoint import AstakosCallpoint

import astakos.im.messages as astakos_messages

logger = logging.getLogger(__name__)

    response = HttpResponse(html, status=status)

    return response

def requires_anonymous(func):

    """

    template_name = login_template_name

    if request.user.is_authenticated():

        return HttpResponseRedirect(reverse('astakos.im.views.edit_profile'))

    return render_response(

        template_name,

        login_form = LoginForm(request=request),

            except ValueError, ve:

                messages.success(request, ve)

    elif request.method == "GET":

    return render_response(template_name,

                           profile_form = form,

                           context_instance = get_context(request,

                                                          extra_context))

        return HttpResponseRedirect(reverse('edit_profile'))

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

    id = get_query(request).get('id')

    try:

        instance = AstakosUser.objects.get(id=id) if id else None

                result = backend.handle_activation(user)

                status = messages.SUCCESS

                message = result.message

                if 'additional_email' in form.cleaned_data:

                    additional_email = form.cleaned_data['additional_email']

                    if additional_email != user.email:

                    transaction.commit()

                    return response

                messages.add_message(request, status, message)

                return render_response(

                    on_success,

                    context_instance=get_context(

def send_activation(request, user_id, template_name='im/login.html', extra_context=None):

    extra_context = extra_context or {}

    try:

        u = AstakosUser.objects.get(id=user_id)

    )

class ResourcePresentation():

    def __init__(self, data):

        self.data = data

    def update_from_result(self, result):

        if result.is_success:

            for r in result.data:

                rname = '%s%s%s' % (r.get('service'), RESOURCE_SEPARATOR, r.get('name'))

                if not rname in self.data['resources']:

                    self.data['resources'][rname] = {}

                self.data['resources'][rname].update(r)

                self.data['resources'][rname]['id'] = rname

                group = r.get('group')

                if not group in self.data['groups']:

                    self.data['groups'][group] = {}

                self.data['groups'][r.get('group')].update({'name': r.get('group')})

    def test(self, quota_dict):

        for k, v in quota_dict.iteritems():

            rname = k

            value = v

            if not rname in self.data['resources']:

                self.data['resources'][rname] = {}

            self.data['resources'][rname]['value'] = value

    def update_from_result_report(self, result):

        if result.is_success:

            for r in result.data:

                rname = r.get('name')

                if not rname in self.data['resources']:

                    self.data['resources'][rname] = {}

                self.data['resources'][rname].update(r)

                self.data['resources'][rname]['id'] = rname

                group = r.get('group')

                if not group in self.data['groups']:

                    self.data['groups'][group] = {}

                self.data['groups'][r.get('group')].update({'name': r.get('group')})

    def get_group_resources(self, group):

        return dict(filter(lambda t: t[1].get('group') == group, self.data['resources'].iteritems()))

    def get_groups_resources(self):

        for g in self.data['groups']:

            yield g, self.get_group_resources(g)

    def get_quota(self, group_quotas):

        for r, v in group_quotas.iteritems():

            rname = str(r)

            quota = self.data['resources'].get(rname)

            quota['value'] = v

            yield quota

    def get_policies(self, policies_data):

        for policy in policies_data:

            rname = '%s%s%s' % (policy.get('service'), RESOURCE_SEPARATOR, policy.get('resource'))

            policy.update(self.data['resources'].get(rname))

            yield policy

    def __repr__(self):

        return self.data.__repr__()

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

        return self.data.__iter__(*args, **kwargs)

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

        return self.data.__getitem__(*args, **kwargs)

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

        return self.data.get(*args, **kwargs)

@require_http_methods(["GET", "POST"])

@signed_terms_required

@login_required

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

    result = callpoint.list_resources()

    resource_catalog = ResourcePresentation(RESOURCES_PRESENTATION_DATA)

    resource_catalog.update_from_result(result)

    if not result.is_success:

        messages.error(

            request,

            'Unable to retrieve system resources: %s' % result.reason

    )

    try:

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

    except:

        return HttpResponseBadRequest(_(astakos_messages.GROUPKIND_UNKNOWN))

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

    context_processors = None

        model=None,

        form_class=AstakosGroupCreationForm

    )

    if request.method == 'POST':

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

        if form.is_valid():

                policies = resource_catalog.get_policies(form.policies()),

                resource_catalog= resource_catalog,

            )

    else:

        now = datetime.now()

        data = {

            data['is_selected_%s' % group] = False

            for resource in resources:

                data['%s_uplimit' % resource] = ''

        form = form_class(data)

    # Create the template, context, response

            msg = _(astakos_messages.OBJECT_CREATED) %\

                {"verbose_name": model._meta.verbose_name}

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

            # send notification

            try:

                send_group_creation_notification(

        else:

            d = {"verbose_name": model._meta.verbose_name,

                 "reason":result.reason}

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

    return render_response(

        template='im/astakosgroup_form_summary.html',

            im_astakosuser_owner.astakosgroup_id = im_astakosgroup.group_ptr_id)

        LEFT JOIN auth_user as owner ON (

            im_astakosuser_owner.astakosuser_id = owner.id)

        """ % (DB_REPLACE_GROUP_SCHEME, request.user.id, request.user.id)

    if sorting:

    else:

    q = AstakosGroup.objects.raw(query)

    # Create the template, context, response

    template_name = "%s/%s_list.html" % (

        q.model._meta.app_label,

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

        if form.is_valid():

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

    else:

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

    result = callpoint.list_resources()

    resource_catalog = ResourcePresentation(RESOURCES_PRESENTATION_DATA)

    resource_catalog.update_from_result(result)

    if not result.is_success:

        messages.error(

            request,

            'Unable to retrieve system resources: %s' % result.reason

    )

    extra_context = {'update_form': update_form,

                     'addmembers_form': addmembers_form,

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

                        SELECT id FROM im_astakosuser_owner

                        WHERE astakosgroup_id = im_astakosgroup.group_ptr_id

                        AND astakosuser_id = %s)

                    })

        if sorting:

            # TODO check sorting value

        q = q.order_by(sorting)

    else:

        q = q.order_by("groupname")

    return object_list(

        request,

        q,

        if max_value > 0 :

            entry['ratio'] = (curr_value / max_value) * 100

        else:

        if entry['ratio'] < 66:

            entry['load_class'] = 'yellow'

        if entry['ratio'] < 33:

        messages.error(request, result.reason)

    resource_catalog = ResourcePresentation(RESOURCES_PRESENTATION_DATA)

    resource_catalog.update_from_result_report(result)

    return render_response('im/resource_list.html',

                           data=data,

                           context_instance=get_context(request),

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

    return data

#@require_http_methods(["GET"])

@require_http_methods(["POST", "GET"])

@signed_terms_required

                           timeline_body=timeline_body)

    return data

# TODO: action only on POST and user should confirm the removal

@require_http_methods(["GET", "POST"])

@login_required

    else:

        raise PermissionDenied

def how_it_works(request):

    return render_response(

        template='im/how_it_works.html',