Synnefo

    pass

AUTO_ACCEPT_POLICY = 1

def get_project_by_application_id(project_application_id):

    try:

        return Project.objects.get(application__id=project_application_id)

    except Project.DoesNotExist:

def get_related_project_id(application_id):

    try:

        app = ProjectApplication.objects.get(id=application_id)

        chain = app.chain

        return chain

        return None

def get_chain_of_application_id(application_id):

    try:

        app = ProjectApplication.objects.get(id=application_id)

        chain = app.chain

        return chain.chain

        return None

def get_project_by_id(project_id):

    try:

        return Project.objects.get(id=project_id)

    except Project.DoesNotExist:

def get_project_by_name(name):

    try:

        return Project.objects.get(name=name)

    except Project.DoesNotExist:

def get_project_for_update(project_id):

    try:

        return Project.objects.get_for_update(id=project_id)

    except Project.DoesNotExist:

def get_application_for_update(application_id):

    try:

        m = _(astakos_messages.UNKNOWN_PROJECT_APPLICATION_ID) % application_id

        raise IOError(m)

def get_user_by_id(user_id):

    try:

        return AstakosUser.objects.get(id=user_id)

    except AstakosUser.DoesNotExist:

def get_user_by_uuid(uuid):

    try:

        return AstakosUser.objects.get(uuid=uuid)

    except AstakosUser.DoesNotExist:

def get_membership_for_update(project_id, user_id):

        return objs.get_for_update(project__id=project_id,

                                   person__id=user_id)

    except ProjectMembership.DoesNotExist:

def checkAllowed(entity, request_user, admin_only=False):

    if isinstance(entity, Project):

def checkAlive(project):

    if not project.is_alive:

def accept_membership_checks(project, request_user):

    checkAllowed(project, request_user)

    join_policy = project.application.member_join_policy

    if join_policy == CLOSED_POLICY:

    if project.violates_members_limit(adding=1):

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

                (membership.person.log_display, project))

    membership_change_notify(project, membership.person, 'accepted')

    return membership

def reject_membership_checks(project, request_user):

    checkAllowed(project, request_user)

    checkAlive(project)

                (membership.person.log_display, project))

    membership_change_notify(project, membership.person, 'rejected')

    return membership

def cancel_membership_checks(project):

    checkAlive(project)

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

                (membership.person.log_display, project))

def remove_membership_checks(project, request_user=None):

    checkAllowed(project, request_user)

    checkAlive(project)

    leave_policy = project.application.member_leave_policy

    if leave_policy == CLOSED_POLICY:

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

    project = get_project_for_update(project_id)

                (membership.person.log_display, project))

    membership_change_notify(project, membership.person, 'removed')

    return membership

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

    project = get_project_for_update(project_id)

    accept_membership_checks(project, request_user)

                (membership.person.log_display, project))

    membership_enroll_notify(project, membership.person)

    return membership

def leave_project_checks(project):

    checkAlive(project)

    leave_policy = project.application.member_leave_policy

    if leave_policy == CLOSED_POLICY:

def can_leave_request(project, user):

    leave_policy = project.application.member_leave_policy

        membership_leave_request_notify(project, membership.person)

    return auto_accepted

def join_project_checks(project):

    checkAlive(project)

    join_policy = project.application.member_join_policy

    if join_policy == CLOSED_POLICY:

def can_join_request(project, user):

    join_policy = project.application.member_join_policy

    auto_accepted = False

    join_policy = project.application.member_join_policy

        membership.accept()

        qh_sync_user(request_user.id)

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

        membership_request_notify(project, membership.person)

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

                    (membership.person.log_display, project))

    return auto_accepted

def submit_application(kw, request_user=None):

    kw['applicant'] = request_user

    application_submit_notify(application)

    return application

def cancel_application(application_id, request_user=None):

    application = get_application_for_update(application_id)

    checkAllowed(application, request_user)

    if not application.can_cancel():

        raise PermissionDenied(m)

    application.cancel()

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

def dismiss_application(application_id, request_user=None):

    application = get_application_for_update(application_id)

    checkAllowed(application, request_user)

    if not application.can_dismiss():

        raise PermissionDenied(m)

    application.dismiss()

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

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

    application = get_application_for_update(application_id)

    checkAllowed(application, request_user, admin_only=True)

    if not application.can_deny():

        raise PermissionDenied(m)

    if reason is None:

                (application.log_display, reason))

    application_deny_notify(application)

def approve_application(app_id, request_user=None):

    try:

    checkAllowed(application, request_user, admin_only=True)

    if not application.can_approve():

        raise PermissionDenied(m)

    project = application.approve()

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

    application_approve_notify(application)

def check_expiration(execute=False):

    objects = Project.objects

    expired = objects.expired_projects()

    return [project.expiration_info() for project in expired]

def terminate(project_id, request_user=None):

    project = get_project_for_update(project_id)

    checkAllowed(project, request_user, admin_only=True)

    project_termination_notify(project)

def suspend(project_id, request_user=None):

    project = get_project_by_id(project_id)

    checkAllowed(project, request_user, admin_only=True)

    project_suspension_notify(project)

def resume(project_id, request_user=None):

    project = get_project_for_update(project_id)

    checkAllowed(project, request_user, admin_only=True)

    qh_sync_projects([project])

    logger.info("%s has been unsuspended." % (project))

def get_by_chain_or_404(chain_id):

    try:

        project = Project.objects.get(id=chain_id)

PENDING_APPLICATION_LIMIT_SETTING = 'PENDING_APPLICATION_LIMIT'

def get_pending_application_limit(user_id):

    key = PENDING_APPLICATION_LIMIT_SETTING

    return get_user_setting(user_id, key)