Synnefo

from django.contrib.auth.models import AnonymousUser

from django.core.exceptions import PermissionDenied

from django.db import IntegrityError

from django.http import Http404

from synnefo_branding.utils import render_to_string

from astakos.im.notifications import build_notification, NotificationError

from astakos.im.models import (

    AstakosUser, Invitation, ProjectMembership, ProjectApplication, Project,

from astakos.im.project_notif import (

    membership_change_notify, membership_enroll_notify,

    membership_request_notify, membership_leave_request_notify,

        raise IOError(m)

    try:

        raise IOError(m)

    try:

    except ProjectApplication.DoesNotExist:

        m = _(astakos_messages.UNKNOWN_PROJECT_APPLICATION_ID) % application_id

        raise IOError(m)

        raise IOError(m)

    try:

    except ProjectMembership.DoesNotExist:

        m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST)

        raise IOError(m)

    try:

    except ProjectMembership.DoesNotExist:

        m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST)

        raise IOError(m)

def accept_membership(project_id, memb_id, request_user=None):

    if not membership.can_accept():

        m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST)

        raise PermissionDenied(m)

    user = membership.person

    membership.accept()

    qh_sync_user(user)

def reject_membership(project_id, memb_id, request_user=None):

    if not membership.can_reject():

        m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST)

        raise PermissionDenied(m)

    user = membership.person

    membership.reject()

    logger.info("Request of user %s for %s has been rejected." %

def cancel_membership(project_id, request_user):

    if not membership.can_cancel():

        m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST)

        raise PermissionDenied(m)

    membership.cancel()

    logger.info("Request of user %s for %s has been cancelled." %

                (membership.person.log_display, project))

def remove_membership(project_id, memb_id, request_user=None):

    if not membership.can_remove():

        m = _(astakos_messages.NOT_ACCEPTED_MEMBERSHIP)

        raise PermissionDenied(m)

    user = membership.person

    membership.remove()

    qh_sync_user(user)

