Synnefo

FEEDBACK_SEND_ERR                       =   EMAIL_SEND_ERR % 'feedback'

CHANGE_EMAIL_SEND_ERR                   =   EMAIL_SEND_ERR % 'feedback'

NOTIFICATION_SEND_ERR                   =   EMAIL_SEND_ERR % 'notification'

MISSING_NEXT_PARAMETER                  =   'No next parameter'

NOT_ALIVE_PROJECT                       =   'Project %(id)s is not alive.'

NOT_ALLOWED                             =   'You do not have the permissions to perform this action.'

MEMBER_NUMBER_LIMIT_REACHED             =   'Maximum participant number has been reached.'

MEMBER_LEAVE_POLICY_CLOSED              =   'The project member leave policy is closed.'

NOT_MEMBERSHIP_REQUEST                  =   'There is no such a membership request.'

MEMBERSHIP_REQUEST_EXISTS               =   'There is alreary such a membership request.'

ADD_PROJECT_MEMBERS_Q_HELP              =   'Add comma separated user emails, eg. user1@user.com, user2@user.com'

MISSING_IDENTIFIER                      =   'Missing identifier.'

UNKNOWN_IDENTIFIER                      =   'Unknown identidier.'

            p = m.project

            if not p.is_active:

                continue

            for g in grants:

                d[str(g.resource)] += g.member_limit or inf

        # TODO set default for remaining

        """

        q = list(get_alive_projects())

        q = filter(lambda p: p.definition.name == self.name , q)

        if self.projectapplication.precursor_application:

                self.projectapplication.precursor_application.id, q)

        if q:

            raise ValidationError(

        application.state = PENDING

        application.save()

        application.definition.resource_policies = resource_policies

        return application

    def approve(self, approval_user=None):

        it is checked whether the request_user is eligible.

        Raises:

        """

        try:

            self.definition.validate_name()

        except:

            project = Project()

            project.creation_date = now

        project.last_application_approved = self

        project.last_approval_date = now

        project.save()

        p = precursor

        while p:

        self.state = APPROVED

        self.save()

        rejected = self.project.sync()

class Project(models.Model):

    application = models.OneToOneField(

    creation_date = models.DateTimeField()

    last_approval_date = models.DateTimeField(null=True)

    termination_start_date = models.DateTimeField(null=True)

    last_application_approved = models.OneToOneField(

        ProjectApplication, related_name='last_project')

    @property

    def definition(self):

    @property

    def violated_members_number_limit(self):

            return

        members = specific_members or self.approved_members

        c, rejected = send_quota(self.approved_members)

        return rejected

    def accept_member(self, user, request_user=None):

            self.termination_date = datetime.now()

            self.save()

    def suspend(self):

        self.last_approval_date = None

        self.save()

        self.sync()

class ProjectMembership(models.Model):

    person = models.ForeignKey(AstakosUser)

        """

            Raises:

                django.exception.PermissionDenied

        """

        try:

            if request_user and \

                    not request_user.is_superuser):

                raise PermissionDenied(_(astakos_messages.NOT_ALLOWED))

            if not self.project.is_alive:

            return

        self.acceptance_date = datetime.now()

        self.save()

        self.sync()

    def reject(self, request_user=None):

        """

            Raises:

        """

        if request_user and \

                not request_user.is_superuser):

            raise PermissionDenied(_(astakos_messages.NOT_ALLOWED))

        if not self.project.is_alive:

        )

        self.delete()

        history_item.save()

    def remove(self, request_user=None):

        """

            Raises:

                django.exception.PermissionDenied

        """

        if request_user and \

                not request_user.is_superuser):

            raise PermissionDenied(_(astakos_messages.NOT_ALLOWED))

        if not self.project.is_alive:

        )

        self.delete()

        history_item.save()

        self.sync()

    def leave(self):

        if leave_policy == get_auto_accept_leave():

            self.remove()

        else:

def check_closed_join_membership_policy(sender, instance, **kwargs):

    if instance.id:

        return

        return

    if join_policy == get_closed_join():

        raise PermissionDenied(_(astakos_messages.MEMBER_JOIN_POLICY_CLOSED))

pre_save.connect(check_closed_join_membership_policy, sender=ProjectMembership)

def check_auto_accept_join_membership_policy(sender, instance, created, **kwargs):

    if not created:

        return

    if join_policy == get_auto_accept_join() and not instance.acceptance_date:

        instance.accept()

post_save.connect(check_auto_accept_join_membership_policy, sender=ProjectMembership)

)

#from astakos.im.tasks import request_billing

from astakos.im.api.callpoint import AstakosCallpoint

import astakos.im.messages as astakos_messages

from astakos.im import settings

            extra_context=extra_context, post_save_redirect='/im/project/list/',

            form_class=ProjectApplicationForm)

        return r

        rollback = True

        return render_response(

            'im/projects/projectapplication_form.html',

            sorting = 'definition__name',

        messages.error(request, msg)

    except PermissionDenied, e:

        messages.error(request, e)

        rollback = True

    else:

        return project_detail(request, id)

    finally:

        else:

            try:

                func(request, m)

                messages.error(request, e)

                rollback = True

        finally:

            if rollback: