Synnefo

# Copyright 2013-2014 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.

import re

from django.utils import simplejson as json

from django.views.decorators.csrf import csrf_exempt

from django.http import HttpResponse

from django.db.models import Q

from django.db import transaction

from astakos.api.util import json_response

from snf_django.lib import api

from snf_django.lib.api import faults

from .util import user_from_token, invert_dict, read_json_body

from astakos.im import functions

from astakos.im.models import (

    AstakosUser, Project, ProjectApplication, ProjectMembership,

    ProjectResourceQuota, ProjectResourceGrant, ProjectLog,

    ProjectMembershipLog)

import synnefo.util.date as date_util

from synnefo.util import units

MEMBERSHIP_POLICY_SHOW = {

    functions.AUTO_ACCEPT_POLICY: "auto",

    functions.MODERATED_POLICY:   "moderated",

    functions.CLOSED_POLICY:      "closed",

}

MEMBERSHIP_POLICY = invert_dict(MEMBERSHIP_POLICY_SHOW)

APPLICATION_STATE_SHOW = {

    ProjectApplication.PENDING:   "pending",

    ProjectApplication.APPROVED:  "approved",

    ProjectApplication.REPLACED:  "replaced",

    ProjectApplication.DENIED:    "denied",

    ProjectApplication.DISMISSED: "dismissed",

    ProjectApplication.CANCELLED: "cancelled",

}

PROJECT_STATE_SHOW = {

    Project.UNINITIALIZED: "uninitialized",

    Project.NORMAL:        "active",

    Project.SUSPENDED:     "suspended",

    Project.TERMINATED:    "terminated",

    Project.DELETED:       "deleted",

}

PROJECT_STATE = invert_dict(PROJECT_STATE_SHOW)

MEMBERSHIP_STATE_SHOW = {

    ProjectMembership.REQUESTED:       "requested",

    ProjectMembership.ACCEPTED:        "accepted",

    ProjectMembership.LEAVE_REQUESTED: "leave_requested",

    ProjectMembership.USER_SUSPENDED:  "suspended",

    ProjectMembership.REJECTED:        "rejected",

    ProjectMembership.CANCELLED:       "cancelled",

    ProjectMembership.REMOVED:         "removed",

}

def _grant_details(grants):

    resources = {}

    for grant in grants:

        if not grant.resource.api_visible:

            continue

        resources[grant.resource.name] = {

            "member_capacity": grant.member_capacity,

            "project_capacity": grant.project_capacity,

        }

    return resources

def _application_details(application, all_grants):

    grants = all_grants.get(application.id, [])

    resources = _grant_details(grants)

    join_policy = MEMBERSHIP_POLICY_SHOW.get(application.member_join_policy)

    leave_policy = MEMBERSHIP_POLICY_SHOW.get(application.member_leave_policy)

    d = {

        "id": application.id,

        "state": APPLICATION_STATE_SHOW[application.state],

        "name": application.name,

        "owner": application.owner.uuid if application.owner else None,

        "applicant": application.applicant.uuid,

        "homepage": application.homepage,

        "description": application.description,

        "start_date": application.start_date,

        "end_date": application.end_date,

        "comments": application.comments,

        "join_policy": join_policy,

        "leave_policy": leave_policy,

        "max_members": application.limit_on_members_number,

        "private": application.private,

        "resources": resources,

    }

    return d

def get_projects_details(projects, request_user=None):

    applications = [p.last_application for p in projects if p.last_application]

    proj_quotas = ProjectResourceQuota.objects.quotas_per_project(projects)

    app_grants = ProjectResourceGrant.objects.grants_per_app(applications)

    deactivations = ProjectLog.objects.last_deactivations(projects)

    l = []

    for project in projects:

        join_policy = MEMBERSHIP_POLICY_SHOW[project.member_join_policy]

        leave_policy = MEMBERSHIP_POLICY_SHOW[project.member_leave_policy]

        quotas = proj_quotas.get(project.id, [])

        resources = _grant_details(quotas)

        d = {

            "id": project.uuid,

            "state": PROJECT_STATE_SHOW[project.state],

            "creation_date": project.creation_date,

            "name": project.realname,

            "owner": project.owner.uuid if project.owner else None,

            "homepage": project.homepage,

            "description": project.description,

            "end_date": project.end_date,

            "join_policy": join_policy,

            "leave_policy": leave_policy,

            "max_members": project.limit_on_members_number,

            "private": project.private,

            "base_project": project.is_base,

            "resources": resources,

            }

        check = functions.project_check_allowed

        if check(project, request_user,

                 level=functions.APPLICANT_LEVEL, silent=True):

            application = project.last_application

            if application:

                d["last_application"] = _application_details(

                    application, app_grants)

            deact = deactivations.get(project.id)

            if deact is not None:

                d["deactivation_date"] = deact.date

        l.append(d)

    return l

