Synnefo

snf-astakos-app/distribute-0.6.10-py2.6.egg

snf-astakos-app/distribute-0.6.10.tar.gz

ASTAKOS_ACCOUNT_CREATION_SUBJECT            '%s alpha2 testing account created (%%(user)s)' % SITENAME                      Account creation email subject

ASTAKOS_GROUP_CREATION_SUBJECT              '%s alpha2 testing group created (%%(group)s)' % SITENAME                       Group creation email subject

                                                                                                                            e.g. ``http://localhost:8080/api/quotaholder/v``

ASTAKOS_SERVICES                            {'cyclades': {'resources': [{'desc': 'Number of virtual machines',              Default cloud service information

                                            'group': 'storage',

                                            'name': 'vm',

                                            'uplimit': 2},

                                            {'desc': 'Virtual machine disk size',

                                            'group': 'storage',

                                            'name': 'disksize',

                                            'unit': 'GB',

                                            'uplimit': 5},

                                            {'desc': 'Number of virtual machine processors',

                                            'group': 'storage',

                                            'name': 'cpu',

                                            'uplimit': 1},

                                            {'desc': 'Virtual machines',

                                            'group': 'storage',

                                            'name': 'ram',

                                            'unit': 'MB',

                                            'uplimit': 1024}],

                                            'url': 'https://node1.example.com/ui/'},

                                            'pithos+': {'resources': [{'desc': 'Pithos account diskspace',

                                            'group': 'compute',

                                            'name': 'diskspace',

                                            'unit': 'bytes',

                                            'uplimit': 5368709120}],

                                            'url': 'https://node2.example.com/ui/'}}                                                                               

                                                                                                                            e.g. ``http://localhost:8888/user``

ASTAKOS_NEWPASSWD_INVALIDATE_TOKEN          True                                                                            Enforce token renewal on password change/reset. If set to False, user can optionally decide

                                                                                                                            whether to renew the token or not.

from astakos.im.functions import (send_verification, send_activation,

                                  send_account_creation_notification,

                                  send_group_creation_notification, activate)

                send_account_creation_notification(

                    dictionary={'user': user, 'group_creation': True}

               url=absolute(request, reverse('index')),

               name=user.email))

                       url=absolute(request, reverse('password_change')),

                       name="Change password"))

                       url=absolute(request, reverse('email_change')),

                       name="Change email"))

                       url=absolute(request, reverse('invite')),

                       name="Invitations"))

                   url=absolute(request, reverse('feedback')),

                   name="Feedback"))

                   url=absolute(request, reverse('group_list')),

                   name="Groups",

                   submenu=(item(

                            url=absolute(request,

                                         reverse('group_list')),

                            name="Overview"),

                   url=absolute(request, reverse('resource_list')),

                   name="Resources"))

                   url=absolute(request, reverse('billing')),

                   name="Billing"))

                   url=absolute(request, reverse('timeline')),

                   name="Timeline"))

                   url=absolute(request, reverse('logout')),

                   name="Sign out"))

# Copyright 2011-2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from astakos.im.api.backends.lib.django import DjangoBackend

def get_backend():

    return DjangoBackend()

class ItemNotExists(NameError):

    pass

class ItemExists(NameError):

    pass

class MissingIdentifier(IOError):

    pass

class BaseBackend(object):

    def update_user():

        pass

    def create_user():

        pass

# Copyright 2011-2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.db import IntegrityError, transaction

from django.core.exceptions import ObjectDoesNotExist

from functools import wraps

from smtplib import SMTPException

from astakos.im.models import AstakosUser, Resource, Service, RESOURCE_SEPARATOR

from astakos.im.api.backends.base import (BaseBackend, ItemNotExists,

                                          ItemExists, MissingIdentifier)

from astakos.im.util import reserved_email, model_to_dict

from astakos.im.endpoints.quotaholder import get_quota

import logging

logger = logging.getLogger(__name__)

DEFAULT_CONTENT_TYPE = None

def safe(propagate_exceptions=False):

    """Decorator function for views that implement an API method."""

    def decorator(func):

        @transaction.commit_manually

        @wraps(func)

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

            logger.debug('%s %s %s' % (func, args, kwargs))

            try:

                r = func(self, *args, **kwargs) or ()

            except Exception, e:

                logger.exception(e)

                transaction.rollback()

                if propagate_exceptions:

                    raise e

                else:

                    args = list(args)

                    args.append(e)

                    r = args

            else:

                transaction.commit()

            r = filter(bool, r) # filter out None elements

            return list(r)

        return wrapper

    return decorator

