Synnefo

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

@component_from_token

def get_pending_commissions(request):

    result = qh.get_pending_commissions(clientkey=client_key)

    return json_response(result)

            if not is_integer(quantity):

                raise ValueError()

        except (TypeError, KeyError, ValueError):

    return lst

    except json.JSONDecodeError:

        raise BadRequest("POST data should be in json format.")

    provisions = input_data.get('provisions')

    if provisions is None:

        raise BadRequest("Provisions are missing.")

    except json.JSONDecodeError:

        raise BadRequest("POST data should be in json format.")

    accept = input_data.get('accept', [])

    reject = input_data.get('reject', [])

@component_from_token

def get_commission(request, serial):

    data = request.GET

    try:

        serial = int(serial)

    except ValueError:

    except ValueError:

        raise BadRequest("Serial should be an integer.")

    accept = 'accept' in input_data

    reject = 'reject' in input_data

        user.moderated_at = datetime.datetime.now()

        user.moderated_data = json.dumps(user.__dict__,

                                         default=lambda obj:

        user.save()

        functions.enable_base_project(user)

        user.moderated_at = datetime.datetime.now()

        user.moderated_data = json.dumps(user.__dict__,

                                         default=lambda obj:

        user.is_rejected = True

        user.rejected_reason = reason

        user.save()

        main_fields = modifies_main_fields(request)

        if main_fields:

            m = (_(astakos_messages.BASE_NO_MODIFY_FIELDS)

            raise ProjectBadRequest(m)

    new_name = request.get("realname")

    main_fields = modifies_main_fields(request)

    if main_fields:

        raise ProjectBadRequest("Cannot modify field(s) '%s' in bulk" %

    projects = Project.objects.initialized(flt).select_for_update()

    _modify_projects(projects, request)

import astakos.im.messages as astakos_messages

from synnefo.lib.ordereddict import OrderedDict

from synnefo.util import units

from astakos.im import presentation

        msg = 'Token renewed for component %s'

        logger.log(astakos_settings.LOGGING_LEVEL, msg, self.name)

        return self.name

    @classmethod

    ui_visible = models.BooleanField(default=True)

    api_visible = models.BooleanField(default=True)

        return self.name

    def full_name(self):

    def get_info(self):

        return {'service': self.service_origin,

    @property

    def group(self):

        default = self.name

    @property

    def help_text(self):

        default = "%s resource" % self.name

    @property

    def help_text_input_each(self):

        default = "%s resource" % self.name

    @property

    def is_abbreviation(self):

    @property

    def report_desc(self):

        default = "%s resource" % self.name

    @property

    def placeholder(self):

    @property

    def verbose_name(self):

    @property

    def display_name(self):

class Chain(models.Model):

    chain = models.AutoField(primary_key=True)

        return "%s" % (self.chain,)

    @property

    def resource_policies(self):

    def is_modification(self):

        # if self.state != self.PENDING:

            return sign + unicode(units.show(v, unit))

        return map(disp, [proj_abs, member_abs])

        return 'Max %s per user: %s' % (self.resource.pluralized_display_name,

                                        self.display_member_capacity())

    objects = ProjectManager()

    def __unicode__(self):

        return _("<project %s '%s'>") % (self.id, self.realname)

        return self.O_STATE_DISPLAY.get(self.overall_state(), _('Unknown'))

    def expiration_info(self):

    def last_deactivation(self):

        objs = self.log.filter(to_state__in=self.DEACTIVATED_STATES)

        unique_together = ("person", "project")

        #index_together = [["project", "state"]]

    def latest_log(self):

        logs = self.log.all()

            try:

                th = holdings[key]

            except KeyError:

                provision = _mkProvision(key, quantity)

                raise NoHoldingError(m,

                                     provision=provision)