Synnefo

        return self._details(g)

    @safe

    def submit_application(self, **kwargs):

        app = self._create_object(ProjectApplication, **kwargs)

        notification = build_notification(

            settings.SERVER_EMAIL,

            [settings.ADMINS],

            _(GROUP_CREATION_SUBJECT) % {'group':app.definition.name},

            _('An new project application identified by %(serial)s has been submitted.') % app.serial

        )

        notification.send()

    @safe

    def list_applications(self):

        return self._list(ProjectAppication)

    @safe

    def approve_application(self, serial):

        app = self._lookup_object(ProjectAppication, serial=serial)

        notify = False

        if not app.precursor_application:

            kwargs = {

                'application':app,

                'creation_date':datetime.now(),

                'last_approval_date':datetime.now(),

            }

            project = self._create_object(Project, **kwargs)

        else:

            project = app.precursor_application.project

            last_approval_date = project.last_approval_date

            if project.is_valid:

                project.application = app

                project.last_approval_date = datetime.now()

                project.save()

            else:

                raise Exception(_(astakos_messages.INVALID_PROJECT) % project.__dict__)

        r = _synchonize_project(project.serial)

        if not r.is_success:

            # revert to precursor

            project.appication = app.precursor_application

            if project.application:

                project.last_approval_date = last_approval_date

            project.save()

            r = synchonize_project(project.serial)

            if not r.is_success:

                raise Exception(_(astakos_messages.QH_SYNC_ERROR))

        else:

            project.last_application_synced = app

            project.save()

            sender, recipients, subject, message

            notification = build_notification(

                settings.SERVER_EMAIL,

                [project.owner.email],

                _('Project application has been approved on %s alpha2 testing' % SITENAME),

                _('Your application request %(serial)s has been apporved.')

            )

            notification.send()

    @safe

    def list_projects(self, filter_property=None):

        if filter_property:

            q = filter_queryset_by_property(

                Project.objects.all(),

                filter_property

            )

            return map(lambda o: self._details(o), q)

        return self._list(Project)

    @safe

    def add_project_member(self, serial, user_id, request_user):

        project = self._lookup_object(Project, serial=serial)

        user = self.lookup_user(user_id)

        if not project.owner == request_user:

            raise Exception(_(astakos_messages.NOT_PROJECT_OWNER))

        if not project.is_alive:

            raise Exception(_(astakos_messages.NOT_ALIVE_PROJECT) % project.__dict__)

        if len(project.members) + 1 > project.limit_on_members_number:

            raise Exception(_(astakos_messages.MEMBER_NUMBER_LIMIT_REACHED))

        m = self._lookup_object(ProjectMembership, person=user, project=project)

        if m.is_accepted:

            return

        m.is_accepted = True

        m.decision_date = datetime.now()

        m.save()

        notification = build_notification(

            settings.SERVER_EMAIL,

            [user.email],

            _('Your membership on project %(name)s has been accepted.') % project.definition.__dict__, 

            _('Your membership on project %(name)s has been accepted.') % project.definition.__dict__,

        )

        notification.send()

    @safe

    def remove_project_member(self, serial, user_id, request_user):

        project = self._lookup_object(Project, serial=serial)

        if not project.is_alive:

            raise Exception(_(astakos_messages.NOT_ALIVE_PROJECT) % project.__dict__)

        if not project.owner == request_user:

            raise Exception(_(astakos_messages.NOT_PROJECT_OWNER))

        user = self.lookup_user(user_id)

        m = self._lookup_object(ProjectMembership, person=user, project=project)

        if not m.is_accepted:

            return

        m.is_accepted = False

        m.decision_date = datetime.now()

        m.save()

        notification = build_notification(

            settings.SERVER_EMAIL,

            [user.email],

            _('Your membership on project %(name)s has been removed.') % project.definition.__dict__, 

            _('Your membership on project %(name)s has been removed.') % project.definition.__dict__,

        )

        notification.send()    

    @safe

    def suspend_project(self, serial):

        project = self._lookup_object(Project, serial=serial)

        project.suspend()

        notification = build_notification(

            settings.SERVER_EMAIL,

            [project.owner.email],

            _('Project %(name)s has been suspended on %s alpha2 testing' % SITENAME),

            _('Project %(name)s has been suspended on %s alpha2 testing' % SITENAME)

        )

        notification.send()

    @safe

    def terminate_project(self, serial):

        project = self._lookup_object(Project, serial=serial)

        project.termination()

        notification = build_notification(

            settings.SERVER_EMAIL,

            [project.owner.email],

            _('Project %(name)s has been terminated on %s alpha2 testing' % SITENAME),

            _('Project %(name)s has been terminated on %s alpha2 testing' % SITENAME)

        )

        notification.send()

    @safe

    def synchonize_project(self, serial):

        project = self._lookup_object(Project, serial=serial)

        project.sync()