class DjangoBackend(BaseBackend):

    def _lookup_object(self, model, **kwargs):

        """

        Returns an object of the specific model having this id.

        """

        if not kwargs:

            raise MissingIdentifier

        try:

            return model.objects.get(**kwargs)

        except model.DoesNotExist:

            raise ItemNotExists()

    def _lookup_user(self, id):

        """

        Returns an AstakosUser having this id.

        """

        return self._lookup_object(AstakosUser, id=id)

    def _lookup_service(self, id):

        """

        Returns an Service having this id.

        """

        return self._lookup_object(Service, id=id)

    def _list(self, model, filter=()):

        q = model.objects.all()

        if filter:

            q = q.filter(id__in=filter)

        return map(lambda o: model_to_dict(o, exclude=[]), q)

    def _create_object(self, model, **kwargs):

        o = model(**kwargs)

        o.save()

        return o

    def _update_object(self, model, id, save=True, **kwargs):

        o = self._lookup_object(model, id=id)

        if kwargs:

            o.__dict__.update(kwargs)

        if save:

            o.save()

        return o

    @safe()

    def update_user(self, user_id, renew_token=False, **kwargs):

        user = self._update_object(AstakosUser, user_id, save=False, **kwargs)

        if renew_token:

            user.renew_token()

        if kwargs or renew_token:

            user.save()

    @safe()

    def create_user(self, **kwargs):

        policies = kwargs.pop('policies', ())

        permissions = kwargs.pop('permissions', ())

        groups = kwargs.pop('groups', ())

        password = kwargs.pop('password', None)

        u = self._create_object(AstakosUser, **kwargs)

        if password:

            u.set_password(password)

        u.permissions = permissions

        u.policies = policies

        u.extended_groups = groups

    @safe()

    def add_policies(self, user_id, update=False, policies=()):

        user = self._lookup_user(user_id)

        rejected = []

        append = rejected.append

        for p in policies:

            service = p.get('service')

            resource = p.get('resource')

            uplimit = p.get('uplimit')

            try:

                user.add_policy(service, resource, uplimit, update)

            except (ObjectDoesNotExist, IntegrityError), e:

                append((service, resource, e))

        if rejected:

            raise Exception(rejected)

    @safe()

    def remove_policies(self, user_id, policies=()):

        user = self._lookup_user(user_id)

        if not user:

            return user_id

        rejected = []

        append = rejected.append

        for p in policies:

            service = p.get('service')

            resource = p.get('resource')

            try:

                user.delete_policy(service, resource)

            except ObjectDoesNotExist, e:

                append((service, resource, e))

        if rejected:

            raise Exception(rejected)

    @safe()

    def add_permissions(self, user_id, permissions=()):

        user = self._lookup_user(user_id)

        rejected = []

        append = rejected.append

        for p in permissions:

            try:

                user.add_permission(p)

            except IntegrityError, e:

                append((p, e))

        if rejected:

            raise Exception(rejected)

    @safe()

    def remove_permissions(self, user_id, permissions=()):

        user = self._lookup_user(user_id)

        rejected = []

        append = rejected.append

        for p in permissions:

            try:

                user.remove_permission(p)

            except (ObjectDoesNotExist, IntegrityError), e:

                append((p, e))

        if rejected:

            raise Exception(rejected)

    @safe()

    def invite_users(self, senderid, recipients=()):

        user = self._lookup_user(senderid)

        rejected = []

        append = rejected.append

        for r in recipients:

            try:

                user.invite(r.get('email'), r.get('realname'))

            except (IntegrityError, SMTPException), e:

                append((email, e))

        if rejected:

            raise Exception(rejected)

    @safe(propagate_exceptions=True)

    def list_users(self, filter=()):

        return self._list(AstakosUser, filter=filter)

    @safe(propagate_exceptions=True)

    def get_resource_usage(self, user_id):

        user = self._lookup_user(user_id)

        c, data = get_quota((user,))

        resources = []

        append = resources.append

        for t in data:

            t = (i if i else 0 for i in t)

            (entity, name, quantity, capacity, importLimit, exportLimit,

             imported, exported, returned, released, flags) = t

            service, sep, resource = name.partition(RESOURCE_SEPARATOR)

            resource = Resource.objects.select_related().get(

                service__name=service, name=resource)

            d = dict(name=name,

                     description=resource.desc,

                     unit=resource.unit or '',

                     maxValue=quantity + capacity,

                     currValue=quantity + imported - released - exported + returned)

            append(d)

        return resources

    @safe(propagate_exceptions=True)

    def list_resources(self, filter=()):

        return self._list(Resource, filter=filter)

    @safe()

    def create_service(self, **kwargs):

        resources = kwargs.pop('resources', ())

        s = self._create_object(Service, **kwargs)

        s.resources = resources

    @safe()

    def remove_services(self, ids=()):

        # TODO return information for unknown ids

        q = Service.objects.filter(id__in=ids)

        q.delete()

    @safe()

    def update_service(self, service_id, renew_token=False, **kwargs):

        s = self._update_object(Service, service_id, save=False, **kwargs)

        if renew_token:

            s.renew_token()

        if kwargs or renew_token:

            s.save()

    @safe()

    def add_resources(self, service_id, update=False, resources=()):

        s = self._lookup_service(service_id)

        rejected = []

        append = rejected.append

        for r in resources:

            try:

                rr = r.copy()

                resource_id = rr.pop('id', None)

                if update:

                    if not resource_id:

                        raise MissingIdentifier

                    resource = self._update_object(Resource, resource_id, **rr)

                else:

                    resource = self._create_object(Resource, service=s, **rr)

            except Exception, e:

                append((r, e))

        if rejected:

            raise Exception(rejected)

    @safe()

    def remove_resources(self, service_id, ids=()):

        # TODO return information for unknown ids

        q = Resource.objects.filter(service__id=service_id,

                                id__in=ids)

        q.delete()

    @safe()

    def create_group(self, **kwargs):

        policies = kwargs.pop('policies', ())

        permissions = kwargs.pop('permissions', ())

        members = kwargs.pop('members', ())

        owners = kwargs.pop('owners', ())

        g = self._create_object(AstakosGroup, **kwargs)

        g.permissions = permissions

        g.policies = policies

        g.members = members

        g.owners = owners