def get_project_details(project, request_user=None):

    return get_projects_details([project], request_user=request_user)[0]

def get_memberships_details(memberships, request_user):

    all_logs = ProjectMembershipLog.objects.last_logs(memberships)

    l = []

    for membership in memberships:

        logs = all_logs.get(membership.id, {})

        dates = {}

        for s, log in logs.iteritems():

            dates[MEMBERSHIP_STATE_SHOW[s]] = log.date

        allowed_actions = functions.membership_allowed_actions(

            membership, request_user)

        d = {

            "id": membership.id,

            "user": membership.person.uuid,

            "project": membership.project.uuid,

            "state": MEMBERSHIP_STATE_SHOW[membership.state],

            "allowed_actions": allowed_actions,

        }

        d.update(dates)

        l.append(d)

    return l

def get_membership_details(membership, request_user):

    return get_memberships_details([membership], request_user)[0]

def _query(attr):

    def inner(val):

        kw = attr + "__in" if isinstance(val, list) else attr

        return Q(**{kw: val})

    return inner

def _get_project_state(val):

    try:

        return PROJECT_STATE[val]

    except KeyError:

        raise faults.BadRequest("Unrecognized state %s" % val)

def _project_state_query(val):

    if isinstance(val, list):

        states = [_get_project_state(v) for v in val]

        return Q(state__in=states)

    return Q(state=_get_project_state(val))

PROJECT_QUERY = {

    "name": _query("realname"),

    "owner": _query("owner__uuid"),

    "state": _project_state_query,

}

def make_project_query(filters):

    qs = Q()

    for attr, val in filters.iteritems():

        try:

            _q = PROJECT_QUERY[attr]

        except KeyError:

            raise faults.BadRequest("Unrecognized filter %s" % attr)

        qs &= _q(val)

    return qs

class ExceptionHandler(object):

    def __enter__(self):

        pass

    EXCS = {

        functions.ProjectNotFound:   faults.ItemNotFound,

        functions.ProjectForbidden:  faults.Forbidden,

        functions.ProjectBadRequest: faults.BadRequest,

        functions.ProjectConflict:   faults.Conflict,

    }

    def __exit__(self, exc_type, value, traceback):

        if value is not None:  # exception

            try:

                e = self.EXCS[exc_type]

            except KeyError:

                return False  # reraise

            raise e(value.message)

@csrf_exempt

def projects(request):

    method = request.method

    if method == "GET":

        return get_projects(request)

    elif method == "POST":

        return create_project(request)

    return api.api_method_not_allowed(request, allowed_methods=['GET', 'POST'])

