views.py

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

def user_state_dict(user):
    return serializers.UserSerializer(user).data

# Response for StateView, LogoutView, and all post requests
def _api_state_response(request):
    if not request.user.is_authenticated:
        return Response(
            {
                'logged_in': False,
            }
        )

    response = {
        'logged_in': True,
        'user': user_state_dict(request.user),
        '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'],
        )

        deployment = models.Deployment.get_deployment(
            request.user,
            request_service,
        )

        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)


class UserDeletionView(views.APIView):
    def delete(self, request):
        # this also logs out the user
        request.user.remove()
        logout(request)
        return _api_state_response(request)