# Copyright 2011-2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from astakos.im.api.spec import AstakosAPI

from backends import get_backend

from commissioning import (Callpoint,

                           #                             CommissionException,

                           #                             CorruptedError, InvalidDataError,

                           #                             InvalidKeyError, NoEntityError,

                           #                             NoQuantityError, NoCapacityError,

                           #                             ExportLimitError, ImportLimitError

                           )

# from commissioning.utils.newname import newname

# from django.db.models import Model, BigIntegerField, CharField, ForeignKey, Q

# from django.db import transaction, IntegrityError

# from .models import (Holder, Entity, Policy, Holding,

#                      Commission, Provision, ProvisionLog, now)

class AstakosDjangoDBCallpoint():

    api_spec = AstakosAPI()

#     http_exc_lookup = {

#         CorruptedError:   550,

#         InvalidDataError: 400,

#         InvalidKeyError:  401,

#         NoEntityError:    404,

#         NoQuantityError:  413,

#         NoCapacityError:  413,

#     }

    def init_connection(self, connection):

        if connection is not None:

            raise ValueError("Cannot specify connection args with %s" %

                             type(self).__name__)

        pass

    def commit(self):

        transaction.commit()

    def rollback(self):

        transaction.rollback()

    def do_make_call(self, call_name, data):

        call_fn = getattr(self, call_name, None)

        if not call_fn:

            m = "cannot find call '%s'" % (call_name,)

            raise CorruptedError(m)

        return call_fn(**data)

    def create_users(self, users=()):

        b = get_backend()

        rejected = (b.create_user(**u) for u in users)

        return rejected

    def update_users(self, users=()):

        b = get_backend()

        rejected = (b.update_user(**u) for u in users)

        return rejected

    def add_user_policies(self, user_id, update=False, policies=()):

        b = get_backend()

        rejected = b.add_policies(user_id, update, policies)

        return rejected

    def remove_user_policies(self, user_id, policies=()):

        b = get_backend()

        rejected = b.remove_policies(user_id, policies)

        return rejected

    def add_user_permissions(self, user_id, permissions=()):

        b = get_backend()

        rejected = b.add_permissions(user_id, permissions)

        return rejected

    def remove_user_permissions(self, user_id, permissions=()):

        b = get_backend()

        rejected = b.remove_permissions(user_id, permissions)

        return rejected

    def invite_users(self, sender_id, recipients=()):

        b = get_backend()

        rejected = b.invite_users(sender_id, recipients)

        return rejected

    def list_users(self, filter=()):

        b = get_backend()

        return b.list_users(filter)

    def get_user_status(self, user_id):

        b = get_backend()

        return b.get_resource_usage(user_id)

    def list_resources(self, filter=()):

        b = get_backend()

        return b.list_resources(filter)

    def add_services(self, services=()):

        b = get_backend()

        rejected = (b.create_service(**s) for s in services)

        return rejected

    def update_services(self, services=()):

        b = get_backend()

        rejected = (b.update_service(**s) for s in services)

        return rejected

    def remove_services(self, ids=()):

        b = get_backend()

        rejected = b.remove_services(ids)

        return rejected

    def add_resources(self, service_id, update=False, resources=()):

        b = get_backend()

        rejected = b.add_resources(service_id, update, resources)

        return rejected

    def remove_resources(self, service_id, ids=()):

        b = get_backend()

        rejected = b.remove_resources(service_id, ids)

        return rejected

    def create_groups(self, groups=()):

        b = get_backend()

        rejected = (b.create_group(**g) for g in groups)

        return rejected

