views.py

import logging
from django.shortcuts import get_object_or_404
from django.core.exceptions import ObjectDoesNotExist
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)


# pylint: disable=too-many-ancestors
class ServiceViewSet(viewsets.ModelViewSet):
    serializer_class = serializers.ServiceSerializer
    queryset = models.Service.objects.all()


class SSHPublicKeyView(views.APIView):
    def post(self, request):
        if 'type' in request.data:
            if request.data['type'] == 'remove':
                if 'id' in request.data:
                    key = get_object_or_404(
                        models.SSHPublicKey,
                        id=request.data['id']
                    )
                    # we do not delete ssh keys directly, as we need to keep track
                    # of them until all clients have also deleted them
                    key.delete_key()
                    return _api_state_response(request)
            elif request.data['type'] == 'add':
                if 'key' in request.data:
                    key = models.SSHPublicKey(
                        user=request.user,
                        name=request.data['key']['name'],
                        key=request.data['key']['key'],
                    )
                    key.save()
                    return _api_state_response(request)

        LOGGER.error('SSHPublicKeyView: malformed request %s', 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 %s', request.data)
            return _api_error_response()

        request_type = request.data['type']
        request_service = models.Service.objects.get(
            id=request.data['service'],
        )
        request_key = models.SSHPublicKey.objects.get(
            id=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 ObjectDoesNotExist:
            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)