WellService/proxy/views.py

from django.shortcuts import render
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.db import IntegrityError
from django.forms.models import model_to_dict
from django.core import serializers

from rest_framework.response import Response
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated

import json
import requests

from .models import Well
from .serializers import WellSerializer
 

#To optain the jwt Token for the first time from other services
'''
import requests
url = 'http://<well_service_url>/token/'

credentials = {
    "username": "your_username",
    "password": "your_password"
}

response = requests.post(url, data=credentials)
token = response.json().get('access')  
'''
# Store this token to use in future requests 
'''
headers = {
    'Authorization': f'Bearer {token}',
}
response = requests.post('http://<well_service_url>/<...>/', headers=headers, json=data_to_send)
'''

#error_list
'''
{
    "200": ({"data": "<serializer.data>", "message": "<costume message>"}, status=status.HTTP_200_OK),
    "400":({"message": serializer.errors}, status=status.HTTP_400_BAD_REQUEST),
    "404": ({"message": "<Not Found>"}, status=status.HTTP_404_NOT_FOUND),
    "409": ({"message":f'<{data["license_code"]} already exists>'}, status=status.HTTP_409_CONFLICT),
    "500": ({"message": "<Internal Server Error>"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR),
}
'''

@api_view(['POST'])
@permission_classes([IsAuthenticated])
def create_well(request):
    try:
        data = json.loads(request.body.decode('utf-8'))
        instance = Well.objects.filter(
            license_code=data["license_code"], log_type = 0)
        if instance:
            return Response(
                {"message":f'{data["license_code"]} already exists'},
                status=status.HTTP_409_CONFLICT
            )
        serializer = WellSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return Response(
                {"data":serializer.data}, 
                status=status.HTTP_201_CREATED
            )
        else:
            return Response(
                {"message":serializer.errors}, 
                status=status.HTTP_400_BAD_REQUEST
            )
    except Exception as e:
        print(e)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

@api_view(['GET'])
@permission_classes([IsAuthenticated])
def send_well_by_well_id(request, obj_id):
    try:
        well = Well.objects.filter(id=obj_id).first()
        if well is None:
            return Response({"message": "Not Found"}, status=status.HTTP_404_NOT_FOUND)
        serializer = WellSerializer(well)
        return Response({"data":serializer.data}, status=status.HTTP_200_OK)
    except Exception as ex:
        print(ex)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def send_wells(request):
    #permission_classes = [IsAuthenticated]
    try:
        # to do: add owner
        # to do: add filter
        # to do: add log_type=0
        #‌ to do: add no return data
        wells = Well.objects.all()
        serializer = WellSerializer(wells, many=True)
        return Response({"data":serializer.data}, status=status.HTTP_200_OK)
    except Exception as ex:
        print(ex)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


@permission_classes([IsAuthenticated])
@api_view(['DELETE'])
def delete_well_by_well_id(request, obj_id):
    try:
        instance = Well.objects.get(id=obj_id, log_type=0)
        instance.log_type = 1
        instance.save()
        return Response({"message": f"Successfully removed {instance.license_code}"}, status=status.HTTP_200_OK)
    except Well.DoesNotExist:
        return Response({"message": "Not Found"}, status=status.HTTP_404_NOT_FOUND)
    except Exception as e:
        print(e)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


@permission_classes([IsAuthenticated])
@api_view(['PUT'])
def update_well_by_well_id(request, obj_id):
    try:
        instance = Well.objects.get(id=obj_id, log_type=0)
        instance.log_type = 2
        instance.save()
        data = json.loads(request.body.decode('utf-8'))
        data["log_type"] = 0
        serializer = WellSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return Response({"data": serializer.data}, status=status.HTTP_200_OK)
        else:
            return Response({"message":serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
    except Well.DoesNotExist:
        return Response({"message": "Not Found"}, status=status.HTTP_404_NOT_FOUND)
    except Exception as e:
        print(e)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


@permission_classes([IsAuthenticated])
@api_view(['PUT'])
def edit_well_by_well_id(request, obj_id):
    try:
        instance = Well.objects.get(id=obj_id, log_type=0)
        instance.log_type = 3
        instance.save()
        data = json.loads(request.body.decode('utf-8'))
        data["log_type"] = 0
        serializer = WellSerializer(data=data)
        if serializer.is_valid(): 
            serializer["log_of"] = instance.id
            serializer.save()   
            return Response({"data": serializer.data}, status=status.HTTP_200_OK)
        else:
            return Response({"message":serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
    except Well.DoesNotExist:
        return Response({"message": "Not Found"}, status=status.HTTP_404_NOT_FOUND)
    except Exception as e:
        print(e)
        return Response({"message": "Internal Server Error"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)