def enroll_member(project_id, user, request_user=None):

    accept_membership_checks(project, request_user)

    membership, created = ProjectMembership.objects.get_or_create(

def leave_project(project_id, request_user):

    if not membership.can_leave():

        m = _(astakos_messages.NOT_ACCEPTED_MEMBERSHIP)

        raise PermissionDenied(m)

    auto_accepted = False

    leave_policy = project.application.member_leave_policy

    if leave_policy == AUTO_ACCEPT_POLICY:

        membership.remove()

        qh_sync_user(request_user)

        logger.info("User %s has left %s." %

        auto_accepted = True

    else:

        membership.leave_request()

        logger.info("User %s requested to leave %s." %

        membership_leave_request_notify(project, membership.person)

    return auto_accepted

def join_project(project_id, request_user):

    join_project_checks(project)

    membership, created = ProjectMembership.objects.get_or_create(

        membership.accept()

        qh_sync_user(request_user)

        logger.info("User %s joined %s." %

        auto_accepted = True

    else:

        membership_request_notify(project, membership.person)

        logger.info("User %s requested to join %s." %

    return auto_accepted

    precursor = None

    if precursor_id is not None:

        if (request_user and

            (not precursor.owner == request_user and

        chain = precursor.chain

        application.chain = chain

        objs = ProjectApplication.objects

        for app in pending:

            app.state = ProjectApplication.REPLACED

            app.save()

def cancel_application(application_id, request_user=None, reason=""):

    checkAllowed(application, request_user)

    if not application.can_cancel():

def dismiss_application(application_id, request_user=None, reason=""):

    checkAllowed(application, request_user)

    if not application.can_dismiss():

def deny_application(application_id, request_user=None, reason=""):

    checkAllowed(application, request_user, admin_only=True)

    application_deny_notify(application)

    try:

    checkAllowed(application, request_user, admin_only=True)

              (application.id, application.state_display()))

        raise PermissionDenied(m)

    logger.info("%s has been approved." % (application.log_display))

    application_approve_notify(application)

def terminate(project_id, request_user=None):

    checkAllowed(project, request_user, admin_only=True)

    checkAlive(project)

def suspend(project_id, request_user=None):

    checkAllowed(project, request_user, admin_only=True)

    checkAlive(project)

def resume(project_id, request_user=None):

    checkAllowed(project, request_user, admin_only=True)

    if not project.is_suspended:

    return usage

    if precursor is None:

        diff = 1

    else:

        q = objs.filter(chain=chain, state=ProjectApplication.PENDING)

        count = q.count()

        diff = 1 - count

    register_pending_apps(user, -1)

from astakos.im.models import AstakosUser

from astakos.im.quotas import (

from astakos.im.functions import get_user_by_uuid

from astakos.im.management.commands._common import is_uuid, is_email

from snf_django.lib.db.transaction import commit_on_success_strict

                               output_format)

        elif verify or sync:

            if verify:

                self.print_verify(qh_limits, diff_q)

            if sync:

        return "application %s (%s) for project %s" % (

            self.id, self.name, self.chain)

    def state_display(self):

        return self.APPLICATION_STATE_DISPLAY.get(self.state, _('Unknown'))

    def project_exists(self):

        return self.get_project() is not None

    def can_cancel(self):

        return self.state == self.PENDING

        return self.state == self.PENDING

    def approve(self, reason):

        if not self.can_approve():

            m = _("cannot approve: project '%s' in state '%s'") % (

            raise AssertionError(m) # invalid argument

        now = datetime.now()

        if project is None:

            project = Project(id=self.chain)

        project.application = self

        project.last_approval_date = now

        project.save()

        return project

    @property

SYSTEM = 'system'

    try:

        s = qh.issue_commission(clientkey='astakos',

                                force=force,

                                provisions=[provision])

    except NoCapacityError as e:

        limit = e.data['limit']

        return False, limit

    return True, None

def add_base_quota(user, resource, capacity):

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

    obj, created = AstakosUserQuota.objects.get_or_create(

        user=user, resource=resource, defaults={

            'capacity': capacity,

    if not created:

        obj.capacity = capacity

        obj.save()

def remove_base_quota(user, resource):

    AstakosUserQuota.objects.filter(

        user=user, resource__name=resource).delete()

def initial_quotas(users):

# Syncing to quotaholder

    uids = [user.id for user in users]

    if sync:

    astakos_quotas = astakos_users_quotas(users)

def qh_sync_user(user):

    qh_sync_users([user])

def qh_sync_project(project):

def qh_add_resource_limit(resource, diff):

    objs = AstakosUser.forupdate.filter(Q(email_verified=True) &

                                        ~Q(policy=resource))

    uuids = [u.uuid for u in users]

    qh.add_resource_limit(holders=uuids, sources=[SYSTEM],

                          resources=[resource.name], diff=diff)

def qh_sync_new_resource(resource, limit):

    users = AstakosUser.forupdate.filter(

    resource_name = resource.name

    data = []

    send_feedback,

    logout as auth_logout,

    invite as invite_func,

    accept_membership, reject_membership, remove_membership, cancel_membership,

    leave_project, join_project, enroll_member, can_join_request,

    can_leave_request,

def project_add(request):

    user = request.user

    if not user.is_project_admin():

        if not ok:

            m = _(astakos_messages.PENDING_APPLICATION_LIMIT_ADD) % limit

            messages.error(request, m)

    if not user.is_project_admin():

        owner = app.owner

        if not ok:

            m = _(astakos_messages.PENDING_APPLICATION_LIMIT_MODIFY) % limit

            messages.error(request, m)

from astakos.im.models import AstakosUser, ProjectApplication

from astakos.im.functions import (join_project, leave_project,

                                  submit_application, approve_application,

from snf_django.lib.db.transaction import commit_on_success_strict

                 if prec is not None

                 else None)

    if not ok:

        raise PermissionDenied('Limit %s reached', limit)