@api.api_method(http_method="GET", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def get_projects(request):

    user = request.user

    filters = {}

    for key in PROJECT_QUERY.keys():

        value = request.GET.get(key)

        if value is not None:

            filters[key] = value

    mode = request.GET.get("mode", "default")

    query = make_project_query(filters)

    projects = _get_projects(query, mode=mode, request_user=user)

    data = get_projects_details(projects, request_user=user)

    return json_response(data)

def _get_projects(query, mode="default", request_user=None):

    projects = Project.objects.filter(query)

    if mode == "member":

        membs = request_user.projectmembership_set.\

            actually_accepted_and_active()

        memb_projects = membs.values_list("project", flat=True)

        is_memb = Q(id__in=memb_projects)

        projects = projects.filter(is_memb)

    elif mode == "default":

        if not request_user.is_project_admin():

            membs = request_user.projectmembership_set.any_accepted()

            memb_projects = membs.values_list("project", flat=True)

            is_memb = Q(id__in=memb_projects)

            owned = Q(owner=request_user)

            active = (Q(state=Project.NORMAL) &

                      Q(private=False))

            projects = projects.filter(is_memb | owned | active)

    else:

        raise faults.BadRequest("Unrecognized mode '%s'." % mode)

    return projects.select_related("last_application")

@api.api_method(http_method="POST", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def create_project(request):

    user = request.user

    data = request.body

    app_data = json.loads(data)

    return submit_new_project(app_data, user)

@csrf_exempt

def project(request, project_id):

    method = request.method

    if method == "GET":

        return get_project(request, project_id)

    if method == "PUT":

        return modify_project(request, project_id)

    return api.api_method_not_allowed(request, allowed_methods=['GET', 'PUT'])

@api.api_method(http_method="GET", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def get_project(request, project_id):

    user = request.user

    with ExceptionHandler():

        project = _get_project(project_id, request_user=user)

    data = get_project_details(project, user)

    return json_response(data)

def _get_project(project_id, request_user=None):

    project = functions.get_project_by_uuid(project_id)

    functions.project_check_allowed(

        project, request_user, level=functions.ANY_LEVEL)

    return project

@api.api_method(http_method="PUT", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def modify_project(request, project_id):

    user = request.user

    data = request.body

    app_data = json.loads(data)

    return submit_modification(app_data, user, project_id=project_id)

def _get_date(d, key):

    date_str = d.get(key)

    if date_str is not None:

        try:

            return date_util.isoparse(date_str)

        except:

            raise faults.BadRequest("Invalid %s" % key)

    else:

        return None

def _get_maybe_string(d, key, default=None):

    value = d.get(key)

    if value is not None and not isinstance(value, basestring):

        raise faults.BadRequest("%s must be string" % key)

    if value is None:

        return default

    return value

def _get_maybe_boolean(d, key, default=None):

    value = d.get(key)

    if value is not None and not isinstance(value, bool):

        raise faults.BadRequest("%s must be boolean" % key)

    if value is None:

        return default

    return value

DOMAIN_VALUE_REGEX = re.compile(

    r'^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}$',

    re.IGNORECASE)

def valid_project_name(name):

    return DOMAIN_VALUE_REGEX.match(name) is not None

def _parse_max_members(s):

    try:

        max_members = units.parse(s)

        if max_members < 0:

            raise faults.BadRequest("Invalid max_members")

        return max_members

    except units.ParseError:

        raise faults.BadRequest("Invalid max_members")

def submit_new_project(app_data, user):

    uuid = app_data.get("owner")

    if uuid is None:

        owner = user

    else:

        try:

            owner = AstakosUser.objects.accepted().get(uuid=uuid)

        except AstakosUser.DoesNotExist:

            raise faults.BadRequest("User does not exist.")

    try:

        name = app_data["name"]

    except KeyError:

        raise faults.BadRequest("Name missing.")

    if not valid_project_name(name):

        raise faults.BadRequest("Project name should be in domain format")

    join_policy = app_data.get("join_policy", "moderated")

    try:

        join_policy = MEMBERSHIP_POLICY[join_policy]

    except KeyError:

        raise faults.BadRequest("Invalid join policy")

    leave_policy = app_data.get("leave_policy", "auto")

    try:

        leave_policy = MEMBERSHIP_POLICY[leave_policy]

    except KeyError:

        raise faults.BadRequest("Invalid leave policy")

    start_date = _get_date(app_data, "start_date")

    end_date = _get_date(app_data, "end_date")

    if end_date is None:

        raise faults.BadRequest("Missing end date")

    try:

        max_members = _parse_max_members(app_data["max_members"])

    except KeyError:

        max_members = units.PRACTICALLY_INFINITE

    private = bool(_get_maybe_boolean(app_data, "private"))

    homepage = _get_maybe_string(app_data, "homepage", "")

    description = _get_maybe_string(app_data, "description", "")

    comments = _get_maybe_string(app_data, "comments", "")

    resources = app_data.get("resources", {})

    submit = functions.submit_application

    with ExceptionHandler():

        application = submit(

            owner=owner,

            name=name,

            project_id=None,

            homepage=homepage,

            description=description,

            start_date=start_date,

            end_date=end_date,

            member_join_policy=join_policy,

            member_leave_policy=leave_policy,

            limit_on_members_number=max_members,

            private=private,

            comments=comments,

            resources=resources,

            request_user=user)

    result = {"application": application.id,

              "id": application.chain.uuid,

              }

    return json_response(result, status_code=201)

def submit_modification(app_data, user, project_id):

    owner = app_data.get("owner")

    if owner is not None:

        try:

            owner = AstakosUser.objects.accepted().get(uuid=owner)

        except AstakosUser.DoesNotExist:

            raise faults.BadRequest("User does not exist.")

    name = app_data.get("name")

    if name is not None and not valid_project_name(name):

        raise faults.BadRequest("Project name should be in domain format")

    join_policy = app_data.get("join_policy")

    if join_policy is not None:

        try:

            join_policy = MEMBERSHIP_POLICY[join_policy]

        except KeyError:

            raise faults.BadRequest("Invalid join policy")

    leave_policy = app_data.get("leave_policy")

    if leave_policy is not None:

        try:

            leave_policy = MEMBERSHIP_POLICY[leave_policy]

        except KeyError:

            raise faults.BadRequest("Invalid leave policy")

    start_date = _get_date(app_data, "start_date")

    end_date = _get_date(app_data, "end_date")

    max_members = app_data.get("max_members")

    if max_members is not None:

        max_members = _parse_max_members(max_members)

    private = _get_maybe_boolean(app_data, "private")

    homepage = _get_maybe_string(app_data, "homepage")

    description = _get_maybe_string(app_data, "description")

    comments = _get_maybe_string(app_data, "comments")

    resources = app_data.get("resources", {})

    submit = functions.submit_application

    with ExceptionHandler():

        application = submit(

            owner=owner,

            name=name,

            project_id=project_id,

            homepage=homepage,

            description=description,

            start_date=start_date,

            end_date=end_date,

            member_join_policy=join_policy,

            member_leave_policy=leave_policy,

            limit_on_members_number=max_members,

            private=private,

            comments=comments,

            resources=resources,

            request_user=user)

    result = {"application": application.id,

              "id": application.chain.uuid,

              }

    return json_response(result, status_code=201)

def get_action(actions, input_data):

    action = None

    data = None

    for option in actions.keys():

        if option in input_data:

            if action:

                raise faults.BadRequest("Multiple actions not supported")

            else:

                action = option

                data = input_data[action]

    if not action:

        raise faults.BadRequest("No recognized action")

    return actions[action], data

PROJECT_ACTION = {

    "terminate": functions.terminate,

    "suspend":   functions.suspend,

    "unsuspend": functions.unsuspend,

    "reinstate": functions.reinstate,

}

APPLICATION_ACTION = {

    "approve": functions.approve_application,

    "deny":    functions.deny_application,

    "dismiss": functions.dismiss_application,

    "cancel":  functions.cancel_application,

}

PROJECT_ACTION.update(APPLICATION_ACTION)

APP_ACTION_FUNCS = APPLICATION_ACTION.values()

@csrf_exempt

@api.api_method(http_method="POST", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def project_action(request, project_id):

    user = request.user

    data = request.body

    input_data = json.loads(data)

    func, action_data = get_action(PROJECT_ACTION, input_data)

    with ExceptionHandler():

        kwargs = {"request_user": user,

                  "reason": action_data.get("reason", ""),

                  }

        if func in APP_ACTION_FUNCS:

            kwargs["application_id"] = action_data["app_id"]

        func(project_id=project_id, **kwargs)

    return HttpResponse()

@csrf_exempt

def memberships(request):

    method = request.method

    if method == "GET":

        return get_memberships(request)

    elif method == "POST":

        return post_memberships(request)

    return api.api_method_not_allowed(request, allowed_methods=['GET', 'POST'])

def make_membership_query(input_data):

    project_id = input_data.get("project")

    if project_id is not None:

        return Q(project__uuid=project_id)

    return Q()

@api.api_method(http_method="GET", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def get_memberships(request):

    user = request.user

    query = make_membership_query(request.GET)

    memberships = _get_memberships(query, request_user=user)

    data = get_memberships_details(memberships, user)

    return json_response(data)

def _get_memberships(query, request_user=None):

    memberships = ProjectMembership.objects

    if not request_user.is_project_admin():

        owned = Q(project__owner=request_user)

        memb = Q(person=request_user)

        memberships = memberships.filter(owned | memb)

    return memberships.select_related(

        "project", "project__owner", "person").filter(query)

def join_project(data, request_user):

    project_id = data.get("project")

    with ExceptionHandler():

        membership = functions.join_project(project_id, request_user)

    response = {"id": membership.id}

    return json_response(response)

def enroll_user(data, request_user):

    project_id = data.get("project")

    email = data.get("user")

    with ExceptionHandler():

        m = functions.enroll_member_by_email(

            project_id, email, request_user)

    response = {"id": m.id}

    return json_response(response)

MEMBERSHIPS_ACTION = {

    "join":   join_project,

    "enroll": enroll_user,

}

@api.api_method(http_method="POST", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def post_memberships(request):

    user = request.user

    data = request.body

    input_data = json.loads(data)

    func, action_data = get_action(MEMBERSHIPS_ACTION, input_data)

    return func(action_data, user)

@api.api_method(http_method="GET", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def membership(request, memb_id):

    user = request.user

    with ExceptionHandler():

        m = _get_membership(memb_id, request_user=user)

    data = get_membership_details(m, user)

    return json_response(data)

def _get_membership(memb_id, request_user=None):

    membership = functions.get_membership_by_id(memb_id)

    functions.membership_check_allowed(membership, request_user)

    return membership

MEMBERSHIP_ACTION = {

    "leave":  functions.leave_project,

    "cancel": functions.cancel_membership,

    "accept": functions.accept_membership,

    "reject": functions.reject_membership,

    "remove": functions.remove_membership,

}

@csrf_exempt

@api.api_method(http_method="POST", token_required=True, user_required=False)

@user_from_token

@transaction.commit_on_success

def membership_action(request, memb_id):

    user = request.user

    input_data = read_json_body(request, default={})

    func, action_data = get_action(MEMBERSHIP_ACTION, input_data)

    with ExceptionHandler():

        func(memb_id, user, reason=action_data)

    return HttpResponse()