views.py

import logging
from django.shortcuts import get_object_or_404
from rest_framework import views, viewsets
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
from rest_framework import status
from . import serializers
from .. import models

LOGGER = logging.getLogger(__name__)


def user_services(user):
    if user.is_authenticated:
        return (
            models.Service.objects
            .filter(groups__user=user)
            .distinct()
        )

    return []

def _api_error_response():
    return Response({'ok': False}, status=status.HTTP_400_BAD_REQUEST)


# Response for StateView, LogoutView, and all post requests
def _api_state_response(request):
    response = {
        'logged_in': request.user.is_authenticated()
    }
    if request.user.is_authenticated():
        response['user'] = serializers.UserSerializer(request.user).data

    response['services'] = serializers.ServiceSerializer(
        user_services(request.user),
        many=True,
    ).data

    if 'error' in request.session:
        response['error'] = request.session['error']
        # we display errors only once
        del request.session['error']

    return Response(response)


class StateView(views.APIView):
    permission_classes = (AllowAny,)

    def get(self, request):
        return _api_state_response(request)


class ServiceViewSet(viewsets.ModelViewSet):
    serializer_class = serializers.ServiceSerializer
    queryset = models.Service.objects.all()


class SSHPublicKeyView(views.APIView):
    def post(self, request):
        if 'type' not in request.data:
            return _api_error_response()

        request_type = request.data['type']

        if request_type == 'remove':
            if 'name' in request.data:
                key = get_object_or_404(
                    models.SSHPublicKey,
                    name=request.data['name']
                )
                # we do not delete ssh keys directly, as we need to keep track
                # of them until all clients have also deleted them

                # key state: -> (1), if there are no deployments
                # key state: -> (5), if there are deployments
                key.delete_key()
                return _api_state_response(request)
        elif request_type == 'add':
            if 'key' in request.data:
                key = models.SSHPublicKey(
                    user=request.user,
                    name=request.data['key']['name'],
                    key=request.data['key']['key'],
                )
                # key state: -> (2)
                key.save()
                return _api_state_response(request)

        return _api_error_response()


class DeploymentView(views.APIView):
    def post(self, request):
        if (
                'type' not in request.data or
                'key' not in request.data or
                'service' not in request.data
        ):
            LOGGER.error(
                'Deployment api got invalid request {}'.format(
                    request.data))
            return _api_error_response()

        request_type = request.data['type']
        request_service = get_object_or_404(
            models.Service, name=request.data['service']
        )
        request_key = get_object_or_404(
            models.SSHPublicKey,
            name=request.data['key'],
        )

        # check if there is already an deployment
        # if not request.user.deployments.filter(service=request_service).exists():
        try:
            deployment = request.user.deployments.get(service=request_service)
        except Exception:
            if request_type == 'remove':
                return _api_error_response()

            deployment = models.Deployment(
                user=request.user,
                service=request_service,
            )
            deployment.save()

        if request_type == 'add':
            deployment.deploy_key(request_key)
        elif request_type == 'remove':
            deployment.withdraw_key(request_key)
        else:
            return _api_error_response()

        deployment.save()
        return _api_state_response(request)