Synnefo

@api.api_method(http_method='GET', token_required=True, user_required=False)

@component_from_token

def get_pending_commissions(request):

    client_key = str(request.component_instance)

    result = qh.get_pending_commissions(clientkey=client_key)

                                 name=name,

                                 force=force)

    if accept:

    return serial

                                 serial=serial)

        status_code = 200

        return json_response(data, status_code)

        return HttpResponse(status=404)

        try:

            super(LoginForm, self).clean()

            if self.user_cache is None:

                raise

            if not self.user_cache.is_active:

    def clean(self):

        userid = self.data.get('user', None)

        self.user = None

        if userid:

            try:

# or implied, of GRNET S.A.

import logging

from django.utils.translation import ugettext as _

from django.core.mail import send_mail, get_connection

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import uuid

import logging

import json

import copy

from datetime import datetime, timedelta

from random import randint

import os

from django.contrib.auth.models import User, UserManager, Group, Permission

from django.utils.translation import ugettext as _

from django.db.models.signals import pre_save, post_save

from django.contrib.contenttypes.models import ContentType

from django.core.urlresolvers import reverse

from django.utils.http import int_to_base36

from django.contrib.auth.tokens import default_token_generator

            uuid_val = str(uuid.uuid4())

            try:

                AstakosUser.objects.get(uuid=uuid_val)

                self.uuid = uuid_val

        return self.uuid

    @property

    def status_display(self):

        msg = ""

        if self.is_active:

            msg = "Accepted/Active"

        if self.is_rejected:

            self.info = json.loads(self.info_data)

            if not self.info:

                self.info = {}

            self.info = {}

        for key, value in self.info.iteritems():

                username = uuid.uuid4().hex[:30]

                try:

                    AstakosUser.objects.get(username=username)

                    self.username = username

        super(PendingThirdPartyUser, self).save(**kwargs)

def project_termination_notify(project):

    app = project.application

    try:

            SENDER,

            [project.application.owner.email],

            _(messages.PROJECT_TERMINATION_SUBJECT) % app.__dict__,

def project_suspension_notify(project):

    try:

            SENDER,

            [project.application.owner.email],

            _(messages.PROJECT_SUSPENSION_SUBJECT) % project.__dict__,

        raise RegisterException("Malformed resource dict.")

    try:

    except Service.DoesNotExist:

        m = "There is no service %s." % service_origin

        raise RegisterException(m)

def action_extra_context(project, table, self):

    user = table.user

    url, action, confirm, prompt = '', '', True, ''

    membership = user.get_membership(project)

    if membership is not None:

# or implied, of GRNET S.A.

import logging

import time

import urllib

from urlparse import urlparse

from datetime import tzinfo, timedelta

from django.template import RequestContext

from django.contrib.auth import authenticate

from django.core.urlresolvers import reverse

from synnefo_branding import utils as branding

from synnefo_branding import settings as branding_settings

import astakos.im.messages as astakos_messages

from astakos.im import activation_backends

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

from django.core.exceptions import PermissionDenied

from django.views.decorators.http import require_http_methods

from snf_django.lib.db.transaction import commit_on_success_strict

        raise PermissionDenied(m)

    try:

    except ProjectApplication.DoesNotExist:

        raise Http404

        raise PermissionDenied(m)

    try:

    except ProjectApplication.DoesNotExist:

        raise Http404

from synnefo.lib.ordereddict import OrderedDict

from astakos.im import presentation

from astakos.im.util import model_to_dict

from astakos.im.models import Resource