API_Callpoint = AstakosDjangoDBCallpoint

#!/usr/bin/env python

from commissioning.clients.http import main, HTTP_API_Client

from astakos.im.api.spec import AstakosAPI

class AstakosHTTP(HTTP_API_Client):

    api_spec = AstakosAPI()

if __name__ == '__main__':

    main(callpoint=AstakosHTTP())

from commissioning.api.specificator import (

    CanonifyException, SpecifyException,

    Specificator, Null, Integer, Text,

    Tuple, ListOf, Dict, Args)

class Name(Text):

    def init(self):

        self.opts.update({'regex': "[\w.:]+", 'maxlen': 512})

Name = Name()

class Email(Text):

    def init(self):

        pattern = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?"

        self.opts.update({'regex': pattern, 'maxlen': 512})

Email = Email()

class Url(Text):

    def init(self):

        pattern = "(((f|ht){1}tp://)[-a-zA-Z0-9@:%_\+.~#?&//=]+)"

        self.opts.update({'regex': pattern, 'maxlen': 512})

Url = Url()

class Filepath(Text):

    def init(self):

        self.opts.update({'regex': "", 'maxlen': 512})

Filepath = Filepath()

class Nonnegative(Integer):

    def init(self):

        self.opts.update({'minimum': 0})

Nonnegative = Nonnegative()

class Boolean(Integer):

    def init(self):

        self.opts.update({'minimum': 0, 'maximum': 1})

Boolean = Boolean()

class GroupKind(Integer):

    def init(self):

        self.opts.update({'minimum': 1, 'maximum': 5})

GroupKind = GroupKind()

Timepoint = Text(classname='Timepoint', maxlen=24)

class AstakosAPI(Specificator):

    def create_users(

        self,

        users=ListOf(

            email=Email,

            first_name=Name,

            last_name=Name,

            is_active=Boolean,

            is_superuser=Boolean,

            affiliation=Name,

            password=Name,

            provider=Name,

            level=Nonnegative,

            invitations=Nonnegative,

            is_verified=Boolean,

            third_party_identifier=Name,

            email_verified=Boolean),

        policies=ListOf(resource=Name, supimit=Nonnegative),

        groups=ListOf(Name),

        permissions=ListOf(Name)

    ):

        rejected = ListOf(user=Email, reason=Text())

        return rejected

    def update_users(

        self,

        users=ListOf(

            pk=Nonnegative,

            renew_token=Boolean,

            data=ListOf(

                first_name=Name,

                last_name=Name,

                is_active=Boolean,

                is_superuser=Boolean,

                affiliation=Name,

                password=Name,

                provider=Name,

                level=Nonnegative,

                invitations=Nonnegative,

                is_verified=Boolean,

                third_party_identifier=Name,

                email_verified=Boolean

            )

        )

    ):

        rejected = ListOf(user_id=Nonnegative, reason=Text())

        return rejected

    def add_user_policies(

        self,

        pk=Nonnegative,

        update=Boolean,

        policies=ListOf(service=Name, resource=Name, upimit=Nonnegative)

    ):

        rejected = ListOf(resource=Name, reason=Text())

        return rejected

    def remove_user_policies(

        self,

        pk=Nonnegative,

        policies=ListOf(service=Name, resource=Name)

    ):

        rejected = ListOf(service=Name, resource=Name)

        return rejected

    def add_user_permissions(

        self,

        pk=Nonnegative,

        permissions=ListOf(permission=Name)

    ):

        rejected = ListOf(permission=Name)

        return rejected

    def remove_user_permissions(

        self,

        pk=Nonnegative,

        permissions=ListOf(permission=Name)

    ):

        rejected = ListOf(permission=Name)

        return rejected

    def invite_users(

        self,

        sender=Email,

        data=ListOf(email=Email, realname=Name)

    ):

        rejected = ListOf(receiver=Email)

        return rejected

    def list_users(

        self,

        filter=ListOf(id=Nonnegative)

    ):

        return ListOf(

            activation_sent=Timepoint,

            affiliation=Name,

            auth_token=Name,

            auth_token_created=Timepoint,

            auth_token_expires=Timepoint,

            date_joined=Timepoint,

            date_signed_terms=Timepoint,

            email=Email,

            email_verified=Boolean,

            first_name=Name,

            has_credits=Boolean,

            has_signed_terms=Boolean,

            id=Nonnegative,

            invitations=Nonnegative,

            invitations_sent=ListOf(

                code=Name,

                consumed=Boolean,

                created=Timepoint,

                id=Nonnegative,

                realname=Name,

                username=Email

            ),

            is_active=Boolean,

            is_staff=Boolean,

            is_superuser=Boolean,

            is_verified=Boolean,

            last_login=Timepoint,

            last_name=Name,

            level=Nonnegative,

            password=Name,

            provider=Name,

            third_party_identifier=Name,

            updated=Timepoint,

            user_permissions=ListOf(

                codename=Name,

                id=Nonnegative,

                name=Name

            ),

            username=Name,

            astakos_groups=ListOf(

                approval_date=Timepoint,

                creation_date=Timepoint,

                desc=Text(),

                max_participants=Nonnegative,

                expiration_date=Timepoint,

                group_ptr=Url,

                homepage=Url,

                id=Nonnegative,

                issue_date=Timepoint,

                kind=Name,

                moderation_enabled=Boolean,

                name=Name,

                #permissions=ListOf(),

                policy=ListOf(id=Nonnegative, name=Name)

            )

        )

    def get_user_status(

        self,

        user_id=Nonnegative

    ):

        return ListOf(

            name=Name,

            description=Text(),

            unit=Name,

            maxValue=Integer(),

            currValue=Integer()

        )

    def list_resources(self, filter=ListOf(id=Nonnegative)):

        return ListOf(

            desc=Text(),

            group=Name,

            id=Nonnegative,

            meta=ListOf(key=Name, value=Name),

            name=Name,

            service=Name,

            unit=Name

        )

    def add_services(

        self,

        services=ListOf(

            name=Name,

            url=Url,

            icon=Filepath,

            resources=ListOf(

                name=Name,

                desc=Text(),

                unit=Name,

                group=Name

            )

        )

    ):

        rejected = ListOf(service=Name)

        return rejected

    def update_services(

        self,

        services=ListOf(id=Nonnegative, url=Url, icon=Filepath)

    ):

        rejected = ListOf(service=Name)

        return rejected

    def remove_services(self, ids=ListOf(Nonnegative)):

        rejected = ListOf(service=Name)

        return rejected

    def add_resources(

        self,

        service_id=Nonnegative,

        update=Boolean,

        resources=ListOf(

            name=Name,

            resources=ListOf(

                name=Name,

                desc=Text(),

                unit=Name,

                group=Name)

        )

    ):

        rejected = ListOf(service=Name)

        return rejected

    def remove_resources(

        self,

        service_id=Nonnegative,

        ids=ListOf(Nonnegative)

    ):

        rejected = ListOf(Name)

        return rejected

    def create_groups(

        self,

        groups=ListOf(

            name=Name,

            kind=GroupKind,

            homepage=Url,

            desc=Text(),

            policies=ListOf(resource=Name, upimit=Nonnegative),

            issue_date=Timepoint,

            expiration_date=Timepoint,

            moderation_enabled=Boolean,

            participants=Nonnegative,

            permissions=ListOf(permission=Name),

            members=ListOf(user=Email, is_approved=Boolean),

            owners=ListOf(user=Email)

        )

    ):

        rejected = ListOf(group=Name)

        return rejected

    def enable_groups(self, data=ListOf(group=Name)):

        rejected = ListOf(group=Name)

        return rejected

    def search_groups(self, key=Name):

        return ListOf(

            group=Name,

            kind=GroupKind,

            homepage=Url,

            desc=Text(),

            creation_date=Timepoint,

            issue_date=Timepoint,

            expiration_date=Timepoint,

            moderation_enabled=Boolean,

            participants=Nonnegative,

            owner=ListOf(user=Email),

            policies=ListOf(resource=Name, upimit=Nonnegative),

            members=ListOf(user=Email, is_approved=Boolean)

        )

    def list_groups(self):

        return ListOf(

            group=Name,

            kind=GroupKind,

            homepage=Url,

            desc=Text(),

            creation_date=Timepoint,

            issue_date=Timepoint,

            expiration_date=Timepoint,

            moderation_enabled=Boolean,

            participants=Nonnegative,

            owners=ListOf(user=Email),

            policies=ListOf(resource=Name, upimit=Nonnegative),

            members=ListOf(user=Email, is_approved=Boolean)

        )

    def add_owners(

        self,

        data=ListOf(group=Name, owners=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def remove_owners(

        self,

        data=ListOf(group=Name, owners=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def add_members(

        self,

        data=ListOf(group=Name, members=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def remove_members(

        self,

        data=ListOf(group=Name, members=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def add_policies(

        self,

        data=ListOf(group=Name, resource=Name, upimit=Nonnegative)

    ):

        rejected = ListOf(group=Name, resource=Name)

        return rejected

    def remove_group_policies(

        self,

        data=ListOf(group=Name, resource=Name, upimit=Nonnegative)

    ):

        rejected = ListOf(group=Name, resource=Name)

        return rejected

    def update_group_policies(

        self, data=ListOf(group=Name, resource=Name, upimit=Nonnegative)

    ):

        rejected = ListOf(group=Name, resource=Name)

        return rejected

    def approve_members(

        self,

        data=ListOf(group=Name, members=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def disapprove_members(

        self,

        data=ListOf(group=Name, members=ListOf(user=Email))

    ):

        rejected = ListOf(user=Email)

        return rejected

    def add_group_permissions(

        self,

        data=ListOf(group=Name, permission=Name)

    ):

        rejected = ListOf(group=Name, permission=Name)

        return rejected

    def delete_group_permissions(

        self,

        data=ListOf(group=Name, permission=Name)

    ):

        rejected = ListOf(group=Name, permission=Name)

        return rejected

    def list_resource_units(self):

        return ListOf(Name)

    def get_approval_terms(term=Nonnegative):

        return Text()

    def add_approval_terms(location=Filepath):

        return Nonnegative

#     def change_emails():

#         pass

    EXTRA_MESSAGES_SET = bool(GLOBAL_MESSAGES or SIGNUP_MESSAGES or

                              LOGIN_MESSAGES or PROFILE_MESSAGES)

                    datefmt='%Y-%m-%d %H:%M:%S'

                    )

                return c, data

            args = (

                user.email, resource, key, quantity, capacity, import_limit,

                export_limit, flags)

            uu_total / t_total,

            tu_total // len(timeline),

        context={},

        after=after,

        before=before,

        get_timeline=[[entity, resource, key]])

                                       PasswordResetForm, PasswordChangeForm,

                                       SetPasswordForm)

                               get_latest_terms, RESOURCE_SEPARATOR)

                                 PASSWORD_RESET_EMAIL_SUBJECT,

                                 NEWPASSWD_INVALIDATE_TOKEN)

class InvitedShibbolethUserCreationForm(ShibbolethUserCreationForm,

                                        InvitedThirdPartyUserCreationForm):

    def clean_username(self):

        if 'username' in self.cleaned_data:

            return self.cleaned_data['username'].lower()

    Most of the fields are readonly since the user is not allowed to change

    them.

    The class defines a save method which sets ``is_verified`` to True so as the

    user during the next login will not to be redirected to profile page.

    if not NEWPASSWD_INVALIDATE_TOKEN:

        renew = forms.BooleanField(label='Renew token', required=False,

                                   initial=True,

                                   help_text='Unsetting this may result in security risk.')

        if NEWPASSWD_INVALIDATE_TOKEN or self.cleaned_data.get('renew'):

            self.user.renew_token()

        return super(ExtendedPasswordChangeForm, self).save(commit=commit)

        required=False

    max_participants = forms.IntegerField(

        widget=forms.HiddenInput(), label='', required=False

    )

        #update QueryDict